15 research outputs found
Lazy Sequentialization for TSO and PSO via Shared Memory Abstractions
Lazy sequentialization is one of the most effective approaches for the bounded verification of concurrent programs. Existing tools assume sequential consistency (SC), thus the feasibility of lazy sequentializations for weak memory models (WMMs) remains untested. Here, we describe the first lazy sequentialization approach for the total store order (TSO) and partial store order (PSO) memory models. We replace all shared memory accesses with operations on a shared memory abstraction (SMA), an abstract data type that encapsulates the semantics of the underlying WMM and implements it under the simpler SC model. We give efficient SMA implementations for TSO and PSO that are based on temporal circular doubly-linked lists, a new data structure that allows an efficient simulation of the store buffers. We show experimentally, both on the SV-COMP concurrency benchmarks and a real world instance, that this approach works well in combination with lazy sequentialization on top of bounded model checking
Embedding weak memory models within eager sequentialization
Sequentialization is one of the most promising approaches for the symbolic analysis of concurrent programs. However, existing sequentializations assume sequential consistency, which modern hardware architectures no longer guarantee. In this paper we describe an approach to embed weak memory models within eager sequentializations (a la Lal/Reps). Our approach is based on the separation of intra-thread computations from inter-thread communications by means of a shared memory abstraction (SMA). We give details of SMA implementations for the SC, TSO, and PSO memory models that are based on the idea of individual memory unwindings, and sketch an extension to the Power memory model. We use our approach to implement a new, efficient BMC-based bug finding tool for multi-threaded C programs under SC, TSO, or PSO based on these SMAs, and show experimentally that it is competitive to existing tools
Parallel bug-finding in concurrent programs via reduced interleaving instances
Concurrency poses a major challenge for program verification, but it can also offer an opportunity to scale when subproblems can be analysed in parallel. We exploit this opportunity here and use a parametrizable code-to-code translation to generate a set of simpler program instances, each capturing a reduced set of the original program’s interleavings. These instances can then be checked independently in parallel. Our approach does not depend on the tool that is chosen for the final analysis, is compatible with weak memory models, and amplifies the effectiveness of existing tools, making them find bugs faster and with fewer resources. We use Lazy-CSeq as an off-the-shelf final verifier to demonstrate that our approach is able, already with a small number of cores, to find bugs in the hardest known concurrency benchmarks in a matter of minutes, whereas other dynamic and static tools fail to do so in hours
Separating computation from communication: a design approach for concurrent program verification
We describe an approach to design static analysis and verification tools for concurrent programs that separates intra-thread computation from inter-thread communication by means of a shared memory abstraction (SMA). We formally characterize the concept of thread-asynchronous transition systems that underpins our approach and that allows us to design tools as two independent components, the intra-thread analysis, which can be optimized separately, and the implementation of the SMA itself, which can be exchanged easily (e.g., from the SC to the TSO memory model). We describe the SMA’s API and show that several concurrent verification techniques from the literature can easily be recast in our setting and thus be extended to weak memory models. We give SMA implementations for the SC, TSO, and PSO memory models that are based on the idea of individual memory unwindings. We instantiate our approach by developing a new, efficient BMC-based bug finding tool for multi-threaded C programs under SC, TSO, or PSO based on these SMAs, and show experimentally that it is competitive to existing tools
Extracting Safe Thread Schedules from Incomplete Model Checking Results
Model checkers frequently fail to completely verify a concurrent program, even if partial-order reduction is applied. The verification engineer is left in doubt whether the program is safe and the effort toward verifying the program is wasted. We present a technique that uses the results of such incomplete verification attempts to construct a (fair) scheduler that allows the safe execution of the partially verified concurrent program. This scheduler restricts the execution to schedules that have been proven safe (and prevents executions that were found to be erroneous). We evaluate the performance of our technique and show how it can be improved using partial-order reduction. While constraining the scheduler results in a considerable performance penalty in general, we show that in some cases our approach—somewhat surprisingly—even leads to faster executions
Computer Aided Verification
The open access two-volume set LNCS 11561 and 11562 constitutes the refereed proceedings of the 31st International Conference on Computer Aided Verification, CAV 2019, held in New York City, USA, in July 2019. The 52 full papers presented together with 13 tool papers and 2 case studies, were carefully reviewed and selected from 258 submissions. The papers were organized in the following topical sections: Part I: automata and timed systems; security and hyperproperties; synthesis; model checking; cyber-physical systems and machine learning; probabilistic systems, runtime techniques; dynamical, hybrid, and reactive systems; Part II: logics, decision procedures; and solvers; numerical programs; verification; distributed systems and networks; verification and invariants; and concurrency
Computer Aided Verification
The open access two-volume set LNCS 11561 and 11562 constitutes the refereed proceedings of the 31st International Conference on Computer Aided Verification, CAV 2019, held in New York City, USA, in July 2019. The 52 full papers presented together with 13 tool papers and 2 case studies, were carefully reviewed and selected from 258 submissions. The papers were organized in the following topical sections: Part I: automata and timed systems; security and hyperproperties; synthesis; model checking; cyber-physical systems and machine learning; probabilistic systems, runtime techniques; dynamical, hybrid, and reactive systems; Part II: logics, decision procedures; and solvers; numerical programs; verification; distributed systems and networks; verification and invariants; and concurrency
Verification and Enforcement of Safe Schedules for Concurrent Programs
Automated software verification can prove the correctness of a
program with respect to a given specification and may be a valuable
support in the difficult task of ensuring the quality of large
software systems. However, the automated verification of concurrent
software can be particularly challenging due to the vast complexity
that non-deterministic scheduling causes.
This thesis is concerned with techniques that reduce the complexity
of concurrent programs in order to ease the verification task. We
approach this problem from two orthogonal directions: state space
reduction and reduction of non-determinism in executions of
concurrent programs.
Following the former direction, we present an algorithm for dynamic
partial-order reduction, a state space reduction technique that
avoids the verification of redundant executions. Our algorithm,
EPOR, eagerly creates schedules for program fragments. In
comparison to other dynamic partial-order reduction algorithms, it
avoids redundant race and dependency checks. Our experiments show
that EPOR runs considerably faster than a state-of-the-art
algorithm, which allows in several cases to analyze programs with a
higher number of threads within a given timeout.
In the latter direction, we present a formal framework for using
incomplete verification results to extract safe schedulers. As
incomplete verification results do not need to proof the correctness
of all possible executions of a program, their complexity can be
significantly lower than complete verification results. Hence, they
can be faster obtained. We constrain the scheduling of programs but
not their inputs in order to preserve their full functionality. In
our framework, executions under the scheduling constraints of an
incomplete verification result are safe, deadlock-free, and fair. We
instantiate our framework with the Impact model checking algorithm
and find in our evaluation that it can be used to model check
programs that are intractable for monolithic model checkers,
synthesize synchronization via assume statements, and
guarantee fair executions.
In order to safely execute a program within the set of executions
covered by an incomplete verification, scheduling needs to be
constrained. We discuss how to extract and encode schedules from
incomplete verification results, for both finite and infinite
executions, and how to efficiently enforce scheduling constraints,
both in terms of reducing the time to look up permission of
executing the next event and executing independent events
concurrently (by applying partial-order reduction).
A drawback of enforcing scheduling constraints is a potential
overhead in the execution time. However, in several cases,
constrained executions turned out to be even faster than
unconstrained executions. Our experimental results show that
iteratively relaxing a schedule can significantly reduce this
overhead. Hence, it is possible to adjust the incurred execution
time overhead in order to find a sweet spot with respect to the
amount of effort for creating schedules (i.e., the duration of
verification). Interestingly, we found cases in which a much earlier
reduction of execution time overhead is obtained by choosing
favorable scheduling constraints, which suggests that execution time
performance does not simply rely on the number of scheduling
constraints but to a large extend also on their structure
Proceedings of the 21st Conference on Formal Methods in Computer-Aided Design – FMCAD 2021
The Conference on Formal Methods in Computer-Aided Design (FMCAD) is an annual conference on the theory and applications of formal methods in hardware and system verification. FMCAD provides a leading forum to researchers in academia and industry for presenting and discussing groundbreaking methods, technologies, theoretical results, and tools for reasoning formally about computing systems. FMCAD covers formal aspects of computer-aided system design including verification, specification, synthesis, and testing