Results 1  10
of
12
MSO decidability of MultiPushdown Systems via SplitWidth
, 2012
"... Multithreaded programs with recursion are naturally modeled as multipushdown systems. The behaviors are represented as multiply nested words (MNWs), which are words enriched with additional binary relations for each stack matching a push operation with the corresponding pop operation. Any MNW ca ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
(Show Context)
Multithreaded programs with recursion are naturally modeled as multipushdown systems. The behaviors are represented as multiply nested words (MNWs), which are words enriched with additional binary relations for each stack matching a push operation with the corresponding pop operation. Any MNW can be decomposed by two basic and natural operations: shuffle of two sequences of factors and merge of consecutive factors of a sequence. We say that the splitwidth of an MNW is k if it admits a decomposition where the number of factors in each sequence is at most k. The MSO theory of MNWs with splitwidth k is decidable. We introduce two very general classes of MNWs that strictly generalize known decidable classes and prove their MSO decidability via their splitwidth and obtain comparable or better bounds of treewidth of known classes.
Bounded phase analysis of messagepassing programs
, 2012
"... We describe a novel technique for bounded analysis of asynchronous messagepassing programs with ordered message queues. Our bounding parameter does not limit the number of pending messages, nor the number of “contextsswitches” between processes. Instead, we limit the number of process communicat ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
(Show Context)
We describe a novel technique for bounded analysis of asynchronous messagepassing programs with ordered message queues. Our bounding parameter does not limit the number of pending messages, nor the number of “contextsswitches” between processes. Instead, we limit the number of process communication cycles, in which an unbounded number of messages are sent to an unbounded number of processes across an unbounded number of contexts. We show that remarkably, despite the potential for such vast exploration, our bounding scheme gives rise to a simple and efficient program analysis by reduction to sequential programs. As our reduction avoids explicitly representing message queues, our analysis scales irrespectively of queue content and variation.
Lineartime modelchecking for multithreaded programs under scopebounding
 In Supratik Chakraborty and Madhavan Mukund, editors, ATVA, volume 7561 of Lecture Notes in Computer Science
, 2012
"... ..."
(Show Context)
Saturation of Concurrent Collapsible Pushdown Systems
"... Multistack pushdown systems are a wellstudied model of concurrent computation using threads with firstorder procedure calls. While, in general, reachability is undecidable, there are numerous restrictions on stack behaviour that lead to decidability. To model higherorder procedures calls, a gene ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Multistack pushdown systems are a wellstudied model of concurrent computation using threads with firstorder procedure calls. While, in general, reachability is undecidable, there are numerous restrictions on stack behaviour that lead to decidability. To model higherorder procedures calls, a generalisation of pushdown stacks called collapsible pushdown stacks are required. Reachability problems for multistack collapsible pushdown systems have been little studied. Here, we study ordered, phasebounded and scopebounded multistack collapsible pushdown systems using saturation techniques, showing decidability of control state reachability and giving a regular representation of all configurations that can reach a given control state.
The complexity of modelchecking multistack systems
, 2012
"... Abstract—We consider the lineartime model checking problem for boolean concurrent programs with recursive procedure calls. While sequential recursive programs are usually modeled as pushdown automata, concurrent recursive programs involve several processes and can be naturally abstracted as pushdo ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Abstract—We consider the lineartime model checking problem for boolean concurrent programs with recursive procedure calls. While sequential recursive programs are usually modeled as pushdown automata, concurrent recursive programs involve several processes and can be naturally abstracted as pushdown automata with multiple stacks. Their behavior can be understood as words with multiple nesting relations, each relation connecting a procedure call with its corresponding return. To reason about multiply nested words, we consider the class of all temporal logics as defined in the book by Gabbay, Hodkinson, and Reynolds (1994). The unifying feature of these temporal logics is that their modalities are defined in monadic secondorder (MSO) logic. In particular, this captures numerous temporal logics over concurrent and/or recursive programs that have been defined so far. Since the general model checking problem is undecidable, we restrict attention to phase bounded executions as proposed by La Torre, Madhusudan, and Parlato (LICS 2007). While the MSO model checking problem in this case is nonelementary, our main result states that the model checking (and satisfiability) problem for all these temporal logics is decidable in elementary time. More precisely, it is solvable in (n + 2)EXPTIME where n is the maximal level of the MSO modalities in the monadic quantifier alternation hierarchy. We complement this result and provide, for each level n, a temporal logic whose model checking problem is nEXPSPACEhard. I.
A Unifying Approach for Multistack Pushdown Automata (Track B)
, 2014
"... We give a general approach to show the closure under complement and decide the emptiness for many classes of multistack visibly pushdown automata (Mvpa). A central notion in our approach is the visibly pathtree, i.e., a stack tree with the encoding of a path that denotes a linear ordering of the no ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We give a general approach to show the closure under complement and decide the emptiness for many classes of multistack visibly pushdown automata (Mvpa). A central notion in our approach is the visibly pathtree, i.e., a stack tree with the encoding of a path that denotes a linear ordering of the nodes. We show that the set of all such trees with a bounded size labeling is regular, and pathtrees allow us to design simple conversions between tree automata and Mvpa’s. As corollaries of our results we get the closure under complement of ordered Mvpa that was an open problem, and a better upper bound on the algorithm to check the emptiness of boundedphase Mvpa’s, that also shows that this problem is fixed parameter tractable in the number of phases.
Senescent Ground Tree Rewrite Systems
"... Ground Tree Rewrite Systems with State are known to have an undecidable control state reachability problem. Taking inspiration from the recent introduction of scopebounded multistack pushdown systems, we define Senescent Ground Tree Rewrite Systems. These are a restriction of ground tree rewrite ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
Ground Tree Rewrite Systems with State are known to have an undecidable control state reachability problem. Taking inspiration from the recent introduction of scopebounded multistack pushdown systems, we define Senescent Ground Tree Rewrite Systems. These are a restriction of ground tree rewrite systems with state such that nodes of the tree may no longer be rewritten after having witnessed an a priori fixed number of control state changes. As well as generalising scopebounded multistack pushdown systems, we show — via reductions to and from reset Petrinets — that these systems have an Ackermanncomplete control state reachability problem. However, reachability of a regular set of trees remains undecidable.
ModelChecking Bounded MultiPushdown Systems
"... We provide complexity characterizations of model checking multipushdown systems. We consider three standard notions for boundedness: context boundedness, phase boundedness and stack ordering. The logical formalism is a lineartime temporal logic extending wellknown operators are parameterized b ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We provide complexity characterizations of model checking multipushdown systems. We consider three standard notions for boundedness: context boundedness, phase boundedness and stack ordering. The logical formalism is a lineartime temporal logic extending wellknown operators are parameterized by stacks. We show that the problem is ExpTimecomplete for contextbounded runs and unary encoding of the number of context switches; we also prove that the problem is 2ExpTimecomplete for phasebounded runs and unary encoding of the number of phase switches. In both cases, the value k is given as an input, which makes a substantial difference in the complexity.
Bounded Model Checking of MultiThreaded C Programs via Lazy Sequentialization
"... Abstract. Bounded model checking (BMC) has successfully been used for many practical program verification problems, but concurrency still poses a challenge. Here we describe a new approach to BMC of sequentially consistent C programs using POSIX threads. Our approach first translates a multithread ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Bounded model checking (BMC) has successfully been used for many practical program verification problems, but concurrency still poses a challenge. Here we describe a new approach to BMC of sequentially consistent C programs using POSIX threads. Our approach first translates a multithreaded C program into a nondeterministic sequential C program that preserves reachability for all roundrobin schedules with a given bound on the number of rounds. It then reuses existing highperformance BMC tools as backends for the sequential verification problem. Our translation is carefully designed to introduce very small memory overheads and very few sources of nondeterminism, so that it produces tight SAT/SMT formulae, and is thus very effective in practice: our prototype won the concurrency category of SVCOMP14. It solved all verification tasks successfully and was 30x faster than the best tool with native concurrency handling. 1
The PathWidth of Integer Linear Programming
"... Abstract. We consider the feasibility problem of integer linear programming (ILP). We show that solutions of any ILP instance can be naturally represented by an FOdefinable class of graphs. For each solution there may be many graphs representing it. However, one of these graphs is of pathwidth at ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We consider the feasibility problem of integer linear programming (ILP). We show that solutions of any ILP instance can be naturally represented by an FOdefinable class of graphs. For each solution there may be many graphs representing it. However, one of these graphs is of pathwidth at most 2n, where n is the number of variables in the instance. Since FO is decidable on graphs of bounded pathwidth, we obtain an alternative decidability result for ILP. The technique we use underlines a common principle to prove decidability which has previously been employed for automata with auxiliary storage. We also show how this new result links to automata theory and program verification. 1