Reliable Self-Stabilizing Communication for Quasi Rendezvous
The paper presents three self-stabilizing protocols for basic fair and reliable link communication primitives. We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours’ registers. The first primitive guarantees that any process writes a new value in its register(s) only after all its neighbours have read the previous value, whatever the initial scheduling of processes’ actions. The second primitive implements a “weak rendezvous” communication mechanism by using an alternating bit protocol: whenever a process consecutively writes n values (possibly the same ones) in a register, each neighbour is guaranteed to read each value from the register at least once. On the basis of the previous protocol, the third primitive implements a “quasi rendezvous”: in words, this primitive ensures furthermore that there exists exactly one reading between two writing operations All protocols are self-stabilizing and run in asynchronous arbitrary networks. The goal of the paper is in handling each primitive by a separate procedure, which can be used as a “black box” in more involved self-stabilizing protocols.
💡 Research Summary
The paper addresses a fundamental problem in distributed systems: how to provide reliable, fair, and self‑stabilizing communication over simple link‑register links where a process can read its neighbors’ registers but cannot write to them. Under the read/write atomicity model, the authors design three distinct communication primitives, each of which can be used as a black‑box building block for higher‑level self‑stabilizing protocols.
The first primitive, called “basic reliable link,” guarantees that a process may write a new value to its own register only after every neighbor has read the previous value. To achieve this, each register is equipped with a read‑acknowledgment flag. Neighbors clear the flag when they read the value; the writer is allowed to update the register only when the flag is cleared. The protocol is self‑stabilizing because, regardless of the initial configuration of flags and data, the system converges to a state where flags correctly reflect whether the current value has been consumed, thereby enforcing a strict write‑after‑read ordering.
The second primitive builds on the first and implements a “weak rendezvous” using an alternating‑bit technique. Every time a process writes, it toggles a single bit (the alternating bit) together with the payload. A neighbor reads the register and compares the stored bit with the last bit it observed; a mismatch indicates a new message, prompting the neighbor to read the payload and update its stored bit. This ensures that for any sequence of n consecutive writes (including repeated values) each neighbor reads each value at least once. The alternating‑bit mechanism eliminates lost or duplicated reads while preserving self‑stabilization: even if bits are initially inconsistent, the protocol drives the system to a consistent alternating pattern.
The third primitive, termed “quasi rendezvous,” refines the weak rendezvous by guaranteeing exactly one read between two successive writes. In addition to the alternating bit, each register carries a read‑counter. When a process writes, it resets the counter to zero; each neighbor increments the counter upon reading. The writer is permitted to issue the next write only after the counter reaches one, i.e., after it has been observed by at least one neighbor. Consequently, two writes are always separated by a single read, providing a tighter synchronization without sacrificing the self‑stabilizing property.
For each primitive the authors present formal proofs of convergence under a fair asynchronous scheduler. They define invariants (e.g., “all flags cleared” for the first primitive, “alternating bit matches stored bit” for the second, “counter equals one before next write” for the third) and show, via induction, that these invariants are eventually established from any arbitrary initial state. Complexity analysis reveals that each round‑trip requires O(Δ) read/write operations, where Δ is the maximum node degree, and only a constant amount of local memory (a flag, a bit, and a counter) per process.
The paper also demonstrates how the three primitives can be composed to implement more sophisticated self‑stabilizing algorithms such as token circulation, leader election, or synchronized data aggregation. By exposing the primitives as independent black boxes, protocol designers can rely on proven reliable communication without re‑deriving correctness for each new application.
Finally, the authors discuss extensions and future work, including handling multiple communication channels, adapting to dynamic topology changes, and optimizing energy consumption for wireless sensor networks. The contribution lies in delivering simple, provably self‑stabilizing communication mechanisms that work in fully asynchronous, arbitrary networks, thereby filling a gap between low‑level link reliability and high‑level self‑stabilizing system design.