Results 1 - 10
of
38
Efficient and Precise Datarace Detection for Multithreaded Object-Oriented Programs
, 2002
"... We present a novel approach to dynamic datarace detection for multithreaded object-oriented programs. Past techniques for onthe -fly datarace detection either sacrificed precision for performance, leading to many false positive datarace reports, or maintained precision but incurred significant over ..."
Abstract
-
Cited by 220 (5 self)
- Add to MetaCart
We present a novel approach to dynamic datarace detection for multithreaded object-oriented programs. Past techniques for onthe -fly datarace detection either sacrificed precision for performance, leading to many false positive datarace reports, or maintained precision but incurred significant overheads in the range of 3# to 30#. In contrast, our approach results in very few false positives and runtime overhead in the 13% to 42% range, making it both efficient and precise. This performance improvement is the result of a unique combination of complementary static and dynamic optimization techniques.
AVIO: Detecting Atomicity Violations via Access Interleaving Invariants
- In ASPLOS
, 2006
"... Abstract Concurrency bugs are among the most difficult to test and diagnoseof all software bugs. The multicore technology trend worsens this ..."
Abstract
-
Cited by 193 (26 self)
- Add to MetaCart
(Show Context)
Abstract Concurrency bugs are among the most difficult to test and diagnoseof all software bugs. The multicore technology trend worsens this
Efficient on-the-fly data race detection in multithreaded C++ programs
- In PPoPP ’03: Proceedings of the ninth ACM SIGPLAN symposium on Principles and practice of parallel programming
, 2003
"... Data race detection is essential for debugging multithreaded programs and assuring their correctness. Nevertheless, there is no single universal technique capable of handling the task efficiently, since the data race detection problem is computationally hard in the general case. Thus, to approximate ..."
Abstract
-
Cited by 76 (1 self)
- Add to MetaCart
(Show Context)
Data race detection is essential for debugging multithreaded programs and assuring their correctness. Nevertheless, there is no single universal technique capable of handling the task efficiently, since the data race detection problem is computationally hard in the general case. Thus, to approximate the possible races in a program, all currently available tools take different “short-cuts”, such as using strong assumptions on the program structure or applying various heuristics. When applied to some general case program, however, they usually result in excessive false alarms or in a large number of undetected races. Another major drawback of many currently available tools is that they are restricted, for perfor-mance reasons, to detection units of fixed size. Thus, they all suffer from the same problem—choosing a small unit might result in missing some of the data races, while choosing a large one might lead to false detection. In this work we present a novel testing tool, called MULTIRACE, which combines improved versions of DJIT and LOCKSET—two very powerful on-the-fly algorithms for dynamic detection of apparent data races. Both extended algorithms detect races in multithreaded programs that may execute on weak consistency systems, and may use two-way as well as global synchronization primitives. By employing novel technologies, MULTIRACE adjusts its detection to the native granularity of objects and variables in the program under examination. In order to monitor all accesses to each of the shared locations, MULTIRACE instruments the C++ source code of the program. It lets the user fine-tune the detection process, but otherwise is completely automatic and transparent. This paper describes the algorithms employed in MULTIRACE, as well as its implementation details. The paper also proposes some alternatives to and optimizations of MULTIRACE. It shows that the overheads imposed by MULTIRACE are often much smaller (orders of magnitude) than those obtained by other existing dynamic techniques.
Toward a Framework and Benchmark for Testing Tools for Multi-Threaded Programs
- Conc. & Comp.: Practice & Experience
, 2007
"... Multi-threaded code is becoming very common, both on the server side, and very recently for personal computers as well. Consequently, looking for intermittent bugs is a problem that is receiving more and more attention. As there is no silver bullet, research focuses on a variety of partial solutions ..."
Abstract
-
Cited by 37 (6 self)
- Add to MetaCart
(Show Context)
Multi-threaded code is becoming very common, both on the server side, and very recently for personal computers as well. Consequently, looking for intermittent bugs is a problem that is receiving more and more attention. As there is no silver bullet, research focuses on a variety of partial solutions. We outline a road map for combining the research within the different disciplines of testing multi-threaded programs and on evaluating the quality of this research. We have three main goals. First, to create a benchmark that can be used to evaluate different solutions. Second, to create a framework with open APIs that enables the combination of techniques in the multi-threading domain. Third, 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 can congregate. We have started creating such a benchmark and describe the lessons learned in the process. The framework will enable technology developers, for example, developers of race detection algorithms, to concentrate on their components and use other ready made components, (e.g., an instrumentor) to create a testing solution.
HARD: Hardware-Assisted Lockset-based Race Detection
"... Abstract The emergence of multicore architectures will lead to anincrease in the use of multithreaded applications that are prone to synchronization bugs, such as data races. Softwaresolutions for detecting data races generally incur large overheads. Hardware support for race detection can sig-nific ..."
Abstract
-
Cited by 35 (2 self)
- Add to MetaCart
(Show Context)
Abstract The emergence of multicore architectures will lead to anincrease in the use of multithreaded applications that are prone to synchronization bugs, such as data races. Softwaresolutions for detecting data races generally incur large overheads. Hardware support for race detection can sig-nificantly reduce that overhead. However, all existing hardware proposals for race detection are based on the happens-before algorithm which is sensitive to thread interleaving and cannot detect races that are not exposed during themonitored run. The lockset algorithm addresses this limitation. Unfortunately, due to the challenging issues suchas storing the lockset information and performing complex set operations, so far it has been implemented only in soft-ware with 10-30 times performance hit. This paper proposes the first hardware implementation(called HARD) of the lockset algorithm to exploit the race detection capability of this algorithm with minimal over-head. HARD efficiently stores lock sets in hardware bloom filters and converts the expensive set operations into fast bit-wise logic operations with negligible overhead. We evaluate HARD using six SPLASH-2 applications with 60 randomlyinjected bugs. Our results show that HARD can detect 54 out of 60 tested bugs, 20 % more than happens-before,with only 0.1-2.6 % of execution overhead. We also show our hardware design is cost-effective by comparing with theideal lockset implementation, which would require a large amount of hardware resources.
Static Datarace Analysis for Multithreaded Object-Oriented Programs
- IBM Research Division, Thomas J. Watson Research Centre
, 2001
"... This paper presents a novel analysis framework and algorithm for statically identifying dataraces in multithreaded object-oriented programs. The framework shows how datarace analysis can be formulated as a conjunction of interthread control flow analysis and points-to analysis of thread objects, syn ..."
Abstract
-
Cited by 22 (1 self)
- Add to MetaCart
(Show Context)
This paper presents a novel analysis framework and algorithm for statically identifying dataraces in multithreaded object-oriented programs. The framework shows how datarace analysis can be formulated as a conjunction of interthread control flow analysis and points-to analysis of thread objects, synchronization objects and access objects. This formulation can be used to identify a spectrum of dataraces depending on the precision of points-to and control flow information received as input. The framework can be used for datarace analysis of programs written in any multithreaded object-oriented language that supports creation of thread objects, monitor-like synchronization of threads via object-based locking, and global memory accesses via static and instance fields.
Cost-Effective (and Nearly Overhead-Free) OrderRecording and Data Race Detection
- in HPCA
, 2006
"... Chip-multiprocessors are becoming the dominant vehicle for general-purpose processing, and parallel software will be needed to effectively utilize them. This parallel software is no-toriously prone to synchronization bugs, which are often dif-ficult to detect and repeat for debugging. While data rac ..."
Abstract
-
Cited by 21 (0 self)
- Add to MetaCart
(Show Context)
Chip-multiprocessors are becoming the dominant vehicle for general-purpose processing, and parallel software will be needed to effectively utilize them. This parallel software is no-toriously prone to synchronization bugs, which are often dif-ficult to detect and repeat for debugging. While data race de-tection and order-recording for deterministic replay are useful in debugging such problems, only order-recording schemes are lightweight, whereas data race detection support scales poorly and degrades performance significantly. This paper presents our CORD (Cost-effective Order-Recor-ding and Data race detection) mechanism. It is similar in cost to prior order-recording mechanisms, but costs considerably less then prior schemes for data race detection. CORD also has a negligible performance overhead (0.4 % on average) and de-tects most dynamic manifestations of synchronization problems (77 % on average). Overall, CORD is fast enough to run always (even in performance-sensitive production runs) and provides the support programmers need to deal with the complexities of writing, debugging, and maintaining parallel software for future multi-threaded and multi-core machines. 1.
Towards Integration of Data Race Detection in DSM Systems
- Journal of Parallel and Distributed Computing
, 1999
"... We present a distributed algorithm, called djit, for detecting data-races in dsm systems. djit is designed as a dsm add-on, detecting a race condition as soon as one is created. It instantly displays to the user the precise place in the program where the race occurred. There are no false detections, ..."
Abstract
-
Cited by 14 (2 self)
- Add to MetaCart
(Show Context)
We present a distributed algorithm, called djit, for detecting data-races in dsm systems. djit is designed as a dsm add-on, detecting a race condition as soon as one is created. It instantly displays to the user the precise place in the program where the race occurred. There are no false detections, and no actual data races are missed. We have implemented djit on top of millipage -- a fine granularity, page-based dsm system. Our implementation makes novel use of the operating system protection mechanisms. In particular, we propose a protection cache, which can be used for local logging of accesses to variables. As a result, our implementation does not increase the message complexity of the execution, piggybacking all its communication activity on top of the dsm-related messages. The performance figures show that our data-race detection mechanism has only a minor influence on performance. The measured overheads, averaging only few percent, are two orders of magnitude smaller than thos...
Instrumenting Where it Hurts -- An Automatic Concurrent Debugging Technique
- ISSTA'07
, 2007
"... As concurrent and distributive applications are becoming more common and debugging such applications is very difficult, practical tools for automatic debugging of concurrent applications are in demand. In previous work, we applied automatic debugging to noise-based testing of concurrent programs. Th ..."
Abstract
-
Cited by 7 (0 self)
- Add to MetaCart
As concurrent and distributive applications are becoming more common and debugging such applications is very difficult, practical tools for automatic debugging of concurrent applications are in demand. In previous work, we applied automatic debugging to noise-based testing of concurrent programs. The idea of noise-based testing is to increase the probability of observing the bugs by adding, using instrumentation, timing ”noise ” to the execution of the program. The technique of finding a small subset of points that causes the bug to manifest can be used as an automatic debugging technique. Previously, we showed that Delta Debugging can be used to pinpoint the bug location on some small programs. In the work reported in this paper, we create and evaluate two algorithms for automatically pinpointing program locations that are in the vicinity of the bugs on a number of industrial