Deadlocks are critical problems afflicting parallel applications, causing software to hang with no further progress. Existing detection tools suffer not only from significant recording performance overhead, but also from excessive memory and/or storage overhead. In addition, they may generate numerous false alarms. Subsequently, after problems have been reported, tremendous manual effort is required to confirm and fix these deadlocks. This paper designs a novel system, UnDead, that helps defeat deadlocks in production software. Different from existing detection tools, UnDead imposes negligible runtime performance overhead (less than 3 % on average) and small memory overhead (around 6%), without any storage consumption. After detection, UnDead automatically strengthens erroneous programs to prevent future occurrences of both existing and potential deadlocks, which is similar to the existing work—Dimmunix. However, UnDead exceeds Dimmunix with several orders of magnitude lower performance overhead, while eliminating numerous false positives. Extremely low runtime and memory overhead, convenience, and automatic prevention make UnDead an always-on detection tool, and a "band-aid" prevention system for production software.

UNDEAD: detecting and preventing deadlocks in production software

A challenge faced by concurrency bug detection techniques is the lack of ground-truth corpora, i.e., a lot of true concurrency bugs, making it difficult to evaluate and verify these technologies and tools, e.g., to precisely measure their false negative and false positive rates. In this paper, we present DRInject, a novel dynamic debugging based technique for producing ground-truth corpora by automatically and quickly injecting lots of realistic data race bugs into program source code. Each data race bug is assured by injecting modifying code to a global variable in two concurrency threads. These bugs are realistic in that they are embedded deep with programs and are triggered by real inputs. We have injected over 600 data race bugs into 10 benchmark or real-world programs, including water-nsquared, X264 and libvips. Moreover, we evaluated four data race detectors using the produced buggy programs and found there are much improvement space for these tools. Preliminary experiments show that DRInject can inject data race bugs in large scale programs and evaluate detect tools with fundamental quantities like false negative and false positive rate, which forms the basis to generate large bug corpora for the future research in concurrency software.

Automated data race bugs addition

Software transactional memory is an effective mechanism to avoid concurrency bugs in multi-threaded programs. However, two problems hinder the adoption of traditional such systems in wild world: high human cost for equipping programs with transaction functionality and low compatibility with I/O calls and conditional variables. This paper presents Convoider to try to solve these problems. By intercepting inter-thread operations and designating code among them as transactions in each thread, Convoider automatically transactionalizes target programs without any source code modification and recompiling. By saving/restoring stack frames and CPU registers on beginning/aborting a transaction, Convoider makes execution flow revocable. By turning threads into processes, leveraging virtual memory protection and customizing memory allocation/deallocation, Convoider makes memory manipulations revocable. By maintaining virtual file systems and redirecting I/O operations onto them, Convoider makes I/O effects revocable. By converting lock/unlock operations to no-ops, customizing signal/wait operations on condition variables and committing memory changes transactionally, Convoider makes deadlocks, data races and atomicity violations impossible. Experimental results show that Convoider succeeds in transparently transactionalizing twelve real-world applications and perfectly avoid 94% of thirty-one concurrency bugs used in our experiments. This study can help efficiently transactionalize legacy multi-threaded applications and effectively improve the runtime reliability of them.

Convoider: A Concurrency Bug Avoider Based on Transparent Software Transactional Memory

Deadlock is among the most complex problems affecting the reliability of programs containing multiple, asynchronous threads. When undetected, deadlocks can lead to permanent thread blockage. Current detection methods are typically based on timeout and rollback of computations, resulting in significant delays. This paper presents Deadlock Detector and Solver (DDS), which can quickly detect and resolve circular deadlocks in Java programs. DDS uses a supervisory controller, which monitors program execution and automatically detects deadlocks resulting from hold-and-wait cycles on monitor locks. When a deadlock is detected, DDS uses a preemptive strategy to break the deadlock. Based on our experiments, DDS can in fact resolve deadlocks without significant run-time overhead.

Deadlock detector and solver (DDS)

Hardware-Assisted Online Data Race Detection.

Mocklinter: Linting Mutual Exclusive Deadlocks with Lock Allocation Graphs

Data races are common concurrency bugs in multi-threaded programs and many of them can cause server failures. They are difficult to be detected or verified due to some non-deterministic interleavings. Numerous static and dynamic program analysis techniques have been proposed to detect data races. However, some of detectors may report large amount of false races and some of them may miss lots of true races. This paper proposes RaceTracker that combines static and dynamic techniques to detect data races effectively and efficiently. First, we use current static detectors to produce potential races and identify ad-hoc synchronizations. Second, we instrument code locations corresponding to potential races to try best to expose them in controlled thread interleavings. Meanwhile, we apply the hybrid dynamic detection techniques to detect races in case they are exposed. Finally, we also apply the hybrid dynamic detection techniques to prune benign and false races mainly caused by ad-hoc synchronization. In order to increase the chances to trigger real race conditions in dynamic analysis, we use some strategies to control the schedule of threads. We have implemented our tool RaceTracker in the dynamic binary instrumentation framework PIN and evaluated with nearly 100 small data race programs from google data-race-test suit and some real-world concurrent applications from SPLASH-2 and Maple. Evaluations show that RaceTracker can identify more data races effectively compared with prior pure dynamic race verifiers and detectors. Meanwhile, compared with grouping verifier, RaceTracker only executes the program twice and reduces the average runtime overhead by 64%.

RaceTracker: Effective and efficient detection of data races

Many techniques for dynamically detecting data races in multithreaded programs have been proposed. However, it is unclear how these techniques compare in terms of precision, overhead and scalability. This paper presents an experiment to evaluate ten data-race detection techniques on 100 small-scale or middle-scale C/C++ programs. The selected ten techniques, implemented in the same Maple framework, cover not only the classical but also the state-of-the-art in dynamical data-race detection. We compare the ten techniques and try to give reasonable explanations for why some techniques are weaker or stronger than other ones. Evaluation results show that no one technique performs perfectly for all programs according to the three criteria. Based on the evaluation and comparison, we give suggestions of which technique is the most suitable one to use when the target program exhibits particular characteristics. Later researchers can also benefit from our results to construct a better detection technique.

Evaluation and comparison of ten data race detection techniques

Existing dynamic deadlock avoidance techniques have four main drawbacks: limited capability, offline avoidance algorithm, passive avoidance strategy and poor usability. To solve these problems, we propose a user-friendly, online and active avoidance technique, called Slider, to avoid multiple types of deadlocks. The key idea of Slider is that deadlocks will not happen if critical sections are executed serially. Slider interferes in thread scheduling to ensure that at any time only one thread is in the critical state. We design Slider to avoid all deadlocks except self-deadlocks caused by mutexes or rwlocks in pthread interface. We implement Slider as a pre-loadable library so that it can be applied directly to existing applications. We do four experiments to evaluate avoidance capability, performance overhead and scalability of Slider, comparing with three state-of-the-art avoidance techniques. Experimental results show Slider can correctly avoid multiple types of deadlocks in an online, active, efficient and scalable way.

Zhen Yu

Papers

Mocklinter: Linting Mutual Exclusive Deadlocks with Lock Allocation Graphs

RaceTracker: Effective and efficient detection of data races

Evaluation and comparison of ten data race detection techniques

Slider: an online and active deadlock avoider by serial execution of critical sections