Results 1  10
of
63
Reducing Concurrent Analysis Under a Context Bound to Sequential Analysis
"... Abstract. This paper addresses the analysis of concurrent programs with shared memory. Such an analysis is undecidable in the presence of multiple procedures. One approach used in recent work obtains decidability by providing only a partial guarantee of correctness: the approach bounds the number of ..."
Abstract

Cited by 72 (12 self)
 Add to MetaCart
Abstract. This paper addresses the analysis of concurrent programs with shared memory. Such an analysis is undecidable in the presence of multiple procedures. One approach used in recent work obtains decidability by providing only a partial guarantee of correctness: the approach bounds the number of context switches allowed in the concurrent program, and aims to prove safety, or find bugs, under the given bound. In this paper, we show how to obtain simple and efficient algorithms for the analysis of concurrent programs with a context bound. We give a general reduction from a concurrent program P, and a given context bound K, to a slightly larger sequential program P K s such that the analysis of P K s can be used to prove properties about P. The reduction introduces symbolic constants and assume statements in P K s. Thus, any sequential analysis that can deal with these two additions can be extended to handle concurrent programs as well, under the context bound. We give instances of the reduction for common program models used in model checking, such as Boolean programs, pushdown systems (PDSs), and symbolic PDSs. 1
Scalable Multicore LTL ModelChecking
 In Model Checking Software, volume 4595 of LNCS
, 2007
"... Abstract. Recent development in computer hardware has brought more widespread emergence of sharedmemory, multicore systems. These architectures offer opportunities to speed up various tasks – among others LTL model checking. In the paper we show a design for a parallel sharedmemory LTL model chec ..."
Abstract

Cited by 26 (7 self)
 Add to MetaCart
(Show Context)
Abstract. Recent development in computer hardware has brought more widespread emergence of sharedmemory, multicore systems. These architectures offer opportunities to speed up various tasks – among others LTL model checking. In the paper we show a design for a parallel sharedmemory LTL model checker, that is based on a distributedmemory algorithm. To achieve good scalability, we have devised and experimentally evaluated several implementation techniques, which we present in the paper. 1
M.: Boosting multicore reachability performance with shared hash tables
 In: Formal Methods in ComputerAided Design
, 2010
"... This paper focuses on data structures for multicore reachability, which is a key component in model checking algorithms and other verification methods. A cornerstone of an efficient solution is the storage of visited states. In related work, static partitioning of the state space was combined with ..."
Abstract

Cited by 14 (4 self)
 Add to MetaCart
(Show Context)
This paper focuses on data structures for multicore reachability, which is a key component in model checking algorithms and other verification methods. A cornerstone of an efficient solution is the storage of visited states. In related work, static partitioning of the state space was combined with threadlocal storage and resulted in reasonable speedups, but left open whether improvements are possible. In this paper, we present a scaling solution for shared state storage which is based on a lockless hash table implementation. The solution is specifically designed for the cache architecture of modern CPUs. Because model checking algorithms impose loose requirements on the hash table operations, their design can be streamlined substantially compared to related work on lockless hash tables. Still, an implementation of the hash table presented here has dozens of sensitive performance parameters (bucket size, cache line size, data layout, probing sequence, etc.). We analyzed their impact and compared the resulting speedups with related tools. Our implementation outperforms two stateoftheart multicore model checkers (SPIN and DiVinE) by a substantial margin, while placing fewer constraints on the load balancing and search algorithms. 1
Efficient LargeScale Model Checking
, 2009
"... Model checking is a popular technique to systematically and automatically verify system properties. Unfortunately, the wellknown state explosion problem often limits the extent to which it can be applied to realistic specifications, due to the huge resulting memory requirements. Distributedmemory m ..."
Abstract

Cited by 12 (6 self)
 Add to MetaCart
(Show Context)
Model checking is a popular technique to systematically and automatically verify system properties. Unfortunately, the wellknown state explosion problem often limits the extent to which it can be applied to realistic specifications, due to the huge resulting memory requirements. Distributedmemory model checkers exist, but have thus far only been evaluated on smallscale clusters, with mixed results. We examine one wellknown distributed model checker in detail, and show how a number of additional optimizations in its runtime system enable it to efficiently check very demanding problem instances on a largescale, multicore compute cluster. We analyze the impact of the distributed algorithms employed, the problem instance characteristics and network overhead. Finally, we show that the model checker can even obtain good performance in a highbandwidth computational grid environment.
Mechanizing the powerset construction for restricted classes of ωautomata
 In ATVA’07, volume 4762 of LNCS
, 2007
"... Abstract. Automata over infinite words provide a powerful framework to solve various decision problems. However, the mechanized reasoning with restricted classes of automata over infinite words is often simpler and more efficient. For instance, weak deterministic Büchi automata (wdbas) can be handle ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Automata over infinite words provide a powerful framework to solve various decision problems. However, the mechanized reasoning with restricted classes of automata over infinite words is often simpler and more efficient. For instance, weak deterministic Büchi automata (wdbas) can be handled algorithmically almost as efficient as deterministic automata over finite words. In this paper, we show how and when the standard powerset construction for automata over finite words can be used to determinize automata over infinite words. An instance is the class of automata that accept wdbarecognizable languages. Furthermore, we present applications of this new determinization construction. Namely, we apply it to improve the automatabased approach for the mixed firstorder linear arithmetic over the reals and the integers, and we utilize it to accelerate finite state model checking. We report on experimental results for these two applications. 1
Revisiting Resistance Speeds Up I/OEfficient LTL Model Checking
, 2008
"... Revisiting resistant graph algorithms are those that can tolerate reexploration of edges without yielding incorrect results. Revisiting resistant I/O efficient graph algorithms exhibit considerable speedup in practice in comparison to nonrevisiting resistant algorithms. In the paper we present a ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
(Show Context)
Revisiting resistant graph algorithms are those that can tolerate reexploration of edges without yielding incorrect results. Revisiting resistant I/O efficient graph algorithms exhibit considerable speedup in practice in comparison to nonrevisiting resistant algorithms. In the paper we present a new revisiting resistant I/O efficient LTL model checking algorithm. We analyze its theoretical I/O complexity and we experimentally compare its performance to already existing I/O efficient LTL model checking algorithms.
HipG: Parallel Processing of LargeScale Graphs
"... Distributed processing of realworld graphs is challenging duetotheirsizeandtheinherentirregularstructureofgraph computations. We present HipG, a distributed framework that facilitates programming parallel graph algorithms by composing the parallel application automatically from the userdefined pie ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
(Show Context)
Distributed processing of realworld graphs is challenging duetotheirsizeandtheinherentirregularstructureofgraph computations. We present HipG, a distributed framework that facilitates programming parallel graph algorithms by composing the parallel application automatically from the userdefined pieces of sequential work on graph nodes. To make the user code highlevel, the framework provides a unified interface to executing methods on local and nonlocal graph nodes and an abstraction of exclusive execution. The graph computations are managed by logical objects called synchronizers, which we used, for example, to implement distributed divideandconquer decomposition into strongly connected components. The code written in HipG is independent of a particular graph representation, to the point that the graph can be created onthefly, i.e. by the algorithm that computes on this graph, which we used to implement a distributed model checker. HipG programs are in general short and elegant; they achieve good portability, memory utilization, and performance. 1.
D.: Model checking via delayed duplicate detection on the GPU
, 2008
"... In this paper we improve largescale diskbased model checking by shifting complex numerical operations to the graphic card, enjoying that during the last decade graphics processing units (GPUs) have become very powerful. For diskbased graph search, the delayed elimination of duplicates is the perf ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
(Show Context)
In this paper we improve largescale diskbased model checking by shifting complex numerical operations to the graphic card, enjoying that during the last decade graphics processing units (GPUs) have become very powerful. For diskbased graph search, the delayed elimination of duplicates is the performance bottleneck as it amounts to sorting large state vector sets. We perform parallel processing on the GPU to improve the sorting speed significantly. Since existing GPU sorting solutions like Bitonic Sort and Quicksort do not obey any speedup on state vectors, we propose a refined GPUbased Bucket Sort algorithm. Alternatively, we study sorting a compressed state vector and obtain speedups for delayed duplicate detection of more than one order of magnitude with a single GPU, located on an ordinary graphic card. 1
A TimeOptimal OntheFly Parallel Algorithm for Model Checking of Weak LTL
 Properties, in: Formal Methods and Software Engineering (ICFEM 2009), Vol. 5885 of LNCS
, 2009
"... Abstract. One of the most important open problems of parallel LTL modelchecking is to design an onthefly scalable parallel algorithm with linear time complexity. Such an algorithm would give the optimality we have in sequential LTL modelchecking. In this paper we give a partial solution to the p ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
(Show Context)
Abstract. One of the most important open problems of parallel LTL modelchecking is to design an onthefly scalable parallel algorithm with linear time complexity. Such an algorithm would give the optimality we have in sequential LTL modelchecking. In this paper we give a partial solution to the problem. We propose an algorithm that has the required properties for a very rich subset of LTL properties, namely those expressible by weak Büchi automata. 1
MultiCore Nested DepthFirst Search
 In ATVA’2011, volume 6996 of LNCS
, 2011
"... Abstract. This paper presents CNDFS, a tight integration of two earlier multicore nested depthfirst search (NDFS) algorithms for LTL model checking. CNDFS combines the different strengths and avoids some weaknesses of its predecessors. We compare CNDFS to an earlier adhoc combination of those two ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
(Show Context)
Abstract. This paper presents CNDFS, a tight integration of two earlier multicore nested depthfirst search (NDFS) algorithms for LTL model checking. CNDFS combines the different strengths and avoids some weaknesses of its predecessors. We compare CNDFS to an earlier adhoc combination of those two algorithms and show several benefits: It has shorter and simpler code and a simpler correctness proof. It exhibits more robust performance with similar scalability, while at the same time reducing memory requirements. The algorithm has been implemented in the multicore backend of the LTSMIN model checker, which is now benchmarked for the first time on a 48 core machine (previously 16). The experiments demonstrate better scalability than other parallel LTL model checking algorithms, but we also investigate apparent bottlenecks. Finally, we noticed that the multicore NDFS algorithms produce shorter counterexamples, surprisingly often shorter than their BFSbased counterparts. 1