Concurrency

CONCURRENCY:
RUBIES, PLURAL

Elise Huard - RubyAndRails 2010
Thursday 21 October 2010

MULTIPROCESSOR/MULTICORE


NETWORK ON CHIP
(50..96..100 CORES)


“... for the ﬁrst time in history, no one is building a
much faster sequential processor. If you want your
programs to run signiﬁcantly faster (...) you’re going
to have to parallelize your program.”

Hennessy and Patterson “Computer Architectures” (4th
edition, 2007)


But ...
forget all that
(mostly)


Your program

language VM

OS
(kernel processes, other processes)

multicore - multiCPU


Concurrent programs
!=
Parallel computing


Scheduling

• preemptive -> thread is told to yield
(by kernel or other thread)
• cooperative -> thread yields control


Processes, Threads
memory space RAM memory space

Process 1 Process 2

thread1 thread2 t1 t2 t3

scheduler (OS)

CPU CPU


Ruby

• Process
• Thread - green in MRI 1.8, native
threads in MRI 1.9, Rubinius, JRuby


MRI: GIL
• only one thread is executed at a time
• fair scheduling: timer thread!
(10 μs for Linux, 10 ms for Windows)
• blocking region to allow limited
concurrency


MRI: GIL

from http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/ @igrigorik


Other Rubies

• @evanphx working on removing the
GIL on Rubinius (Hydra branch)
• JRuby, IronRuby, MacRuby don’t have
GIL


Parallel quicksort

[5, 3, 22, 12, 15, -112, 6]

[-122, 5, 3, 6] 12 [22, 15]

[-122] 3 [5, 6]


multiprocess

• advantage: separate state
• disadvantage: overhead to
spawning + context
switching


Ruby: multiprocess

• fork and IPC: IO.pipe,
Mmap, ...
• DRb


Ruby: multiprocess
def execute(&block)
rd, wr = IO.pipe # to retrieve results
pid = fork do
rd.close
result = block.call
wr.write result.to_json
wr.close
end
wr.close
sorted = JSON.parse(rd.read)
rd.close
Process.waitpid(pid)
sorted
end


Threads

Shared state:
Mutex
ConditionVariable (semaphore)
MonitorMixin, Sync_m


Ruby threads
def execute(&block)
sorted = nil
thread = Thread.new do
sorted = block.call
end
thread.join
sorted
end


Fibers

• cooperative scheduling
• coroutines
• for MRI: lightweight
• JRuby, Rubinius: Fiber mapped to
native thread


Ruby: Coroutines
require 'fiber'

# coroutines
ary = []
f2 = nil
f1 = Fiber.new{ output:
puts "please give your login" please give your login
login = f2.transfer johndoe
puts login
puts "give password"
give password
pass = f2.transfer ultrasecret
puts pass ***** no cigar *****
f2.transfer
f2.transfer('***** no cigar *****')
}
f2 = Fiber.new{
f1.transfer('johndoe')
f1.transfer('ultrasecret')
answer = f1.transfer
puts answer
}

vaguely inspired by http://sheddingbikes.com/posts/1287306747.html
f1.resume

MVM
Rubinius (2008): no parallel execution
of threads in one VM ... so let’s create
one VM per native thread

vm = Rubinius::VM.spawn "blah", "-e", "puts 'hellon'"


shared state:
will melt your brain
• non-determinism
• atomicity
• deadlock
• livelock
• fairness/starvation
• race conditions

actor model

• named actors: have no shared state
• asynchronous message passing (ﬁre
and forget)


CSP

• member of family of Process Calculi
(mathematical theory)
• events, processes
• synchronous (rendez-vous) message passing
• named channels - dual to Actor model


Concurrency oriented
languages
• Erlang (Actors)
• Clojure
• Go (CSP)
• Haskell (several)
• Scala (Actors)
• ...

Ideas
• functional programming: side effect
free function calls
- immutable data
• nothing shared (advantage: distributed
= local)
• message passing

erlang

• Actor model: Actors, asynchronous
message passing
• actors = “green processes”
• efﬁcient VM (SMP enabled since R12B)
• high reliability
© ericsson 2007


Erlang

spawn(fun() ->sort(Self, List) end)
pmap_gather([]) ->
[];
pmap_gather([H|T]) ->
receive
{H, Ret} -> [Ret|pmap_gather(T)]
end;


Rubinius: Actors

• actors in the language: threads with
inbox
• VM actors to communicate between
actors in different VMs


Ruby: Revactor

• erlang-like semantics: actor spawn/receive,
ﬁlter
• Fibers (so cooperative scheduling)
• Revactor::TCP for non-blocking network
access (1.9.2) (rev eventloop)


Go
• Fairly low-level - ﬁt for systems
programming (close to C)
• static typing
• goroutines: parallel execution - sort of
async lightweight thread
• channels !


Go
lessReply = make(chan []int)
(...)
lessReq.data = less
lessReq.replyChannel = lessReply
go sort(&lessReq) // asyncstart parallel
execution of sort

listener:
append(<-lessReply, pivot, <-greaterReply)


clojure
functional, Lisp-like
concurrency: Software Transactional
Memory System:
• Vars = variable state is thread isolated
• Refs = shared, and mutation within a
transaction (atomic, consistent, isolated) -
Multiversion Concurrency Control -


Ruby: STM

• @mentalguy thought experiment
• @technomancy clojure-gem


others to handle
concurrency
futures
joins
see http://moonbase.rydia.net/mental/
blog/programming/concurrency-ﬁve-
ways.html (@mentalguy)


Kernel stuff

Some of these problems have
been solved before ...


FUN :)


References:

http://www.delicious.com/elisehuard/concurrency

http://github.com/elisehuard/rubyandrails-2010

Elise Huard
@elise_huard
http://jabberwocky.eu


Concurrency

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (6)

En vedette

En vedette (13)

Similaire à Concurrency

Similaire à Concurrency (20)

Plus de ehuard

Plus de ehuard (6)

Dernier

Dernier (20)

Concurrency