Intuition

Without a global clock, we need a discipline for talking about 'before' and 'after'. Lamport's happened-before relation $(\to )$ captures *causal* ordering; logical clocks (scalar, vector, matrix) implement that relation in code. The trade-off is storage vs information: scalar = 1 int (cheap, but loses converse); vector = n ints (strongly consistent); matrix = n × n ints (also tracks what others know about each other — enables obsolete-message GC).

Explanation

The DS model. A collection of processors $P_1,\dots ,P_n$ connected by channels $C_{ij}$. Processors may fail; share no global memory; have no global clock. Channels may not respect FIFO ordering, may not deliver in causal order, may lose messages.

State of a process / channel. State of $P_i$ = local memory + history of activity on it. State of $C_{ij}$ = set of messages sent on it but not yet received.

Three event types in a distributed program. (1) Local action (internal) — doesn't involve another process. (2) Message send. (3) Message receive. Each event changes the state of one (or two, for send/recv) processes.

**Lamport's happened-before relation $(\to )$.** Defined by three rules: (a) same-process order — if $e,e^{\prime }$ are in the same process and $e$ occurs before $e^{\prime }$, then $e\to e^{\prime }$; (b) send precedes receive — if $e=\text{send}(m)$ and $e^{\prime }=\text{receive}(m)$, then $e\to e^{\prime }$; (c) transitive — $e\to e^{\prime }\wedge e^{\prime }\to e^{\prime \prime }\Rightarrow e\to e^{\prime \prime }$. Two events are concurrent iff neither $e\to e^{\prime }$ nor $e^{\prime }\to e$.

Logical clock — definition + consistency. A function $C$ assigning a timestamp to each event such that if $e\to e^{\prime }$ then $C(e)<C(e^{\prime })$ (clock consistency / monotonicity). Strong consistency: $e\to e^{\prime }\iff C(e)<C(e^{\prime })$ — both directions. Scalar clocks satisfy only $\Rightarrow$; vector and matrix clocks satisfy $\iff$.

Scalar (Lamport) clock rules. Each $P_i$ keeps integer $c_i$, initially 0. R1 (before any event): $c_i:=c_i+d$ (typically $d=1$). R2 (on receive of $m$ with timestamp $t_m$): $c_i:=\max (c_i,t_m)$, then apply R1, then deliver. Total order tie-breaker: $(t,i)$ — timestamp first, then process ID. 'Height' of event = its scalar timestamp.

Scalar clock limitation — why not strongly consistent. $C(e)<C(e^{\prime })$ does NOT imply $e\to e^{\prime }$. Two events at different processes can have ordered scalar timestamps without any causal relation. Example: $P_1$'s third local event has $c_1=3$; $P_2$ runs independently to $c_2=5$. $3<5$ but the events are concurrent.

Vector clock rules. Each $P_i$ keeps vector $V_i[\mathrm{1..}n]$, initially $[0,\dots ,0]$. R1 (before any event): $V_i[i]:=V_i[i]+1$. R2 (on receive of $m$ with vector $V_m$): $\forall k:V_i[k]:=\max (V_i[k],V_m[k])$, then apply R1, then deliver. Comparison: $V_h<V_k⟺\forall i:V_h[i]\le V_k[i]\wedge \exists i:V_h[i]<V_k[i]$. Concurrent: $V_h\Vert V_k$ iff neither $<$ nor $>$.

Vector clock strong consistency. $e\to e^{\prime }\iff V(e)<V(e^{\prime })$ — both directions. The $i$-th component of $P_i$'s vector clock = number of events at $P_i$ that causally precede the current event.

Vector clock limitations. Message size $O(n)$ per message → grows linearly with the number of processes. In large clusters this is significant overhead.

Singhal-Kshemkalyani optimisation. Send only entries that have *changed* since the last send to that recipient. Each $P_i$ maintains $L{S}_i[j]$ = value of $V_i[i]$ when last sent to $P_j$, and $L{U}_i[j]$ = value of $V_i[i]$ when $V_i[j]$ was last updated. On send to $P_j$, send only $(k,V_i[k])$ where $L{U}_i[k]>L{S}_i[j]$. Requires FIFO channels because the recipient must reconstruct the full vector incrementally.

**Matrix clock — what's in $mt[j,k]$.** $P_i$'s matrix $m{t}_i$ has $m{t}_i[i,\ast ]=$ its own vector clock, and $m{t}_i[j,k]=$ $P_i$'s knowledge of $P_j$'s knowledge of $P_k$'s clock — second-order knowledge. Killer use case: garbage collection of obsolete messages. Once ${\min }_{k}m{t}_i[k,i]\ge t$, $P_i$ knows that every process has seen $P_i$'s clock pass $t$ — so messages with timestamps $\le t$ can be safely discarded.

Comparison table. Scalar: 1 int, consistent only, total ordering. Vector: $n$ ints, strongly consistent, detects concurrency. Matrix: $n^2$ ints, strongly consistent + knows what others know, used for GC / replicated databases.

Physical time — why needed. Each node's quartz crystal drifts (seconds per day). Many applications need globally meaningful time: file timestamps for make, transaction timestamps, log ordering, distributed debugging, security tokens, time-based protocol timeouts.

Cristian's algorithm. Single master server. Client sends request at $T_0$; server replies with UTC time $T_s$; client receives at $T_1$. RTT = $T_1-T_0$. Knowing min one-way transit time ${\delta }_{\min }$, the actual server time is in $[T_s+{\delta }_{\min },T_s+\text{RTT}-{\delta }_{\min }]$. Client sets clock to $T_s+\text{RTT}/2$ (best estimate). Drawback: server is a single point of failure.

Berkeley algorithm. Master daemon polls all slaves for their local times. Computes the average (after correcting for transit delay, discarding outliers). Sends each slave the delta it should adjust. No UTC source needed — used in internal LANs where the cluster only needs to agree among itself, not with the outside world.

Decentralised averaging. At fixed agreed times, every machine broadcasts its local time. Each computes the average of all received timestamps and sets its clock to that. Fully decentralised; no master, no UTC.

NTP (Network Time Protocol). Most widely used Internet protocol for clock sync (~10–20 M servers). Hierarchical strata: Stratum 0 (atomic clocks, GPS); Stratum 1 (primary servers directly connected to stratum 0); Stratum 2+ (secondary servers synchronising from above). Clients exchange four timestamps with servers and compute offset + delay. Accuracy: ms on WANs, sub-ms on LANs. Cannot achieve perfect sync — different nodes may use different NTP servers; stratum delay accumulates.

Why still need logical clocks if NTP exists? NTP guarantees only approximate sync (offsets in milliseconds). Many DS algorithms (mutex, snapshots, deadlock detection) need *causal correctness*, not numeric closeness — even tiny clock skews break safety properties. Logical clocks capture causality exactly, regardless of physical drift.

Definitions

• Happened-before $(\to)$ — Lamport's partial order on events: (a) same-process order, (b) send → recv, (c) transitive. Events not related by → are concurrent.
• Logical clock consistency — $e\to e^{\prime }\Rightarrow C(e)<C(e^{\prime })$. Required minimum; satisfied by scalar, vector, matrix.
• Strong consistency of logical clocks — $e\to e^{\prime }\iff C(e)<C(e^{\prime })$. Both directions. Vector and matrix satisfy this; scalar does not.
• Scalar (Lamport) clock — Single integer per process. R1: increment before event. R2: max(local, msg ts) + d on receive. Total-order tie-break: (t, i).
• Vector clock — n-dim vector per process. R1: V[i]++. R2: componentwise max, then R1. Compares with V_h < V_k iff componentwise ≤ and ∃ strict.
• Matrix clock — n × n matrix per process. mt[i, k] = own knowledge of k's clock; mt[j, k] = i's knowledge of j's knowledge of k's clock. Enables obsolete-message GC.
• Singhal-Kshemkalyani optimisation — Vector-clock optimisation: send only entries changed since last send to that recipient. Uses LS[j] (last sent value of V[i]) and LU[j] (last update of V[j]). Requires FIFO.
• Cristian's algorithm — Client polls a UTC-aware server. Sets local clock to T_s + RTT/2. Single-master; UTC reference.
• Berkeley algorithm — Master polls all slaves, computes average local time, sends each its delta. No UTC; for internal LAN agreement only.
• NTP — Hierarchical Internet protocol. Stratum 0 (atomic / GPS), 1 (primary servers), 2+ (secondary). Computes offset+delay from four timestamps. Accuracy: ms WAN, sub-ms LAN.

Formulas

• $$\text{Happened-before:}e\to e^{\prime }⟺(\text{same-process order})\vee (e=\text{send},e^{\prime }=\text{recv})\vee \text{transitive}$$
• $$\text{Scalar R1:}{c}_i:=c_i+d;\text{R2:}{c}_i:=\max (c_i,t_m)+d$$
• $$\text{Vector R1:}{V}_i[i]:=V_i[i]+1;\text{R2:}\forall k{V}_i[k]:=\max (V_i[k],V_m[k]),\text{then R1}$$
• $$\text{Vector comparison:}{V}_h<V_k⟺(\forall i{V}_h[i]\le V_k[i])\wedge (\exists i{V}_h[i]<V_k[i])$$
• $$\text{Matrix GC:}\underset{k}{\min }m{t}_i[k,i]\ge t\Rightarrow \text{discard messages with ts}\le t$$
• $$\text{Singhal-Kshemkalyani send:}\text{include}(k,V_i[k])\text{iff}L{U}_i[k]>L{S}_i[j]$$
• $$\text{Cristian’s estimate:}{T}_{\text{client}}:=T_s+\text{RTT}/2$$
• $$\text{Total order tie-break:}(t,i){<}_{\text{lex}}(t^{\prime },j)$$

Derivations

Scalar clock is consistent but not strongly consistent. Forward direction: if $e\to e^{\prime }$, the rules ensure $C(e)<C(e^{\prime })$ by induction on the path. Counter-example for the converse: $P_1$ and $P_2$ run independently. $P_1$'s event $e_1$ has $c_1=3$; $P_2$'s event $e_2$ has $c_2=5$. $C(e_1)<C(e_2)$ but neither $e_1\to e_2$ nor $e_2\to e_1$ — concurrent.

Vector clock captures causality exactly. Forward: if $e\to e^{\prime }$ via a chain, every send/recv preserves componentwise max, so $V(e)\le V(e^{\prime })$ componentwise; at least the originating process's component strictly increments. Reverse: if $V(e)<V(e^{\prime })$ componentwise, then for the originating process of $e$, its component strictly increased at $e^{\prime }$ — which means $e^{\prime }$ either is at that process after $e$ or received a message chain from that process after $e$.

Why Singhal-Kshemkalyani needs FIFO. The recipient updates $V_i[k]$ only for the components included in the message — relying on every previous update having already arrived. If a later message's partial-vector arrives before an earlier message's update, the recipient misses an intermediate value of $V_i[k]$ and corrupts causality. FIFO guarantees previous updates from the same sender arrive first.

Matrix clock obsolete-message GC argument. $m{t}_i[k,i]$ = $P_i$'s knowledge of $P_k$'s knowledge of $P_i$'s clock. If ${\min }_{k}m{t}_i[k,i]\ge t$, then every $P_k$ has been observed (by $P_i$) to have seen $P_i$'s clock pass $t$. By transitivity, every $P_k$ already received all of $P_i$'s messages with timestamp $\le t$ — so $P_i$ can safely discard them from its outgoing buffer.

Examples

• 3-process vector clock trace. $P_1$ sends $m_1$ to $P_2$ at $e_1$; $P_2$ sends $m_2$ to $P_3$ at $e_2$ (after recv $m_1$); $P_3$ receives $m_2$. After $e_1$: $V_1=[1,0,0]$. $P_2$ recv: max + inc → $V_2=[1,1,0]$. $P_2$ send: $V_2=[1,2,0]$. $P_3$ recv: max + inc → $V_3=[1,2,1]$. Conclusion: $e_1\to (P_3$'s recv) since $[1,0,0]<[1,2,1]$ componentwise.
• Scalar clock counter-example to converse. $P_1$ at $c_1=3$ (3 local events). $P_2$ at $c_2=5$ (5 local events, no comms with $P_1$). $C(e_3^{P_1})=3<5=C(e_5^{P_2})$ but they are concurrent — scalar fails the $\Leftarrow$ direction.
• Cristian's worked example. Client sends at $T_0=100$ ms. Server responds with UTC = $1234567890.500$ s. Client receives at $T_1=110$ ms. RTT = 10 ms. Client sets clock = $1234567890.500+5=1234567890.505$ s. Uncertainty interval ± min one-way delay.
• Matrix GC scenario. Replicated database with 4 sites. Each update propagated and ack'd. Once ${\min }_{k}m{t}_1[k,1]\ge 100$, site 1 knows all sites have seen its updates up to logical time 100 — safe to discard those updates from its outbound buffer.

Diagrams

• Three-process happened-before chain: events as nodes, same-process arrows + send/recv arrows; concurrent events are not connected.
• Vector-clock lattice for 2 processes: 2D grid of (V[1], V[2]) values; partial order ≤ defines causality; concurrent points are non-comparable.
• Comparison table: rows = scalar / vector / matrix; cols = storage, consistency (forward only / both), application (total order / causality / GC).
• Cristian's RTT measurement diagram: client request at T0 → server reply at Ts → client receive at T1; estimated time = Ts + RTT/2.
• NTP stratum hierarchy: stratum 0 (atomic / GPS) at top, fanning out to stratum 1 (primary), stratum 2 (secondary), etc.

Edge cases

• Concurrent scalar timestamps after tie-break. When two events have equal scalar timestamp, the tie-break is $(t,i)$ — lexicographic by process ID. This gives total order but is arbitrary across processes.
• Vector-clock storage explosion in systems with thousands of processes. Use Singhal-Kshemkalyani (send only changed entries) or matrix-clock GC.
• Singhal-Kshemkalyani without FIFO corrupts vector reconstruction at the recipient.
• Cristian's with asymmetric routes breaks the RTT/2 assumption — better symmetric estimate is $T_s+{\delta }_{\min }$ to $T_s+\text{RTT}-{\delta }_{\min }$.
• Berkeley with malicious slave reporting wildly wrong time can poison the average. Use outlier rejection.

Common mistakes

• 'Scalar clocks are strongly consistent.' Wrong — only forward direction holds. Concurrent events can have ordered scalar timestamps.
• 'Vector R2 is just max(V, Vm).' Wrong — must also increment own component after taking max.
• 'NTP gives perfect sync.' Wrong — only approximate (ms on WAN, sub-ms on LAN). Not sufficient for causality-sensitive DS algorithms.
• **Confusing $(t,i)$ tie-break with global ordering of events.** The tie-break gives a *total* order, but it does not reflect causality between concurrent events.
• 'Singhal-Kshemkalyani works on non-FIFO channels.' Wrong — it requires FIFO.
• **Treating matrix-clock $mt[i,j]$ as 'i's clock from j's view'** — backwards. $m{t}_i[j,k]$ = $P_i$'s knowledge of $P_j$'s knowledge of $P_k$.

Shortcuts

• Scalar R2: $c_i=\max (c_i,t_m)+d$.
• Vector R2: componentwise max, then ++own.
• Strong consistency: vector ✓, matrix ✓, scalar ✗.
• Singhal-Kshemkalyani trio: LS, LU, FIFO required.
• Matrix GC: ${\min }_{k}mt[k,i]\ge t$ → discard.
• Cristian's: $T_s+\text{RTT}/2$, single master, UTC.
• Berkeley: poll + average, no UTC, LAN-only.
• NTP strata: 0 atomic → 1 primary → 2+ secondary. ms WAN, sub-ms LAN.

Proofs / Algorithms

Vector clock is strongly consistent. Forward: if $e\to e^{\prime }$ via a chain of events, each step preserves $\le$ componentwise (R1 only increments own, R2 only does max). The originating process's component strictly increments at $e$, and this strict increase propagates along the chain. Backward: if $V(e)<V(e^{\prime })$ componentwise with strict-component $i$, then $V(e)[i]<V(e^{\prime })[i]$ means $P_i$ either has the event $e^{\prime }$ after $e$ or received a chain originating from $e$. By construction $e\to e^{\prime }$.

Matrix-clock GC correctness. When ${\min }_{k}m{t}_i[k,i]\ge t$, every process $P_k$ has $m{t}_i[k,i]\ge t$, meaning $P_i$ has received evidence that $P_k$'s vector clock at $P_i$ shows $V_k[i]\ge t$. Since vector clocks are strongly consistent, this means every message $P_i$ sent with timestamp $\le t$ has been acknowledged transitively by every $P_k$. So $P_i$ can discard its sent buffer up to time $t$.