The Design of a Multicore Extension of the SPIN Model Checker

@article{Holzmann2007TheDO,
  title={The Design of a Multicore Extension of the SPIN Model Checker},
  author={Gerard J. Holzmann and Dragan Bo{\vs}na{\vc}ki},
  journal={IEEE Transactions on Software Engineering},
  year={2007},
  volume={33},
  url={https://api.semanticscholar.org/CorpusID:9080331}
}
The extensions discussed here require only relatively small changes in the SPIN source code and are compatible with most existing verification modes such as partial order reduction, the verification of temporal logic formulas, bitstate hashing, and hash-compact compression.
View on IEEE
pure.tue.nl
145 Citations
Highly Influential Citations
15
Background Citations
62
Methods Citations
43
Results Citations
3

Figures and Tables from this paper

145 Citations

A Stack-Slicing Algorithm for Multi-Core Model Checking

Parallelizing the Spin Model Checker

An extension of the Spin model checker is described that allows us to take advantage of the increasing number of cpu-cores available on standard desktop systems and a small modification of the parallel search algorithm, called the piggyback algorithm, that is remarkably effective in catching violations for an interesting class of liveness properties at little cost.

Distributed Verification of Multi-threaded C++ Programs

Scalable Multi-core Model Checking Fairness Enhanced Systems

This work proposes an on-the-fly parallel model checking algorithm based on the Tarjan's strongly connected components (SCC) detection algorithm that can be applied to general LTL model checking or with different fairness assumptions and shows its usability via the automated verification of several real-life systems.

Scalable shared memory LTL model checking

A design for a parallel shared memory LTL model checker that is based on a distributed memory algorithm that exhibits significant speedup in comparison with sequential tools, which improves the workflow of verification in general.

Parallel Model Checking With Lazy Cycle Detection - MCLCD

New algorithms for exhaustive parallel model checking that are as efficient as possible, but also ''friendly'' with respect to the work-sharing policies that are used for the state space generation are presented.

Towards a GPGPU-parallel SPIN model checker

This work shows how the 2012 multicore CPU-parallel state-space exploration algorithm of the SPIN model checker can be re-engineered to take advantage of the unique parallel-processing capabilities of the GPGPU architecture, and demonstrates how to overcome the non-trivial design obstacles presented by this task.

Distributed Verification of Multi-threaded C++ Programs

This paper presents efforts in addressing verification of multi-threaded C++ programs by combining an efficient use of hard disk with the distribution of the state space on several computing nodes, applicable to clusters and multi-core machines with single or multiple hard disks.

Partial-Order Reduction for GPU Model Checking

This work proposes novel parallel algorithms for three practical approaches to partial-order reduction for on-the-fly explicit-state model checking using GPUs, and shows that the implementation achieves a reduction similar to or better than the state-of- the-art techniques for CPUs.

Verifying Multi-threaded C Programs with SPIN

A tool for verifying multi-threaded C programs that uses the SPIN model checker that can check code aftercompiler optimizations, and a reduction method that reduces context switches using dynamic knowledge computed on-the-fly, while being sound for both safety and liveness properties.
...

45 References

A Stack-Slicing Algorithm for Multi-Core Model Checking

Distributed-Memory Model Checking with SPIN

This paper explores the possibility of exploiting a distributed-memory execution environment, such as a network of workstations interconnected by a standard LAN, to extend the size of the verification problems that can be successfully handled by SPIN.

Parallel External Directed Model Checking with Linear I/O

Parallel External A*, a parallel variant of external memory directed model checking, assuming a sufficient number of processors and number of open file pointers per process, the I/O complexity is reduced to linear by exploiting a hash-function based state space partition scheme.

Parallelizing the Murphi Verifier

A parallel version of the explicit state enumeration verifier Murϕ for distributed memory multiprocessors and networks of workstations that is based on the message passing paradigm shows close to linear speedups, which are largely insensitive to communication latency and bandwidth.

CTL* model checking on a shared-memory architecture

The analysis shows not only the practicality and effective speedup of the algorithm, but also the main pitfalls of parallelising model checking for shared-memory architectures.

Distributing Timed Model Checking - How the Search Order Matters

This paper addresses the problem of distributing model checking of timed automata and shows how in the timed case the search order of the state space is crucial for the effectiveness and scalability of the exploration.

Combining partial order reductions with on-the-fly model-checking

    D. Peled
    Computer Science
    Formal Methods Syst. Des.
  • 1994
An extension of the model-checker SPIN, which implements this combination, is studied, showing substantial reduction over traditional search, not only in the number of reachable states, but directly in the amount of memory and time used.

A mini challenge: build a verifiable filesystem

The paper argues why it is believed a filesystem is the right candidate for a mini challenge and describes a project in which a small embedded filesystem is built for use with flash memory.

Parallel breadth-first search LTL model-checking

This work proposes a practical parallel on-the-fly algorithm for enumerative LTL (linear temporal logic) model checking for cluster of workstations communicating via MPI (message passing interface) and shows promising results.

Distributed Explicit Fair Cycle Detection (Set Based Approach)

This paper presents a new distributed scalable algorithm for explicit fair cycle detection that combines the simplicity of the distribution of explicitly presented data structure and the features of symbolic algorithm allowing for an efficient parallelisation.