1,345 research outputs found
Using heuristic search for finding deadlocks in concurrent systems
AbstractModel checking is a formal technique for proving the correctness of a system with respect to a desired behavior. This is accomplished by checking whether a structure representing the system (typically a labeled transition system) satisfies a temporal logic formula describing the expected behavior. Model checking has a number of advantages over traditional approaches that are based on simulation and testing: it is completely automatic and when the verification fails it returns a counterexample that can be used to pinpoint the source of the error. Nevertheless, model checking techniques often fail because of the state explosion problem: transition systems grow exponentially with the number of components. The aim of this paper is to attack the state explosion problem that may arise when looking for deadlocks in concurrent systems described through the calculus of communicating systems. We propose to use heuristics-based techniques, namely the A* algorithm, both to guide the search without constructing the complete transition system, and to provide minimal counterexamples. We have realized a prototype tool to evaluate the methodology. Experiments we have conducted on processes of different size show the benefit from using our technique against building the whole state space, or applying some other methods
Comparing metaheuristic algorithms for error detection in Java programs
Chicano, F., Ferreira M., & Alba E. (2011). Comparing Metaheuristic Algorithms for Error Detection in Java Programs. In Proceedings of Search Based Software Engineering, Szeged, Hungary, September 10-12, 2011. pp. 82–96.Model checking is a fully automatic technique for checking concurrent software properties in which the states of a concurrent system are explored in an explicit or implicit way. The main drawback of this technique is the high memory consumption, which limits the size of the programs that can be checked. In the last years, some researchers have focused on the application of guided non-complete stochastic techniques to the search of the state space of such concurrent programs. In this paper, we compare five metaheuristic algorithms for this problem. The algorithms are Simulated Annealing, Ant Colony Optimization, Particle Swarm Optimization and two variants of Genetic Algorithm. To the best of our knowledge, it is the first time that Simulated Annealing has been applied to the problem. We use in the comparison a benchmark composed of 17 Java concurrent programs. We also compare the results of these algorithms with the ones of deterministic algorithms.Universidad de Málaga. Campus de Excelencia Internacional AndalucÃa Tech. This research has been partially funded by the Spanish Ministry of Science and Innovation and FEDER under contract TIN2008-06491-C04-01 (the M∗ project) and the Andalusian Government under contract P07-TIC-03044 (DIRICOM project)
DELFIN+: An efficient deadlock detection tool for CCS processes
AbstractModel checking is a formal technique for proving the correctness of a system with respect to a desired behavior. However, deadlock detection via model checking is particularly difficult for the following two problems: (i) the state explosion problem, due to the exponential increase in the size of a finite state model as the number of system components grows; and (ii) the output interpretation problem, as often counter-examples are so long that they are hard to understand. The aim of this paper is to solve both problems by using heuristic-based search strategies. We have realized DELFIN+ (DEadLock FINder) a tool supporting efficient deadlock detection in CCS processes. We have used this tool to verify a sample of CCS processes, in order to evaluate the method on them
Producing Scheduling that Causes Concurrent Programs to Fail
A noise maker is a tool that seeds a concurrent program with conditional synchronization primitives (such as yield()) for the purpose of increasing the likelihood that a bug manifest itself. This work explores the theory and practice of choosing where in the program to induce such thread switches at runtime. We introduce a novel fault model that classifies locations as .good., .neutral., or .bad,. based on the effect of a thread switch at the location. Using the model we explore the terms in which efficient search for real-life concurrent bugs can be carried out. We accordingly justify the use of probabilistic algorithms for this search and gain a deeper insight of the work done so far on noise-making. We validate our approach by experimenting with a set of programs taken from publicly available multi-threaded benchmark. Our empirical evidence demonstrates that real-life behavior is similar to what our model predicts
Practical Distributed Control Synthesis
Classic distributed control problems have an interesting dichotomy: they are
either trivial or undecidable. If we allow the controllers to fully
synchronize, then synthesis is trivial. In this case, controllers can
effectively act as a single controller with complete information, resulting in
a trivial control problem. But when we eliminate communication and restrict the
supervisors to locally available information, the problem becomes undecidable.
In this paper we argue in favor of a middle way. Communication is, in most
applications, expensive, and should hence be minimized. We therefore study a
solution that tries to communicate only scarcely and, while allowing
communication in order to make joint decision, favors local decisions over
joint decisions that require communication.Comment: In Proceedings INFINITY 2011, arXiv:1111.267
Benchmark and Framework for Encouraging Research on Multi-Threaded Testing Tools
A problem that has been getting prominence in testing is that of looking for intermittent bugs. Multi-threaded code is becoming very common, mostly on the server side. As there is no silver bullet solution, research focuses on a variety of partial solutions. In this paper (invited by PADTAD 2003) we outline a proposed project to facilitate research. The project goals are as follows. The first goal is to create a benchmark that can be used to evaluate different solutions. The benchmark, apart from containing programs with documented bugs, will include other artifacts, such as traces, that are useful for evaluating some of the technologies. The second goal is to create a set of tools with open API s that can be used to check ideas without building a large system. For example an instrumentor will be available, that could be used to test temporal noise making heuristics. The third goal is to create a focus for the research in this area around which a community of people who try to solve similar problems with different techniques, could congregate
A Compositional Deadlock Detector for Android Java
We develop a static deadlock analysis for commercial Android Java applications, of sizes in the tens of millions of
LoC, under active development at Facebook. The analysis runs
primarily at code-review time, on only the modified code and
its dependents; we aim at reporting to developers in under 15
minutes.
To detect deadlocks in this setting, we first model the real
language as an abstract language with balanced re-entrant locks,
nondeterministic iteration and branching, and non-recursive
procedure calls. We show that the existence of a deadlock in this
abstract language is equivalent to a certain condition over the
sets of critical pairs of each program thread; these record, for all
possible executions of the thread, which locks are currently held
at the point when a fresh lock is acquired. Since the critical pairs
of any program thread is finite and computable, the deadlock
detection problem for our language is decidable, and in NP.
We then leverage these results to develop an open-source
implementation of our analysis adapted to deal with real Java
code. The core of the implementation is an algorithm which
computes critical pairs in a compositional, abstract interpretation
style, running in quasi-exponential time. Our analyser is built in
the INFER verification framework and has been in industrial
deployment for over two years; it has seen over two hundred
fixed deadlock reports with a report fix rate of ∼54%
- …