Concurrency

CONCURRENCY: RUBIES, PLURAL Elise Huard - Arrrrcamp 2010 Friday 29 October 2010

MULTIPROCESSOR/MULTICORE Friday 29 October 2010

NETWORK ON CHIP (50..96..100 CORES) Friday 29 October 2010

“... 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) Friday 29 October 2010

But ... forget all that (mostly) Friday 29 October 2010

Friday 29 October 2010

Your program language VM OS (kernel processes, other processes) multicore - multiCPU Friday 29 October 2010

Concurrent programs != Parallel computing Friday 29 October 2010

3 threads, 2 cores 1 1 2 2 3 1 3 3 2 1 core1 core2 core1 core2 Friday 29 October 2010

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

Processes, Threads memory space RAM memory space Process 1 Process 2 thread1 thread2 t1 t2 t3 scheduler (OS) CPU CPU Friday 29 October 2010

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

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

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 Friday 29 October 2010

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

Multiprocess • advantage: separate state • disadvantage: overhead to spawning + context switching Friday 29 October 2010

Ruby: multiprocess • fork and IPC: IO.pipe, Mmap, sockets ... • DRb • Queues Friday 29 October 2010

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 Friday 29 October 2010

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

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 Friday 29 October 2010

Fibers • cooperative scheduling • coroutines • for MRI: lightweight • JRuby, Rubinius: Fiber mapped to native thread Friday 29 October 2010

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 Friday 29 October 2010

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'" Friday 29 October 2010

Shared State: will melt your brain • non-determinism • atomicity • deadlock - livelock • fairness/starvation • race conditions • locks: loss of performance Friday 29 October 2010

Actor model • named actors: no shared state • asynchronous message passing (ﬁre and forget) Friday 29 October 2010

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

Concurrency oriented languages • Erlang (Actors) • Go (CSP) • Haskell (several) • Scala (Actors) • Clojure • IO Friday 29 October 2010

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

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

Erlang pid = spawn(fun() ->sort(Self, List) end) pmap_gather([]) -> []; pmap_gather([H|T]) -> receive {H, Ret} -> [Ret|pmap_gather(T)] end; Friday 29 October 2010

Rubinius: Actors • actors in the language: threads with inbox • VM actors to communicate between actors in different VMs Friday 29 October 2010

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) Friday 29 October 2010

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

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 Friday 29 October 2010

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 Friday 29 October 2010

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 Friday 29 October 2010

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))) Friday 29 October 2010

Ruby: STM • @mentalguy thought experiment • @technomancy clojure-gem Friday 29 October 2010

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

Kernel stuff Some of these problems have been solved before ... Friday 29 October 2010

FUN :) Friday 29 October 2010

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

Concurrency

by ehuard

Accessibility

Categories

Upload Details

Usage Rights

1 Embed 14

Statistics

Concurrency Presentation Transcript