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
The existence of refinement mappings
Theoretical Computer Science
Compiler correctness for parallel languages
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
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
Local rely-guarantee reasoning
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
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
Abstraction for concurrent objects
Theoretical Computer Science
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
A rely-guarantee-based simulation for verifying concurrent program transformations
POPL '12 Proceedings of the 39th 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
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 article, 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 with respect to 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.