Transactional Events

Transcription

1 Transactional Events... and how we implemented them Matthew Fluet 1 Kevin Donnelly 2 1 Toyota Technological Institute at Chicago 2 Boston University PL-Lunch February 9, 2007 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

2 Outline 1 Overview 2 TxEvents 3 Semantics Synchronous Evaluation Concurrent Evaluation 4 Expressiveness Guarded Receive N-way Rendezvous Boolean Satisfiability 5 Implementation Implementation Overview Refined Semantics (I) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

3 What are Transactional Events? A new high-level concurrency abstraction: Transactional Events = Atomic Transactions + First-class Synchronous- Message-Passing Events Insight: atomicity can enhance the expressive power of first-class synchronous-message-passing events. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

4 What are Transactional Events? TxEvents enable simple, compositional implementations where (complex, non-compositional) protocols are otherwise needed. e.g., guarded synchronous receive TxEvents enable more powerful abstractions. e.g., triple-swap channels TxEvents enable easier reasoning about sequential composition and non-deterministic choice. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

5 TxEvent Events are an abstract type data Evt a denotes an abstract synchronous operation that yields a result of type a when synchronized upon. Events may be synchronized: sync :: Evt a -> IO a not a pure function, but rather depends upon the state of concurrently synchronizing threads. yields an IO action, although it does not itself perform any observable I/O. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

6 TxEvent Synchronous channels are an abstract type data SChan a ing and receiving are events sendevt :: SChan a -> a -> Evt () recvevt :: SChan a -> Evt a blocks until there is a matching communication Channel creation is an event newschan :: Evt (SChan a) may create local channels inside of transactional event synchronizations. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

7 TxEvent main = do ch <- sync newschan forkio (sync (sendevt ch A )) c <- sync (recvevt ch) putchar c Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

8 TxEvent Events form a monad alwaysevt :: a -> Evt a alwaysevt e =... immediately yields e when synchronized upon. thenevt :: Evt a -> (a -> Evt b) -> Evt b evt thenevt f =... tentatively synchronizes on the event evt, yielding the result r, and then synchronizes on the event f r. if these synchronizations cannot successfully complete in sequence, then the composed event cannot successfully complete. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

9 TxEvent evt1 = do sendevt ch 0 sendevt ch 1 alwaysevt () evt2 = do a <- recvevt ch b <- recvevt ch alwaysevt (a, b) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

10 TxEvent Events form a monad-with-plus neverevt :: Evt a neverevt =... never yields a value when synchronized upon. chooseevt :: Evt a -> Evt a -> Evt a evt1 chooseevt evt2 =... synchronizes as either evt1 or evt2, but only commits to a choice that can successfully complete. until such a choice can be determined, the composed event cannot successfully complete. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

11 TxEvent evt1 = (do sendevt ch 0 sendevt ch 1 alwaysevt ()) chooseevt (do a <- recvevt ch alwaysevt ()) evt2 = do a <- recvevt ch b <- recvevt ch alwaysevt (a, b) evt3 = sendevt ch 2 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

12 TxEvent Events for exceptions... Events for thread identity... Events for time delays... Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

13 Dynamic Semantics Three levels of evaluation: Sequential Evaluation of pure terms e e Synchronous Evaluation of synchronizing events (Evt monad) S S Concurrent Evaluation of concurrent threads (IO monad) T a T Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

14 Synchronous Evaluation (S S ) Synchronizing Event S ::= θ, e Synchronization Group S ::= {S,...} Synchronous Evaluation Context M Evt ::= [] thenevt M Evt 1 e 2 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

15 Synchronous Evaluation (S S ) EVTEVAL e e S { θ, M Evt [e] } S { θ, M Evt [e ] } EVTTHENALWAYS S { θ, M Evt [thenevt (alwaysevt e 1 ) e 2 ] } S { θ, M Evt [e 2 e 1 ] } EVTCHOOSELEFT S { θ, M Evt [chooseevt e 1 e 2 ] } S { θ, M Evt [e 1 ] } EVTCHOOSERIGHT S { θ, M Evt [chooseevt e 1 e 2 ] } S { θ, M Evt [e 2 ] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

16 Synchronous Evaluation (S S ) EVTNEWSCHAN κ fresh S { θ, M Evt [newschan] } S { θ, M Evt [alwaysevt κ ] } EVTSENDRECV S { θ s, Ms Evt S { θ s, M Evt s [sendevt κ e], θ r, M Evt r [alwaysevt ()], θ r, M Evt r [recvevt κ] } [alwaysevt e] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

17 Synchronous Evaluation (S S ) What are the terminal configurations for? { θ 1, e 1,..., θ n, e n }??? good terminal configurations : { θ 1, alwaysevt e 1,..., θ n, alwaysevt e n } bad terminal configurations : {..., θ, M Evt [neverevt],...} {..., θ, M Evt [recvevt κ],...} (unmatched) {..., θ, M Evt [sendevt κ e],...} (unmatched) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

18 Synchronous Evaluation (S S ) What are the terminal configurations for? { θ 1, e 1,..., θ n, e n }??? good terminal configurations : { θ 1, alwaysevt e 1,..., θ n, alwaysevt e n } bad terminal configurations : {..., θ, M Evt [neverevt],...} {..., θ, M Evt [recvevt κ],...} (unmatched) {..., θ, M Evt [sendevt κ e],...} (unmatched) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

19 Concurrent Evaluation (T a T ) Concurrent Thread T ::= θ, e Thread Soup T ::= {T,...} Actions a ::=?c!c ɛ Concurrent Evaluation Context M IO ::= [] bindio M IO 1 e 2 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

20 Concurrent Evaluation (T a T ) IOEVAL e e T { θ, M IO [e] } ɛ T { θ, M IO [e ] } IOBINDUNIT T { θ, M IO [bindio (unitio e 1 ) e 2 ] } ɛ T { θ, M IO [e 2 e 1 ] } IOGETCHAR T { θ, M IO [getchar] }?c T { θ, M IO [unitio c] } IOPUTCHAR T { θ, M IO [putchar c] }!c T { θ, M IO [unitio ()] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

21 Concurrent Evaluation (T a T ) IOFORK θ fresh T { θ, M IO [forkio e] } ɛ T { θ, M IO [unitio θ ], θ, e } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

22 Concurrent Evaluation (T a T ) IOSYNC T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

23 Concurrent Evaluation (T a T ) IOSYNC { θ 1, e 1,..., θ k, e k } T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

24 Concurrent Evaluation (T a T ) IOSYNC { θ 1, e 1,..., θ k, e k } { θ 1, alwaysevt e 1,..., θ k, alwaysevt e k } T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

25 Concurrent Evaluation (T a T ) IOSYNC { θ 1, e 1,..., θ k, e k } { θ 1, alwaysevt e 1,..., θ k, alwaysevt e k } T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } T { θ 1, M1 IO [unitio e 1],..., θ k, Mk IO [unitio e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

26 Concurrent Evaluation (T a T ) IOSYNC { θ 1, e 1,..., θ k, e k } { θ 1, alwaysevt e 1,..., θ k, alwaysevt e k } T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } ɛ T { θ 1, M1 IO [unitio e 1],..., θ k, Mk IO [unitio e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

27 Guarded Receive Receive a mesage on a channel only if the message satisfies a boolean guard. grecvevt :: (a -> Bool) -> SChan a -> Evt a grecvevt g ch = do { x <- recvevt ch ; if g x then return x else neverevt } This synchronous operation uses existing synchronous channel type (SChan a); can be freely composed, either sequentially (with thenevt) or alternatively (with chooseevt), with other synchronous operations. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

28 Guarded Receive Receive a mesage on a channel only if the message satisfies a boolean guard. grecvevt :: (a -> Bool) -> SChan a -> Evt a grecvevt g ch = do { x <- recvevt ch ; if g x then return x else neverevt } This synchronous operation uses existing synchronous channel type (SChan a); can be freely composed, either sequentially (with thenevt) or alternatively (with chooseevt), with other synchronous operations. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

29 N-way Rendezvous (with CML) Theorem (CML Expressivity) Given the standard CML event combinators and an n-way rendezvous base-event constructor, one cannot implement an (n + 1)-way rendezvous operation abstractly (i.e., as an event value). Corollary Given two-way rendezvous primitives (sendevt and recvevt), one cannot implement a 3-way redezvous operation as an event value. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

30 N-way Rendezvous (with CML) Theorem (CML Expressivity) Given the standard CML event combinators and an n-way rendezvous base-event constructor, one cannot implement an (n + 1)-way rendezvous operation abstractly (i.e., as an event value). Corollary Given two-way rendezvous primitives (sendevt and recvevt), one cannot implement a 3-way redezvous operation as an event value. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

31 N-way Rendezvous (with TxEvents) Theorem (TxEvents Expressivity) Given the standard transactional event combinators and an n-way rendezvous base-event constructor, one can implement an (n + 1)-way rendezvous operation abstractly. Proof. By construction of 3-way rendezvous using two-way rendezvous primitives (sendevt and recvevt). Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

32 N-way Rendezvous (with TxEvents) Theorem (TxEvents Expressivity) Given the standard transactional event combinators and an n-way rendezvous base-event constructor, one can implement an (n + 1)-way rendezvous operation abstractly. Proof. By construction of 3-way rendezvous using two-way rendezvous primitives (sendevt and recvevt). Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

33 Triple-swap channel type TriSChan a newtrischan :: Evt (TriSChan a) swapevt :: TriSChan a -> a -> Evt (a, a) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

34 Triple-swap channel type TriSChan a = SChan (a, SChan (a, a)) newtrischan :: Evt (TriSChan a) newtrischan = newschan swapevt :: TriSChan a -> a -> Evt (a, a) swapevt ch x1 = client chooseevt leader where client = do { replych <- newschan ; sendevt ch (x1, replych) ; recvevt replych } leader = do { (x2, replych2) <- recvevt ch ; (x3, replych3) <- recvevt ch ; sendevt replych2 (x3, x1) ; sendevt replych3 (x1, x2) ; alwaysevt (x2, x3) } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

35 Boolean Satisfiability Boolean satisfiability (SAT) is the problem of determining whether there exists a satisfying assignment to a classical propositional formula in n variables. (NP-complete) Three encodings of SAT into Tx Events: n + 1 threads, using chooseevt and communication; one thread, using chooseevt (and no communication); three threads, using communication (and no chooseevt) Assume a SAT-checker: evalformula :: [Bool] -> Formula -> Bool Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

36 Boolean Satisfiability (n + 1 threads) sat n formula = do ch <- sync newschan mapm_ (\_ -> forkio (sync ((sendevt ch True) chooseevt (sendevt ch False)))) [1..n] sync (do input <- mapm (_ -> recvevt ch) [1..n] let b = evalformula input formula if b then alwaysevt () else neverevt) putstrln "Satisfiable" Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

37 Implementation Overview delivered as a Haskell library written using STM extensions of GHC required no changes to runtime or compiler runs on shared-memory multiprocessors does not require a global lock synchronization of a group of thread will not (unduly) impact the progress of non-synchronizing threads; synchronization of one group of threads impact the progress towards synchronization of another independent group of threads. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

38 Implementation Considerations Written semantics have no direct implementation: IOSYNC { θ 1, e 1,..., θ k, e k } { θ 1, alwaysevt e 1,..., θ k, alwaysevt e k } T { θ 1, M1 IO [sync e 1],..., θ k, Mk IO [sync e k] } ɛ T { θ 1, M1 IO [unitio e 1 ],..., θ k, Mk IO [unitio e k ] } Optimistic assumption used in software transactional memory doesn t apply to transactional events. randomly select an alternative at uses of chooseevt eagerly match senders with receivers Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

39 Refined Semantics (I) Concurrent Thread T ::= θ, e Suspended and Search Threads S ::= θ, M IO, e θ, e, ρ Thread Soup P ::= {T,..., S,...} Path Element ρ ::= Left Right ( θ r, ρ r ) ( θ s, ρ s ) Path ρ ::= ρ:ρ Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

40 Refined Semantics (I) Definition (Extends) The path ρ a extends the path ρ b, written ρ a ρ b, if ρ a is an extension of ρ b (alternatively, if ρ b is a suffix of ρ a ). Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

41 Refined Semantics (I) Definition (Dependencies) The dependencies of a trail θ, ρ, written Dep( θ, ρ ), is the set of trails implied by the trail. Formally, Dep( θ, ρ ) = { θ, ρ } DepAux( θ, ρ ) DepAux( θ, ) = {} DepAux( θ, Left:ρ ) = DepAux( θ, ρ ) DepAux( θ, Right:ρ ) = DepAux( θ, ρ ) DepAux( θ, ( θ r, ρ r ):ρ ) = { θ r, ( θ, ρ):ρ r } DepAux( θ, ρ ) DepAux( θ r, ρ r ) DepAux( θ, ( θ s, ρ s ):ρ ) = { θ s, ( θ, ρ):ρ s } DepAux( θ, ρ ) DepAux( θ s, ρ s ) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

42 Refined Semantics (I) Definition (Consistent (I)) The trail θ, ρ is consistent if no thread identifier in the dependencies of θ, ρ is paired with incomparable paths. Formally, Consistent( θ, ρ ) θ 1, ρ 1 Dep( θ, ρ ). θ 2, ρ 2 Dep( θ, ρ ). θ 1 = θ 2 (ρ 1 ρ 2 ρ 2 ρ 1 ). Remark The dependencies of a consistent trail may be efficiently represented by a finite map from thread identifiers to maximal paths. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

43 Refined Semantics (I) Definition (Consistent (I)) The trail θ, ρ is consistent if no thread identifier in the dependencies of θ, ρ is paired with incomparable paths. Formally, Consistent( θ, ρ ) θ 1, ρ 1 Dep( θ, ρ ). θ 2, ρ 2 Dep( θ, ρ ). θ 1 = θ 2 (ρ 1 ρ 2 ρ 2 ρ 1 ). Remark The dependencies of a consistent trail may be efficiently represented by a finite map from thread identifiers to maximal paths. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

44 Refined Semantics (I) Definition (Committable (I)) A set of trails { θ 1, ρ 1,... θ n, ρ n } is committable if each θ i is unique and all dependencies of each trail are satisfied by the set. Formally, Committable({ θ 1, ρ 1,... θ n, ρ n }) i {1,..., n}. j {1,..., n}. i j θ i θ j i {1,..., n}. θ, ρ Dep( θ i, ρ i ). j {1,..., n}. θ j = θ ρ j ρ. Lemma If a set of trails { θ 1, ρ 1,... θ n, ρ n } is committable, then each trail θ i, ρ i is consistent. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

45 Refined Semantics (I) Definition (Committable (I)) A set of trails { θ 1, ρ 1,... θ n, ρ n } is committable if each θ i is unique and all dependencies of each trail are satisfied by the set. Formally, Committable({ θ 1, ρ 1,... θ n, ρ n }) i {1,..., n}. j {1,..., n}. i j θ i θ j i {1,..., n}. θ, ρ Dep( θ i, ρ i ). j {1,..., n}. θ j = θ ρ j ρ. Lemma If a set of trails { θ 1, ρ 1,... θ n, ρ n } is committable, then each trail θ i, ρ i is consistent. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

46 Refined Semantics (I) SYNCINIT P { θ, M IO [sync e] } ɛ P { θ, M IO, e, θ, e, } SYNCCOMMIT Committable({ θ 1, ρ 1,..., θ k, ρ k }) P { θ 1, M1 IO, _, θ 1, alwaysevt e 1, ρ 1,..., θ k, Mk IO, _, θ k, alwaysevt e k, ρ k } ɛ P \ {θ1,...,θ k } { θ 1, M1 IO [unitio e 1],..., θ k, Mk IO [unitio e k] } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

47 Refined Semantics (I) EVTEVAL e e P { θ, M Evt [e], ρ } ɛ P { θ, M Evt [e ], ρ } EVTTHENALWAYS P { θ, M Evt [thenevt (alwaysevt e 1 ) e 2 ], ρ } ɛ P { θ, M Evt [e 2 e 1 ], ρ } EVTNEVER P { θ, M Evt [neverevt], ρ } ɛ P EVTCHOOSE P { θ, M Evt [chooseevt e 1 e 2 ], ρ } ɛ P { θ, M Evt [e 1 ], Left:ρ, θ, M Evt [e 2 ], Right:ρ } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

48 Refined Semantics (I) EVTSENDRECV P { θ s, Ms Evt [sendevt κ e], ρ s, θ r, Mr Evt [recvevt κ], ρ r } ɛ P { θ s, Ms Evt [sendevt κ e], ρ s, θ r, Mr Evt [recvevt κ], ρ r, θ s, Ms Evt [alwaysevt ()], ( θ r, ρ r ):ρ s, θ r, Mr Evt [alwaysevt e], ( θ s, ρ s ) :ρ r } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

49 Refined Semantics (I) EVTSENDRECV Coherent( θ s, ρ s, θ r, ρ r ) P { θ s, Ms Evt [sendevt κ e], ρ s, θ r, Mr Evt [recvevt κ], ρ r } ɛ P { θ s, Ms Evt [sendevt κ e], ρ s, θ r, Mr Evt [recvevt κ], ρ r, θ s, Ms Evt [alwaysevt ()], ( θ r, ρ r ):ρ s, θ r, Mr Evt [alwaysevt e], ( θ s, ρ s ) :ρ r } Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

50 Refined Semantics (I) Definition (Coherent (I)) The trails θ s, ρ s and θ r, ρ r are coherent if the trails are an acceptable sender/receiver pair. Formally, Coherent( θ s, ρ s, θ r, ρ r ) θ s θ r θ, ρ Dep( θ r, ρ r ). θ s = θ ρ s ρ θ, ρ Dep( θ s, ρ s ). θ r = θ ρ r ρ θ 1, ρ 1 Dep( θ s, ρ s ). θ 2, ρ 2 Dep( θ r, ρ r ). θ 1 = θ 2 (ρ s ρ r ρ r ρ s ) Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

51 Refined Semantics (I) Lemma If the trails θ s, ρ s and θ r, ρ r are consistent and coherent, then the trails θ s, ( θ r, ρ r ):ρ s and θ r, ( θ s, ρ s ):ρ r are consistent. Lemma Suppose P a P according to the refined semantics. If, for each search thread θ, e, ρ P, the trail θ, ρ is consistent, then, for each search thread θ, e, ρ P, the trail θ, ρ is consistent. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

52 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 swapevt ch x2 swapevt ch x1 swapevt ch x3 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

53 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 recvevt rch2 do { (x3,rch3) < recvevt ch sendevt rch2 (x3,x1) sendevt rch3 (x1,x2) ; alwaysevt (x2,x3) swapevt ch x3 Left Right Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

54 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 do { sendevt rch3 (x1,x2) alwaysevt (x3,x1) ; alwaysevt (x2,x3) recvevt rch3 Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

55 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x3,x1) alwaysevt (x2,x3) alwaysevt (x1,x2) Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

56 Remaining Implementation Considerations EVTSENDRECV requires matching two search threads in the thread soup that are attempting to communicate on the same channel. search threads corresponding to the sender and the receiver remain in the thread soup; evaluation may repeatedly spawn redundant search threads. Solution: represent a channel as a list of senders and receivers A sender must atomically add itself to the list of senders and take the list of receivers. A receiver must atomically add itself to the list of receivers and take the list of senders. Space considerations require periodically cleaning the lists of expired senders and receivers. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

57 Remaining Implementation Considerations SYNCCOMMIT requires removing from the thread soup all other search threads that were searching on behalf of the now synchronized concurrent threads. Solution: give every synchronization a unique boolean reference. Initialize the boolean reference to False. Every search thread terminates itself if it sees the boolean reference go to True. A synchronization committment must check that all committable search threads have boolean references set to False and must atomically set all boolean references to True. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

58 Remaining Implementation Considerations SYNCCOMMIT requires finding a committable set of search threads in the thread soup. Solution: give every communication path element pointers to completed search threads. See picture. Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

59 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x3,x1) alwaysevt (x2,x3) alwaysevt (x1,x2) Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

60 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 swapevt ch x2 swapevt ch x1 swapevt ch x3 Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

61 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 recvevt rch2 do { (x3,rch3) < recvevt ch sendevt rch2 (x3,x1) sendevt rch3 (x1,x2) ; alwaysevt (x2,x3) swapevt ch x3 {} {} Left Right Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

62 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 do { sendevt rch3 (x1,x2) ; alwaysevt (x2,x3) recvevt rch3 alwaysevt (x3,x1) b2 r2 { } {} {} {} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

63 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 do { sendevt rch3 (x1,x2) ; alwaysevt (x2,x3) recvevt rch3 alwaysevt (x3,x1) b2 r2 { } {} {} {} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

64 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x2,x3) b1 r1 alwaysevt (x1,x3) alwaysevt (x3,x1) b2 r2 { } {} { } {...,,...} {...,,...} {...,,...} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

65 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x2,x3) b1 r1 alwaysevt (x1,x3) alwaysevt (x3,x1) b2 r2 { } {} { } {...,,...} {...,,...} {...,,...} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

66 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x2,x3) b1 r1 alwaysevt (x1,x2) b3 r3 alwaysevt (x3,x1) b2 r2 { } { } { } {...,,...} {...,,...} {...,,...} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59

67 Search threads for a committable triple-swap Thread 2 Thread 1 Thread 3 alwaysevt (x2,x3) b1 r1 alwaysevt (x1,x2) b3 r3 alwaysevt (x3,x1) b2 r2 { } { } { } {...,,...} {...,,...} {...,,...} {...,,...} {...,,...} Left Right Left Fluet, Donnelly (TTI-C, BU) Transactional Events PL-Lunch February 9, / 59