Tentative steps toward a development method for interfering programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Mostly parallel garbage collection
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Compiler correctness for parallel languages
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Compiler Correctness for Concurrent Languages
COORDINATION '96 Proceedings of the First International Conference on Coordination Languages and Models
Simple relational correctness proofs for static analyses and program transformations
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Threads cannot be implemented as a library
Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation
A parallel, incremental, mostly concurrent garbage collector for servers
ACM Transactions on Programming Languages and Systems (TOPLAS)
Correctness-preserving derivation of concurrent garbage collection algorithms
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Variables as Resource in Hoare Logics
LICS '06 Proceedings of the 21st Annual IEEE Symposium on Logic in Computer Science
Theoretical Computer Science
A general framework for certifying garbage collectors and their mutators
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Foundations of the C++ concurrency memory model
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
A model of cooperative threads
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Abstraction for Concurrent Objects
ESOP '09 Proceedings of the 18th European Symposium on Programming Languages and Systems: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
Biorthogonality, step-indexing and compiler correctness
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
A Formally Verified Compiler Back-end
Journal of Automated Reasoning
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
Formal derivation of concurrent garbage collectors
MPC'10 Proceedings of the 10th international conference on Mathematics of program construction
Relaxed-memory concurrency and verified compilation
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A kripke logical relation between ML and assembly
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A separation logic for refining concurrent objects
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Verifying local transformations on relaxed memory models
CC'10/ETAPS'10 Proceedings of the 19th joint European conference on Theory and Practice of Software, international conference on Compiler Construction
Verifying a compiler for java threads
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Simplifying linearizability proofs with reduction and abstraction
TACAS'10 Proceedings of the 16th international conference on Tools and Algorithms for the Construction and Analysis of Systems
A marriage of rely/guarantee and separation logic
CONCUR'07 Proceedings of the 18th international conference on Concurrency Theory
Abstraction as a unifying link for formal approaches to concurrency
SEFM'12 Proceedings of the 10th international conference on Software Engineering and Formal Methods
Logical relations for fine-grained concurrency
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular verification of linearizability with non-fixed linearization points
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Characterizing progress properties of concurrent objects via contextual refinements
CONCUR'13 Proceedings of the 24th international conference on Concurrency Theory
Replicated data types: specification, verification, optimality
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Rely-Guarantee-Based Simulation for Compositional Verification of Concurrent Program Transformations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Hi-index | 0.00 |
Verifying program transformations usually requires proving that the resulting program (the target) refines or is equivalent to the original one (the source). However, the refinement relation between individual sequential threads cannot be preserved in general with the presence of parallel compositions, due to instruction reordering and the different granularities of atomic operations at the source and the target. On the other hand, the refinement relation defined based on fully abstract semantics of concurrent programs assumes arbitrary parallel environments, which is too strong and cannot be satisfied by many well-known transformations. In this paper, we propose a Rely-Guarantee-based Simulation (RGSim) to verify concurrent program transformations. The relation is parametrized with constraints of the environments that the source and the target programs may compose with. It considers the interference between threads and their environments, thus is less permissive than relations over sequential programs. It is compositional w.r.t. parallel compositions as long as the constraints are satisfied. Also, RGSim does not require semantics preservation under all environments, and can incorporate the assumptions about environments made by specific program transformations in the form of rely/guarantee conditions. We use RGSim to reason about optimizations and prove atomicity of concurrent objects. We also propose a general garbage collector verification framework based on RGSim, and verify the Boehm et al. concurrent mark-sweep GC.