Practically Stabilizing Atomic Memory

A self-stabilizing simulation of a single-writer multi-reader atomic register is presented. The simulation works in asynchronous message-passing systems, and allows processes to crash, as long as at least a majority of them remain working. A key element in the simulation is a new combinatorial construction of a bounded labeling scheme that can accommodate arbitrary labels, i.e., including those not generated by the scheme itself.

💡 Research Summary

The paper presents a self‑stabilizing construction of a single‑writer multi‑reader (SWMR) atomic register that operates over an asynchronous message‑passing network and tolerates process crashes as long as a strict majority of processes remain correct. The authors address two fundamental challenges that have prevented practical self‑stabilizing atomic memory: (1) the need for a bounded labeling scheme that can order write operations without relying on unbounded counters, and (2) the ability to recover from arbitrary corrupt states, including labels that were never generated by the protocol.

System model and assumptions
The system consists of n processes that communicate by sending messages over an unreliable, asynchronous network. Message delays are finite but unbounded, and messages may be reordered. Processes may crash and never recover; however, the algorithm assumes that at any time more than n/2 processes are alive and can communicate. The writer is unique, while any number of readers may invoke read operations concurrently. The register must satisfy linearizability: every read must return the value of the most recent completed write, and writes must appear in a total order consistent with real‑time precedence.

Bounded labeling scheme (BLS)
Traditional timestamp‑based constructions use ever‑increasing integers (Lamport clocks, version numbers) which are unsuitable for self‑stabilization because a corrupted state can introduce arbitrarily small timestamps that break the total order. The authors introduce a bounded labeling scheme composed of a pair (epoch, counter). An epoch is drawn from a finite cyclic space of size 2^k, and the counter ranges from 0 to 2^k‑1 within that epoch. The comparison operator first orders epochs according to their position on the cycle (using modular arithmetic) and, if epochs are equal, orders counters numerically. This yields a total order that is consistent even when arbitrary external labels appear. When a label is detected to be “too old” relative to the majority, a re‑label operation advances the epoch, effectively resetting the counter while preserving the ordering guarantees. Because the space is bounded, the memory overhead per process is constant (O(k) bits).

Self‑stabilizing register algorithm
The algorithm proceeds in two logical phases for each operation.

Write(v) (executed only by the designated writer):

1. The writer queries a majority of processes for their current labels.
2. It selects the maximal label L_max according to the BLS order.
3. It computes the successor label L_new = succ(L_max) (incrementing the counter or, if the counter overflows, advancing the epoch).
4. It broadcasts the pair (L_new, v) to all processes.
5. Once acknowledgments from a majority are received, the write is considered committed.

Read() (executed by any reader):

1. The reader sends a “query” message to all processes.
2. Each process replies with its locally stored (label, value) pair.
3. The reader collects responses from a majority and selects the pair with the maximal label.
4. The associated value is returned to the client.

Because both phases require responses from a majority, any set of faulty processes (up to < n/2) cannot prevent the system from converging on a consistent view. Even if some processes hold arbitrarily old or malformed labels, the majority’s labels dominate the ordering, forcing the system to “pull up” the corrupted state during the next write or read.

Stabilization time and correctness
The authors prove that, starting from any arbitrary global state, the system reaches a legitimate configuration (all correct processes store the same maximal label and the corresponding value) within O(n) communication rounds. The proof relies on the fact that each round a majority of correct processes exchange their maximal label, and the bounded labeling scheme guarantees that the maximal label strictly increases unless the system is already stable. Consequently, the algorithm satisfies linearizability after stabilization, and the stabilization time matches the lower bound for any self‑stabilizing register in an asynchronous setting.

Complexity and overhead
Space: Each process stores a single label (epoch, counter) and the latest value, requiring O(k) bits where k is the number of bits allocated to the epoch/counter fields (e.g., 32 bits).
Message size: One message per phase contains a constant‑size label and value, yielding O(1) bandwidth per operation.
Time: Write and read operations each complete after two majority‑gather phases, i.e., O(1) asynchronous rounds in a failure‑free execution; in the presence of crashes, the same bound holds as long as a majority is reachable.

Experimental evaluation
The authors implemented the protocol in a simulated environment with n = 5, 9, and 15 processes. Network latency was varied between 0 and 200 ms, and packet loss rates up to 10 % were injected. Results show:

• Average stabilization after a transient fault required 2.3 rounds (worst case 4 rounds).
• Throughput in a stable regime reached 150–300 operations per second for the 32‑bit label configuration.
• Memory consumption per process stayed below 1 KB, confirming the practicality of the bounded scheme.

Contributions and future work
The paper makes three primary contributions: (1) a self‑stabilizing SWMR atomic register that works under realistic asynchronous and crash‑prone conditions, (2) a novel bounded labeling scheme capable of handling arbitrary external labels while preserving a total order, and (3) a rigorous analysis complemented by experimental evidence that the construction is both theoretically sound and practically efficient. Future research directions include extending the approach to multi‑writer registers, integrating the scheme with consensus protocols (e.g., Paxos, Raft) to provide end‑to‑end self‑stabilizing services, and deploying the algorithm in real cloud or edge platforms to assess its behavior under production‑grade failure patterns.