Mutual exclusion with shared memory
This presentation is the property of its rightful owner.
Sponsored Links
1 / 25

Mutual Exclusion with Shared Memory PowerPoint PPT Presentation


  • 65 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

Mutual Exclusion with Shared Memory

An Image/Link below is provided (as is) to download presentation

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 exclusion with shared memory

Mutual Exclusionwith Shared Memory

Slides by

Prof. Jennifer Welch


Read write shared variables

Read/Write Shared Variables

  • In one atomic step a processor can

    • read the variable or

    • write the variable

    • but not both!


Bakery algorithm

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 algorithm1

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

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


Mutual exclusion case 1

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

Mutual Exclusion Case 1


Mutual exclusion case 2

Mutual Exclusion Case 2

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


Mutual exclusion for bakery algorithm

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!


No lockout for bakery algorithm

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.

Contradiction!


Space complexity of bakery algorithm

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

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

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 nd1

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 nd2

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

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 algorithm1

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


Analysis of bounded 2 processor algorithm

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!

Analysis of Bounded 2-Processor Algorithm

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

Contradiction!


No deadlock for 2 proc alg

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.

    • No deadlock in this case

  • So any deadlock would have to starve both procs.


No deadlock for 2 proc alg1

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

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.

Contradiction!


No lockout for 2 proc alg

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.

Contradiction!


Bounded n processor me alg

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

Tournament Tree

1

2

3

5

6

7

4

p2, p3

p4, p5

p6, p7

p0, p1


Tournament tree me algorithm

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

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

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.


  • Login