1 / 21

Token-passing Algorithms for mutual exclusion

Suzuki-Kasami algorithm The Main idea Completely connected network of processes There is one token in the network. The holder of the token has the permission to enter CS.

stamos
Download Presentation

Token-passing Algorithms for mutual exclusion

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. Suzuki-Kasami algorithm The Main idea Completely connected network of processes There is one token in the network. The holder of the token has the permission to enter CS. Any other process trying to enter CS must acquire that token. Thus the token will move from one process to another based on demand. Token-passing Algorithms for mutual exclusion I want to enter CS I want to enter CS

  2. Process i broadcasts (i, num) Each process maintains -an array req: req[j] denotes the sequence no of the latest request from process j (Some requests will be stale soon) Additionally, the holder of the token maintains -an array last: last[j] denotes the sequence number of the latest visit to CS from for process j. - a queueQ of waiting processes Suzuki-Kasami Algorithm req last req Sequence number of the request queue Q req req req req: array[0..n-1] of integer last: array [0..n-1] of integer

  3. When a process i receives a request (k, num) from process k, it sets req[k] to max(req[k], num). The holder of the token --Completes its CS --Sets last[i]:= its own num --Updates Q by retaining each process k only if 1+last[k] = req[k] (This guarantees the freshness of the request) --Sends the token to the head of Q, along with the array last and the tail of Q In fact, token  (Q, last) Suzuki-Kasami Algorithm Req: array[0..n-1] of integer Last: Array [0..n-1] of integer

  4. Suzuki-Kasami’s algorithm {Program of process j} Initially, i: req[i] = last[i] = 0 * Entry protocol * req[j] := req[j] + 1 Send (j, req[j]) to all Wait until token (Q, last) arrives Critical Section * Exit protocol * last[j] := req[j] k ≠ j: k  Q  req[k] = last[k] + 1  append k to Q; if Q is not empty  send (tail-of-Q, last) to head-of-Q fi * Upon receiving a request (k, num) * req[k] := max(req[k], num)

  5. Example req=[1,0,0,0,0] req=[1,0,0,0,0] last=[0,0,0,0,0] 1 0 2 req=[1,0,0,0,0] 4 req=[1,0,0,0,0] 3 req=[1,0,0,0,0] initial state: process 0 has sent a request to all, and grabbed the token

  6. Example req=[1,1,1,0,0] req=[1,1,1,0,0] last=[0,0,0,0,0] 1 0 2 req=[1,1,1,0,0] 4 req=[1,1,1,0,0] 3 req=[1,1,1,0,0] 1 & 2 send requests to enter CS

  7. Example req=[1,1,1,0,0] req=[1,1,1,0,0] last=[1,0,0,0,0] Q=(1,2) 1 0 2 req=[1,1,1,0,0] 4 req=[1,1,1,0,0] 3 req=[1,1,1,0,0] 0 prepares to exit CS

  8. Example req=[1,1,1,0,0] last=[1,0,0,0,0] Q=(2) req=[1,1,1,0,0] 1 0 2 req=[1,1,1,0,0] 4 req=[1,1,1,0,0] 3 req=[1,1,1,0,0] 0 passes token (Q and last) to 1

  9. Example req=[2,1,1,1,0] last=[1,0,0,0,0] Q=(2,0,3) req=[2,1,1,1,0] 1 0 2 req=[2,1,1,1,0] 4 req=[2,1,1,1,0] 3 req=[2,1,1,1,0] 0 and 3 send requests

  10. Example req=[2,1,1,1,0] req=[2,1,1,1,0] 1 0 2 req=[2,1,1,1,0] last=[1,1,0,0,0] Q=(0,3) 4 req=[2,1,1,1,0] 3 req=[2,1,1,1,0] 1 sends token to 2

  11. Raymond’s tree-based algorithm 1 4 1 4,7 1,4 1,4,7 want to enter their CS

  12. Raymond’s Algorithm 1 4 1,4 4,7 2 sends the token to 6

  13. Raymond’s Algorithm 4 4 These two directed edges will reverse their direction 4 4,7 6 forwards the token to 1 The message complexity is O(diameter) of the tree. Extensive empirical measurements show that the average diameter of randomly chosen trees of size n is O(log n). Therefore, the authors claim that the average message complexity is O(log n)

  14. Distributed Snapshot

  15. -- How many messages are in transit on the internet? -- What is the global state of a distributed system of N processes? How do we compute these? Distributed snapshot

  16. -- How many messages are in transit on the internet? -- What is the global state of a distributed system of N processes? How do we compute these? Think about these

  17. One-dollarbank Let a $1 coin circulate in a network of a million banks. How can someone count the total $ in circulation? If not counted “properly,” then one may think the total $ in circulation to be one million.

  18. Major uses in - deadlock detection - termination detection - rollback recovery - global predicate computation Importance of snapshots

  19. (aconsistent cutC)  (b happened before a) b  C If this is not true, then the cut is inconsistent Consistent cut A cut is a set of events. b g time c a d P1 e m f P2 P3 k h i j Cut 1 Cut 2 (Not consistent) (Consistent)

  20. Consistent snapshot The set of states immediately following the events (actions) in a consistent cut forms a consistent snapshot of a distributed system. • A snapshot that is of practical interest is the most recent one. Let C1 and C2 be two consistent cuts and C1C2. Then C2 is more recent than C1. • Analyze why certain cuts in the one-dollar bank are inconsistent.

  21. Consistent snapshot How to record a consistent snapshot? Note that 1. The recording must be non-invasive. 2. Recording must be done on-the-fly. You cannot stop the system.

More Related