Effect Summaries for Thread-Modular Analysis - Sound Analysis Despite an Unsound Heuristic

  title={Effect Summaries for Thread-Modular Analysis - Sound Analysis Despite an Unsound Heuristic},
  author={Luk{\'a}s Hol{\'i}k and Roland Meyer and Tom{\'a}s Vojnar and Sebastian Wolff},
We propose a novel guess-and-check principle to increase the efficiency of thread-modular verification of lock-free data structures. We build on a heuristic that guesses candidates for stateless effect summaries of programs by searching the code for instances of a copy-and-check programming idiom common in lock-free data structures. These candidate summaries are used to compute the interference among threads in linear time. Since a candidate summary need not be a sound effect summary, we show… Expand
Rely-guarantee bound analysis of parameterized concurrent shared-memory programs
A thread-modular proof method for complexity and resource bound analysis of concurrent, shared-memory programs, and automatically infer time complexity for a family of fine-grained concurrent algorithms, lock-free data structures, to the authors' knowledge for the first time. Expand
Rely-Guarantee Reasoning for Automated Bound Analysis of Lock-Free Algorithms
We present a thread-modular proof method for complexity and resource bound analysis of concurrent, shared-memory programs, lifting Jones’ rely-guarantee reasoning to assumptions and commitmentsExpand
Pointer life cycle types for lock-free data structures with memory reclamation
This work considers the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm and introduces angels, ghost variables with an angelic semantics, to automate the type inference and the invariant check. Expand
Decoupling lock-free data structures from memory reclamation for static analysis
The approach is implemented and was able to verify linearizability of Michael&Scott's queue and the DGLM queue for both hazard pointers and epoch-based reclamation, the first to verify such implementations fully automatically. Expand
Fine-Grained Complexity of Safety Verification
Formally, it is shown that there is no polynomial kernel, no compression algorithm that reduces D or s to aPolynomial dependence on P and t, which indicates that symbolic methods may be harder to find for this problem. Expand
Reasoning About Weak Semantics via Strong Semantics
Programs are often well-behaved in that they appear to be executed under sequentially-consistent memory, garbage collection, and with few clients—although they are not, and there is a correspondence between the actual semantics and an idealized much simpler variant. Expand
New Challenges in Parallelism
A continuing goal of current multiprocessor software design is to improve the performance and reliability of parallel algorithms. Parallel programming has traditionally been attacked from widelyExpand
Fine-Grained Complexity of Safety Verification
The fine-grained complexity of Leader Contributor Reachability and Bounded-Stage Reachability, two variants of the safety verification problem for shared memory concurrent programs, is studied and the absence of polynomial kernels is proved. Expand


Effect Summaries for Thread-Modular Analysis
This work proposes a novel guess-and-check principle to increase the efficiency of thread-modular verification of lock-free data structures and shows how to fully automatically check whether the precision of candidate summaries is sufficient. Expand
Abstract Transformers for Thread Correlation Analysis
A technique that exploits the notion of footprints and memoization to compute individual abstract transformers more efficiently is introduced and used to prove properties of fine-grained concurrent programs with a shared, mutable, heap in the presence of an unbounded number of objects and threads. Expand
Static Analysis of Run-Time Errors in Embedded Critical Parallel C Programs
This work presents a static analysis by Abstract Interpretation to check for run-time errors in parallel C programs, and proves the soundness of the method with respect to a sequential consistent semantics and a reasonable weakly consistent memory semantics. Expand
Relational Thread-Modular Static Value Analysis by Abstract Interpretation
This work formalizes by abstract interpretation of a rely-guarantee concrete semantics which is thread-modular, constructive, and complete for safety properties, and shows that previous analyses based on non-relational interferences can be retrieved as coarse computable abstractions of this semantics. Expand
Thread-modular shape analysis
This work presents the first shape analysis for multithreaded programs that avoids the explicit enumeration of execution-interleavings and shows that resource invariants of a certain class can be characterized as least fixed points and computed via repeated applications of shape analysis only on each individual thread. Expand
Reduction for compositional verification of multi-threaded programs
This paper proposes proof rules for safety and termination of multi-threaded programs that integrate into an Owicki-Gries based compositional verifier, and presents preliminary experimental results that show the advantages of the approach when compared to state-of-the-art verifiers of C programs. Expand
Precise Thread-Modular Abstract Interpretation of Concurrent Programs Using Relational Interference Abstractions
A static analysis by abstract interpretation of numeric properties in multi-threaded programs that builds on previous work that formalized rely-guarantee verification methods as a concrete, fixpoint-based semantics and applies classic numeric abstractions to abstract independently thread states and thread interference. Expand
Atomicity Refinement for Verified Compilation
This article proposes a refinement-based proof methodology that precisely relates concurrent code expressed at different abstraction levels, cognizant throughout of the relaxed memory semantics of the underlying processor. Expand
Thread Quantification for Concurrent Shape Analysis
An instantiation of the technique with Canonical Abstraction as the base abstraction is implemented and used to successfully verify linearizability of data-structures in the presence of an unbounded number of threads. Expand
Pointer Race Freedom
We propose a novel notion of pointer race for concurrent programs manipulating a shared heap. A pointer race is an access to a memory address which was freed, and it is out of the accessor's controlExpand