Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Simple, fast, and practical non-blocking and blocking concurrent queue algorithms
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Verifying properties of parallel programs: an axiomatic approach
Communications of the ACM
An axiomatic basis for computer programming
Communications of the ACM
BI as an assertion language for mutable data structures
POPL '01 Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Static prediction of heap space usage for first-order functional programs
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
A Pragmatic Implementation of Non-blocking Linked-Lists
DISC '01 Proceedings of the 15th International Conference on Distributed Computing
Obstruction-Free Synchronization: Double-Ended Queues as an Example
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
Nonblocking synchronization and system design
Nonblocking synchronization and system design
Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
IEEE Transactions on Parallel and Distributed Systems
A scalable lock-free stack algorithm
Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures
Transition predicate abstraction and fair termination
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Permission accounting in separation logic
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular verification of a non-blocking stack
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Resources, concurrency, and local reasoning
Theoretical Computer Science
Proving that non-blocking algorithms don't block
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Local rely-guarantee reasoning
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A general technique for proving lock-freedom
Science of Computer Programming
Communications of the ACM - Security in the Browser
Progress guarantee for parallel programs via bounded lock-freedom
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
A hybrid type system for lock-freedom of mobile processes
ACM Transactions on Programming Languages and Systems (TOPLAS)
Verifying lock-freedom using well-founded orders
ICTAC'07 Proceedings of the 4th international conference on Theoretical aspects of computing
Concurrent abstract predicates
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Temporal logic verification of lock-freedom
MPC'10 Proceedings of the 10th international conference on Mathematics of program construction
Reasoning about optimistic concurrency using a program logic for history
CONCUR'10 Proceedings of the 21st international conference on Concurrency theory
Data structures in the multicore age
Communications of the ACM
Concurrent Separation Logic and Operational Semantics
Electronic Notes in Theoretical Computer Science (ENTCS)
Amortised resource analysis with separation logic
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
A marriage of rely/guarantee and separation logic
CONCUR'07 Proceedings of the 18th international conference on Concurrency Theory
| Hi-index | 0.00 |
This article describes a novel quantitative proof technique for the modular and local verification of lock-freedom. In contrast to proofs based on temporal rely-guarantee requirements, this new quantitative reasoning method can be directly integrated in modern program logics that are designed for the verification of safety properties. Using a single formalism for verifying memory safety and lock-freedom allows a combined correctness proof that verifies both properties simultaneously. This article presents one possible formalization of this quantitative proof technique by developing a variant of concurrent separation logic (CSL) for total correctness. To enable quantitative reasoning, CSL is extended with a predicate for affine tokens to account for, and provide an upper bound on the number of loop iterations in a program. Lock-freedom is then reduced to total-correctness proofs. Quantitative reasoning is demonstrated in detail, both informally and formally, by verifying the lock-freedom of Treiber's non-blocking stack. Furthermore, it is shown how the technique is used to verify the lock-freedom of more advanced shared-memory data structures that use elimination-back off schemes and hazard-pointers.