cpsc 668set 7: mutual exclusion with read/write variables1 cpsc 668 distributed algorithms and...

CPSC 668 Set 7: Mutual Exclusion with Read/Write Variables 1

CPSC 668Distributed Algorithms and Systems

Fall 2009

Prof. Jennifer Welch


Read/Write Shared Variables

• In one atomic step a processor can– read the variable or– write the variable– but not both!


Bakery Algorithm

• An algorithm for– 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


Bakery AlgorithmCode for entry section:

Choosing[i] := trueNumber[i] := max{Number[0], …,

Number[n-1]} + 1Choosing[i] := falsefor j := 0 to n-1 (except i) do

wait until Choosing[j] = falsewait until Number[j] = 0 or (Number[j],j) > (Number[i],i)

endfor

Code for exit section:Number[i] := 0


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 in CS andNumber[k] ≠ 0

pi 's most recentread of Number[k];Case 1: returns 0Case 2: (Number[k],k) > (Number[i],i)


Mutual Exclusion Case 1

pi in CS andNumber[k] ≠ 0

pi 's most recentread of Number[k],returns 0.So pk is in remainderor choosing number.

pi 's most recentread of Choosing[k],returns false.So pk is not in middleof choosing number.

pi 's most recentwrite to Number[i]

So pk chooses number in this interval,sees pi 's number, and chooses a larger one.


Mutual Exclusion Case 2

• Is proved using arguments similar to those for Case 1.


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)


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

(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.


Space Complexity of Bakery Algorithm

• Number of shared variables is 2n• Choosing variables are variable• Number variables are unbounded

• Is it possible for an algorithm to use less shared space?


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


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


Bounded 2-Processor ME Algorithm with NDCode for p0 's entry section:

1 .2 .3 W[0] := 14 .5 .6 wait until W[1] = 0

Code for p0 's exit section:7 .8 W[0] := 0


Bounded 2-Processor ME Algorithm with NDCode for p1 's entry section:

1 W[1] := 02 wait until W[0] = 03 W[1] := 14 .5 if (W[0] = 1) then goto Line 16 .

Code for p1 's exit section:7 .8 W[1] := 0


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


Bounded 2-Processor ME Algorithm

Code for entry section:1 W[i] := 02 wait until W[1-i] = 0 or Priority = i3 W[i] := 14 if (Priority = 1-i) then5 if (W[1-i] = 1) then goto Line 16 else wait until (W[1-i] = 0)

Code for exit section:7 Priority := 1-i8 W[i] := 0


Analysis of Bounded 2-Processor Algorithm• Mutual Exclusion: Suppose in contradiction

p0 and p1 are simultaneously in CS.

W[0] = W[1] = 1,both procs in CS

p1 's mostrecent writeof 1 to W[1](Line 3)

p0 's mostrecent writeof 1 to W[0](Line 3)

p0 's most recentread of W[1] (Line 6):must return 1, not 0!


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.


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 stuckin Line 2, skipsline 5, stuck in Line 6 with W[0] = 1waiting forW[1] to be 0

p0 seesW[1] = 0,enters CS

p1 skipsLine 6, stuckat Line 2 withW[1] = 0, waitingfor W[0] to be 0


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.

p1 at Line 7;Priority = 0forever after

p0 stuckin entry

p0 stuck atLine 6 withW[0] = 1, waitingfor W[1] to be 0

p1 entersentry, getsstuck atLine 2, waitingfor W[0] to be 0


Bounded n-Processor ME Alg.

• Can we get a bounded space 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


Tournament Tree

1

2 3

4 5 6 7

p0, p1 p2, p3 p4, p5 p6, p7


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.


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


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.

cpsc 668set 7: mutual exclusion with read/write variables1 cpsc 668 distributed algorithms and...

Documents