• Computer Science > Distributed, Parallel, and Cluster Computing [Submitted on 18 Feb 2026] Title:Read-Modify-Writable Snapshots from Read/Write operations View PDFAbstract:In the context of asynchronous concurrent shared-memory systems, a snapshot algorithm allows failure-prone processes to concurrently and atomically write on the entries of a shared array MEM , and also atomically read the whole array. • Recently, Read-Modify-Writable (RMWable) snapshot was proposed, a variant of snapshot that allows processes to perform operations more complex than just read and write, specifically, each entry MEM[k] is an arbitrary readable object. • The known RMWable snapshot algorithms heavily rely on powerful low-level operations such as compare&swap or load-link/store-conditional to correctly produce snapshots of MEM. • Following the large body of research devoted to understand the limits of what can be solved using the simple read/write low-level operations, which are known to be strictly weaker than compare&swap and load-link/store-conditional, we explore if RMWable snapshots are possible using only read/write operations. • We present two read/write RMWable snapshot algorithms, the first one in the standard concurrent shared-memory model where the number of processes n is finite and known in advance, and the second one in a variant of the standard model with unbounded concurrency, where there are infinitely many processes, but at any moment only finitely many processes participate in an exec

Article Summaries:

  • Researchers have introduced two algorithms that enable Read‑Modify‑Writable (RMWable) snapshots in asynchronous shared‑memory systems using only basic read/write operations, eliminating the need for stronger primitives such as compare‑and‑swap. RMWable snapshots extend traditional snapshot protocols by allowing each array entry to be an arbitrary readable object, supporting more complex operations. The first algorithm works in the standard model with a finite, known number of processes, while the second accommodates unbounded concurrency, permitting infinitely many processes but only finitely many active at any time. These results advance the understanding of what can be achieved with minimal synchronization primitives in fault‑tolerant distributed computing.

Sources: