1 / 53

Distributed Synchronization: outline

Distributed Synchronization: outline. Introduction Causality and time Lamport timestamps Vector timestamps Causal communication Snapshots. This presentation is based on the book: “Distributed operating-systems & algorithms” by Randy Chow and Theodore Johnson. Distributed systems.

grahamdale
Download Presentation

Distributed Synchronization: outline

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. Distributed Synchronization: outline • Introduction • Causality and time • Lamport timestamps • Vector timestamps • Causal communication • Snapshots This presentation is based on the book: “Distributed operating-systems & algorithms” by Randy Chow and Theodore Johnson Operating Systems, 2012, Danny Hendler & Roie Zivan

  2. Distributed systems • A distributed system is a collection of independent computational nodes, communicating over a network, that is abstracted as a single coherent system • Grid computing • Cloud computing (“infrastructure as a service”, “software as a service”) • Peer-to-peer computing • Sensor networks • … • A distributed operating system allows sharing of resources and coordination of distributed computation in a transparent manner (a), (b) – a distributed system(c) – a multiprocessor Operating Systems, 2012, Danny Hendler & Roie Zivan

  3. Distributed synchronization • Underlies distributed operating systems and algorithms • Processes communicate via message passing (no shared memory) • Inter-node coordination in distributed systems challenged by • Lack of global state • Lack of global clock • Communication links may fail • Messages may be delayed or lost • Nodes may fail • Distributed synchronization supports correct coordination in distributed systems • May no longer use shared-memory based locks and semaphores Operating Systems, 2012, Danny Hendler & Roie Zivan

  4. Distributed Synchronization: outline • Introduction • Causality and time • Lamport timestamps • Vector timestamps • Causal communication • Snapshots Operating Systems, 2012, Danny Hendler & Roie Zivan

  5. Distributed computation model • Events • Sending a message • Receiving a message • Timeout, internal interrupt • Processors send control messages to each other • send(destination, action; parameters) • Processes may declare that they are waiting for events: • Wait for A1, A2, …., An A1(source; parameters) code to handle A1 . . An(source; parameters) code to handle An Operating Systems, 2012, Danny Hendler & Roie Zivan

  6. Causality and events ordering • A distributed system has no global state nor global clock  no global order on all events may be determined • Each processor knows total orders on events occurring in it • There is a causal relation between the sending of a message and its receipt Lamport's happened-before relation H e1 <p e2 e1 <H e2(events within same processor are ordered) e1 <m e2 e1 <H e2 (each message m is sent before it is received) e1 <H e2 AND e2 <H e3 e1 <H e3(transitivity) Leslie Lamport (1978): “Time, clocks, and the ordering of events in a distributed system” Operating Systems, 2012, Danny Hendler & Roie Zivan

  7. Causality and events ordering (cont'd) Time P1 P2 P3 e5 e7 e4 e1 e2 e3 e6 e8 Yes. Yes. Yes. e1 <H e7? e1 <H e3? e1 <H e8? No. e5 <H e7? Operating Systems, 2012, Danny Hendler & Roie Zivan

  8. Lamport's timestamp algorithm 1 Initially my_TS=0 2 Upon event e, 3 if e is the receipt of message m 4 my_TS=max(m.TS, my_TS) 5 my_TS++ 6 e.TS=my_TS 7 If e is the sending of message m 8 m.TS=my_TS To create a total order, ties are broken by process ID Operating Systems, 2012, Danny Hendler & Roie Zivan

  9. Lamport's timestamps (cont'd) Time P1 P2 P3 e1 1.1 e7 e4 1.2 e2 e5 2.2 e3 2.1 3.2 e6 1.3 3.1 4.3 e8 Operating Systems, 2012, Danny Hendler & Roie Zivan

  10. Distributed Synchronization: outline • Introduction • Causality and time • Lamport timestamps • Vector timestamps • Causal communication • Snapshots Operating Systems, 2012, Danny Hendler & Roie Zivan

  11. Vector timestamps - motivation • Lamport's timestamps define a total order • e1 <H e2 e1.TS < e2.TS • However, e1.TS < e2.TS  e1 <H e2 does not hold, in general.(concurrent events ordered arbitrarily) • Definition: Message m1casually precedes message m2 (written as m1 <c m2) if • s(m1) <Hs(m2) (sending m1 happens before sending m2) • Definition: causality violation occurs if m1 <c m2 but r(m2) <p r(m1). • In other words, m1 is sent to processor p before m2 but is received after it. • Lamport's timestamps do not allow to detect (hence nor prevent) causality violations. Operating Systems, 2012, Danny Hendler & Roie Zivan

  12. Causality violations – an example P1 P2 P3 Migrate O to P2 Where is O? On p2 M2 Where is O? M1 M3 I don’t know ERROR! Causality violation between… M1 and M3. Operating Systems, 2012, Danny Hendler & Roie Zivan

  13. Vector timestamps • 1 Initially my_VT=[0,…,0] • 2 Upon event e, • 3 if e is the receipt of message m • for i=1 to M • my_VT[i]=max(m.VT[i], my_VT[i]) • My_VT[self]++ • e.VT=my_VT • if e is the sending of message m • m.VT=my_VT • e1.VT ≤V e2.VT if and only if e1.VT[i] ≤ e2.VT[i], for every i=1,…,M • e1.VT <V e2.VT if and only if e1.VT ≤V e2.VT and e1.VT ≠ e2.VT For vector timestamps it does hold that: e1 <VT e2e1 <H e2 Operating Systems, 2012, Danny Hendler & Roie Zivan

  14. An example of a vector timestamp P1 P2 P3 P4 1 1 1 1 2 2 3 2 2 3 3 3 4 4 5 4 5 6 e e.VT=(3,6,4,2) Operating Systems, 2012, Danny Hendler & Roie Zivan

  15. Comparison of vector timestamps P1 P2 P3 P4 1 1 1 1 2 2 3 2 2 3 3 3 4 e3 4 5 4 5 6 e1 e2 e1.VT=(5,4,1,3) e2.VT=(3,6,4,2) e3.VT=(0,0,1,3) Operating Systems, 2012, Danny Hendler & Roie Zivan

  16. VTs can be used to detect causality violations P1 P2 P3 (1,0,0) (0,0,1) Migrate O to P2 Where is O? (2,0,1) On p2 M2 (3,0,2) (3,0,1) Where is O? (3,1,3) M1 M3 (3,0,3) I don’t know (3,2,3) ERROR! (3,2,4) (3,3,3) Causality violation between… M1 and M3. Operating Systems, 2012, Danny Hendler & Roie Zivan

  17. Distributed Synchronization: outline • Introduction • Causality and time • Lamport timestamps • Vector timestamps • Causal communication • Snapshots Operating Systems, 2012, Danny Hendler & Roie Zivan

  18. Preventing causality violations A processor cannot control the order in which it receives messages… But it may control the order in which they are delivered to applications Application Deliver in FIFO order Message arrival order x1 x2 x4 x5 x3 FIFO ordering Assigntimestamps Deliver x1 Deliver x2 Buffer x4 Buffer x5 Deliever x3 x4 x5 Message passing Protocol for FIFO message delivery(as in, e.g., TCP) Operating Systems, 2012, Danny Hendler & Roie Zivan

  19. Preventing causality violations (cont'd) • Senders attach a timestamp to each message • Destination delays the delivery of out-of-order messages • Hold back a message m until we are assured that no message m’ <H m will be delivered • For every other process p, maintain the earliest timestamp of a message m that may be delivered from p • Do not deliver a message if an earlier message may still be delivered from another process Operating Systems, 2012, Danny Hendler & Roie Zivan

  20. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order For each processor p, the earliest timestamp with which a message from p may still be delivered Operating Systems, 2012, Danny Hendler & Roie Zivan

  21. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order For each process p, the messages from p that were received but were not delivered yet Operating Systems, 2012, Danny Hendler & Roie Zivan

  22. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order List of messages to be delivered as a result of m’s receipt Operating Systems, 2012, Danny Hendler & Roie Zivan

  23. If no blocked messages from p, update earliest[p] Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order Operating Systems, 2012, Danny Hendler & Roie Zivan

  24. Algorithm for preventing causality violations m is now the most recent message from p not yet delivered • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order Operating Systems, 2012, Danny Hendler & Roie Zivan

  25. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order If there is a process k with delayed messages for which it is now safe to deliver its earliest message… Operating Systems, 2012, Danny Hendler & Roie Zivan

  26. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order Remove k'th earliest message from blocked queue, make sure it is delivered Operating Systems, 2012, Danny Hendler & Roie Zivan

  27. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order If there are additional blocked messages of k, update earliest[k] to be the timestamp of the earliest such message Operating Systems, 2012, Danny Hendler & Roie Zivan

  28. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order Otherwise the earliest message that may be delivered from k would have previous timestamp with the k'th component incremented Operating Systems, 2012, Danny Hendler & Roie Zivan

  29. Algorithm for preventing causality violations • earliest[1..M] initially [ <1,0,…0>, <0,1,…,0>, …, <0,0,…,1> ] • blocked[1…M] initially [ {}, …, {} ] • Upon the receipt of message m from processor p • Delivery_list = {} • If (blocked[p] is empty) • earliest[p]=m.timestamp • Add m to the tail of blocked[p] • While (k such that blocked[k] is non-empty AND i  {1,…,M} (except k and Self) not_earlier(earliest[i], earliest[k]) • remove the message at the head of blocked[k], put it in delivery_list • if blocked[k] is non-empty • earliest[k]  m'.timestamp, where m' is at the head of blocked[k] • else • increment the k'th element of earliest[k] • End While • Deliver the messages in delivery_list, in causal order Finally, deliver set of messages that will not cause causality violation (if there are any). Operating Systems, 2012, Danny Hendler & Roie Zivan

  30. Execution of the algorithm as multicast p3 state earliest[1] earliest[2] earliest[3] P1 P2 P3 (1,0,0) (0,1,0) (0,0,1) (0,1,0) m1 Upon receipt of m2 m2 (1,1,0) (0,1,0) (0,0,1) (1,1,0) Upon receipt of m1 m2 m2 m1 (1,1,0) (0,1,0) (0,0,1) deliver m1 m2 (1,1,0) (0,2,0) (0,0,1) deliver m2 (2,1,0) (0,2,0) (0,0,1) Since the algorithm is “interested” only in causal order of sending events, vector timestamp is incremented only upon send events. Operating Systems, 2012, Danny Hendler & Roie Zivan

  31. Distributed Synchronization: outline • Introduction • Causality and time • Lamport timestamps • Vector timestamps • Causal communication • Snapshots Operating Systems, 2012, Danny Hendler & Roie Zivan

  32. Snapshots motivation – phantom deadlock • Assume we would like to implement a distributed deadlock-detector • We record process states to check if there is a waits-for-cycle P1 r1 r2 P2 request r1 OK p1 p2 request r2 Observed waits-for graph OK 3 1 2 4 release request r1 OK p1 p2 request r2 Actual waits-for graph Operating Systems, 2012, Danny Hendler & Roie Zivan

  33. What is a snapshot? • Global system state: • S=(s1, s2, …, sM) – local processor states • The contents Li,j=(m1, m2, …, mk) of each communication channel Ci,j(channels assumed to be FIFO)These are messages sent but not yet received • Global state must be consistent • If we observe in state si that pireceived message m from pk, then in observation sk ,k must have sent m. • Each Li,jmust contain exactly the set of messages sent by pibut not yet received by pj, as reflected by si, sj. • Snapshot state much be consistent, one that might have existed during the computation. • Observations must be mutually concurrent that is, no observation casually precedes another observation (a consistent cut) Operating Systems, 2012, Danny Hendler & Roie Zivan

  34. Snapshot algorithm – informal description • Upon joining the algorithm, a process records its local state • The process that initiates the snapshot sends snapshot tokens to its neighbors (before sending any other messages) • Neighbors send them to their neighbors – broadcast • Upon receiving a snapshot token: • a process records its state prior to sending/receiving additional messages • Must then send tokens to all its other neighbors • How shall we record sets Lp,q? • q receives token from p and that is the first time q receives token:Lp,q={ } • q receives token from p but q received token before:Lp,q={all messages received by q from p since q received token} Operating Systems, 2012, Danny Hendler & Roie Zivan

  35. Snapshot algorithm – data structures • The algorithm supports multiple ongoing snapshots – one per process • Different snapshots from same process distinguished by version number The version number of my current snapshot • Per process variables • integer my_version initially 0 • integer current_snap[1..M] initially [0,…,0] • integer tokens_received[1..M] • processor_state S[1…M] • channel_state [1..M][1..M] Operating Systems, 2012, Danny Hendler & Roie Zivan

  36. Snapshot algorithm – data structures • The algorithm supports multiple ongoing snapshots – one per process • Different snapshots from same process distinguished by version number current_snap[r] contains version number of snapshot initiated by processor r • Per process variables • integer my_version initially 0 • integer current_snap[1..M] initially [0,…,0] • integer tokens_received[1..M] • processor_state S[1…M] • channel_state [1..M][1..M] Operating Systems, 2012, Danny Hendler & Roie Zivan

  37. Snapshot algorithm – data structures • The algorithm supports multiple ongoing snapshots – one per process • Different snapshots from same process distinguished by version number tokens_received[r] contains the number of tokens received for the snapshot initiated by processor r • Per process variables • integer my_version initially 0 • integer current_snap[1..M] initially [0,…,0] • integer tokens_received[1..M] • processor_state S[1…M] • channel_state [1..M][1..M] Operating Systems, 2012, Danny Hendler & Roie Zivan

  38. processor_state[r] contains the state recorded for the snapshot of processor r Snapshot algorithm – data structures • The algorithm supports multiple ongoing snapshots – one per process • Different snapshots from same process distinguished by version number • Per process variables • integer my_version initially 0 • integer current_snap[1..M] initially [0,…,0] • integer tokens_received[1..M] • processor_state S[1…M] • channel_state [1..M][1..M] Operating Systems, 2012, Danny Hendler & Roie Zivan

  39. channel_state[r][q] records the state of channel from q to current processor for the snapshot initiated by processor r Snapshot algorithm – data structures • The algorithm supports multiple ongoing snapshots – one per process • Different snapshots from same process distinguished by version number • Per process variables • integer my_version initially 0 • integer current_snap[1..M] initially [0,…,0] • integer tokens_received[1..M] • processor_state S[1…M] • channel_state [1..M][1..M] Operating Systems, 2012, Danny Hendler & Roie Zivan

  40. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Operating Systems, 2012, Danny Hendler & Roie Zivan

  41. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Operating Systems, 2012, Danny Hendler & Roie Zivan

  42. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Increment version number of this snapshot, record my local state Operating Systems, 2012, Danny Hendler & Roie Zivan

  43. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Send snapshot-token on all outgoing channels, initialize number of received tokens for my snapshot to 0 Operating Systems, 2012, Danny Hendler & Roie Zivan

  44. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Upon receipt from q of TOKEN for snapshot (r,version) Operating Systems, 2012, Danny Hendler & Roie Zivan

  45. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished If this is first token for snapshot (r,version) Operating Systems, 2012, Danny Hendler & Roie Zivan

  46. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Record local state for r'th snapshotUpdate version number of r'th snapshot Operating Systems, 2012, Danny Hendler & Roie Zivan

  47. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Set of messages on channel from q is empty Send token on all outgoing channels Initialize number of received tokens to 1 Operating Systems, 2012, Danny Hendler & Roie Zivan

  48. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Not the first token for (r,version) Operating Systems, 2012, Danny Hendler & Roie Zivan

  49. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished Yet another token for snapshot (r,version) Operating Systems, 2012, Danny Hendler & Roie Zivan

  50. Snapshot algorithm – pseudo-code • execute_snapshot() • Wait for a snapshot request or a token • Snapshot request: • my_version++, current_snap[self]=my_version • S[self]  my_state • for each outgoing channel q, send(q, TOEKEN; self, my_version) • tokens_received[self]=0 • TOKEN(q; r,version): • If current_snap[r] < version • S[r]  my state • current_snap[r]=version • L[r][q]  empty, send token(r, version) on each outgoing channel • tokens_received[r]  1 • else • tokens_received[r]++ • L[r][q]  all messages received from q since first receiving token(r,version) • if tokens_received = #incoming channels, local snapshot for (r,version) is finished These messages are the state of the channel from q for snapshot (r,version) Operating Systems, 2012, Danny Hendler & Roie Zivan

More Related