168 research outputs found
Platform Dependent Verification: On Engineering Verification Tools for 21st Century
The paper overviews recent developments in platform-dependent explicit-state
LTL model checking.Comment: In Proceedings PDMC 2011, arXiv:1111.006
DiVinE-CUDA - A Tool for GPU Accelerated LTL Model Checking
In this paper we present a tool that performs CUDA accelerated LTL Model
Checking. The tool exploits parallel algorithm MAP adjusted to the NVIDIA CUDA
architecture in order to efficiently detect the presence of accepting cycles in
a directed graph. Accepting cycle detection is the core algorithmic procedure
in automata-based LTL Model Checking. We demonstrate that the tool outperforms
non-accelerated version of the algorithm and we discuss where the limits of the
tool are and what we intend to do in the future to avoid them
BioDiVinE: A Framework for Parallel Analysis of Biological Models
In this paper a novel tool BioDiVinEfor parallel analysis of biological
models is presented. The tool allows analysis of biological models specified in
terms of a set of chemical reactions. Chemical reactions are transformed into a
system of multi-affine differential equations. BioDiVinE employs techniques for
finite discrete abstraction of the continuous state space. At that level,
parallel analysis algorithms based on model checking are provided. In the
paper, the key tool features are described and their application is
demonstrated by means of a case study
From Model Checking to Runtime Verification and Back
We describe a novel approach for adapting an existing software model checker
to perform precise runtime verification. The software under test is allowed to
communicate with the wider environment (including the file system and network).
The modifications to the model checker are small and self-contained, making
this a viable strategy for re-using existing model checking tools in a new
context.
Additionally, from the data that is gathered during a single execution in the
runtime verification mode, we automatically re-construct a description of the
execution environment which can then be used in the standard, full-blown model
checker. This additional verification step can further improve coverage,
especially in the case of parallel programs, without introducing substantial
overhead into the process of runtime verification
Parallel symbolic state-space exploration is difficult, but what is the alternative?
State-space exploration is an essential step in many modeling and analysis
problems. Its goal is to find the states reachable from the initial state of a
discrete-state model described. The state space can used to answer important
questions, e.g., "Is there a dead state?" and "Can N become negative?", or as a
starting point for sophisticated investigations expressed in temporal logic.
Unfortunately, the state space is often so large that ordinary explicit data
structures and sequential algorithms cannot cope, prompting the exploration of
(1) parallel approaches using multiple processors, from simple workstation
networks to shared-memory supercomputers, to satisfy large memory and runtime
requirements and (2) symbolic approaches using decision diagrams to encode the
large structured sets and relations manipulated during state-space generation.
Both approaches have merits and limitations. Parallel explicit state-space
generation is challenging, but almost linear speedup can be achieved; however,
the analysis is ultimately limited by the memory and processors available.
Symbolic methods are a heuristic that can efficiently encode many, but not all,
functions over a structured and exponentially large domain; here the pitfalls
are subtler: their performance varies widely depending on the class of decision
diagram chosen, the state variable order, and obscure algorithmic parameters.
As symbolic approaches are often much more efficient than explicit ones for
many practical models, we argue for the need to parallelize symbolic
state-space generation algorithms, so that we can realize the advantage of both
approaches. This is a challenging endeavor, as the most efficient symbolic
algorithm, Saturation, is inherently sequential. We conclude by discussing
challenges, efforts, and promising directions toward this goal
Distributed MAP in the SpinJa Model Checker
Spin in Java (SpinJa) is an explicit state model checker for the Promela
modelling language also used by the SPIN model checker. Designed to be
extensible and reusable, the implementation of SpinJa follows a layered
approach in which each new layer extends the functionality of the previous one.
While SpinJa has preliminary support for shared-memory model checking, it did
not yet support distributed-memory model checking. This tool paper presents a
distributed implementation of a maximal accepting predecessors (MAP) search
algorithm on top of SpinJa.Comment: In Proceedings PDMC 2011, arXiv:1111.006
- …