1. Mutual Exclusion Using Atomic Registers Lecturer: Netanel Dahan Instructor: Prof. Yehuda Afek B.Sc. Seminar on Distributed Computation Tel-Aviv University 11.03.07 Based on the book ‘Synchronization Algorithms and Concurrent Programming’ by Gadi Taubenfeld

2. Overview Introduction. Algorithms for two processes: Peterson ’ s and Kessels ’ algorithms. Tournament algorithms. Lamport ’ s fast algorithm. Starvation free algorithms: the bakery algorithm and the black-white bakery version. Tight space bounds: lower and upper bounds of shared resources.

3. Introduction

4. The mutual exclusion problem is the guarantee of mutually exclusive access to a shared resource, or resources when there are several competing processes. A situation as described above, where several processes may access the same resource and the final result depends on who runs when, is called a race condition, and the problem is essentially avoiding such conditions. The problem was first introduced by Edsgar W. Dijkstra in 1965. The Mutual Exclusion Problem

5. remainder code entry code critical section exit code The part of the code in which the shared resources reside. Surprise, surprise: the rest of the code. In order to solve the problem, we add the entry and exit code, in a way which guarantees that the mutual exclusion and deadlock freedom properties are satisfied. General Solution

6. Assumptions The remainder code may not influence other processes. Shared objects appearing in the entry or exit code may not be referred to in the remainder or critical section. A process can not fail when not in the remainder. Once a process starts executing the CS and exit code, it always finishes them.

7. Related Concepts Mutual Exclusion: No two processes are in their critical section at the same time. Deadlock Freedom: If a process is trying to enter its critical section, then some process, not necessarily the same one, will eventually enter the critical section. Starvation Freedom: If a process is trying to enter its critical section, eventually it will succeed.

8. Algorithms for two processes

9. We start with describing two algorithms that solve the mutual exclusion problem for two processes. They will be used for introducing the problem and possible solutions using atomic registers. Throughout the presentation, it shall be known that the only atomic operations on shared registers are reads and writes. In addition, we will use the statement await condition as an abbreviation for while !condition do skip. Algorithms for two processes

10. Peterson ’ s Algorithm Developed by Gary L. Peterson in 1981. The algorithm makes use of a register called turn, which can take the values 0 and 1, the identifiers for the two possible processes, and two boolean registers b[0] and b[1]. Both processes can read and write to turn, read b[0] and b[1], but only process i can write to b[i ].

11. Peterson ’ s Algorithm Process 0: 1. b[0] := true; 2. turn := 0; 3. await (b[1] = false or turn = 1) 4. critical section; 5. b[0] := false; Process 1: 1. b[1] := true; 2. turn := 1; 3. await (b[0] = false or turn = 0) 4. critical section; 5. b[1] := false; Initially: b[0] = b[1] = false, turn is immaterial.

12. Peterson ’ s Algorithm Process i: 1. b[i] := true; 2. turn := i; 3. await (b[1-i] = false or turn = 1-i) 4. critical section; 5. b[i] := false; Indicate I am in contention for the critical section. Cross the turn barrier and indicate the crossing for later observation. Check if there is contention. If not, I can go in the CS. Else… Check if I crossed the barrier first. If so I can go in the CS, else I have to wait. Indicate I am not contending anymore. Do my thang…

13. Properties Satisfies mutual exclusion and starvation freedom. Contention-free time complexity is four accesses to the shared memory. Process time complexity is unbounded. Three shared registers are used.

14. Kessels ’ single-writer algorithm A variation of peterson ’ s algorithm which uses single-writer registers. Uses 2 registers, which can take the values 0 and 1, and 2 boolean registers. Developed by J. L. W. Kessels in 1982.

15. Kessels ’ single-writer algorithm Process 0: 1. b[0] := true; 2. local[0] := turn[1]; 3. turn[0] := local[0]; 4. await (b[1] = false or local[0] ≠ turn[1]); 5. critical section; 6. b[0] := false; Process 1: 1. b[1] := true; 2. local[1] := 1 - turn[0]; 3. turn[1] := local[1]; 4. await (b[0] = false or local[1] = turn[0]); 5. critical section; 6. b[1] := false; Initially: b[0] = b[1] = false, turn[0] and turn[1] are immaterial. Only process i can write to b[i] and turn[i]. local[i] is local for process i.

16. Same as Peterson ’ s algorithm, besides the use of 4 shared registers. In addition, satisfies local spinning. Properties ?

17. Local Spinning Accessing a physically remote register is costly. When a process waits, using an await statement, it does so by spinning (busy- waiting) on registers. It is much more efficient to spin on a locally-accessible registers.

18. Kessels ’ single-writer algorithm Process 0: 1. b[0] := true; 2. local[0] := turn[1]; 3. turn[0] := local[0]; 4. await (b[1] = false or local[0] ≠ turn[1]); 5. critical section; 6. b[0] := false; Process 1: 1. b[1] := true; 2. local[1] := 1 - turn[0]; 3. turn[1] := local[1]; 4. await (b[0] = false or local[1] = turn[0]); 5. critical section; 6. b[1] := false; Initially: b[0] = b[1] = false, turn[0] and turn[1] are immaterial. Only process i can write to turn[i]. local[i] is local for process i.

19. Tournament Algorithms

20. A generalization method which enables the construction of an algorithm for n processes from any given solution for 2 processes. Developed by Gary L. Peterson and Michael J. Fischer in 1977.

21. Tournament Algorithms

22. An important side affect is that a process may enter the critical section an arbitrary number of times before some other process in a different subtree.

23. Lamport ’ s Fast Algorithm

24. Lamport ’ s Fast algorithm An algorithm for n processes. Provides fast access to the critical section in the absence of contention. Uses 2 registers which are long enough to store a process ’ identifier, and a boolean registers array. Developed in 1987 by Lamport.

25. Lamport ’ s Fast algorithm Process i ’ s program: 1. start: b[i] := true; 2. x := i; 3. if y ≠ 0 then b[i] := false; 4. await y = 0; 5. goto start fi; 6. y := i; 7. if x ≠ i then b[i] := false; 8. for j := 1 to n do await !b[j] od; 9. if y ≠ i then await y = 0; 10. goto start fi fi; 11. critical section; 12. y := 0; 13. b[i] := false;

26. Indicate contending b[i] := true Indicate contending b[i] := true Barrier y := i Barrier y := i Contention? x  i ? Contention? x  i ? critical section exit code Last to cross the barrier? y = i ? Last to cross the barrier? y = i ? yes Contention? y ≠ 0 ? Contention? y ≠ 0 ? Continue only after it is guaranteed that no one can cross the barrier Continue only after it is guaranteed that no one can cross the barrier no Wait until CS is released yes The last to cross the barrier! no

27. Properties Satisfies mutual exclusion and deadlock freedom. Starvation of individual processes is possible. Fast access: In the absence of contention, only 7 accesses to the shared memory are required. Process time complexity is unbounded. n + 2 shared registers are used.

28. Starvation Free Algorithms

29. In many practical systems, since contention is rare deadlock freedom is a sufficient property. For other systems, it might be a too weak requirement, such as in cases where a process stays a long time in the critical section.

30. The Bakery Algorithm Based on the same policy as in a bakery, where each customer gets a number which is larger then the numbers waiting in line, and the lowest number holder gets served. Assumed to be up to n processes contending to enter the CS. Each process is identified by a unique number from {1 … n}.

31. The Bakery Algorithm The algorithm makes use of a boolean array choosing[1 … n] and an integer array number[1 … n]. Entries choosing[i] and number[i] can be read by all processes but written only by process i. The relation <, is used on pairs of integers and is called the lexicographic order relation. It is defined by (a, b) < (c, d) if a < c or if a = c and b < d.

32. The Bakery Algorithm Initially: all entries in number and choosing are 0 and false respectively. process i ’ s program: 1. chossing[ i ] := true; 2. number[ i ] := 1 + maximum(number[1], …,number[n]); 3. choosing[ i ] := false; 4. for j = 1 to n do 5. await choosing[ j ] = false; 6. await (number[ j ] = 0 or (number[ i ], i) < (number[ j ], j)) 7. od; 8. critical section; 9. number[ i ] := 0;

33. Properties Satisfies mutual exclusion and first- come-first-served. The algorithm is not fast: even in the absence of contention a process is required to access the shared memory 3(n-1) times.

34. Properties Uses 2n shared registers. Non-atomic registers: it is enough to assume that the registers are safe, meaning that writes which are concurrent with reads will return an arbitrary value. The size of number[i] is unbounded.

35. The Bakery Algorithm

36. The Black-White Bakery Algorithm A variant of the bakery algorithm developed by Gadi Taubenfeld in 2004. By using a single additional shared bit the amount of space required is bounded. The shared bit represents a color for the customer ’ s tickets, while the idea is that there is a priority to the holders of a ticket which color is different then the shared bit.

37. The Black-White Bakery Algorithm

38. Tight Space Bounds

39. We show that for n processes, n shared bits are necessary and sufficient for solving the mutual exclusion problem assuming the only atomic operations are reads and writes, and the processes are asynchronous.

40. A Lower Bound Any deadlock free mutual exclusion algorithm for n processes must use at least n shared registers. Proved by James E. Burns and Nancy A. Lynch in 1980.

41. Definitions Event: an action carried by a specific process. x, y and z will denote runs. When x is a prefix of y, (y – x) denotes the suffix of y obtained by removing x.

42. Definitions x; y is an extension of x by y. We always know where (remainder, entry, CS, exit) a process is. If a run involves only process p, then all events in the run involve only process p.

43. Definitions Run x looks like run y to process p. Process p is hidden in run x. Process p covers register r in run x.

44. Illustrations Run x looks like run y to process p. run x p reads 5 from r1 q writes 6 to r1 p writes 7 to r1 q writes 8 to r1 p reads 8 from r1 run y p reads 5 from r1 p writes 7 to r1 q writes 6 to r1 q reads 6 from r1 q writes 8 to r1 p reads 8 from r1 q writes 6 to r1

45. Illustrations Process p is hidden in run x. p reads 5 from r1 q reads 5 from r1 p writes 7 to r1 q writes 8 to r1 p reads 8 from r1 q writes 6 to r1

46. Illustrations Process p covers register r in run x. p writes 7 to r1 q writes 8 to r1 p reads 8 from r1 p writes 2 to r1 p covers r1 at this point

47. Lemma 1 Let x be a run which looks like run y to every process in a set P. if z is an extension of x which involves only processes in P then y ; (z – x) is a run. x y z P events only then, this is also a run

48. Lemma 2 If a process p is in its CS in run z, then p is not hidden in z. z p is in its critical section then, p is not hidden

49. Lemma 3 Let x be a run in which all the processes are hidden. Then, for any process p, there exists a run y which looks like x to p, where all processes except maybe p are in their remainders. Proof: by induction on the number of steps of processes other then p.

50. Lemma 4 Let x be a run where all the processes are hidden. Then, for any process p, there is an extension z of x which involves only p in which p covers some register that is not covered by any other process.

51. Proof From lemma 3, there exists a run y which looks like x to p, where all processes except maybe p are in their remainders. By the deadlock freedom property, starting from y process p is able to enter the CS on its own.

52. Proof By lemma 1, since y looks like x to p, p should be able to do the same starting from x. Suppose p only writes registers covered by other processes before entering the CS.

53. Proof Then, when all covered registers are written one after the other we get a run in which p is hidden and is in its CS. By lemma 2, this is not possible.

54. Main Lemma Let x be a run in which all the processes are in their remainders. Then, for every set of processes P there is an extension z of x which involves only processes in P, in which the processes in P are hidden and cover |P| distinct registers. Proof: by induction on the size of P.

55. An Upper Bound There is a deadlock free mutual exclusion algorithm for n processes which uses n shared bits. As a prove we will see the One-Bit Algorithm developed independently by J. E. Burns (1981) and L. Lamport (1986).

56. The One-Bit Algorithm Up to n processes may be contending to enter the CS, each with a unique identifier from {1 … n}. Uses a boolean array b, where all processes can read all entries, but only process i can write b[i].

57. The One-Bit Algorithm Initially: all entries in b are false. Process i ’ s program: 1. repeat 2. b[i] := true; j := 1; 3. while (b[i] = true) and (j < i) do 4. if b[j] = true then b[i] = false; await b[j] = false fi; 5. j := j + 1; 6. od 7. until b[i] := true; 8. for j := i + 1 to n do await b[j] = false od; 9. critical section; 10. b[i] := false;

58. Properties Satisfies mutual exclusion and deadlock freedom. Starvation of individual processes is possible. Not fast: even in the absence of contention a process needs to access all of the n shared bits.

59. Properties Not symmetrical: a process with a smaller identifier has higher priority. Uses only n shared bits, hence it is space optimal. Non-atomic registers: it is enough to assume that the registers are safe, meaning that writes which are concurrent with reads will return an arbitrary value.

60. Questions ?

61. Thank you for listening…