Intuition

Mutual exclusion in a distributed system is the same idea as a critical section in OS — except there's no shared memory, no semaphore, no central arbitrator. Everything is messages. Five algorithms attack the problem in two families: non-token (request-permission from peers — Lamport, R-A, Maekawa) and token (a single token grants entry — Suzuki-Kasami, Raymond). Trade-offs: message count, synchronisation delay, FIFO requirement, fault behaviour.

Explanation

Three required properties of any DME algorithm. Safety — at any instant, at most one process in the CS. Liveness — no endless wait; every request eventually granted in finite time. Fairness — CS requests granted in order of their logical-clock arrival (timestamp order).

Four performance metrics. Message complexity — messages per CS invocation. Synchronisation delay (SD) — time after one site leaves CS before the next enters. Response time — time from a request being made until CS execution completes. System throughput $=1/(\text{SD}+E)$ where $E$ = average CS execution time.

Two algorithm families. Non-token (permission-based): Lamport, Ricart-Agrawala, Maekawa. Token-based: Suzuki-Kasami (broadcast request, token holds queue), Raymond (token migrates along tree).

LAMPORT — assumptions. FIFO channels, bidirectional, scalar (Lamport) timestamps, no failures.

Lamport — algorithm. *Request*: $S_i$ broadcasts $\text{REQUEST}(t{s}_i,i)$ to all; places own request in ${\text{request\_queue}}_i$. *Receive REQUEST*: $S_k$ puts the request in its queue and sends a timestamped REPLY to $S_i$. *Enter CS*: $S_i$ enters when (L1) it has received a message with timestamp $>(t{s}_i,i)$ from every other site (need not be a REPLY — any later message works), AND (L2) its own request is at the top of its queue. *Release*: $S_i$ removes its request from queue and broadcasts RELEASE; on receipt, every $S_j$ removes $S_i$'s request from its queue.

Lamport — metrics. Messages = $3(N-1)$ per CS (REQUEST + REPLY + RELEASE to each of $N-1$ peers). SD = max message transmission time $T$. Requests granted in increasing timestamp order — strong fairness.

RICART-AGRAWALA — improvement over Lamport. Eliminates RELEASE messages. A site need not REPLY immediately — it *defers* a REPLY when it has a higher-priority (smaller-ts) request of its own.

Ricart-Agrawala — algorithm. *Request*: broadcast timestamped REQUEST. *Receive REQUEST* at $S_k$: send REPLY if $S_k$ is idle OR $S_k$ is requesting but $S_i$'s request has smaller timestamp. Else *defer* (set $R{D}_k[i]=1$). *Enter CS*: $S_i$ enters after receiving REPLY from all $N-1$ sites. *Release*: for every $j$ with $R{D}_i[j]=1$, send REPLY to $S_j$; reset $R{D}_i[j]=0$.

Ricart-Agrawala — metrics + advantage. $2(N-1)$ messages per CS. Does not require FIFO. SD = $T$.

Roucairol-Carvalho optimisation. Once $S_i$ has received a REPLY from $S_j$, $S_i$ need not send a REQUEST to $S_j$ again to re-enter CS — unless $S_i$ has since sent a REPLY to $S_j$. Message complexity varies from $0$ to $2(N-1)$. Worst-case unchanged.

MAEKAWA — quorum key idea. Each site $S_i$ has a Request Set $R_i$ (quorum); permission needed only from $R_i$. Requirements: (i) $i\in R_i$; (ii) $\forall i,j:R_i\cap R_j\ne \varnothing$ (every two quorums intersect — the common member arbitrates); (iii) $|R_i|=K$ for all $i$; (iv) every node is in exactly $D$ quorums. Optimum: $K=D=\sqrt{N}$ (minimises total messages while satisfying intersection).

Maekawa V1 protocol. Send timestamped REQUEST to all in $R_i$. On receiving a request → send ACK to lowest-timestamp requester; lock yourself to it; queue others. Enter CS after ACK from every member of $R_i$. To exit: send RELEASE to all in $R_i$. Recipient unlocks; sends ACK to next-lowest in queue. Messages: $3\sqrt{N}$ per CS.

Why Maekawa V1 deadlocks. Cyclic locking among quorums. Three sites $S_1,S_2,S_3$ with overlapping quorums can each lock one another's quorum member, cycle, deadlock. V2 fix adds three messages: FAILED — sent when reply already given to a higher-priority request. INQUIRE — sent by $S_k$ when a higher-priority request arrives; asks the previously-acked site 'are you in CS?'. YIELD — sent by a process that received a FAILED elsewhere, relinquishing its lock so $S_k$ can grant to the higher-priority one. V2 messages: up to $5\sqrt{N}$. SD = $2T$ (double Lamport / R-A).

SUZUKI-KASAMI — token-based with broadcast request. Data structures: Token contains a FIFO queue $Q$ of pending requestor IDs, and $LN[\mathrm{1..}n]$ where $LN[j]$ = sequence number of most recently executed request of $P_j$. Each site $P_i$ maintains $R{N}_i[\mathrm{1..}n]$ — the largest sequence number it has seen in any REQUEST from $P_j$.

Suzuki-Kasami — algorithm. *Request CS*: if $P_i$ doesn't hold token, $R{N}_i[i]$++ and broadcast $\text{REQUEST}(i,R{N}_i[i])$. *Receive REQUEST $(i,sn)$ at $P_j$*: $R{N}_j[i]:=\max (R{N}_j[i],sn)$. If $P_j$ has the token and is idle and $R{N}_j[i]=LN[i]+1$ (this is a fresh, not outdated request), send token to $P_i$. *Enter CS*: on receiving token. *Release CS*: $LN[i]:=R{N}_i[i]$. For every $j$ not in $Q$, if $R{N}_i[j]=LN[j]+1$, append $j$ to $Q$. If $Q$ non-empty, pop head and send token to it.

Suzuki-Kasami — metrics. Messages = $0$ (if already holds token) or $N$ (broadcast REQUEST + token transfer = $N-1+1=N$). SD = $0$ or max msg delay. No starvation. The condition $R{N}_j[i]=LN[i]+1$ filters outdated requests.

RAYMOND — token-based tree. Logical k-ary directed tree, root = token holder. Each node has: Holder pointer — points to its parent on the path to the current root (itself if it holds the token). **FIFO queue $Q_i$** of pending requests (its own and from children).

Raymond — algorithm. *Request CS*: place own request in $Q_i$. If not token-holder and $Q_i$ was previously empty, send REQUEST to Holder. *Non-root receives REQUEST*: place in $Q_j$. If no prior REQUEST sent up, send REQUEST to Holder. *Root receives REQUEST*: send token to requester; set Holder := requester. *On receiving token*: pop head of $Q$; if popped entry is self, enter CS; else forward token to that node and set Holder := that node. If $Q$ still non-empty, send REQUEST upward (to new parent). *Release CS*: same as receiving-token logic for next in queue.

Raymond — metrics. Average $O(\log N)$ messages per CS in a balanced tree. SD $=(\log N)/2\cdot T$.

Comparison table (memorise — high-yield). Lamport — non-token, $3(N-1)$ msgs, $T$ SD, FIFO required. Ricart-Agrawala — non-token, $2(N-1)$ msgs, $T$ SD, no FIFO. Maekawa V1 — quorum, $3\sqrt{N}$ msgs, $2T$ SD, deadlock possible. Maekawa V2 — quorum, up to $5\sqrt{N}$ msgs, $2T$ SD, deadlock-free. Suzuki-Kasami — token, $0$ or $N$ msgs, $0$ or $T$ SD. Raymond — token tree, $O(\log N)$ msgs, $(\log N)/2\cdot T$ SD.

Why Lamport needs FIFO but Ricart-Agrawala doesn't. Lamport relies on the order REQUEST → RELEASE — if RELEASE could overtake an earlier REQUEST from the same sender, sites would remove a request that hasn't yet been queued. Ricart-Agrawala has no RELEASE at all; deferred REPLYs implicitly serialise things by timestamp.

**Why Maekawa picks $\sqrt{N}$.** Cost $=K+K$ (request + reply + release in quorum) $=O(K)$ msgs. Quorum intersection forces $K^2\ge N$ (Fisher inequality), so $K\ge \sqrt{N}$. Minimum $K=\sqrt{N}$.

**Why Suzuki-Kasami's $R{N}_j[i]=LN[i]+1$.** $LN[i]$ = last executed seq num for $P_i$. $R{N}_j[i]$ = max seen by $P_j$. Equality confirms the request is *fresh* (immediately next) — not a stale duplicate from a delayed message. Filters out outdated requests so the token isn't sent for a request that's already been served.

Token-based DME — disadvantages. Token loss requires regeneration. Token-holder failure halts the system. Suzuki-Kasami broadcasts → doesn't scale beyond moderate $N$. Raymond — all requests funnel through the root → root bottleneck.

Centralised mutex — why not preferred in DS. Single coordinator = single point of failure. Communication bottleneck. High latency for far-away nodes. Coordinator crash blocks everything.

Definitions

• DME — safety / liveness / fairness — Safety: ≤ 1 in CS. Liveness: every requester eventually enters. Fairness: served in timestamp arrival order.
• Synchronisation delay (SD) — Time after one site leaves the CS before the next enters. Determines throughput as $1/(\text{SD}+E)$.
• Lamport DME — Non-token. FIFO required. Per-site request queue. Entry: L1 (later-ts msg from every site) ∧ L2 (own at top). 3(N-1) msgs per CS.
• Ricart-Agrawala — Non-token. No FIFO. REQUEST + REPLY only; REPLY deferred when own ts is smaller. 2(N-1) msgs per CS.
• Roucairol-Carvalho — Optimisation of R-A: once you have a REPLY from $S_j$, don't re-request from $S_j$ unless you've replied to $S_j$ in between. 0 to 2(N-1) msgs.
• Maekawa quorum — Request set $R_i$ with $|R_i|=K$, every pair $R_i\cap R_j\ne \varnothing$, optimum $K=\sqrt{N}$. Quorum-based permission.
• Maekawa V2 messages — FAILED (replied to higher), INQUIRE (higher arrived; ask 'in CS?'), YIELD (relinquish lock after FAILED). Breaks V1's cyclic deadlock.
• Suzuki-Kasami — Token-based with broadcast REQUEST. Token holds Q + LN[]. Each site has RN[]. Token sent only on fresh request ($RN[i]=LN[i]+1$).
• Raymond's tree algorithm — Token-based on a logical tree. Holder pointer at each node points toward root. Token migrates along Holder chain. $O(\log N)$ in balanced tree.
• Token-based vs non-token DME — Token: a single privilege passes around; requires fault-tolerant token. Non-token: each request asks permission from peers; no token to lose, but more messages per CS.

Formulas

• $$\text{Lamport msgs:}3(N-1)\text{per CS}$$
• $$\text{Ricart-Agrawala msgs:}2(N-1)$$
• $$\text{Maekawa V1:}3\sqrt{N};\text{V2 up to}5\sqrt{N}$$
• $$\text{Suzuki-Kasami:}0\text{(holds token)}\text{or}N$$
• $$\text{Raymond:}O(\log N)\text{(balanced tree)}$$
• $$\text{Throughput:}1/(\text{SD}+E)$$
• $$\text{Lamport entry:}L1\text{(later-ts msg from every site)}\wedge L2\text{(own at top)}$$
• $$\text{Maekawa quorum optimum:}K=D=\sqrt{N},K^2\ge N\text{(intersection)}$$

Derivations

Lamport DME safety. Suppose $S_i,S_j$ both in CS simultaneously. Both have own requests at top of their queues. WLOG $(t{s}_i,i)<(t{s}_j,j)$. By L1, $S_i$ has received a message from $S_j$ with timestamp $>(t{s}_i,i)$. By FIFO, this means $S_j$'s REQUEST (which has $t{s}_j>t{s}_i$) has been queued at $S_i$. Since $(t{s}_j,j)>(t{s}_i,i)$, $S_j$'s request is below $S_i$'s in the queue — contradiction with $S_j$'s L2.

**Why R-A is $2(N-1)$ msgs.** REQUEST to $N-1$ peers + REPLY from $N-1$ peers (eventually). No RELEASE. Total $2(N-1)$.

**Maekawa quorum intersection ⇒ $K^2\ge N$.** Consider all $\left(\genfrac{}{}{0ex}{}{N}{2}\right)$ pairs of quorums. Each pair must share at least one element. Each quorum has size $K$, hence appears in $\left(\genfrac{}{}{0ex}{}{K}{2}\right)$ pair-intersections from its own members. Sum over pairs gives a counting bound that yields $K^2\ge N$. Hence $K\ge \sqrt{N}$.

Examples

• Lamport trace for 3 sites. $S_1$ wants CS at time $(2,1)$. $S_2$ wants at $(3,2)$. $S_1$ broadcasts $\text{REQUEST}(2,1)$. $S_2,S_3$ queue it and REPLY. $S_2$ broadcasts $\text{REQUEST}(3,2)$. $S_3$ queues and replies. $S_1$'s queue: $[(2,1)\to S_1,(3,2)\to S_2]$. $(2,1)$ at top + L1 satisfied → $S_1$ enters. RELEASE. Queue: $[(3,2)\to S_2]$. $S_2$ enters next.
• Ricart-Agrawala defer. $S_1$ requests $(2,1)$ → $S_2$ replies (idle). $S_2$ requests $(3,2)$ → $S_1$ defers because $(2,1)<(3,2)$ and $S_1$ has its own request pending. After $S_1$ leaves CS, $S_1$ sends deferred REPLY to $S_2$. $S_2$ enters.
• **Maekawa quorum example $N=7$.** Pick $K=3$. One valid quorum design: $R_1=\{1,2,3\}$, $R_2=\{1,4,5\}$, $R_3=\{1,6,7\}$ — every pair shares 1. Each node in $D=3$ quorums (designed so total $K\cdot N/D=K^2=N$).
• Suzuki-Kasami token transfer. $P_1$ holds token. $P_2$ requests: $R{N}_2[2]=5$, broadcast REQUEST$(2,5)$. $P_1$ receives, updates $R{N}_1[2]=5$. $L{N}_1[2]=4$ (previous). $5=4+1$ ✓ fresh → send token to $P_2$ if $P_1$ is idle.
• Raymond tree, 7-node balanced tree, P4 holds token. $P_3$ requests CS: pushes self to $Q_3$ (empty before); sends REQUEST to Holder (P_4's parent). REQUEST flows up the tree; root forwards token to $P_3$ through Holder chain; tree pointers update along path.

Diagrams

• Comparison table: rows = Lamport / R-A / Maekawa-V2 / Suzuki-Kasami / Raymond; cols = type, msgs, SD, assumption, fault note.
• Lamport request flow: 3-process timeline with REQUEST, REPLY, RELEASE arrows + per-site queues at each instant.
• Maekawa quorum diagram: $N=7$ with $K=3$; show three quorums and their pairwise intersections.
• Maekawa V2 deadlock fix: arrows for FAILED, INQUIRE, YIELD.
• Suzuki-Kasami token state: token's $Q$ + $LN[]$ visualised as data structures.
• Raymond tree with Holder pointers all converging to root token-holder.

Edge cases

• Lamport without FIFO breaks: RELEASE may overtake REQUEST, removing a queue entry that hasn't been added.
• Maekawa V1 deadlock in cyclic locking; V2 with FAILED/INQUIRE/YIELD breaks the cycle.
• Token loss in Suzuki-Kasami / Raymond → need regeneration protocol (election + reset $LN[]$ / Holder).
• Suzuki-Kasami broadcast doesn't scale to thousands of nodes.
• Raymond root bottleneck if request rate is high near the root.
• Tied timestamps — break with process ID; without tie-break, fairness breaks.

Common mistakes

• Confusing message counts: Lamport = 3(N-1), R-A = 2(N-1), Maekawa V1 = 3√N, V2 = up to 5√N, S-K = 0 or N, Raymond = O(log N). Memorise the table.
• Saying 'R-A needs FIFO'. No — R-A's beauty is that it doesn't.
• Forgetting L1 + L2 are BOTH required in Lamport. Either alone is insufficient.
• Saying 'Maekawa V1 is deadlock-free'. No — V1 can deadlock; V2 fixes it.
• Suzuki-Kasami token send condition is $RN[i]=LN[i]+1$ (strict equality) — not $\ge$ or $\le$.

Shortcuts

• Lamport: 3(N-1) msgs, FIFO, L1+L2 entry.
• R-A: 2(N-1) msgs, no FIFO, deferred REPLY.
• Maekawa: K=D=√N, V1 deadlocks → V2 FAILED/INQUIRE/YIELD, SD = 2T.
• **S-K: 0 or N msgs, broadcast REQ + fresh-only token, $RN[i]=LN[i]+1$.**
• Raymond: O(log N), Holder pointer, root bottleneck.

Proofs / Algorithms

Lamport DME safety (formal). Assume two sites $S_i,S_j$ in CS at same time with $(t{s}_i,i)<(t{s}_j,j)$. Both satisfy L2 — own request at top. $S_j$ has $(t{s}_j,j)$ at top. But $S_j$ must have queued $S_i$'s REQUEST (broadcasted) by FIFO + the fact that L1 at $S_j$ requires a message from $S_i$ with timestamp $>(t{s}_j,j)$. The only way is $S_i$'s RELEASE arriving after $S_j$ broadcast its REQUEST — but then $(t{s}_i,i)$ has been removed from $S_j$'s queue. Trace shows contradiction with L2 at $S_j$.

Ricart-Agrawala safety. $S_i$ enters CS after REPLY from all $N-1$. If $S_j$ has a higher-priority pending request, $S_j$ would have deferred $S_i$'s REPLY until $S_j$ leaves CS — so $S_i$ couldn't have all REPLYs while $S_j$ is in CS. Hence at most one site in CS.

Maekawa intersection-based safety. Two simultaneous requesters $S_i,S_j$ need ACK from disjoint sets. But $R_i\cap R_j\ne \varnothing$ — some site $S_k$ in both. $S_k$ can only ACK one at a time. So only one of $S_i,S_j$ gets full ACKs and enters CS.

Suzuki-Kasami safety. Only the token-holder can enter CS. Token is unique (single token in system). Hence safety.