CoVer-ability: Consistent Versioning in Asynchronous, Fail-Prone, Message-Passing Environments
MetadataShow full item record
An object type characterizes the domain space and the operations that can be invoked on an object of that type. In this paper we introduce a new property for concurrent objects, we call coverability, that aims to provide precise guarantees on the consistent evolution of the version (and thus value) of an object. This new property is suitable for a variety of distributed objects, including concurrent file objects, that demand operations to manipulate the latest version of the object. To preserve the order of versions, traditional approaches use locking, compare-andswap (CAS), or linked-load/conditional-store (LL/SC) primitives to allow a single modification at a time on such objects. Such primitives however can be used to solve consensus, and thus are impossible to be implemented in an asynchronous, message passing environment with failures. Coverability, relaxes the strong requirements imposed by stronger primitives, and allows us to define and implement consistent versioning in the aforementioned adversarial environment. In particular, coverability allows multiple operations to modify the same version of an object concurrently, leading to a set of different versions. Given an order of operations, coverability properties specify a single version in that set that any subsequent operation may modify, preserving this way the consistent evolution of the object. We first define versioned objects and then provide the specification of coverability. We then combine coverability with atomic guarantees to yield coverable atomic read/write registers; we show that coverable registers cannot be implemented by similar types of registers, such as ranked-registers. Next, we show how coverable registers may be implemented by modifying an existing MWMR atomic register implementation, and we continue by showing that coverable registers may be used to implement basic (weak) read-modify-write and file objects.