1. CSCE 668 DISTRIBUTED ALGORITHMS AND SYSTEMS
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668 DISTRIBUTED ALGORITHMS AND SYSTEMS
CSCE 668
Fall 2011
Prof. Jennifer Welch

2. Read/Write Shared Variables
In one atomic step a processor can
read the variable or
write the variable
but not both!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

3. Bakery Algorithm An algorithm for using 2n shared read/write variables
no lockout
mutual exclusion
using 2n shared read/write variables
booleans Choosing[i] : initially false, written by pi and read by others
integers Number[i] : initially 0, written by pi and read by others
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

4. 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
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

5. Bakery Algorithm Provides Mutual Exclusion
Lemma (4.5): If pi is in the critical section and Number[k] ≠ 0 (k ≠ i), then (Number[k],k) > (Number[i],i).
Proof: Consider two cases:
pi 's most recent
read of Number[k];
Case 1: returns 0
Case 2: (Number[k],k) > (Number[i],i)
pi in CS and
Number[k] ≠ 0
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

6. Mutual Exclusion Case 1 pi 's most recent pi in CS and
write to Number[i]
pi 's most recent
read of Choosing[k],
returns false.
So pk is not in middle
of choosing number.
pi 's most recent
read of Number[k],
returns 0.
So pk is in remainder
or choosing number.
pi in CS and
Number[k] ≠ 0
So pk chooses number in this interval,
sees pi 's number, and chooses a larger one.
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

7. Mutual Exclusion Case 2
Is proved using arguments similar to those for Case 1.
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

8. Mutual Exclusion for Bakery Algorithm
Lemma (4.6): If pi is in the critical section, then Number[i] > 0.
Proof is a straightforward induction.
Mutual Exclusion: Suppose pi and pk are simultaneously in CS.
By Lemma 4.6, both have Number > 0.
By Lemma 4.5,
(Number[k],k) > (Number[i],i) and
(Number[i],i) > (Number[k],k)
Contradiction!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

9. No Lockout for Bakery Algorithm
Assume in contradiction there is a starved processor.
Starved processors are stuck at Line 5 or 6 (wait stmts), not while choosing a number.
Let pi be starved processor with smallest pair (Number[i],i).
Any processor entering entry section after pi has chosen its number chooses a larger number.
Every processor with a smaller number eventually enters CS (not starved) and exits.
Thus pi cannot be stuck at Line 5 or 6.
Contradiction!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

10. Space Complexity of Bakery Algorithm
Number of shared variables is 2n
Choosing variables are boolean
Number variables are unbounded
Is it possible for an algorithm to use less shared space?
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

11. Bounded 2-Processor ME Algorithm
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
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

12. 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.
Some ideas used in 2-processor algorithm:
each processor has a shared boolean W[i] indicating if it wants the CS
p0 always has priority over p1 ; asymmetric code
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

13. 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
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

14. 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:
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

15. Discussion of 2-Processor ND Algorithm
Satisfies mutual exclusion: processors use W variables to make sure of this
Satisfies no deadlock (exercise)
But unfair (lockout)
Fix by having the processors alternate having the priority:
shared variable Priority, read and written by both
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

16. Bounded 2-Processor ME Algorithm
Code for 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 exit section:
Priority := 1-i
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

17. Analysis of Bounded 2-Processor Algorithm
Mutual Exclusion: Suppose in contradiction p0 and p1 are simultaneously 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] (Line 6):
must return 1, not 0!
W[0] = W[1] = 1,
both procs in CS
Contradiction!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

18. No-Deadlock for 2-Proc. Alg.
Useful for showing no-lockout.
If one proc. ever enters remainder for good, other one cannot be starved.
Ex: If p1 enters remainder for good, then p0 will keep seeing W[1] = 0.
So any deadlock would starve both procs.
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

19. No-Deadlock for 2-Proc. Alg.
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.
p0 and p1
stuck in entry,
Priority = 0
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 skips
Line 6, stuck
at Line 2 with
W[1] = 0, waiting
for W[0] to be 0
p0 sees
W[1] = 0,
enters CS
Contradiction!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

20. No-Lockout for 2-Proc. Alg.
Suppose in contradiction p0 is 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.
p0 stuck
in entry
p1 at Line 7;
Priority = 0
forever after
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
Contradiction!
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

21. Bounded n-Processor ME Alg.
Can we get a bounded space mutex algorithm for n larger than 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
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

22. Tournament Tree 1 2 3 5 6 7 4 p0, p1 p2, p3 p4, p5 p6, p7
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

23. 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.
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

24. More on Tournament Tree Alg.
Code in book 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's parent v/2 to root
real critical section
exit code for all nodes on path from root to v/2
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668

25. Tournament Tree Analysis
Correctness: based on correctness of 2-processor algorithm and tournament structure:
projection of an admissible execution of tournament alg. onto a particular tree node gives an admissible execution of 2-proc. alg.
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.
Set 7: Mutual Exclusion with Read/Write Variables
CSCE 668