Shared state model. April 3, / 29

Transcription

1 Shared state April 3, / 29

2 the s s limitations of explicit state: cells equivalence of the two s programming in limiting interleavings locks, monitors, transactions comparing the 3 s 2 / 29

3 Message passing Limitation: passing value around Limitation: large structures Limitation: cyclic data structures the s s 3 / 29

4 Message passing Message passing Limitation: passing value around Limitation: large structures Limitation: cyclic data structures the s s declarative + ports exchange messages In this shared data structures are like constant values changing them in place is not possible dataflow variables are like one-message channels Sometimes we want to change memory cell value in place (mutable variable) 4 / 29

5 Limitation: passing value around Message passing Limitation: passing value around Limitation: large structures Limitation: cyclic data structures the s s We need to pass a value around accumulator usually part of the algorithm function call counter profiling code Can be implemented with ports use local scope to define port (agent) agent holds the value get/set value trough port not a nice solution 5 / 29

6 Limitation: large structures Message passing Limitation: passing value around Limitation: large structures Limitation: cyclic data structures large arrays in declarative cannot change one element in-place need copy the whole data structure too expensive ports cannot solve this problem the s s 6 / 29

7 Limitation: cyclic data structures Message passing Limitation: passing value around Limitation: large structures Limitation: cyclic data structures the s s double linked lists, graphs in declarative cannot change on element in place need to copy the whole structure may be expensive cannot work on the same structure ports cannot solve this problem 7 / 29

8 Explicit vs implicit state Cells Example: cells Arrays the s s 8 / 29

9 Explicit vs implicit state Explicit vs implicit state Cells Example: cells Arrays the s s What is state? often exists only in programmers view e.g. iterating variable in tail recursion each (recursive) call creates new variables for the arguments declare proc {Iteration X Sum?R} if X>=10 then R=Sum else {Show X} {Iteration X+1 Sum+X R} end end Result={Iteration 0 0} 9 / 29

10 Cells Explicit vs implicit state Cells Example: cells Arrays the s s Cell abstraction multiple-assignment variable {NewCell C} read write with C:=5 replace with Y=C:=X (sugar for Exchange function) local C={NewCell 0} X Y in C:=X thread Y=@C+2 end X=3 {Browse Y} end 10 / 29

11 Example: cells Explicit vs implicit state Cells Example: cells Arrays the s s Not a typical code, just for comparison declare X Sum R X={NewCell 0} Sum={NewCell 0} proc {Iteration} then R=@Sum else X:=@X+1 Sum:=@Sum+@X {Iteration} end end {Iteration} 11 / 29

12 Arrays Explicit vs implicit state Cells Example: cells Arrays the s s {NewArray L H I?A} creates an array A lower bound L upper bound H initial value for all cells I {Array.low A?L} returns the lower index {Array.high A?L} returns the higher index R:=A.I returns A[I] in R A.I:=X assigns X to the entry A[I] The syntax is clear if you think of it as a tuple containing cells. 12 / 29

13 the s Ports using cells Cells using ports s the s 13 / 29

14 Ports using cells the s Ports using cells Cells using ports s a cell holds stream tail Key={NewName} % key for accessing cells fun {NewCPort S} T P C={NewCell T} % cell holds stream tail in S=!!T % expose protected tail P={NewChunk port(key:c)} % a port is a chunk P % a chunk is a "protected" record, % so others can t access the cell end proc {CSend P M} C=P.Key OldT NewT in OldT=C:=NewT % atomically exchange tail OldT=M!!NewT % extend stream end 14 / 29

15 Cells using ports the s Ports using cells Cells using ports s an agent holds cell value fun {PCellFun State M} case M of get(?v) then V=State State % leave the state [] set(v) then V % change the state to V [] exchange(?oldv NewV) then OldV=State NewV % change the state to NewV end end fun {NewPCell I} {NewPortObject I PCellFun} end 15 / 29

16 the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s 16 / 29

17 Limiting interleavings the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s Typical imperative language (C, Java) allows almost any interleaving limit to correct ones So, shared-state concurrency is about filtering out incorrect ones Compare with previous approaches declarative interleavings without observable non-determinism defined by data dependencies still quite restricted (by message dependencies) 17 / 29

18 Race conditions the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking declare X={NewCell 0} thread X:=1 end thread X:=2 end value of X is 1, 2 or 0 s 18 / 29

19 Locks the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s Locks only one thread holds it at a time non-reentrant locks can be implemented with single cell reentrant locks {NewLock L} returns new lock {IsLock X} returns true if X references a lock Critical section single lock for accessing code section lock X then stmt end grabs lock X and executes the statement stmt releasing the lock at the end pattern for simple case 19 / 29

20 Monitors the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s How to protect a code with lock, grab it only if some condition is satisfied? e.g. read a buffer if it is not empty polling? Monitors only grab it if condition is satisfied, otherwise wait conditional locks wait thread releases the lock and suspends on exit (when awakened) grabs the lock! notify, notifyall thread wakes up one (or all) threads waiting on lock 20 / 29

21 Example: monitors the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s Reading element from a queue protect with lock + check if not empty proc {GetValue Queue X} lock M then if {Queue.isEmpty} then {M.Wait} {GetValue Queue X} else {Queue.get X} end end end Cannot be implemented with locks and if statement wait entrance must be atomic (release+suspend) 21 / 29

22 Transactions the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s do not limit interleavings explicitely, track the interleaving rollback if you do not like it fixes/changes the interleaving A transaction is an operation (with ACID properties) atomic intermediate states not visible consistent must leave the system in acceptable state isolation concurrent execution of transactions behaves like sequential durability must leave the system in consistent state even in case of system crash 22 / 29

23 Programming with locking the s Limiting interleavings Race conditions Locks Monitors Example: monitors Transactions Programming with locking s Deadlock two locks A and B thread 1 grabs in order A then B thread 2 in the opposite order B then A solve with ordering of locks Inconsistent locking two variables X and Y (with locks), two transactions transaction 1 atomically changes X transaction 2 atomically changes Y transaction 1 atomically changes Y transaction 2 atomically changes X solve with two-phase locking (grab all release all) 23 / 29

24 the s s Expressiveness Readability Reasoning Which to use? Other languages s 24 / 29

25 Expressiveness the s s Expressiveness Readability Reasoning Which to use? Other languages which kind of programs can be implemented in the? declarative is less expressive cannot have non-determinism and are equal stateful concurrent s 25 / 29

26 Readability the s s Expressiveness Readability Reasoning Which to use? Other languages how easy it is to read and understand program code? declarative is limited all state must be carried around in arguments some algorithms may appear clumsy and s advertise very different styles of programming depends on the algorithm agents centric data centric 26 / 29

27 Reasoning the s s Expressiveness Readability Reasoning Which to use? Other languages how easy it is to understand and verify program behavior? declarative the easiest although dataflow variables make slightly more complicated concurrency is not a problem managable reason about each agent, then reason about the whole terrible think trough every possible interleaving and limit to acceptable ones 27 / 29

28 Which to use? the s s Expressiveness Readability Reasoning Which to use? Other languages Mix all of them! consider declarative first if readability or efficiency does not suffer too much consider ports (agents) add explicit state only where required unlike Java (C,C++) approach 28 / 29

29 Other languages the s s Expressiveness Readability Reasoning Which to use? Other languages Scala has vals and vars, only latter are mutable has case classes, structures with all immutable fields Clojure ( Vars, Refs, Agents and Atoms Erlang immutable variables special libraries provide distributed mutable structures 29 / 29