Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Verifying properties of parallel programs: an axiomatic approach
Communications of the ACM
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
A Practical Multi-word Compare-and-Swap Operation
DISC '02 Proceedings of the 16th International Conference on Distributed Computing
Local Reasoning about Programs that Alter Data Structures
CSL '01 Proceedings of the 15th International Workshop on Computer Science Logic
Permission accounting in separation logic
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verification of Concurrent Programs with Chalice
Foundations of Security Analysis and Design V
Local reasoning for storable locks and threads
APLAS'07 Proceedings of the 5th Asian conference on Programming languages and systems
Concurrent abstract predicates
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
A quick tour of the VeriFast program verifier
APLAS'10 Proceedings of the 8th Asian conference on Programming languages and systems
Automatically proving linearizability
CAV'10 Proceedings of the 22nd international conference on Computer Aided Verification
A marriage of rely/guarantee and separation logic
CONCUR'07 Proceedings of the 18th international conference on Concurrency Theory
VeriFast: a powerful, sound, predictable, fast verifier for C and java
NFM'11 Proceedings of the Third international conference on NASA Formal methods
Barriers in concurrent separation logic
ESOP'11/ETAPS'11 Proceedings of the 20th European conference on Programming languages and systems: part of the joint European conferences on theory and practice of software
Concurrent Separation Logic and Operational Semantics
Electronic Notes in Theoretical Computer Science (ENTCS)
Orchestrating security and system engineering for evolving systems
ServiceWave'11 Proceedings of the 4th European conference on Towards a service-based internet
The VerCors project: setting up basecamp
PLPV '12 Proceedings of the sixth workshop on Programming languages meets program verification
ACM Transactions on Programming Languages and Systems (TOPLAS)
Variable permissions for concurrency verification
ICFEM'12 Proceedings of the 14th international conference on Formal Engineering Methods: formal methods and software engineering
Subjective auxiliary state for coarse-grained concurrency
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular reasoning about separation of concurrent data structures
ESOP'13 Proceedings of the 22nd European conference on Programming Languages and Systems
Joins: a case study in modular specification of a concurrent reentrant higher-order library
ECOOP'13 Proceedings of the 27th European conference on Object-Oriented Programming
Aliasing in Object-Oriented Programming
Software verification with VeriFast: Industrial case studies
Science of Computer Programming
| Hi-index | 0.00 |
Compared to coarse-grained external synchronization of operations on data structures shared between concurrent threads, fine-grained, internal synchronization can offer stronger progress guarantees and better performance. However, fully specifying operations that perform internal synchronization modularly is a hard, open problem. The state of the art approaches, based on linearizability or on concurrent abstract predicates, have important limitations on the expressiveness of specifications. Linearizability does not support ownership transfer, and the concurrent abstract predicates-based specification approach requires hardcoding a particular usage protocol. In this paper, we propose a novel approach that lifts these limitations and enables fully general specification of fine-grained concurrent data structures. The basic idea is that clients pass the ghost code required to instantiate an operation's specification for a specific client scenario into the operation in a simple form of higher-order programming. We machine-checked the theory of the paper using the Coq proof assistant. Furthermore, we implemented the approach in our program verifier VeriFast and used it to verify two challenging fine-grained concurrent data structures from the literature: a multiple-compare-and-swap algorithm and a lock-coupling list.