The Case of Unreliable Base Objects

Abstract

The previous chapter presented universal constructions that allow one to build implementations of any object defined by a sequential specification (on total operations) that are wait-free, i.e., that tolerate any number of process crashes. As we have seen, these constructions rest on two types of objects: atomic read/write registers and consensus objects. These universal constructions assume that these base objects are reliable; namely, they implicitly consider that their behavior always complies with their specification. As an example, given an atomic register $R$, it is assumed that an invocation of $R.\mathsf{{read}}()$ always returns the last value that was written into $R$ (“last” is with respect to the linearization order). Similarly, given a consensus object $CONS$, an invocation $CONS .\mathsf{{propose}}()$ is assumed to always return the single value decided by this consensus object.

This chapter revisits the failure-free object assumption and investigates the case where the base objects are prone to failure. It focuses on the self-implementation of such objects. Self-implementation means that the internal representation of the reliable object $RO$ that is built relies on a bounded number $m$ of objects $O_1,\ldots ,O_m$ of the very same type. Hence, a reliable atomic register is built from a set of atomic registers of which some (not known in advance) can be faulty, and similarly for a consensus object. Moreover, such a self-implementation has to be $t$-tolerant. This means that the reliability of the object $RO$ that is built has to be guaranteed despite the fact that up to $t$ of the base objects $O_1,\ldots ,O_m$ which implement $RO$ can be faulty (Fig. 15.1). Hence, this chapter is devoted to the self-implementation of $t$-tolerant atomic read/write registers and consensus objects.

From a terminology point of view, wait-freedom is related to process crashes while $t$-tolerance is related to the failure of base objects.