Tentative steps toward a development method for interfering programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
In transition from global to modular temporal reasoning about programs
Logics and models of concurrent systems
ACM Transactions on Programming Languages and Systems (TOPLAS)
Transactional memory: architectural support for lock-free data structures
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
The ``Hoare Logic'' of CSP, and All That
ACM Transactions on Programming Languages and Systems (TOPLAS)
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Proceedings of the Conference on Logic of Programs
Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
IEEE Transactions on Parallel and Distributed Systems
Variables as Resource in Hoare Logics
LICS '06 Proceedings of the 21st Annual IEEE Symposium on Logic in Computer Science
Modular verification of a non-blocking stack
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proofs of Networks of Processes
IEEE Transactions on Software Engineering
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
On the relationship between concurrent separation logic and assume-guarantee reasoning
ESOP'07 Proceedings of the 16th European conference on Programming
DISC'06 Proceedings of the 20th international conference on Distributed Computing
A marriage of rely/guarantee and separation logic
CONCUR'07 Proceedings of the 18th international conference on Concurrency Theory
Formal verification of a lock-free stack with hazard pointers
ICTAC'11 Proceedings of the 8th international conference on Theoretical aspects of computing
Verification of scalable synchronous queue
CPP'11 Proceedings of the First international conference on Certified Programs and Proofs
How to prove algorithms linearisable
CAV'12 Proceedings of the 24th international conference on Computer Aided Verification
Subjective auxiliary state for coarse-grained concurrency
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verifying concurrent memory reclamation algorithms with grace
ESOP'13 Proceedings of the 22nd European conference on Programming Languages and Systems
Quantitative Reasoning for Proving Lock-Freedom
LICS '13 Proceedings of the 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science
| Hi-index | 0.00 |
Optimistic concurrency algorithms provide good performance for parallel programs but they are extremely hard to reason about. Program logics such as concurrent separation logic and rely-guarantee reasoning can be used to verify these algorithms, but they make heavy uses of history variables which may obscure the high-level intuition underlying the design of these algorithms. In this paper, we propose a novel program logic that uses invariants on history traces to reason about optimistic concurrency algorithms. We use past tense temporal operators in our assertions to specify execution histories. Our logic supports modular program specifications with history information by providing separation over both space (program states) and time. We verify Michael's non-blocking stack algorithm and show that the intuition behind such algorithm can be naturally captured using trace invariants.