Advertisement

The Case of Unreliable Base Objects

  • Michel RaynalEmail author
Chapter
  • 2.5k Downloads

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.

Keywords

Arbitrary failure Atomic read/write register Bounded versus unbounded implementation Consensus object Crash failure Graceful degradation Omission failure Responsive versus non-responsive failure Self-implementation  \(t\)-Tolerant implementation Wait-freedom 

Copyright information

© Springer-Verlag Berlin Heidelberg 2013

Authors and Affiliations

  1. 1.IRISA-ISTICInstitut Universitaire de FranceRennes CedexFrance

Personalised recommendations