Deadlock — Same Idea, Harder Problem

In an OS, deadlock detection is a single-machine wait-for graph traversal: cheap. In a distributed system, the same wait-for graph is *split across nodes*. No single node sees the whole graph. Even reconstructing it takes communication — and while you collect, the graph changes.

The exam wants you fluent in three things: the resource model that determines what counts as a deadlock; the WFG criterion for each model; and the detection algorithms for each.

Five Resource Models

• Single resource — at most one pending request per process.
• AND — process needs ALL requested resources together.
• OR — process needs ANY ONE of the requested resources.
• AND-OR — arbitrary combination, e.g., $X\wedge (Y\vee Z)$.
• P-out-of-Q — needs any $p$ of $q$ resources.

The deadlock criterion changes with the model.

Cycle vs Knot

Single-resource and AND: deadlock iff WFG has a cycle.

OR: a cycle is NOT enough. A process in a cycle might also be waiting on a resource outside the cycle — which could be granted, breaking the wait. Only when the SCC has *no outgoing edges* — a knot — is every process in it permanently blocked.

Definition: a knot is an SCC where every node reaches only other knot nodes. Equivalently, the SCC is a sink in the condensation graph.

Common exam mistake: "OR deadlock iff cycle." Wrong — it must be a knot.

Three Strategies

Prevention — design so deadlock can't happen (pre-order resources globally; require pre-claim). Slow, may starve.

Avoidance — needs global state knowledge (Banker's-style). Expensive in DS where there is no global state.

Detection — run an algorithm when deadlock is suspected; then preempt and restart. Most popular in DS because it's the only one that doesn't need expensive global state.

Once detected, three recovery options: process termination, resource preemption, or rollback to a checkpoint.

Control Organisations

Centralised — one site builds the global WFG. Single point of failure.

Distributed — every node equally responsible; uses waves/probes.

Hierarchical — tree of sites; the lowest common ancestor of involved sites detects.

Phantom Deadlock

Because we collect WFG dependencies non-atomically, while we collect, the WFG changes. A resource is released; a process unblocks. The cycle we "see" in the assembled WFG may never have existed simultaneously. This is a false or phantom deadlock. Algorithms try to reduce it (Ho-Ramamoorthy collects twice; CMH uses persistent dependencies).

Algorithms By Model

Ho-Ramamoorthy (Centralised)

2-phase: collect process status from each site twice; keep only edges in both snapshots. 1-phase: each site keeps Process Status Table (per process: held/waited) + Resource Status Table (per resource: holder/waiter). Edge valid iff both tables agree.

Chandy-Misra-Haas (AND, Distributed) — The Probe

A blocked $P_i$ sends a probe $(i,j,k)$ along its outgoing dependency edges:

• $i$ = initiator.
• $j$ = sender.
• $k$ = receiver.

$P_j$ forwards the probe to $P_k$ when $P_j$ is blocked waiting on $P_k$. When $P_k$ receives a probe:

• If $P_k$ is blocked AND not yet noted dependency on $i$ AND not yet replied to $P_j$ — note the dependency.
• **If $k=i$ → deadlock detected.**
• Else forward the probe along $P_k$'s own dependency edges.

Worked trace on a 4-cycle $P_1\to P_2\to P_3\to P_4\to P_1$:

1. $P_1$ blocks; sends probe$(1,1,2)$ to $P_2$. 2. $P_2$ blocked on $P_3$; forwards probe$(1,2,3)$. 3. $P_3$ blocked on $P_4$; forwards probe$(1,3,4)$. 4. $P_4$ blocked on $P_1$; forwards probe$(1,4,1)$. 5. $P_1$ receives probe with $i=k=1$ → deadlock detected.

Four messages for a 4-cycle. General bound: $\le m(s-1)/2$ where $s$ sites, $m$ processes per site.

Mitchell-Merritt (Single-Resource) — Label Passing

Each node has a public and a private label, initially equal.

• Block: pick a new unique private value; set public = private.
• Activate: unblock.
• Transmit: blocked node $u\to v$ with $u.\text{public}<v.\text{public}$ copies $v.\text{public}$ into $u.\text{public}$ — propagates labels backward.
• Detect: a node receiving its own public label back ⇒ deadlock. Highest-label-in-cycle detects.

Key: probes travel OPPOSITE to WFG edges.

Chandy Diffusion (OR Model)

Initiator sends $\text{query}(i,i,j)$ to every $P_j$ in its dependent set. Each blocked $P_k$, on receiving the FIRST (engaging) query for initiator $i$, forwards queries to its own dependent set and waits. Replies propagate back; if initiator gets replies from all branches and ${\text{num}}_k(i)=0$ — declares deadlock.

Algorithm Choice Cheat-Sheet

| Model | Algorithm | |---|---| | Single resource | Mitchell-Merritt, Ho-Ramamoorthy | | AND | Chandy-Misra-Haas probe | | OR | Chandy diffusion | | AND-OR | Repeated OR tests over conjunctive sub-clauses |

What You Walk In Carrying

Five resource models. Cycle vs knot criterion (knot for OR). Three handling strategies (detection wins in DS). Three control organisations. Phantom-deadlock concept. Ho-Ramamoorthy 1/2-phase tables. CMH probe format $(i,j,k)$ + detection rule $i=k$. Mitchell-Merritt label-passing in OPPOSITE direction. Chandy diffusion for OR. Algorithm-by-model table.