[Paper Review] Faster linearizability checking via $P$-compositionality

Alex Horn, Daniel Kroening|arXiv (Cornell University)|Apr 1, 2015

Distributed systems and fault tolerance16 references4 citations

TL;DR

This paper introduces P-compositionality, a novel partitioning technique that generalizes Herlihy and Wing's locality principle to enable faster linearizability checking in concurrent data types. By exploiting independence among operations on the same object—such as those in concurrent sets—it reduces the search space, resulting in a linearizability checker that is up to one order of magnitude faster and more space-efficient than the state-of-the-art WGL algorithm, particularly when applied to implementations like Intel's TBB.

ABSTRACT

Linearizability is a well-established consistency and correctness criterion for concurrent data types. An important feature of linearizability is Herlihy and Wing's locality principle, which says that a concurrent system is linearizable if and only if all of its constituent parts (so-called objects) are linearizable. This paper presents $P$-compositionality, which generalizes the idea behind the locality principle to operations on the same concurrent data type. We implement $P$-compositionality in a novel linearizability checker. Our experiments with over nine implementations of concurrent sets, including Intel's TBB library, show that our linearizability checker is one order of magnitude faster and/or more space efficient than the state-of-the-art algorithm.

Motivation & Objective

• To address the high computational cost of linearizability checking in concurrent systems, which is NP-complete and suffers from massive search spaces.
• To generalize Herlihy and Wing’s locality principle to operations on the same concurrent object, enabling more effective pruning of the search space.
• To develop a precise, fully automatic, and efficient linearizability checker that integrates with runtime monitors and executable specifications.
• To evaluate the performance of the new checker on real-world concurrent data type implementations, especially those from Intel’s TBB library.
• To demonstrate that P-compositionality enables significant speedups and memory efficiency improvements over existing state-of-the-art algorithms.

Proposed method

• Propose P-compositionality as a generalization of Herlihy and Wing’s locality principle, enabling partitioning of the linearizability problem into independent subproblems based on operation keys or components.
• Base the implementation on the WGL algorithm, which uses state equivalence pruning to avoid redundant exploration of isomorphic states.
• Integrate the P-compositionality optimization into the WGL framework to accelerate search by solving independent subproblems in parallel or sequentially with reduced state space.
• Use executable specifications (code) as input, enabling seamless integration with runtime monitors to generate histories from actual program runs.
• Preserve precision by avoiding false positives and ensuring correctness through formal guarantees of the underlying decision procedure.
• Apply the checker to nine concurrent set implementations, including Intel’s TBB, to empirically evaluate performance and scalability.

Experimental results

Research questions

• RQ1 Can P-compositionality be formally defined and applied to generalize the locality principle beyond individual objects to operations on the same object?
• RQ2 Does P-compositionality enable significant performance improvements in linearizability checking compared to existing state-of-the-art algorithms?
• RQ3 To what extent can P-compositionality be applied to real-world concurrent data structures, such as those in Intel’s TBB library?
• RQ4 How does the performance of the P-compositional checker compare to the WGL algorithm in terms of time and memory usage across diverse concurrent set implementations?
• RQ5 Can the proposed technique be integrated into existing runtime verification pipelines without requiring manual specification or annotation?

Key findings

• The proposed linearizability checker based on P-compositionality achieves a speedup of at least one order of magnitude over the WGL algorithm on nine concurrent set implementations.
• The checker is also more memory-efficient, reducing space usage by up to an order of magnitude in the evaluated benchmarks.
• The performance improvement is consistent across diverse implementations, including production-grade code from Intel’s TBB library.
• The technique maintains full precision, reporting no false positives, which is critical for large-scale validation of concurrent systems.
• The integration with executable specifications and runtime monitors enables practical deployment in real-world software validation pipelines.
• P-compositionality enables effective pruning of the search space by exploiting structural independence in operations, particularly in key-based concurrent data types.