5 research outputs found
Partial Orders for Efficient BMC of Concurrent Software
This version previously deposited at arXiv:1301.1629v1 [cs.LO]The vast number of interleavings that a concurrent program can have is typically identified as the root cause of the difficulty of automatic analysis of concurrent software. Weak memory is generally believed to make this problem even harder. We address both issues by modelling programs' executions with partial orders rather than the interleaving semantics (SC). We implemented a software analysis tool based on these ideas. It scales to programs of sufficient size to achieve first-time formal verification of non-trivial concurrent systems code over a wide range of models, including SC, Intel x86 and IBM Power
Software Model Checking with Explicit Scheduler and Symbolic Threads
In many practical application domains, the software is organized into a set
of threads, whose activation is exclusive and controlled by a cooperative
scheduling policy: threads execute, without any interruption, until they either
terminate or yield the control explicitly to the scheduler. The formal
verification of such software poses significant challenges. On the one side,
each thread may have infinite state space, and might call for abstraction. On
the other side, the scheduling policy is often important for correctness, and
an approach based on abstracting the scheduler may result in loss of precision
and false positives. Unfortunately, the translation of the problem into a
purely sequential software model checking problem turns out to be highly
inefficient for the available technologies. We propose a software model
checking technique that exploits the intrinsic structure of these programs.
Each thread is translated into a separate sequential program and explored
symbolically with lazy abstraction, while the overall verification is
orchestrated by the direct execution of the scheduler. The approach is
optimized by filtering the exploration of the scheduler with the integration of
partial-order reduction. The technique, called ESST (Explicit Scheduler,
Symbolic Threads) has been implemented and experimentally evaluated on a
significant set of benchmarks. The results demonstrate that ESST technique is
way more effective than software model checking applied to the sequentialized
programs, and that partial-order reduction can lead to further performance
improvements.Comment: 40 pages, 10 figures, accepted for publication in journal of logical
methods in computer scienc
Shared Memory Concurrent System Verification using Kronecker Algebra
The verification of multithreaded software is still a challenge. This comes
mainly from the fact that the number of thread interleavings grows
exponentially in the number of threads. The idea that thread interleavings can
be studied with a matrix calculus is a novel approach in this research area.
Our sparse matrix representations of the program are manipulated using a lazy
implementation of Kronecker algebra. One goal is the generation of a data
structure called Concurrent Program Graph (CPG) which describes all possible
interleavings and incorporates synchronization while preserving completeness.
We prove that CPGs in general can be represented by sparse adjacency matrices.
Thus the number of entries in the matrices is linear in their number of lines.
Hence efficient algorithms can be applied to CPGs. In addition, due to
synchronization only very small parts of the resulting matrix are actually
needed, whereas the rest is unreachable in terms of automata. Thanks to the
lazy implementation of the matrix operations the unreachable parts are never
calculated. This speeds up processing significantly and shows that this
approach is very promising. Various applications including data flow analysis
can be performed on CPGs. Furthermore, the structure of the matrices can be
used to prove properties of the underlying program for an arbitrary number of
threads. For example, deadlock freedom is proved for a large class of programs.Comment: 31 page