Efficient Linearizability Monitoring

2025-09-22

AI Summary

This work addresses the linearizability monitoring problem for execution histories of concurrent data structures—namely stacks, queues, sets, and multisets. Existing approaches suffer from high computational complexity and lack formal correctness guarantees. To overcome these limitations, we propose a novel monitoring algorithm grounded in the data-independence assumption. Our method achieves optimal time complexities: *O*(*n*²) for stacks, *O*(*n* log *n*) for queues, and *O*(*n*) for sets—each constituting the first known optimal bounds for their respective structures—and provides full formal correctness proofs. Technically, the approach integrates sequential constraint modeling, partial-order reduction, and event-matching techniques to balance precision and efficiency. We implement our algorithm in LiMo, a practical tool that significantly outperforms the state-of-the-art Violin on standard benchmarks, enabling scalable, efficient linearizability verification for large-scale concurrent histories.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Knowledge Representation and Reasoning: Computational Complexity of Reasoning
• Planning, Routing, and Scheduling: Plan Execution and Monitoring

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Security and Privacy: Data transparency and provenance
• Systems and Infrastructure for Web, Mobile and WoT: Web performance, measurement, and characterization

Abstract

This paper revisits the fundamental problem of monitoring the linearizability of concurrent stacks, queues, sets, and multisets. Given a history of a library implementing one of these abstract data types, the monitoring problem is to answer whether the given history is linearizable. For stacks, queues, and (multi)sets, we present monitoring algorithms with complexities $mathcal{O}(n^2)$, $mathcal{O}(n; log, n)$, and $mathcal{O}{(n)}$, respectively, where $n$ is the number of operations in the input history. For stacks and queues, our results hold under the standard assumption of {it data-independence}, i.e., the behavior of the library is not sensitive to the actual values stored in the data structure. Past works to solve the same problems have cubic time complexity and (more seriously) have correctness issues: they either (i) lack correctness proofs or (ii) the suggested correctness proofs are erroneous (we present counter-examples), or (iii) have incorrect algorithms. Our improved complexity results rely on substantially different algorithms for which we provide detailed proofs of correctness. We have implemented our stack and queue algorithms in LiMo (Linearizability Monitor). We evaluate LiMo and compare it with the state-of-the-art tool Violin -- whose correctness proofs we have found errors in -- which checks for linearizability violations. Our experimental evaluation confirms that LiMo outperforms Violin regarding both efficiency and scalability.

Problem

• Monitoring linearizability of concurrent data structures like stacks and queues
• Developing efficient algorithms with improved time complexity for verification
• Addressing correctness issues in previous linearizability monitoring approaches

Innovation

• Developed efficient linearizability monitoring algorithms for concurrent data structures
• Achieved improved time complexities from O(n²) to O(n log n)
• Implemented LiMo tool with proven correctness and better performance