Snapshot Protocols. Angel Alvarez. January 17, 2012

Size: px

Start display at page:

Download "Snapshot Protocols. Angel Alvarez. January 17, 2012"

Madison Miller
6 years ago
Views:

1 Angel Alvarez January 17, 2012

2 1 We have seen how to monitor a distributed computation in a passive manner We have also seen how to do active monitoring, and an instance of an inconsistent observation Now we will present an algorithm due to Chandy and Lamport that constructs only consistent observations in an active manner, also called snapshots (because it is like taking a picture of the computation)

3 (Cont.) 2 (Cont.) We will start assuming first that the system is synchronous, and then gradually relax the synchronous assumptions to obtain an asynchronous algorithm Now we will explicitly consider the state of the (unidirectional) communication channels, i.e. the messages in the pipe at the time of the snapshot, as well as the states of the processes It is just a mere convenience for the state of the channels can be always encoded as part of the processes state if so desired

4 (Cont.) 3 (Cont.) Let us first assume that there is a real time global clock, that channels implement FIFO communication, and that messages transmission delays and processor speeds are bounded The system is further assumed to be strongly connected although not necessarily fully connected For every process p i, let IN i be the set of processes p j from which p i has incoming channels and OUT i be the set of processes to which p i has outgoing channels Apart from the processor states σ i, the protocol will construct also channels states χ j,i for every incoming channel from p j IN i to p i

5 (Cont.) 4 (Cont.) The first snapshot protocol will have all processes record their states at the same real time. To facilitate the recording of channel states it is assumed that messages carry as a timestamp the time at which they were sent Let one of the processes, call it p 0, be the one who starts the protocol

6 (Cont.) 5 (Cont.) 1. Process p 0 picks a time t ss far enough in the future and sends a message to all the processes requesting them to record their state at time t ss 2. When time t ss arrives, each process p i : Records its local state Issues an empty message along each of its outgoing channels Sets χ j,i to empty for each of its incoming channels All this is done interrupting the underlying computation 3. When the first message from p j IN i with timestamp t ss arrives, p i closes χ j,i

7 (Cont.) 6 (Cont.) The global state constructed this way did in fact occur (precisely at time t ss... only that we do not have a real time clock!) The empty messages at step 2 serve to guarantee liveness Because C ss, the cut associated with the global state constructed, includes all events e such that RC(e) < t ss, and (e e) (RC(e ) < RC(e)), it follows that e C ss and (e e) e C ss That is, the clock condition is what makes the global state consistent And we know that logical clocks also satisfy the clock condition...

8 (Cont.) 7 (Cont.) There are two more properties of synchronous systems that need to be supplied: 1. when LC = t do S does not make sense now... To solve the problem we just need to look ahead 2. we need to assume there is a integer value ω large enough that no logical clock can reach it With these considerations we can repeat the former algorithm just replacing t ss by ω and making p 0 set its own logical clock to ω right after sending the take snapshot at ω messages to all processes

9 Chandy and Lamport Snapshot Protocol 8 Chandy and Lamport Snapshot Protocol We can observe that ω actually fits no purpose A process does nothing from the time it gets the take snapshot message at time ω until it receives the first empty message that causes its clock to pass through ω We can then do away with ω and have a process record its state the first time it receives an empty message Better to call it now take snapshot message This way we do not need to have timestamps in the messages and so we remove the last reference to time and clocks

10 Chandy and Lamport Snapshot Protocol (Cont.) 9 Chandy and Lamport Snapshot Protocol (Cont.) 1. Process p 0 starts the protocol by sending itself a take snapshot message 2. When a process p i gets its first take snapshot message from process p j : Records its local state Issues a take snapshot message along each of its outgoing channels Declares χ j,i to empty Sets χ k,i to empty for each of its other incoming channels All this is done interrupting the underlying computation 3. When a take snapshot message from p k IN i (k j) arrives, p i closes χ k,i

A subtle problem. An obvious problem. An obvious problem. An obvious problem. t ss

A subtle problem. An obvious problem. An obvious problem. An obvious problem. t ss A subtle problem An obvious problem when LC = t do S doesn t make sense for Lamport clocks! there is no guarantee that LC will ever be t S is anyway executed after LC = t Fixes: if e is internal/send and