Mutual Exclusion with Shared Memory

1 / 25

# Mutual Exclusion with Shared Memory - PowerPoint PPT Presentation

Mutual Exclusion with Shared Memory. Slides by 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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' Mutual Exclusion with Shared Memory' - charity-haney

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Mutual Exclusionwith Shared Memory

Slides by

Prof. Jennifer Welch

• In one atomic step a processor can
• 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 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

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

Case 1: returns 0

Case 2: (Number[k],k) > (Number[i],i)

pi in CS and

Number[k] ≠ 0

pi \'s most recent

• returns false.
• k reads Number[i]only after pi wroteNumber [i]
• (Number[i],i)<(Number[k],k)

piin CS and

Number[k] ≠ 0

pi \'s most recent

returns 0.

So pk is in remainder

or choosing number.

pi \'s most recent

write to Number[i]

So pk chooses number in this interval,

sees pi \'s number, and chooses a larger one.

Mutual Exclusion Case 1
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 binary
• 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 ND

Code for p0 \'s entry section:

• .
• .
• W[0] := 1
• .
• .
• wait until W[1] = 0

Code for p0 \'s exit section:

• .
• W[0] := 0
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
Discussion of 2-Processor ND Algorithm
• Satisfies mutual exclusion: processors use W variables to make sure of this
• 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:

• 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
• W[i] := 0

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

must return 1, not 0!

Analysis of Bounded 2-Processor Algorithm
• Mutual Exclusion: Suppose in contradiction p0 and p1 are simultaneously in CS.

• 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.
• No deadlock in this case
• So any deadlock would have to starve both procs.

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 does not reach

Line 6, 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

• W.l.o.g., suppose Priority gets stuck at 0 after both processors are stuck in their entry sections.

p1 enters

entry, gets

stuck at

Line 2, waiting

for W[0] to

be 0

p0 stuck at

Line 6 with

W[0] = 1, waiting

for W[1] to be 0

p1 at Line 7;

Priority = 0

forever after

p0 stuck

in entry

No-Lockout for 2-Proc. Alg.
• 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.

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

5

6

7

4

p2, p3

p4, p5

p6, p7

p0, p1

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.