1 / 25

Mutual Exclusion with Shared Memory

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Mutual Exclusionwith Shared Memory Slides by 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!

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

  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

  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

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

  7. Mutual Exclusion Case 2 • Is proved using arguments similar to those for Case 1.

  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!

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

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

  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

  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

  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

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

  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

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

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

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

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

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

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

  22. Tournament Tree 1 2 3 5 6 7 4 p2, p3 p4, p5 p6, p7 p0, p1

  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.

  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

  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.

More Related