Fork-Consistent Constructions from Registers

Abstract

Abstract. Users increasingly execute services online at remote providers, but they may have security concerns and not always trust the providers. Fork-consistent emulations offer one way to protect the clients of a remote service, which is usually correct but may suffer from Byzantine faults. They feature linearizability as long as the service behaves correctly, and gracefully degrade to fork-consistent semantics in case the service becomes faulty. This guarantees data integrity and service consistency to the clients. All currently known fork-consistent emulations require the execution of nontrivial computation steps by the service. From a theoretical viewpoint, such a service constitutes a read-modify-write object, representing the strongest object in Herlihy's wait-free hierarchy [1]. A read-modify-write object is much more powerful than a shared memory made of so-called registers, which lie in the weakest class of all shared objects in this hierarchy. In practical terms, it is important to reduce the complexity and cost of a remote service implementation as computation resources are typically more expensive than storage resources. In this paper, we address the fundamental structure of a fork-consistent emulation and ask the question: Can one provide a fork-consistent emulation in which the service does not execute computation steps, but can be realized only by a shared memory? Surprisingly, the answer is yes. Specifically, we provide two such algorithms that can be built only from registers: A fork-linearizable construction of a universal type, in which operations are allowed to abort under concurrency, and a weakly fork-linearizable emulation of a shared memory that ensures waitfreedom when the registers are correct.

Fork-consistent constructions from registers

“…For two operations of a shared memory o and o in σ, o causally precedes o (o → σ o ), if o, o are called by the same client and o happens before o , or if o is a READ operation that returns the value written by WRITE operation o. The next definition formalizes the notion of forklinearizability [4] and weak fork-linearizability [7]; for a formal definition of the term possible view as well as the above-mentioned notions we refer to the Technical Report [21].…”

“…An invocation to INC&READ(C ) advances the counter object C and returns a value which is higher than any value returned before, and READ(C) returns the current value of the counter object. An implementation of the INC&READ counter is given in the Technical Report [21] together with its formal properties. Our implementation uses wait-free atomic registers as base objects which makes it a wait-free variant of the abortable INC&READ counter described by Aguilera et al [13].…”

“…However, it is still possible that some operation of C j is affected by aborted o. In this case we call o relevant for C j (refer to the Technical Report [21] for a formal definition).…”