Verifying a Quantitative Relaxation of Linearizability via Refinement

Abstract

Concurrent data structures have found increasingly widespread use in both multicore and distributed computing environments, thereby escalating the priority for verifying their correctness. The thread safe behavior of these concurrent objects is often described using formal semantics known as linearizability, which requires that every operation in a concurrent object appears to take effect between its invocation and response. Quasi linearizability is a quantitative relaxation of linearizability to allow more implementation freedom for performance optimization. However, ensuring the quantitative aspects of this new correctness condition is an arduous task. We propose the first method for formally verifying quasi linearizability of the implementation model of a concurrent data structure. The method is based on checking the refinement relation between the implementation model and a specification model via explicit state model checking. It can directly handle multi-threaded programs where each thread can make infinitely many method calls, without requiring the user to manually annotate for the linearization points. We have implemented and evaluated our method in the PAT model checking toolkit. Our experiments show that the method is effective in verifying quasi linearizability and in detecting its violations.

Efficient linearizability checking for actor‐based systems

“…The authors of a tool called Inspect implemented a fully automatic approach using LLVM to detect and report real violation of quasi linearizability. Adhikari et al 79 verify quantitative relaxation of quasi linearizability of an implementation model of the data structure. It is based on checking the refinement relation between the implementation and a specification model.…”