Intuition

We can't freeze time across a distributed system to take a snapshot. Instead, each process records its own local state independently, and the algorithm records the in-transit messages on each channel such that the combined picture is one the system *could have been in* in an equivalent execution — even if it wasn't actually in that exact state at any single instant. The channel-type assumption (FIFO / non-FIFO / causal) determines which algorithm applies.

Explanation

Why is recording a snapshot hard? No global clock to coordinate; can't stop the system; messages are in transit on channels. Naive 'everyone record now' fails because clocks differ.

Cut. A *cut* is a set of local states, one per process. A cut is consistent iff for every message $m$ recorded as received in the cut, $\text{send}(m)$ is also recorded in the cut. (No 'ghost' receives — no effect without its cause.) Equivalently: no message arrow goes future → past.

C1 and C2 conditions (formal definition of consistent global state). C1: send recorded ⇒ msg in channel state XOR msg recorded as received (conservation — no message lost). C2: send NOT recorded ⇒ msg NOT in channel state AND NOT recorded as received (cause-before-effect — no premature receives).

Banking trap example. Suppose three banks. P1 records its state $1000at$t_0$.P2recordsat$t_2$—bywhichtimeithasreceived$400 from P1. P1 also has a $150transferinflighton$C_{12}$.IfwerecordC12=$150$andC21=$100$(inflight):total$1000 + (\text{$300+$400}) + $200+$150 + $100=$2150$.Butthesystemstartedwith$2500$.\ast \ast Inconsistent\ast \ast —w{e}^{\prime }vecountedthe$400 transfer's receive without its send.

Chandy-Lamport algorithm — FIFO channels. Assumes FIFO. Uses a special marker message that separates pre- from post-snapshot messages. Initiator: record own state; send MARKER on every outgoing channel before any other message. **On receiving MARKER on channel $C$ from $P_j$: (a) First marker received** by this process → record own state; record channel $C$ state as $\varnothing$; send MARKER on all outgoing channels; start recording on all *other* incoming channels. (b) Already recorded → stop recording $C$; channel $C$ state = messages received on $C$ between when state was recorded and this marker arrived.

Why FIFO? Messages sent BEFORE the marker on a channel must arrive before the marker (and be counted as channel state); messages sent AFTER the marker must NOT be counted. FIFO guarantees that anything arriving after the marker on $C$ is logically post-snapshot. Without FIFO, a post-snapshot message could overtake the marker and be wrongly included.

Chandy-Lamport termination. Algorithm terminates when each process has received a MARKER on *every* incoming channel. At that point every process has a recorded local snapshot and channel states for all its inbound channels.

Chandy-Lamport complexity. Messages: $O(|E|)$ — one marker per channel direction. Time: $O(d)$ where $d$ = diameter of the network.

Lai-Yang algorithm — non-FIFO channels. Uses message colouring instead of markers. Every process initially white; turns red when it records its state. Rule: every white process records its snapshot at its convenience but no later than receiving the first red message. Every white process records the history of all white messages sent or received. Channel state $C_{ij}=\{\text{white msgs received by }{P}_j\text{ after recording}\}\setminus \{\text{white msgs sent by }{P}_i\text{ before recording}\}$. Computed from histories.

Lai-Yang trade-off. Works on non-FIFO channels — useful when underlying network is unordered. Cost: heavy storage — each process keeps a complete history of white message traffic until snapshot completes.

Acharya-Badrinath algorithm — causal channels. Assumes causal delivery (stronger than FIFO). Each $P_i$ maintains $SEN{T}_i[\mathrm{1..}N]$ = count of msgs sent to each $P_j$, and $REC{D}_i[\mathrm{1..}N]$ = count of msgs received from each $P_j$. Protocol: initiator broadcasts a token (including to self). Each $P_i$ on receiving the token records local snapshot + sends $SEN{T}_i,REC{D}_i$ to initiator. Initiator computes channel state from $P_i$ to $P_j$ as messages indexed $\{REC{D}_j[i]+1,\dots ,SEN{T}_i[j]\}$. Complexity: $2N$ messages (token + reply per process).

Algorithm comparison. Chandy-Lamport — FIFO required, $O(|E|)$ msgs, no extra storage. Lai-Yang — non-FIFO OK, $O(|E|)$ msgs, heavy history storage. Acharya-Badrinath — causal required, $2N$ msgs (light), small SENT/RECD counters.

Correctness intuition. The recorded snapshot is a *consistent global state* — one the system *could* have been in if some events were reordered (the events themselves are unchanged; only their position relative to the snapshot moves). The snapshot may not be a state the system was actually in at any wall-clock instant, but it is indistinguishable from one.

Definitions

• Global snapshot — A recorded state of all processes plus the messages in flight on all channels, captured without stopping the system.
• Consistent cut — A cut where every recorded receive has its corresponding send also recorded. Equivalently, no message arrow goes future → past.
• C1 condition — Send recorded ⇒ msg is either in channel state OR recorded as received (not both, not neither). Conservation of messages.
• C2 condition — Send NOT recorded ⇒ msg NOT in channel state AND NOT recorded as received. Cause-before-effect.
• Marker (Chandy-Lamport) — Special control message that separates pre-snapshot from post-snapshot messages on a FIFO channel. First marker on a channel triggers recording; subsequent markers stop it.
• White/Red colouring (Lai-Yang) — Process colour state: white = pre-snapshot, red = post-snapshot. A red message forces the receiver to finalise its own snapshot. Used when channels are non-FIFO.
• SENT / RECD arrays (Acharya-Badrinath) — Per-process counters of messages sent to / received from each other process. Channel state derived as messages numbered between sent and received counts.

Formulas

• $$\text{C1:}\text{send recorded}\Rightarrow \text{msg in channel state}\oplus \text{msg received}$$
• $$\text{C2:}\text{send NOT recorded}\Rightarrow \text{msg NOT in channel}\wedge \text{NOT received}$$
• $$\text{Acharya-Badrinath channel:}{C}_{ij}=\{m_k:REC{D}_j[i]<k\le SEN{T}_i[j]\}$$
• $$\text{Chandy-Lamport msgs:}O(|E|);\text{time}O(d)$$
• $$\text{Acharya-Badrinath msgs:}2N\text{(token + reply)}$$

Derivations

Why Chandy-Lamport produces a consistent cut. Consider any message $m$ in the recorded state. If $m$ is recorded in the channel state, then by the marker rules $m$ arrived after $P_i$'s state record but before its outgoing marker — so $\text{send}(m)$ was before $P_i$'s state record (in $P_i$'s snapshot). If $m$ is recorded as 'received' in $P_j$'s state, then by FIFO, $m$ preceded $P_i$'s marker on that channel — so $\text{send}(m)$ was before $P_i$'s state record. In both cases the send is in the snapshot ⇒ C1 holds. Similar argument gives C2.

Banking inconsistent cut. $P_1$ records at $t_0$: $1000$. $P_2$ at $t_2$: $300+400$ (already received the $400$ from $P_1$) $=700$. $P_3$ at $t_2$: $200$. Suppose at $t_0$, $P_1$ had sent a $150$ to $P_2$ in flight, recorded in $C_{12}$. And $C_{21}$ has $100$ in flight. Total = $1000+700+200+150+100=2150\ne 2500$ (true total). The $400$ transfer's send is BEFORE $P_1$'s snapshot but its receive is AFTER $P_2$'s snapshot — sent in past, received in future — inconsistent cut (a 'ghost receive' but inverse: an 'invisible send').

Examples

• Chandy-Lamport 3-process banking trace. $P_1,P_2,P_3$ with FIFO channels. $P_1$ records first, sends markers on $C_{12},C_{13}$. $P_2$ receives marker on $C_{12}$ first: records its state, $C_{12}=\varnothing$, sends markers on $C_{21},C_{23}$. Suppose $P_2$ had already sent $$50$ on $C_{23}$ before this. $P_3$ receives marker on $C_{13}$ first: records, $C_{13}=\varnothing$. Then $P_3$ receives the $$50$ on $C_{23}$ (still before $P_2$'s marker on $C_{23}$, by FIFO) — records as channel state. When marker on $C_{23}$ arrives, stops recording. Result includes the $$50$ → total preserved.
• Acharya-Badrinath channel-state computation. Initiator collects: $P_1$ has $SEN{T}_1[2]=5,REC{D}_1[2]=3$; $P_2$ has $SEN{T}_2[1]=3,REC{D}_2[1]=4$. Channel state $C_{1\to 2}$ = msgs indexed $\{REC{D}_2[1]+1,\dots ,SEN{T}_1[2]\}=\{5\}$ — one message in transit. Channel state $C_{2\to 1}$ = $\{REC{D}_1[2]+1,\dots ,SEN{T}_2[1]\}=\{4\}$ — wait, $REC{D}_1[2]=3$ and $SEN{T}_2[1]=3$, so $\{4,\dots ,3\}=\varnothing$ (empty). Reading order matters.
• Lai-Yang colouring. $P_1$ goes red; sends a colored message to $P_2$. $P_2$, seeing a red message arrive, must finalize its own snapshot before processing — its own state must already be recorded (or recorded now). Histories of white messages give the channel states.

Diagrams

• Chandy-Lamport marker flow on 3 processes: $P_1$ initiates, sends markers on outgoing channels; each receiver applies first-vs-later marker rules; channels record in-flight messages.
• Consistent vs inconsistent cut: two timelines for $P_1$ and $P_2$ with arrows for messages; consistent cut has all arrows going past → future across the cut; inconsistent has at least one going future → past.
• Lai-Yang colour transitions: events as white/red dots; red messages crossing the cut force receiver's snapshot.
• Algorithm comparison table: rows = Chandy-Lamport / Lai-Yang / Acharya-Badrinath; cols = channel assumption, messages, extra storage, complexity.

Edge cases

• Chandy-Lamport without FIFO breaks: a post-snapshot message can overtake the marker and be wrongly counted.
• Multiple concurrent initiators in Chandy-Lamport: each initiator runs its own snapshot; markers can collide; multiple snapshots are recorded; pick one or merge.
• Acharya-Badrinath with non-causal channels breaks: $REC{D}_j[i]+1,\dots ,SEN{T}_i[j]$ assumes monotonic counter delivery.
• Lai-Yang heavy storage — for long-running snapshots, history can grow unboundedly. Snapshot must complete promptly.
• Initiator failure during snapshot leaves the system without an aggregator. Recovery: re-run; some algorithms tolerate this with re-snapshot.

Common mistakes

• Saying 'a snapshot captures the exact state at one instant'. No — it captures a *consistent* state the system COULD have been in, not necessarily the actual instantaneous state.
• Chandy-Lamport without stating FIFO. Always state the channel assumption — it's typically a 1-mark sub-part.
• Forgetting that the initiator records its own state first in Chandy-Lamport (before sending markers).
• Confusing C1 and C2. C1: send recorded ⇒ msg present (in channel OR received). C2: send NOT recorded ⇒ msg absent.
• Lai-Yang on FIFO channels. Inefficient — Chandy-Lamport is lighter. Lai-Yang's value is non-FIFO support.

Shortcuts

• Chandy-Lamport: FIFO, markers, $O(|E|)$ msgs, $O(d)$ time.
• Lai-Yang: non-FIFO, white/red colouring, heavy history.
• Acharya-Badrinath: causal, $2N$ msgs, SENT/RECD counters.
• Consistent cut: no message arrow goes future → past.
• C1 (conservation), C2 (cause-effect).
• Banking trap: if total ≠ initial total, cut is inconsistent.

Proofs / Algorithms

C1 from Chandy-Lamport. Suppose $\text{send}(m)$ is recorded in $P_i$'s snapshot. Two subcases. (a) $m$ is delivered to $P_j$ before $P_j$ records its state — then $m$ is in $P_j$'s state ('received'). (b) $m$ is delivered after $P_j$'s state record but before the marker on the channel — then by the algorithm $m$ is recorded as channel state. In either case the message is accounted for ⇒ C1 holds.

C2 from Chandy-Lamport (FIFO-dependent). Suppose $\text{send}(m)$ is NOT recorded — meaning $\text{send}(m)$ happened after $P_i$'s state record. By the algorithm, $P_i$'s marker was sent before any other message on that channel (after recording). By FIFO, $m$ arrives at $P_j$ AFTER the marker. So $P_j$ has either already stopped recording the channel (then $m$ is excluded) or never received the marker yet (then $P_j$'s state hasn't been recorded). In neither case is $m$ in the snapshot ⇒ C2 holds.