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.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
Copyright information
© 2013 Springer-Verlag Berlin Heidelberg
About this chapter
Cite this chapter
Raynal, M. (2013). The Case of Unreliable Base Objects. In: Concurrent Programming: Algorithms, Principles, and Foundations. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-32027-9_15
Download citation
DOI: https://doi.org/10.1007/978-3-642-32027-9_15
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-642-32026-2
Online ISBN: 978-3-642-32027-9
eBook Packages: Computer ScienceComputer Science (R0)