On the robustness of (semi) fast quorum-based implementations of atomic shared memory

Abstract

Abstract. This paper studies a trade-off between fault-tolerance and latency in implementations of atomic read/write objects in message-passing systems. In particular, considering fast or semifast quorum-based implementations, that is, implementations where all or respectively most read and write operations complete in a single communication round-trip, it is shown that such implementations are not robust due to the fact that they necessarily require a quorum system with a common intersection between its quorums. To trade speed for fault-tolerance, the notion of weak-semifast implementations is introduced. Here more than a single complete slow (two round-trip) read operation is allowed for each write operation (semifast implementations allow only one such slow read). A quorum-based algorithm is given next and it is formally shown that it constitutes a weak-semifast implementation of atomic registers. The algorithm uses the notion of Quorum Views to facilitate the characterization of all possible object timestamp distributions that a read operation may witness during its first communication round-trip. Noteworthy is that the algorithm allows fast read operations even if they are concurrent with other read and write operations. Finally, experimental results were gathered by simulating the algorithm using the NS-2 network simulator. The results show that under realistic conditions, less than 13% of read operations are slow, thus the overwhelming majority of operations take a single communication round-trip.

On the Efficiency of Atomic Multi-reader, Multi-writer Distributed Memory

“…A long string of research has been addressing the consistency challenge by devising efficient, wait-free, atomic (linearizable [21]) read/write sharable objects in message-passing systems (e.g., [1,2,3,5,7,14,15,19,20,23,26]). An atomic read/write object, or register [22], provides the semantics of a sequentially accessed single object.…”

“…They also show that semifast MWMR implementations are impossible. Other works, e.g., [1,19,20,14], pursue bounds on the efficiency of distributed storage in a variety of organizational and failure models. For example, [19,1], explore conditions under which two round operations are required by safe and regular SWMR registers.…”

“…Recently quorum-based approaches were further explored in the context of efficient atomic registers [20,14]. Guerraoui and Vukolić [20] defined the notion of Refined Quorum Systems (RQS), where quorums are classified in three categories, according to their intersection size with other quorums.…”

“…In synchronous failure-free runs their implementation is fast. Georgiou et al [14] specified the properties that a general quorum system must possess in order to achieve single round operations in the presence of crashes and asynchrony. They showed that fast and semifast quorum-based SWMR implementations are possible iff a common intersection exists among all quorums, hence a single point of failure exists in such solutions (i.e., any server in the common intersection), making such implementations not robust.…”

“…They showed that fast and semifast quorum-based SWMR implementations are possible iff a common intersection exists among all quorums, hence a single point of failure exists in such solutions (i.e., any server in the common intersection), making such implementations not robust. To trade efficiency for improved fault-tolerance, weak-semifast implementations are introduced in [14] that require at least one single slow read per write operation, and where all writes are fast. In addition, they present a client-side prediction tool called Quorum Views that enables fast read operations in general quorum-based implementations even under read/write concurrency.…”