20 research outputs found
Context-Bounded Analysis For Concurrent Programs With Dynamic Creation of Threads
Context-bounded analysis has been shown to be both efficient and effective at
finding bugs in concurrent programs. According to its original definition,
context-bounded analysis explores all behaviors of a concurrent program up to
some fixed number of context switches between threads. This definition is
inadequate for programs that create threads dynamically because bounding the
number of context switches in a computation also bounds the number of threads
involved in the computation. In this paper, we propose a more general
definition of context-bounded analysis useful for programs with dynamic thread
creation. The idea is to bound the number of context switches for each thread
instead of bounding the number of switches of all threads. We consider several
variants based on this new definition, and we establish decidability and
complexity results for the analysis induced by them
Context-bounded analysis for concurrent programs with dynamic creation of threads.
Abstract. Context-bounded analysis has been shown to be both efficient and effective at finding bugs in concurrent programs. According to its original definition, context-bounded analysis explores all behaviors of a concurrent program up to some fixed number of context switches between threads. This definition is inadequate for programs that create threads dynamically because bounding the number of context switches in a computation also bounds the number of threads involved in the computation. In this paper, we propose a more general definition of context-bounded analysis useful for programs with dynamic thread creation. The idea is to bound the number of context switches for each thread instead of bounding the number of switches of all threads. We consider several variants based on this new definition, and we establish decidability and complexity results for the analysis induced by them
Scope-bounded multistack pushdown systems: fixed-point, sequentialization, and tree-width
We present a novel fixed-point algorithm to solve reachability of multi-stack pushdown systems restricted to runs of bounded-scope. The followed approach is compositional, in the sense that the runs of the system are summarized by bounded-size interfaces. Moreover, it is suitable for a direct implementation and can be exploited to prove two new results. We give a sequentialization for this class of systems, i.e., for each such multi-stack pushdown system we construct an equivalent single-stack pushdown system that faithfully simulates the behaviour of each thread. We prove that the behaviour graphs (multiply nested words) for these systems have bounded three-width, and thus a number of decidability results can be derived from Courcelleās theorem
Reachability Analysis of Asynchronous Dynamic Pushdown Networks Based on Tree Semantics Approach
ADPN (Asynchronous Dynamic Pushdown Networks) are an abstract model for concurrent programs with recursive procedures and dynamic thread creation. Usually, asynchronous dynamic pushdown networks are described with interleaving semantics, in which the backward analysis is not effective. In order to improve interleaving semantics, tree semantics approach was introduced. This paper extends the tree semantics to ADPN. Because the reachability problem of ADPN is also undecidable, we address the context-bounded reachability problem and provide an algorithm for backward reachability analysis with tree-based semantics Approach
Model checking Branching-Time Properties of Multi-Pushdown Systems is Hard
We address the model checking problem for shared memory concurrent programs
modeled as multi-pushdown systems. We consider here boolean programs with a
finite number of threads and recursive procedures. It is well-known that the
model checking problem is undecidable for this class of programs. In this
paper, we investigate the decidability and the complexity of this problem under
the assumption of bounded context-switching defined by Qadeer and Rehof, and of
phase-boundedness proposed by La Torre et al. On the model checking of such
systems against temporal logics and in particular branching time logics such as
the modal -calculus or CTL has received little attention. It is known that
parity games, which are closely related to the modal -calculus, are
decidable for the class of bounded-phase systems (and hence for bounded-context
switching as well), but with non-elementary complexity (Seth). A natural
question is whether this high complexity is inevitable and what are the ways to
get around it. This paper addresses these questions and unfortunately, and
somewhat surprisingly, it shows that branching model checking for MPDSs is
inherently an hard problem with no easy solution. We show that parity games on
MPDS under phase-bounding restriction is non-elementary. Our main result shows
that model checking a context bounded MPDS against a simple fragment of
CTL, consisting of formulas that whose temporal operators come from the set
{\EF, \EX}, has a non-elementary lower bound
History-Register Automata
Programs with dynamic allocation are able to create and use an unbounded
number of fresh resources, such as references, objects, files, etc. We propose
History-Register Automata (HRA), a new automata-theoretic formalism for
modelling such programs. HRAs extend the expressiveness of previous approaches
and bring us to the limits of decidability for reachability checks. The
distinctive feature of our machines is their use of unbounded memory sets
(histories) where input symbols can be selectively stored and compared with
symbols to follow. In addition, stored symbols can be consumed or deleted by
reset. We show that the combination of consumption and reset capabilities
renders the automata powerful enough to imitate counter machines, and yields
closure under all regular operations apart from complementation. We moreover
examine weaker notions of HRAs which strike different balances between
expressiveness and effectiveness.Comment: LMCS (improved version of FoSSaCS
Small Vertex Cover makes Petri Net Coverability and Boundedness Easier
The coverability and boundedness problems for Petri nets are known to be
Expspace-complete. Given a Petri net, we associate a graph with it. With the
vertex cover number k of this graph and the maximum arc weight W as parameters,
we show that coverability and boundedness are in ParaPspace. This means that
these problems can be solved in space O(ef(k,W)poly(n)), where ef(k,W) is some
exponential function and poly(n) is some polynomial in the size of the input.
We then extend the ParaPspace result to model checking a logic that can express
some generalizations of coverability and boundedness.Comment: Full version of the paper appearing in IPEC 201
Computing downward closures for stacked counter automata
The downward closure of a language of words is the set of all (not
necessarily contiguous) subwords of members of . It is well known that the
downward closure of any language is regular. Although the downward closure
seems to be a promising abstraction, there are only few language classes for
which an automaton for the downward closure is known to be computable.
It is shown here that for stacked counter automata, the downward closure is
computable. Stacked counter automata are finite automata with a storage
mechanism obtained by \emph{adding blind counters} and \emph{building stacks}.
Hence, they generalize pushdown and blind counter automata.
The class of languages accepted by these automata are precisely those in the
hierarchy obtained from the context-free languages by alternating two closure
operators: imposing semilinear constraints and taking the algebraic extension.
The main tool for computing downward closures is the new concept of Parikh
annotations. As a second application of Parikh annotations, it is shown that
the hierarchy above is strict at every level.Comment: 34 pages, 1 figure; submitte