Concurrency

CONCURRENCY:
RUBIES, PLURAL
Elise Huard - Arrrrcamp 2010
Friday 29 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)

language VM
OS
(kernel processes, other processes)
Your program
multicore - multiCPU

Concurrent programs
!=
Parallel computing

3 threads, 2 cores
1
2
3
1
1
2
3
1
2
3
core1 core2 core1 core2

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

Processes,Threads
Process 2
RAMmemory space
Process 1
thread1
scheduler (OS)
CPU CPU
memory space
thread2 t1 t2 t3

Ruby
• Process
• Thread:
• green threads in MRI 1.8
• native threads in MRI 1.9, Rubinius,
JRuby, ...

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

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

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

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

Ruby: multiprocess
•fork and IPC: IO.pipe,
Mmap, sockets ...
•DRb
•Queues

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
Ruby: multiprocess

Threads
Shared state: locking to avoid race
conditions
Mutex.synchronize do
...
end
ConditionVariable (semaphore)
MonitorMixin, Sync_m

Ruby threads
require 'thread'
threads = []
account = UnsafeAccount.new
mutex = Mutex.new
10.times do
threads << Thread.new do
mutex.synchronize do
account.receive(10)
end
end
end
threads.each {|t| t.join }
puts account.balance

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{
puts "please give your login"
login = f2.transfer
puts login
puts "give password"
pass = f2.transfer
puts pass
f2.transfer
f2.transfer('***** no cigar *****')
}
f2 = Fiber.new{
f1.transfer('johndoe')
f1.transfer('ultrasecret')
answer = f1.transfer
puts answer
}
f1.resume
vaguely inspired by http://sheddingbikes.com/posts/1287306747.html
output:
please give your login
johndoe
give password
ultrasecret
***** no cigar *****

MVM
Rubinius (2008): no parallel execution
of threads in oneVM ... so let’s create
oneVM 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
• locks: loss of performance

Actor model
•named actors: 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)
• Go (CSP)
• Haskell (several)
• Scala (Actors)
• Clojure
• IO

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

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

Erlang
pid = 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 differentVMs

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
ReplyChannel = make(chan []int)
(...)
request.data = less
request.replyChannel = ReplyChannel
go sort(&request) // async start parallel
execution
in sort:
request.replyChannel <- sorted
listener:
result := <-replyChannel

Ruby: futures
Lazy.rb gem (@mentalguy)
puts "before first future"
future1 = Lazy::Future.new { fib(40) }
puts "before second future"
future2 = Lazy::Future.new { fib(40) }
puts "and now we're waiting for results ..."
puts future1
# maybe some more code here
puts future2

Clojure
functional, Lisp-like, on JVM
concurrency: Software Transactional
Memory System:
• Refs = shared, and mutation within a
transaction (atomic, consistent, isolated) -
Multiversion Concurrency Control -
retried if conﬂict
• Agents: independent, asynchronous change

Clojure
(import '(java.util.concurrent Executors))
(defn parallel-stm [start amount nthreads]
(let [balance (ref start)
pool (Executors/newFixedThreadPool nthreads)
tasks (map (fn [t]
(fn []
(dosync
(alter balance transfer amount))))
(range nthreads))]
(doseq [future (.invokeAll pool tasks)]
(.get future))
(.shutdown pool)
(deref balance)))

Ruby: STM
• @mentalguy thought experiment
• @technomancy clojure-gem

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

Kernel stuff
Some of these problems have
been solved before ...

References:
http://www.delicious.com/elisehuard/concurrency
Elise Huard
@elise_huard
http://jabberwocky.eu

Concurrency

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à Concurrency

Similaire à Concurrency (20)

Plus de ehuard

Plus de ehuard (13)

Dernier

Dernier (20)

Concurrency