Dynamic slicing of multithreaded programs for race detection

Tallam, Sriraman; Tian, Chen; Gupta, Rajiv

doi:10.1109/icsm.2008.4658058

Cited by 18 publications

(15 citation statements)

References 28 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our current work that generalizes our approach to handle multithreading bugs is inspired by several key observations taken from prior work. The first of these comes from Tallam et al work on extending dynamic slicing to capture data race bugs [11]. In this work, the authors observed that dynamic slicing traditionally considers only RAW data and control dependencies, and this may result in dynamic slices failing to capture relevant data race bugs in an execution.…”

Section: Related Workmentioning

confidence: 99%

“…Figure 2 shows the pseudocode for this on-the-fly approach for detecting data races. This accounts for the observation by Tallam et al [11] that data races can be represented by either RAW, WAR, or WAW dependencies. Note that in Figure 1, the checking for RAW data races is done on-the-fly while also performing the suppression.…”

Section: Data Race Bugsmentioning

confidence: 99%

“…There has been significant prior research on techniques for locating bugs that often does not explicitly deal with multithreading bugs. Slicing-based techniques are one such thread of research (though it has recently been extended [11] to handle data race bugs). Static slicing [52] identifies a subset of program statements that may influence the value of a variable at a program location.…”

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Isolating bugs in multithreaded programs using execution suppression

et al. 2011

Self Cite

View full text Add to dashboard Cite

SUMMARYMemory-related program failures in multithreaded programs can be caused by a variety of bugs. Concurrency bugs can occur due to unexpected or incorrect thread interleavings during execution. Other kinds of memory bugs, such as buffer overflows and uninitialized reads, may also occur in multithreaded as well as single-threaded programs. Most prior techniques for isolating these bugs are specialized, addressing only one type of concurrency bug or certain types of other memory bugs. The memory corruption caused by these bugs can also undergo significant propagation during program execution. When a program failure finally occurs due to memory corruption, the true root cause of the failure may be effectively concealed as significant portions of memory may have become corrupted. We propose a general framework that can isolate the root cause of any failure in a multithreaded program that involves memory corruption and reveals at least a subset of this memory corruption. This includes three important types of concurrency bugs-data races, atomicity violations, and order violations-as well as other kinds of memory bugs. To account for propagation of memory corruption, our approach uses a dynamic technique called 'execution suppression' that iteratively reveals memory corruption in a failing execution to isolate the true root cause of the failure.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: Data Race Bugsmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Isolating bugs in multithreaded programs using execution suppression

et al. 2011

Self Cite

View full text Add to dashboard Cite

show abstract

“…In lines 11-15, the algorithm adds a dependence d to the slice and the work list, if d is a value difference or a flow difference. Otherwise, the algorithm handles def-use differences by adding the dependence d to the slice if the dependence d ′ corresponding to d in the passing run does not align with d (lines [16][17][18][19][20][21]. Observe that though d is added to the slice it is not placed in the work list.…”

Section: Inputmentioning

confidence: 99%

Analyzing concurrency bugs using dual slicing

Weeratunge

Zhang

Sumner

et al. 2010

Proceedings of the 19th International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

Recently, there has been much interest in developing analyzes to detect concurrency bugs that arise because of data races, atomicity violations, execution omission, etc. However, determining whether reported bugs are in fact real, and understanding how these bugs lead to incorrect behavior, remains a labor-intensive process. This paper proposes a novel dynamic analysis that automatically produces the causal path of a concurrent failure leading from the root cause to the failure. Given two schedules, one inducing the failure and the other not, our technique collects traces of the two executions, and compares them to identify salient differences. The causal relation between the differences is disclosed by leveraging a novel slicing algorithm called dual slicing that slices both executions alternatively and iteratively, producing a slice containing trace differences from both runs. Our experiments show that dual slices tend to be very small, often an order of magnitude or more smaller than the corresponding dynamic slices; more importantly, they enable precise analysis of real concurrency bugs for large programs, with reasonable overhead.

show abstract

“…Many static and dynamic analysis techniques [32], [33], [44] can be classified as model-based debugging as well. Although few model-based techniques have employed the concept of failure association, incorporating association measures and other statistical analyses into program models can be a future direction for improving the performance of model-based debugging techniques.…”

Section: A Fault Localizationmentioning

confidence: 99%

Comprehensive evaluation of association measures for fault localization

Lucia

Jiang

et al. 2010

2010 IEEE International Conference on Software Maintenance

View full text Add to dashboard Cite

Abstract-In statistics and data mining communities, there have been many measures proposed to gauge the strength of association between two variables of interest, such as odds ratio, confidence, Yule-Y, Yule-Q, Kappa, and gini index. These association measures have been used in various domains, for example, to evaluate whether a particular medical practice is associated positively to a cure of a disease or whether a particular marketing strategy is associated positively to an increase in revenue, etc. This paper models the problem of locating faults as association between the execution or non-execution of particular program elements with failures. There have been special measures, termed as suspiciousness measures, proposed for the task. Two state-of-the-art measures are Tarantula and Ochiai, which are different from many other statistical measures. To the best of our knowledge, there is no study that comprehensively investigates the effectiveness of various association measures in localizing faults. This paper fills in the gap by evaluating 20 wellknown association measures and compares their effectiveness in fault localization tasks with Tarantula and Ochiai. Evaluation on the Siemens programs show that a number of association measures perform statistically comparable as Tarantula and Ochiai.

show abstract

Dynamic slicing of multithreaded programs for race detection

Abstract: Abstract

Cited by 18 publications

References 28 publications

Isolating bugs in multithreaded programs using execution suppression

Isolating bugs in multithreaded programs using execution suppression

Analyzing concurrency bugs using dual slicing

Comprehensive evaluation of association measures for fault localization

Contact Info

Product

Resources

About