Corpus ID: 7372536

Finding and Reproducing Heisenbugs in Concurrent Programs

@inproceedings{Musuvathi2008FindingAR,
  title={Finding and Reproducing Heisenbugs in Concurrent Programs},
  author={M. Musuvathi and S. Qadeer and T. Ball and G. Basler and Piramanayagam Arumuga Nainar and Iulian Neamtiu},
  booktitle={OSDI},
  year={2008}
}
Concurrency is pervasive in large systems. Unexpected interference among threads often results in "Heisenbugs" that are extremely difficult to reproduce and eliminate. We have implemented a tool called CHESS for finding and reproducing such bugs. When attached to a program, CHESS takes control of thread scheduling and uses efficient search techniques to drive the program through possible thread interleavings. This systematic exploration of program behavior enables CHESS to quickly uncover bugs… Expand
Deconstructing concurrency heisenbugs
TLDR
For each bug, CHESS consistently reproduces an erroneous execution manifesting the bug, thereby making it significantly easier to debug the problem. Expand
Assertions for debugging parallel programs
TLDR
This dissertation introduces parallel assertions which allow programmers to express these assumptions for parallel programs using simple and intuitive syntax and semantics, and shows how formalizing the semantics under weak memory models leads to an optimization that gives a 2x speedup while allowing more bugs to be exposed. Expand
Finding complex concurrency bugs in large multi-threaded applications
TLDR
A Concurrency bug detector that automatically identifies when an execution of a program triggers a concurrency bug, and was able to find several concurrency bugs in a stable version of the application, including subtle violations of application semantics, latent bugs, and incorrect error replies. Expand
A Lightweight and Portable Approach to Making Concurrent Failures Reproducible
TLDR
This paper presents an approach, called ConCrash, that automatically and deterministically reproduces concurrent failures by recording logical thread schedule and generating unit tests, and employs a static data race detection technique to report potential possible race conditions. Expand
Concurrent predicates: A debugging technique for every parallel programmer
TLDR
Concurrent predicates (CPs) and concurrent predicate expressions (CPEs) are presented, which allow programmers to single out a specific bug by specifying the schedule and program state that must be satisfied for the bug to be reproduced. Expand
Parallel bug-finding in concurrent programs via reduced interleaving instances
TLDR
This work uses Lazy-CSeq as an off-the-shelf final verifier to demonstrate that this approach is able, already with a small number of cores, to find bugs in the hardest known concurrency benchmarks in a matter of minutes, whereas other dynamic and static tools fail to do so in hours. Expand
COVER FE ATURE ELIMINATING CONCURRENCY BUGS WITH CONTROL ENGINEERING
mer. In recent years, however, uniprocessor performance has flattened out due to heat dissipation barriers. For the foreseeable future, multicore processors promise more cores, rather than fasterExpand
Adaptive Randomized Scheduling for Concurrency Bug Detection
TLDR
This work proposes an adaptive randomized scheduling algorithm~(ARS), which adaptively explores the search space and detects concurrency bugs more efficiently with less efforts, and shows a good potential in detecting hard-to-expose bugs. Expand
Cooperari: a tool for cooperative testing of multithreaded Java programs
TLDR
Cooperari is presented, a tool for deterministic testing of multithreaded Java code based on cooperative execution, that effectively finds, characterizes, and deterministically reproduces bugs that are not detected under unconstrained preemptive semantics. Expand
Concurrent breakpoints
TLDR
Concurrent breakpoints is proposed, a light-weight and programmatic way to make a concurrency bug reproducible and used to deterministically reproduce several known non-deterministic bugs in real-world concurrent Java and C/C++ programs with almost 100% probability. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 59 REFERENCES
Framework for testing multi‐threaded Java programs
TLDR
This work presents a methodology for testing multi‐threaded programs which has minimal impact on the user and is likely to find interleaving bugs, and reruns existing tests in order to detect synchronization faults. Expand
WiDS Checker: Combating Bugs in Distributed Systems
TLDR
This paper presents WiDS Checker, a unified framework that can check distributed systems through both simulation and reproduced runs from real deployment, and found non-trivial bugs, including one in a previously proven Paxos specification. Expand
Systematic testing of multithreaded Java programs
TLDR
A testing algorithm called ExitBlock is designed, proved correct, and implemented that systematically and deterministically finds program errors resulting from unintended timing dependencies, and its ability to detect errors in actual programs is demonstrated. Expand
Iterative context bounding for systematic testing of multithreaded programs
TLDR
This paper proposes iterative context-bounding, a new search algorithm that systematically explores the executions of a multithreaded program in an order that prioritizes executions with fewer context switches, and shows both theoretically and empirically that context-bounded search is an effective method for exploring the behaviors of multith readed programs. Expand
Effective Program Verification for Relaxed Memory Models
TLDR
A new verification technique for the most common relaxation, store buffers, that finds relaxed memory model bugs in several programs, including two previously unknown bugs in a production-level concurrency library that would have been difficult to find by other means. Expand
Debugging Parallel Programs with Instant Replay
TLDR
This paper presents a general solution for reproducing the execution behavior of parallel programs, termed Instant Replay, which provides for replay of an entire program, rather than individual processes in isolation. Expand
Replay and testing for concurrent programs
TLDR
The purpose of deterministic execution debugging to to replay executions of a concurrent program so that debugging information can be collected and the process of designing replay tubes is described. Expand
Learning from mistakes: a comprehensive study on real world concurrency bug characteristics
TLDR
This study carefully examined concurrency bug patterns, manifestation, and fix strategies of 105 randomly selected real world concurrency bugs from 4 representative server and client open-source applications and reveals several interesting findings that provide useful guidance for concurrency Bug detection, testing, and concurrent programming language design. Expand
Model Checking Programs
TLDR
A verification and testing environment for Java, called Java PathFinder (JPF), which integrates model checking, program analysis and testing, and uses state compression to handle big states and partial order and symmetry reduction, slicing, abstraction, and runtime analysis techniques to reduce the state space. Expand
Replay for concurrent non-deterministic shared-memory applications
TLDR
An algorithm is presented, called the repeatable scheduling algorithm, combining scheduling and instruction counts to provide an invariant for efficient, language independent replay of concurrent shared-memory applications, shown to have trace overheads that are independent of the amount of sharing that takes place. Expand
...
1
2
3
4
5
...