State-space Generation Algorithms Research Articles

An approximation algorithm for box abstraction of transition systems on real state spaces

Predicate abstraction is a powerful technique for extracting finite-state models from infinite-state systems such as computer software, and is applied to verification of safety properties. Predicate abstraction is also applied to verification of dynamical systems on real state spaces such as hybrid dynamical systems. In this paper, we propose a fast algorithm for computing entire abstract state spaces of transition systems on real state spaces. The method is based on the box abstraction of state spaces, and requires a relatively smaller number of reachability checks and Boolean operations. We also propose a fast method for computing the set of boxes that intersect a given convex polyhedron. This computation is a part of the proposed state-space generation algorithm. Effectiveness of the algorithm is evaluated by the computation time and by the difference of the approximated state space from the exact state space.

CoInDiVinE: Parallel Distributed Model Checker for Component-Based Systems

CoInDiVinE is a tool for parallel distributed model checking of interactions among components in hierarchical component-based systems. The tool extends the DiVinE framework with a new input language (component-interaction automata) and a property specification logic (CI-LTL). As the language differs from the input language of DiVinE, our tool employs a new state space generation algorithm that also supports partial order reduction. Experiments indicate that the tool has good scaling properties when run in parallel setting.

Parallel symbolic state-space exploration is difficult, but what is the alternative?

State-space exploration is an essential first step in many modeling and analys is problems. Its goal is to find and store all the states reachable from the initial state(s) of a discre te-state high-level model described, for example, using pseudocode or Petri nets. The state space can then be used to answer important questions, such as “Is there a dead state?” and “Can variable n ever become negative?”, or as the starting point for sophisticated investigations expressed in temporal logic . Unfortunately, the state space is often so large that ordinary explicit data s tructures and sequential algorithms simply cannot cope, prompting the exploration of parallel or symbolic approaches. The former uses multiple processors, from simple networks of workstations to expensive shared-memory supercomputers or, more recently, powerful multicore workstations, to satisfy the large memory and runtime requirements. The latter uses decision diagrams to compactly encode the large structured sets and relations manipulated during state-space generation. Both approaches have merits and limitations. Parallel explicit state-space gen eration is challenging, but close to linear speedup can be achieved, thus its scalability can be quite g ood; however, the analysis is ultimately and obviously limited by the amount of memory and number of processors available overall. Symbolic methods rely on the heuristic properties of decision diagrams, which can encode many, but by no means all, functions over a structured and exponentially large domain in polynomial space; here the pitfalls are subtler, as the performance of symbolic approaches can vary widely depending on the particular class of decision diagram chosen, on the order in which the variables describing the state are considered, and on many obscure algorithmic parameters. In this paper, we survey both approaches. Observing that symbolic approaches are often enormously more efficient than explicit ones for many practical models (although it is rar ely obvious a priori whether this will be the case on a particular application), we argue for the need to par allelize symbolic state-space generation algorithms, so that we can realize the advantage of both approaches. Unfortunately, this is a very challenging endeavor, as the most efficient symbolic algorithm, Satura tion, is inherently sequential. We conclude by discussing challenges, efforts, and promising directions toward this goal.

Multi-Layer Network Performance and Reliability Analysis

The authors describe a methodology for evaluating the performability (combined performance and reliability) of large communications networks. Networks are represented by a 4-level hierarchical model, consisting of traffic matrix, network graph, “components” representing failure modes, and reliability information. Network states are assignments of modes to the network components, which usually represent network elements and their key modules, although they can be more abstract. The components can be binary or multi-modal, and each of their failure modes may change a set of attributes of the graph (e.g. the capacity or cost of a link). Their methodology also captures the effect of automatic restoration against network failures by including two common rerouting methods. To compute network performability measures, including upper and lower bounds on their cumulative distribution functions, we augment existing probabilistic state-space generation algorithms with our new “hybrid” algorithm. To characterize the network failures of highest impact, we compute the Pareto boundaries of the network’s risk space. The authors have developed a network analysis tool called nperf that embodies this methodology. To illustrate the methodology and the practicality of the tool, they describe a performability analysis of three design alternatives for a large commercial IP backbone network.

To Parallelize or to Optimize?

Model checking is a popular and successful technique for verifying complex digital systems. Carrying this technique—and its underlying state-space generation algorithms—beyond its current limitations presents itself with a number of alternatives. Our focus is on parallelization which is made attractive by the current trend in hardware architectures towards multi-core, multi-processor systems. The main obstacle in this endeavour is that, in particular, symbolic state-space generation algorithms are notoriously hard to parallelize. In this article, we describe the process of taking a sequential symbolic state-space generation algorithm, namely a generic, symbolic BFS algorithm, through a sequence of optimizations that leads up to the Saturation algorithm and follow the impact these sequential algorithms have on their parallel counterparts. In particular, we develop a parallel version of Saturation, discuss the challenges faced in its design and conduct extensive experimental studies of its implementation. We employ rigorous analysis tools and techniques for measuring and evaluating parallel overheads and the quality of the parallelization. The outcome of these studies is that the performance of a parallel symbolic state-space generation algorithm is almost impossible to predict and highly dependent on the model to which it is applied. In most situations, perceivable speed-ups are hard to achieve, but real-world applications where our technique produces significant improvements do exist. Nevertheless, it appears that time is better invested in optimizing sequential symbolic model checking algorithms rather than parallelizing them.