Modern Concurrency Practices in Ruby

Presented at RuLu'14: http://rulu.eu/speakers/#arnab

Transcript

1. Modern Concurrency Practices in Ruby @arnab_deka
6. Agenda I would remove the thread and add actors or some other more advanced concurrency features — Matz
7. Agenda... 4 Elixir 4 Clojure 4 Go 4 Of course, Ruby ... 4 Even some French!
8. Agenda... 4 Elixir 4 Clojure 4 Go 4 Of course, Ruby ... 4 Even some French! Sadly, NO Pascal
9. Arnab 4 @arnab_deka 4 http://arnab-deka.com/ 4 Assam > Kerala > Pune > NYC > Seattle > Bangalore 4 Infosys/Goldman > Amazon > LivingSocial 4 C/C++ > Perl > Java > Ruby > Ruby/Clojure
13. Warm up class Counter attr_reader :count def initialize @count = 0 end def inc @count += 1 end end
14. Warm up... counter = Counter.new t1 = Thread.new { 1000.times { counter.inc } } t2 = Thread.new { 1000.times { counter.inc } } t1.join; t2.join puts "Final count: #{counter.count}"
15. Solution? Mutexes! Of course!
16. Solution? Mutexes! But... 4 testing? 4 debugging? 4 waking up at 3 AM to solve that Race condition?
18. STM
19. STMs: sidetrack on atoms 4 Compare and Swap 4 Lock-free 4 Non-blocking
21. STMs: sidetrack on atoms... require 'atomic' class Counter def initialize @count = Atomic.new(0) end def inc @count.update { |num| num + 1 } end def count @count.value end end
22. STMs: sidetrack on atoms... counter = Counter.new t1 = Thread.new { 1000.times { counter.inc } } t2 = Thread.new { 1000.times { counter.inc } } t1.join; t2.join puts "Final count, using atomic: #{counter.count}"
23. STM... (def transfer-count (atom 0)) (let [fn-nonnegative #(>= % 0)] (def alice (ref 1000 :validator fn-nonnegative)) (def bob (ref 2000 :validator fn-nonnegative)))
24. STM... (defn transfer [from to amount] (dosync (swap! transfer-count inc) (alter from - amount) (alter to + amount)))
25. STM... (repeatedly 25 #(transfer alice bob 100)) => IllegalStateException (println[@alice @bob @transfer-count]) ;; => [0 3000 11]
26. STM... ✔Atomic
27. STM... ✔Atomic ✔Consistent
28. STM... ✔Atomic ✔Consistent ✔Isolated
29. STM... ✔Atomic ✔Consistent ✔Isolated But... ✘ Durable
30. STM... 4 Synchronous 4 Retries...
31. STMs in Ruby??? :(
32. STMs in Ruby??? Alternatives... 4 HTM 4 Intel's Transactional Synchronization Extensions 4 PyPy's Transactional Memory 4 Atoms
33. counting.rubis classe Compteur attr_lire :recenser définir initialiser @recenser = 0 fin définir accroissement @recenser += 1 fin fin
34. Step 1 1763: French Indian War
35. Step 2 East India Companies: French > Brits
38. French in the US and in India... 4 ENIEO, not ENIAC 4 La sous-traitance, not "outsourcing" 4 ... 4 ... 4 ... 4 "Le Rubis", not Ruby
40. Actors
41. WHAT OOP WAS MEANT TO BE.
42. Actors in Elixir defmodule Player do def play(name) do receive do {:serve} -> # do it ... end end end p1 = spawn_link(Player, :play, ["Djokovic"]) send(p1, {:serve}) # or register to a name Process.register(p1, :djoker) send(:djoker, {:serve})
43. Actors in Ruby class Player include Celluloid def initialize(name); end def serve; end end djoker = Player.new djoker.async.serve Player.supervise_as(:djoker, "Djokovic") Celluloid::Actor[:djoker].async.serve
44. Erlang/Elixir: there's more... 4 Processes are very very light-weight
45. Erlang/Elixir: there's more... 4 Processes are very very light-weight 4 fault-tolerance: let it crash
46. Erlang/Elixir: there's more... 4 Processes are very very light-weight 4 fault-tolerance: let it crash 4 OTP framework
47. Erlang/Elixir: there's more... 4 Processes are very very light-weight 4 fault-tolerance: let it crash 4 OTP framework 4 Distributed
48. What about Ruby? 4 Celluloid 4 DCell
49. Actors in Ruby: DCell 4 Over 0mq require 'dcell' DCell.start :id => "itchy", :addr => "tcp://127.0.0.1:9001" DCell.start :id => "scratchy", :addr => "tcp://127.0.0.1:9002" itchy_node = DCell::Node["itchy"]
50. Channels
51. Actors 4 focus: named processes/actors 4 coupled to message format Channels 4 focus: transport, not receiver 4 anything can produce/consume
52. side-track: #golang board := make([][]string, m) for i := range board { board[i] = make([]string, n) }
53. side-track: #golang board = Array.new(Array.new)
54. core.async (def c (chan)) (thread (println "Pouring: " (<!! c) " from channel")) (>!! c "Hello RuLu")
55. core.async: buffering 4 unbuffered by default. Will block on 4 reading from empty channels 4 writing to non-empty channels
56. core.async: buffering 4 will buffer upto n: (def bc (chan 20)) (>!! bc "Hello") (>!! bc "RuLu") (<!! bc) ;;; "Hello" (<!! bc) ;;; "RuLu"
57. core.async: buffering 4 dropping channels (def c (chan (dropping-buffer 20))) 4 sliding channels (def c (chan (sliding-buffer 20))) 4 Why not handle buffering automatically?
58. core.async: channel functions 4 map-chan 4 onto-chan 4 ...
59. core.async: go blocks (def c (chan)) (go (let [x (<! c) y (<! c)] (println (clojure.string/join " " [x y])))) (>!! c "Hello") (>!! c "RuLu!")
61. Channels in Ruby require 'jo' include Jo c = chan jo do x = c.take y = c.take puts (x + y) end c << 10 c << 25
62. Closing thoughts & Advice
63. Experiment
64. Keep it simple
66. Resources 4 github: arnab/modern-concurrency-rulu 4 presentation/resources.md
67. RuLu