THIRD PART Algorithms for Concurrent Distributed Systems: The Mutual Exclusion problem

1. THIRD PARTAlgorithms forConcurrentDistributed Systems:The Mutual Exclusion problem

2. Concurrent Distributed Systems Changes to the model from the MPS: • MPS basically models a distributed system in which processors needs to coordinate to perform a widesystem goal (e.g., electing their leader) • Now, we turn our attention to concurrent systems, where the processors run in parallel but without necessarily cooperating (for instance, they might just be a set of laptops in a LAN)

3. Shared Memory Model Changes to the model from the MPS: • No cooperation  no communication channels between processors and no inbuf and outbuf state components • Processors communicate via a set of shared variables, instead of passing messages  no any communication graph! • Each shared variable has a type, defining a set of operations that can be performed atomically (i.e.,instantaneously, without interferences)

4. Shared Memory processors

5. Types of Shared Variables • Read/Write • Read-Modify-Write • Test & Set • Fetch-and-add • Compare-and-swap • . • . • . We will focus on the Read/Writetype (the simplest one to be realized)

6. Read/Write Variables Read(v) Write(v,a) v = a; return(v); • In one atomic step a processor can: • read the variable, or • write the variable • … but not both!

7. write 10

8. write 10 10

9. read write 10 10

10. read write 10 10 10

11. Simultaneous writes write 20 write 10

12. Simultaneous writes are scheduled: Possibility 1 write 20 write 10 10

13. Simultaneous writes are scheduled: Possibility 2 write 20 write 10 20

14. Simultaneous writes are scheduled: In general: write write xє{a1,…,ak} write write

15. Simultaneous Reads: no problem! read read a a a All read the same value

16. Computation Step in the Shared Memory Model • When processor pi takes a step: • pi's state in old configuration specifies which shared variable is to be accessed and with which operation • operation is done: shared variable's value in the new configuration changes according to the operation • pi 's state in new configuration changes according to its old state and the result of the operation

17. The mutual exclusion (mutex) problem • The main challenge in managing concurrent systems is coordinating access to resources that are shared among processes • Assumptions on the system: • Non-anonymous • Asynchronous • Fault-free

18. entry critical exit remainder Mutex code sections • Each processor's code is divided into four sections: • entry: synchronize with others to ensure mutually exclusive access to the … • critical: use some resource; when done, enter the… • exit: clean up; when done, enter the… • remainder: not interested in using the resource

19. Mutex Algorithms • A mutual exclusion algorithm specifies code for entry and exit sections to ensure: • mutual exclusion: at most one processor is in its critical section at any time, and • some kind of liveness condition. There are three commonly considered ones…

20. Mutex Liveness Conditions • no deadlock: if a processor is in its entry section at some time, then later some processor is in its critical section • no lockout: if a processor is in its entry section at some time, then later the sameprocessor is in its critical section • bounded waiting: no lockout + while a processor is in its entry section, any other processor can enter the critical section no more than a bounded number of times. These conditions are increasingly strong.

21. Mutex Algorithms: assumptions • The code for the entry and exit sections is allowed to assume that • no processor stays in its critical section forever • shared variables used in the entry and exit sections are not accessed during the critical and remainder sections

22. Complexity Measure for Mutex • Main complexity measure of interest for shared memory mutex algorithms is amount of shared space needed. • Space complexity is affected by: • how powerful is the type of the shared variables • how strong is the progress property to be satisfied (no deadlock vs. no lockout vs. bounded waiting)

23. Mutex Results Using R/W

24. Bakery Algorithm • Guaranteeing: • Mutual exclusion • Bounded waiting • Using 2n shared read/write variables • booleansChoosing[i]: initially false, written by pi and read by others • integers Number[i]: initially 0, written by pi and read by others

25. Bakery Algorithm Code for entry section: Choosing[i] := true Number[i] := max{Number[0],..., Number[n-1]} + 1 Choosing[i] := false for j := 0 to n-1 (except i) do wait until Choosing[j] = false wait until Number[j] = 0 or (Number[j],j) > (Number[i],i) endfor Code for exit section: Number[i] := 0

26. BA Provides Mutual Exclusion Lemma 1: If pi is in the critical section, then Number[i] > 0. Proof: Trivial. Lemma 2: If pi is in the critical section andNumber[k] ≠ 0 (k ≠ i), then (Number[k],k) > (Number[i],i). Proof: Observe that a chosen number changes only after exiting from the CS. Since pi is in the CS, it passed the second wait statement for j=k. There are two cases: pi 's most recent read of Number[k]; Case 1: returns 0 Case 2: returns (Number[k],k) > (Number[i],i) pi in CS and Number[k] ≠ 0

27. pi's most recent read of Choosing[k], returns false. So pk is not in the middle of choosing number. pi in CS and Number[k] ≠ 0 pi's most recent read of Number[k], returns 0. So pk is in remainder or choosing number. pi's most recent write to Number[i] So pk chooses its number in this interval, sees pi's number, and chooses a larger one (and so it will never enter in CS before pi, which means that its number cannot change before pi exits from the CS, and so the claim is true) Case 1

28. pi in CS and Number[k] ≠ 0 Case 2 pi's most recent read of Number[k] returns (Number[k],k)>(Number[i],i). So pk has already taken its number. So pk chooses a number not less than that of pi in this interval. Observe that it maybe pk finished its choice before than pi, but since (Number[k],k)>(Number[i],i), it must be Number[i]≤Number[k]. Thus, pk will never enter in CS before pi. Indeed, either pk will be stopped by pi in the first wait statement (in case Number[i]=Number[k] but pi is still choosing its number), or in the second one (in case Number[i]<Number[k]), and so the claim is true END of PROOF

29. Mutual Exclusion for BA • Mutual Exclusion: Suppose pi and pk are simultaneously in CS. • By Lemma 1, both have number > 0. • By Lemma 2, • (Number[k],k) > (Number[i],i) and • (Number[i],i) > (Number[k],k) Contradiction!

30. No Lockout for BA • Assume in contradiction there is a starved processor. • Starved processors are stuck at the wait statements, not while choosing a number. • Starved processors can be stuck only at the second wait statement, clearly. • Let pi be a starved processor with smallest (Number[i],i). • Any processor entering entry section after pi has chosen its number, chooses a larger number, and therefore cannot overtake pi • Every processor with a smaller ticket eventually enters CS (not starved) and exits, setting its number to 0. • Thus pi cannot be stuck at the second wait statement forever by another processor. Contradiction!

31. What about bounded waiting? YES: It’s easy to see that any processor in the entry section can be overtaken at most once by any other processor (and so in total it can be overtaken at most n-1 times).

32. Space Complexity of BA • Number of shared variables is 2n • Choosing variables are booleans • Number variables are unbounded: as long as the CS is occupied and some processor enters the entry section, the ticket number increases • Is it possible for an algorithm to use less shared space?

33. Bounded 2-Processor ME Algorithm with ND • Start with a bounded algorithm for 2 processors with ND, then extend to NL, then extend to n processors. • Uses 2 binary shared read/write variables: W[0]: initially 0, written by p0 and read by p1 W[1]: initially 0, written by p1 and read by p0 • Asymmetric code: p0 always has priority over p1

34. Bounded 2-Processor ME Algorithm with ND Code for p0 's entry section: • . • . • W[0] := 1 • . • . • wait until W[1] = 0 Code for p0 's exit section: • . • W[0] := 0

35. Bounded 2-Processor ME Algorithm with ND Code for p1's entry section: • W[1] := 0 • wait until W[0] = 0 • W[1] := 1 • . • if (W[0] = 1) then goto Line 1 • . Code for p1's exit section: • . • W[1] := 0

36. Discussion of 2-Processor ND Algorithm • Satisfies mutual exclusion: processors use W variables to make sure of this (a processor enters only when the other W variable is set to 0) • Satisfies no deadlock • But unfair w.r.t. p1 (lockout) • Fix by having the processors alternate in having the priority

37. Bounded 2-Processor ME Algorithm with NL Uses 3 binary shared read/write variables: • W[0]: initially 0, written by p0 and read by p1 • W[1]: initially 0, written by p1 and read by p0 • Priority: initially 0, written and read by both

38. Bounded 2-Processor ME Algorithm with NL Code for pi’s entry section: • W[i] := 0 • wait until W[1-i] = 0 or Priority = i • W[i] := 1 • if (Priority = 1-i) then • if (W[1-i] = 1) then goto Line 1 • else wait until (W[1-i] = 0) Code for pi’s exit section: • Priority := 1-i • W[i] := 0

39. W[0]=W[1]=1, both procs in CS p1's most recent write of 1 to W[1] (Line 3) p0 's most recent write of 1 to W[0] (Line 3) p0 's most recent read of W[1] before entering CS (Line 5 or 6): must return 1, not 0! Analysis: ME Mutual Exclusion: Suppose in contradiction p0 and p1 are simultaneously in CS. W.l.o.g., assume p1 last write of W before entering CS happens not later than p0last write of W before entering CS Contradiction!

40. Analysis: No-Deadlock • Useful for showing no-lockout. • If one processor ever enters remainder forever, other one cannot be starved. • Ex: If p1 enters remainder forever, then p0 will keep seeing W[1] = 0. • So any deadlock would starve both processors in the entry section

41. p0 not stuck in Line 2, skips Line 5, stuck in Line 6 with W[0]=1 waiting for W[1] to be 0 p1 sent back in Line 5, stuck at Line 2 with W[1]=0, waiting for W[0] to be 0 p0 and p1 stuck in entry Priority=0 p0 sees W[1]=0, enters CS Analysis: No-Deadlock • Suppose in contradiction there is deadlock. • W.l.o.g., suppose Priority gets stuck at 0 after both processors are stuck in their entry sections. Contradiction!

42. p0 stuck at Line 6 with W[0]=1, waiting for W[1] to be 0 p1 enters entry, gets stuck at Line 2, waiting for W[0] to be 0: it cannot reenter in CS! DEADLOCK! p1 at Line 7; Priority=0 forever after p0 stuck in entry Analysis: No-Lockout • Suppose in contradiction p0is starved. • Since there is no deadlock, p1 enters CS infinitely often. • The first time p1 executes Line 7 in exit section after p0 is stuck in entry, Priority gets stuck at 0. Contradiction!

43. Bounded Waiting? • NO: A processor, even if having priority, might be overtaken repeatedly (in principle, an unbounded number of times) when it is in between Line 2 and 3.

44. Bounded n-Processor ME Alg. • Can we get a bounded space NL mutex algorithm for n>2 processors? • Yes! • Based on the notion of a tournament tree: complete binary tree with n-1 nodes • tree is conceptual only! does not represent message passing channels • A copy of the 2-proc. algorithm is associated with each tree node • includes separate copies of the 3 shared variables

45. Tournament Tree 1 2 3 5 6 7 4 p2, p3 p4, p5 p6, p7 p0, p1

46. Tournament Tree ME Algorithm • Each proc. begins entry section at a specific leaf (two procs per leaf) • A proc. proceeds to next level in tree by winning the 2-proc. competition for current tree node: • on left side, play role of p0 • on right side, play role of p1 • When a proc. wins the 2-proc. algorithm associated with the tree root, it enters CS.

47. The code

48. More on Tournament Tree Alg. • Code is recursive • pi begins at tree node 2k + i/2, playing role of pi mod 2, where k = log n -1. • After winning node v, "critical section" for node v is • entry code for all nodes on path from v/2 to root • real critical section • exit code for all nodes on path from root to v/2

49. Tournament Tree Analysis • Correctness: based on correctness of 2-processor algorithm and tournament structure: • ME for tournament alg. follows from ME for 2-proc. alg. at tree root. • NL for tournament alg. follows from NL for the 2-proc. algs. at all nodes of tree • Space Complexity: 3n boolean read/write shared variables. • Bounded Waiting? No, as for the 2-processor algorithm.