1 / 25

CPSC 668 Distributed Algorithms and Systems

This document explores the bakery algorithm for mutual exclusion using shared read/write variables, designed to prevent lockouts and ensure fair access among multiple processors. It outlines the algorithm components, including the Choosing and Number arrays, crucial for ensuring mutual exclusion. Additionally, it discusses the bounded mutual exclusion algorithm tailored for two processors, ensuring fair resource allocation through priority management. Key concepts such as the critical section, space complexity, and possible improvements are also examined, making this a comprehensive guide to mutual exclusion algorithms.

dylan-shepard
Télécharger la présentation

CPSC 668 Distributed Algorithms and Systems

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. CPSC 668Distributed Algorithms and Systems Spring 2008 Prof. Jennifer Welch Set 7: Mutual Exclusion with Read/Write Variables

  2. Read/Write Shared Variables • In one atomic step a processor can • read the variable or • write the variable • but not both! Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  6. pi 's most recent read of Choosing[k], returns false. So pk is not in middle of choosing number. 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 Set 7: Mutual Exclusion with Read/Write Variables

  7. Mutual Exclusion Case 2 • Is proved using arguments similar to those for Case 1. Set 7: Mutual Exclusion with Read/Write Variables

  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! Set 7: Mutual Exclusion with Read/Write Variables

  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! Set 7: Mutual Exclusion with Read/Write Variables

  10. 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? Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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! Set 7: Mutual Exclusion with Read/Write Variables

  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. • So any deadlock would starve both procs. Set 7: Mutual Exclusion with Read/Write Variables

  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 skips 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! Set 7: Mutual Exclusion with Read/Write Variables

  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! Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  22. Tournament Tree 1 2 3 5 6 7 4 p2, p3 p4, p5 p6, p7 p0, p1 Set 7: Mutual Exclusion with Read/Write Variables

  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. Set 7: Mutual Exclusion with Read/Write Variables

  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 Set 7: Mutual Exclusion with Read/Write Variables

  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. Set 7: Mutual Exclusion with Read/Write Variables

More Related