Loading in 5 sec....

Mutual Exclusion with Shared MemoryPowerPoint Presentation

Mutual Exclusion with Shared Memory

- 83 Views
- Uploaded on
- Presentation posted in: General

Mutual Exclusion with Shared Memory

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

Mutual Exclusionwith Shared Memory

Slides by

Prof. Jennifer Welch

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

- 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

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

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

- pi 's most recent
- read of Choosing[k],
- 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

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 number in this interval,

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

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

- 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!

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

Contradiction!

- 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?

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

- 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

Code for p0 's entry section:

- .
- .
- W[0] := 1
- .
- .
- wait until W[1] = 0
Code for p0 's exit section:

- .
- W[0] := 0

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

- 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

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

read of W[1] (Line 6):

must return 1, not 0!

- Mutual Exclusion: Suppose in contradiction p0 and p1 are simultaneously in CS.

Contradiction!

- 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

- 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!

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

- 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!

- 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

1

2

3

5

6

7

4

p2, p3

p4, p5

p6, p7

p0, p1

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

- 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

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