Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Many Ways to Concur

Many Ways to Concur

Easy concurrency is one of the main prophesied benefits of the modern functional programming (FP) languages. But the implementation of concurrency differs widely between different FP languages. In this talk, we shall explore the methods and primitives of concurrency across three FP languages: Haskell, Erlang, and Clojure (with core.async).

We shall learn about and compare the trade-offs between
- the green threads and STM channels oriented concurrency of Haskell
- everything-is-a-process and message-passing actor pattern of Erlang
- macro-based CSP of Clojure/core.async

4d29918c109bc75d2a1fd8420660d72b?s=128

Abhinav Sarkar

December 15, 2018
Tweet

Transcript

  1. Many Ways to Concur Abhinav Sarkar Functional Conf / Bengaluru,

    2018
  2. Source: Wikipedia

  3. Concurrency

  4. Concurrency is a program- structuring technique in which there are

    multiple threads of control which execute "at the same time". — Simon Marlow, Parallel and Concurrent Programming in Haskell
  5. Threads » A sequence of instructions along with a context.

    » Run by processors. » Managed by schedulers. Source: Wikipedia
  6. Green Threads » Green threads are scheduled by the runtime

    system or the virtual machine instead of the OS kernel. » Starting green threads is cheaper and faster. Context switches are faster too. » Making system calls blocks the thread. So the runtime needs to support asynchronous IO. » Cannot exploit multiprocessor parallelism in their simplest form.
  7. None
  8. Synchronization

  9. Synchronization » The process by which multiple threads agree (or

    concur) on something. » Locks prevent concurrent access to critical sections/memory. » Locks do not compose.
  10. Synchronization » Lock-free shared-state concurrency » Software Transactional Memory »

    Communicating Sequential Processes » No shared-state concurrency » Actor Model
  11. Actor Model

  12. Actor Model » An actor is an entity which can

    » create new actors » send messages to actors » behaves in a certain way on receiving a message
  13. Source: cwiki.apache.org/confluence/display/FLINK/Akka+and+Actors

  14. -module(echo). -export([loop/0]). loop() -> receive quit -> io:fwrite("Bye~n"); Num ->

    io:fwrite("Received: ~p~n", [Num]), loop() end. > Pid = spawn(fun echo:loop/0). > Pid ! 232. Received: 232 > Pid ! quit. Bye
  15. -module(counter). -export([loop/1]). loop(N) -> receive {inc} -> loop(N+1); {get, Sender}

    -> Sender ! N, loop(N) end. > Pid = spawn(counter, loop, [0]). > Pid ! {inc}. > Pid ! {get, self()}. > receive Value -> io:fwrite("~p~n", [Value]) end. 1 > Pid ! {getx, self()}. > receive Value -> io:fwrite("~p~n", [Value]) > after 1000 -> io:fwrite("Timeout~n") end. Timeout
  16. +----------------------------------+ | | | PID / Status / Registered Name

    | Process | | Control | Initial Call / Current Call +----> Block | | (PCB) | Mailbox Pointers | | | +----------------------------------+ | | | Function Parameters | | | Process | Return Addresses +----> Stack | | | Local Variables | | | +-------------------------------+--+ | | | | ^ v +----> Free | | | Space +--+-------------------------------+ | | | Mailbox Messages (Linked List) | | | Process | Compound Terms (List, Tuples) +----> Private | | Heap | Terms Larger than a word | | | +----------------------------------+
  17. Erlang Actors » Pros: » Communication is synchronization. » No

    need to worry about mutual exclusion. » Models distributed systems very well. » Cons: » Can be slower compared to Shared-state Concurrency. » Multi entity consensus is difficult to achieve. » Mailboxes may overflow if the message processing is slow.
  18. Software Transactional Memory

  19. Software Transactional Memory » Software transactional memory (STM) allows changing

    multiple mutable variables together in a single atomic operation. » Atomicity: All the state changes in an atomic operation become visible too all the threads at once. » Isolation: The atomic operation is completely unaffected by whatever other threads are doing.
  20. data STM a -- abstract instance Monad STM -- among

    other things data TVar a -- abstract newTVar :: a -> STM (TVar a) readTVar :: TVar a -> STM a writeTVar :: TVar a -> a -> STM () atomically :: STM a -> IO a retry :: STM a orElse :: STM a -> STM a -> STM a
  21. None
  22. import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Account { private int id,

    amount; private Lock lock = new ReentrantLock(); Account(int id, int initialAmount) { this.id = id; this.amount = initialAmount; } public void withdraw(int n) { this.lock.lock(); try { this.amount -= n; } finally { this.lock.unlock(); } } public void deposit(int n) { this.withdraw(-n); } public void transfer(Account other, int n) { this.withdraw(n); other.deposit(n); } }
  23. class Account { public void transfer(Account other, int n) {

    if (this.id < other.id) { this.lock.lock(); other.lock.lock(); } else { other.lock.lock(); this.lock.lock(); } try { this.amount -= n; other.amount += n; } finally { if (this.id < other.id) { this.lock.unlock(); other.lock.unlock(); } else { other.lock.unlock(); this.lock.unlock(); } } } }
  24. import System.IO import Control.Concurrent.STM type Account = TVar Int withdraw

    :: Account -> Int -> STM () withdraw acc amount = do bal <- readTVar acc writeTVar acc (bal - amount) deposit :: Account -> Int -> STM () deposit acc amount = withdraw acc (- amount) transfer :: Account -> Account -> Int -> IO () transfer from to amount = atomically $ do deposit to amount withdraw from amount amount :: Account -> IO Int amount acc = atomically $ readTVar acc
  25. main = do -- create accounts from <- atomically (newTVar

    200) to <- atomically (newTVar 100) -- transfer amount transfer from to 50 -- get amounts and print v1 <- amount from v2 <- amount to putStrLn $ (show v1) ++ ", " ++ (show v2) -- prints "150, 150"
  26. None
  27. retry :: STM a checkedWithdraw :: Account -> Int ->

    STM () checkedWithdraw acc amount = do bal <- readTVar acc if amount >= bal then writeTVar acc (bal - amount) else retry orElse :: STM a -> STM a -> STM a backupWithdraw :: Account -> Account -> Int -> STM () backupWithdraw acc1 acc2 amount = checkedWithdraw acc1 amt `orElse` checkedWithdraw acc2 amt
  28. data TChan a newTChan :: STM (TChan a) writeTChan ::

    TChan a -> a -> STM () readTChan :: TChan a -> STM a
  29. Haskell STM » Pros » Composable atomicity and blocking. »

    Type system prevents side effects. » Dataflow programming with TChans. » Cons » Transactions which touch many variables are expensive. » A long-running transaction may re-execute indefinitely because it may be repeatedly aborted by shorter transactions.
  30. Communicating Sequential Processes

  31. Communicating Sequential Processes » Independent threads of activity. » Synchronous

    communication through channels. » Multiplexing of channels with alternation.
  32. Source: arild.github.io/csp-presentation

  33. (go (println "hi")) (def echo-chan (chan)) (go (println (<! echo-chan)))

    (go (>! echo-chan "hello")) ; => hello (def echo-chan (chan 10))
  34. (let [c1 (chan) c2 (chan) c3 (chan)] (dotimes [n 3]

    (go (let [[v ch] (alts! [c1 c2 c3])] (println "Read" v "from" ch)))) (go (>! c1 "hello")) (go (>! c2 "allo") (go (>! c2 "hola"))) ; => Read allo from #<ManyToManyChannel ...> ; => Read hola from #<ManyToManyChannel ...> ; => Read hello from #<ManyToManyChannel ...>
  35. (parse-to-state-machine (macroexpand-1 `(clojure.core.async/go (if (= :x 1) :true :false))) {})

  36. [inst_10125 {:bindings {:terminators ()}, :block-id 1, :blocks {1 [{:ast (let

    [c__7560__auto__ (core.async/chan 1) captured-bindings__7561__auto__ (Var/getThreadBindingFrame)] (core.async.impl.dispatch/run (fn* [] (let [f__7562__auto__ (fn state-machine__7066__auto__ ([] (core.async.impl.ioc-macros/aset-all! (java.util.concurrent.atomic.AtomicReferenceArray. 7) 0 state-machine__7066__auto__ 1 1)) ([state_10123] (let [old-frame__7067__auto__ (Var/getThreadBindingFrame) ret-value__7068__auto__ (try (Var/resetThreadBindingFrame (core.async.impl.ioc-macros/aget-object state_10123 3)) (loop [] (let [result__7069__auto__ (case (int (core.async.impl.ioc-macros/aget-object state_10123 1)) 1 (let [inst_10121 (if (= :x 1) :true :false)] (core.async.impl.ioc-macros/return-chan state_10123 inst_10121)))] (if (identical? result__7069__auto__ :recur) (recur) result__7069__auto__))) (catch java.lang.Throwable ex__7070__auto__ (core.async.impl.ioc-macros/aset-all! state_10123 2 ex__7070__auto__) (if (seq (core.async.impl.ioc-macros/aget-object state_10123 4)) (core.async.impl.ioc-macros/aset-all! state_10123 1 (first (core.async.impl.ioc-macros/aget-object state_10123 4)) 4 (rest (core.async.impl.ioc-macros/aget-object state_10123 4))) (throw ex__7070__auto__)) :recur) (finally (Var/resetThreadBindingFrame old-frame__7067__auto__)))] (if (identical? ret-value__7068__auto__ :recur) (recur state_10123) ret-value__7068__auto__)))) state__7563__auto__ (-> (f__7562__auto__) (core.async.impl.ioc-macros/aset-all! core.async.impl.ioc-macros/USER-START-IDX c__7560__auto__ core.async.impl.ioc-macros/BINDINGS-IDX captured-bindings__7561__auto__))] (core.async.impl.ioc-macros/run-state-machine-wrapped state__7563__auto__)))) c__7560__auto__), :locals nil, :id inst_10124} {:value inst_10124, :id inst_10125}]}, :block-catches {1 nil}, :start-block 1, :current-block 1}]
  37. Source: Implementation details of core.async Channels - Rich Hickey

  38. Source: Implementation details of core.async Channels - Rich Hickey

  39. Clojure core.async » Pros » Just a library. No special

    runtime needed. » Easy Dataflow programming with many combinators available. » Works on JVM and browser. » Cons » Doing blocking IO in go-threads blocks them. » Error handling is complicated.
  40. Learnings » Green threads FTW. » Decomplect using higher level

    concurrency models. » Different techniques are suitable for different situations.
  41. References » Software Transactional Memory chapter from the Parallel and

    Concurrent Programming in Haskell book » Processes chapter from The Erlang Runtime System book » Timothy Baldridge's screencasts on Clojure/ core.async internals » Rich Hickey's talk on Clojure/core.async internals
  42. Thanks @abhin4v abhinavsarkar.net