Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Reasoning about systems with many processes
Journal of the ACM (JACM)
The serializability of concurrent database updates
Journal of the ACM (JACM)
Combining funnels: a dynamic approach to software combining
Journal of Parallel and Distributed Computing
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
A scalable lock-free stack algorithm
Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures
Using elimination to implement scalable and lock-free FIFO queues
Proceedings of the seventeenth annual ACM symposium on Parallelism in algorithms and architectures
Thread Quantification for Concurrent Shape Analysis
CAV '08 Proceedings of the 20th international conference on Computer Aided Verification
Comparison under abstraction for verifying linearizability
CAV'07 Proceedings of the 19th international conference on Computer aided verification
Flat combining and the synchronization-parallelism tradeoff
Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures
Verifying linearizability with hindsight
Proceedings of the 29th ACM SIGACT-SIGOPS symposium on Principles of distributed computing
On inter-procedural analysis of programs with lists and data
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Automatically proving linearizability
CAV'10 Proceedings of the 22nd international conference on Computer Aided Verification
Model checking of linearizability of concurrent list implementations
CAV'10 Proceedings of the 22nd international conference on Computer Aided Verification
How to prove algorithms linearisable
CAV'12 Proceedings of the 24th international conference on Computer Aided Verification
Hi-index | 0.00 |
An execution containing operations performing queries or updating a concurrent object is linearizable w.r.t an abstract implementation (called specification) iff for each operation, one can associate a point in time, called linearization point, such that the execution of the operations in the order of their linearization points can be reproduced by the specification. Finding linearization points is particularly difficult when they do not belong to the operations's actions. This paper addresses this challenge by introducing a new technique for rewriting the implementation of the concurrent object and its specification such that the new implementation preserves all executions of the original one, and its linearizability (w.r.t. the new specification) implies the linearizability of the original implementation (w.r.t. the original specification). The rewriting introduces additional combined methods to obtain a library with a simpler linearizability proof, i.e., a library whose operations contain their linearization points. We have implemented this technique in a prototype, which has been successfully applied to examples beyond the reach of current techniques, e.g., Stack Elimination and Fetch&Add.