🤖 AI Summary
This paper addresses the runtime verification of linearizability for concurrent shared objects. We propose the first fully asynchronous, wait-free, and fault-tolerant detection algorithm—departing from conventional approaches that rely on consensus or synchronization assumptions. Our method builds an indirect verification framework and an object-class transformation mechanism atop primitive read/write objects, enabling strong verification and self-strengthening implementations for arbitrary concurrent objects. We introduce a novel predictive variant of verification and rigorously establish the undecidability boundary for general linearization verification. The system generates machine-checkable certificates and supports generalized correctness conditions—including set-linearizability and interval-linearizability—without requiring consensus primitives. This work establishes a new paradigm for modular, verifiable concurrent systems, delivering provably strong verification guarantees under minimal assumptions.
📝 Abstract
This paper studies the problem of verifying linearizability at runtime, where one seeks for a concurrent algorithm for verifying that the current execution of a given concurrent shared object implementation is linearizable. It shows that it is impossible to runtime verify linearizability for some common sequential objects, regardless of the consensus power of base objects. Then, it argues that actually a stronger version of the problem can be solved, if linearizability is verified indirectly. Namely, it shows that (1) linearizability of a class of concurrent implementations can be strongly verified using only read/write base objects (i.e. without the need of consensus), and (2) any implementation can be transformed to its counterpart in the class (which implements the same object) using only read/write objects too. As far as we know, this is the first runtime verification algorithm for any correctness condition that is fully asynchronous and fault-tolerant. As a by-product, a simple and generic methodology for deriving self-enforced linearizable implementations is obtained. This type implementations produce outputs that are guaranteed linearizable, and are able to produce a certificate of it, which allows the design of concurrent systems in a modular manner with accountable and forensic guarantees. These results hold not only for linearizability but for a correctness condition that includes generalizations of it such as set-linearizability and interval-linearizability.