7 research outputs found
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
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
Modelling and verifying dynamic access control policies in workflow-based healthcare systems
Access control system is an important component to protect patients’ information from abuse in a health care system. It is a major concern in the management, design, and development of healthcare systems. Designing access control policies for healthcare systems is complicated due to the dynamic and inherent complexity of the tasks performed by the healthcare
personnel. Permissions in access control systems are usually granted on the basis of static policies. However, static policies are not enough to cope with various situations such as emergencies. Most often, the Break-the-glass mechanism is used to bypass static policies to handle emergency situations. Since healthcare systems are critical systems, where errors can be very costly in terms of lives, quality of life, and/or dollars, it is crucial to identify discrepancies between policy
specifications and their intended function to implement correctly a flexible access control system. Formal verifications are necessary for exhaustive verification and validation of policy specifications to ensure that the policy specifications
truly encapsulate the desires of the policy authors. We present a verifiable framework to enact a dynamic access control model by integrating the ANSI/INCTIS RBAC Reference Model in a workflow and an approach for property verifications of
the access control model. Access control policies are expressed by the formal semantics of a model checker and properties are verified by the DiVinE model checker
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
McMini: A Programmable DPOR-based Model Checker for Multithreaded Programs
Model checking has become a key tool for gaining confidence in correctness of
multi-threaded programs. Unit tests and functional tests do not suffice because
of race conditions that are not discovered by those tests. McMini is an
extensible model checker based on DPOR (Dynamic Partial Order Reduction). A
mechanism was invented to declare to McMini new, primitive thread operations,
typically in 100~lines or less of C~code. The mechanism was extended to also
allow the end user to declare alternative thread wakeup policies, including
spurious wakeups from condition variables. One declares: (I) under what
conditions an operation is enabled; (ii) which thread operations are
independent of each other; and (iii) when two operations can be considered as
co-enabled. An optional wakeup policy is implemented by defining when a wait
operation (on a semaphore, condition variable, etc.) is enabled. A new enqueue
thread operation is described, allowing a user to declare alternative wakeup
policies. McMini was first confirmed to operate correctly and efficiently as a
traditional, but extensible model checker for mutex, semaphore, condition
variable, and reader-writer. McMini's extensibility was then tested on novel
primitive operations, representing other useful paradigms for multithreaded
operations. An example is readers-and-two-writers. The speed of model checking
was found to be five times faster and more, as compared to traditional
implementations on top of condition variables. Alternative wakeup policies
(e.g., FIFO, LIFO, arbitrary, etc.) were then tested using an enqueue
operation. Finally, spurious wakeups were tested with a program that exposes a
bug only in the presence of a spurious wakeup.Comment: 24 pages, 1 figur