7 research outputs found
Parameterised Pushdown Systems with Non-Atomic Writes
We consider the master/slave parameterised reachability problem for networks
of pushdown systems, where communication is via a global store using only
non-atomic reads and writes. We show that the control-state reachability
problem is decidable. As part of the result, we provide a constructive
extension of a theorem by Ehrenfeucht and Rozenberg to produce an NFA
equivalent to certain kinds of CFG. Finally, we show that the non-parameterised
version is undecidable.Comment: This is the long version of a paper appearing in FSTTCS 201
Model-Checking Parameterized Concurrent Programs Using Linear Interfaces
We consider the verification of parameterized Boolean programs— abstractions of shared-memory concurrent programs with an unbounded number of threads. We propose that such programs can be model-checked by iteratively considering the program under k-round schedules, for increasing values of k, using a novel compositional construct called linear interfaces that summarize the effect of a block of threads in a k-round schedule. We also develop a game-theoretic sound technique to show that k rounds of schedule suffice to explore the entire search-space, which allows us to prove a parameterized program entirely correct. We implement a symbolic model-checker, and report on experiments verifying parameterized predicate abstractions of Linux device drivers interacting with a kernel to show the efficacy of our technique
On the Completeness of Verifying Message Passing Programs under Bounded Asynchrony
We address the problem of verifying message passing programs, defined as a
set of parallel processes communicating through unbounded FIFO buffers. We
introduce a bounded analysis that explores a special type of computations,
called k-synchronous. These computations can be viewed as (unbounded) sequences
of interaction phases, each phase allowing at most k send actions (by different
processes), followed by a sequence of receives corresponding to sends in the
same phase. We give a procedure for deciding k-synchronizability of a program,
i.e., whether every computation is equivalent (has the same happens-before
relation) to one of its k-synchronous computations. We also show that
reachability over k-synchronous computations and checking k-synchronizability
are both PSPACE-complete. Furthermore, we introduce a class of programs called
{\em flow-bounded} for which the problem of deciding whether there exists a k>0
for which the program is k-synchronizable, is decidable
On the Completeness of Verifying Message Passing Programs Under Bounded Asynchrony
International audienceWe address the problem of verifying message passing programs , defined as a set of processes communicating through unbounded FIFO buffers. We introduce a bounded analysis that explores a special type of computations, called k-synchronous. These computations can be viewed as (unbounded) sequences of interaction phases, each phase allowing at most k send actions (by different processes), followed by a sequence of receives corresponding to sends in the same phase. We give a procedure for deciding k-synchronizability of a program, i.e., whether every computation is equivalent (has the same happens-before relation) to one of its k-synchronous computations. We show that reachability over k-synchronous computations and checking k-synchronizability are both PSPACE-complete
The Decidability of Verification under Promising 2.0
In PLDI'20, Lee et al. introduced the \emph{promising } semantics PS 2.0 of
the C++ concurrency that captures most of the common program transformations
while satisfying the DRF guarantee. The reachability problem for finite-state
programs under PS 2.0 with only release-acquire accesses is already known to be
undecidable. Therefore, we address, in this paper, the reachability problem for
programs running under PS 2.0 with relaxed accesses together with promises. We
show that this problem is undecidable even in the case where the input program
has finite state. Given this undecidability result, we consider the fragment of
PS 2.0 with only relaxed accesses allowing bounded number of promises. We show
that under this restriction, the reachability is decidable, albeit very
expensive: it is non-primitive recursive. Given this high complexity with
bounded number of promises and the undecidability result for the RA fragment of
PS 2.0, we consider a bounded version of the reachability problem. To this end,
we bound both the number of promises and the "view-switches", i.e, the number
of times the processes may switch their local views of the global memory. We
provide a code-to-code translation from an input program under PS 2.0, with
relaxed and release-acquire memory accesses along with promises, to a program
under SC. This leads to a reduction of the bounded reachability problem under
PS 2.0 to the bounded context-switching problem under SC. We have implemented a
prototype tool and tested it on a set of benchmarks, demonstrating that many
bugs in programs can be found using a small bound