Lazy-CSeq 2.0: Combining Lazy Sequentialization with Abstract Interpretation

Nguyen, Truc L.; Inverso, Omar; Fischer, Bernd; Torre, Salvatore La; Parlato, Gennaro

doi:10.1007/978-3-662-54580-5_26

Cited by 8 publications

(2 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…More specifically, we run the Frama-C abstract interpretation tool over the programs constructed by Lazy-CSeq to compute overapproximating intervals for all (original) program variables and then exploit CBMC's bitvector support to reduce the number of bits required to represent these in the sequentialized program. We have implemented this approach on top of Lazy-CSeq and have demonstrated the effectiveness of this approach; it has performed very well in SV-COMP'17 competition, where it solved all tasks [26]. In this paper, in particular, we have further shown that it leads to large performance gains for very hard verification problems.…”

Section: Discussionmentioning

confidence: 79%

Concurrent Program Verification with Lazy Sequentialization and Interval Analysis

et al. 2017

Self Cite

View full text Add to dashboard Cite

Abstract. Lazy sequentialization has proven to be one of the most effective techniques for concurrent program verification. The Lazy-CSeq sequentialization tool performs a "lazy" code-to-code translation from a concurrent program into an equivalent non-deterministic sequential program, i.e., it preserves the valuations of the program variables along its executions. The obtained program is then analyzed using sequential bounded model checking tools. However, the sizes of the individual states still pose problems for further scaling. We therefore use abstract interpretation to minimize the representation of the concurrent program's (shared global and thread-local) state variables. More specifically, we run the Frama-C abstract interpretation tool over the programs constructed by Lazy-CSeq to compute overapproximating intervals for all (original) state variables and then exploit CBMC's bitvector support to reduce the number of bits required to represent these in the sequentialized program. We have implemented this approach in the last release of Lazy-CSeq and demonstrate the effectiveness of this approach; in particular, we show that it leads to large performance gains for very hard verification problems.

show abstract

Section: Discussionmentioning

confidence: 79%

Concurrent Program Verification with Lazy Sequentialization and Interval Analysis

et al. 2017

Self Cite

View full text Add to dashboard Cite

show abstract

“…The method recurs on all the instances where the timeout is reached. This method has the potential to take advantage of both the best available technologies for finding bugs, such as those based on BMC [17], [46], [47], [48], [49] and testing [38], [36], [22], and for proving absence of bugs, such as abstract interpretation [50], enhanced with the VERISMART approach.…”

Section: Discussionmentioning

confidence: 99%

Parallel bug-finding in concurrent programs via reduced interleaving instances

Nguyen

Schrammel

Fischer

et al. 2017

2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)

Self Cite

View full text Add to dashboard Cite

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.

show abstract

Automatic Verification of C and Java Programs: SV-COMP 2019

Beyer

2019

Tools and Algorithms for the Construction and Analysis of Systems

View full text Add to dashboard Cite

This report describes the 2019 Competition on Software Verification (SV-COMP), the 8 th edition of a series of comparative evaluations of fully automatic software verifiers for C programs, and now also for Java programs. The competition provides a snapshot of the current state of the art in the area, and has a strong focus on replicability of its results. The repository of benchmark verification tasks now supports a new, more flexible format for task definitions (based on YAML), which was a precondition for conveniently benchmarking Java programs in the same controlled competition setting that was successfully applied in the previous years. The competition was based on 10 522 verification tasks for C programs and 368 verification tasks for Java programs. Each verification task consisted of a program and a property (reachability, memory safety, overflows, termination). SV-COMP 2019 had 31 participating verification systems from 14 countries.

show abstract

Lazy-CSeq 2.0: Combining Lazy Sequentialization with Abstract Interpretation

Cited by 8 publications

References 11 publications

Concurrent Program Verification with Lazy Sequentialization and Interval Analysis

Concurrent Program Verification with Lazy Sequentialization and Interval Analysis

Parallel bug-finding in concurrent programs via reduced interleaving instances

Automatic Verification of C and Java Programs: SV-COMP 2019

Contact Info

Product

Resources

About