ACM Home Page
Please provide us with feedback. Feedback
Automatically classifying benign and harmful data racesallusing replay analysis
Full text PdfPdf (274 KB)
Source
Conference on Programming Language Design and Implementation archive
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation table of contents
San Diego, California, USA
SESSION: Errors detected & corrected table of contents
Pages: 22 - 31  
Year of Publication: 2007
ISBN:978-1-59593-633-2
Also published in ...
Authors
Satish Narayanasamy  UC San Diego, La Jolla, CA
Zhenghao Wang  Microsoft, Redmond, WA
Jordan Tigani  Microsoft, Redmond, WA
Andrew Edwards  Microsoft, Redmond, WA
Brad Calder  Microsoft, Redmond, WA
Sponsors
SIGPLAN: ACM Special Interest Group on Programming Languages
ACM: Association for Computing Machinery
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 19,   Downloads (12 Months): 204,   Citation Count: 13
Additional Information:

abstract   references   cited by   index terms   collaborative colleagues  

Tools and Actions: Request Permissions Request Permissions    Review this Article  
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/1250734.1250738
What is a DOI?

ABSTRACT

Many concurrency bugs in multi-threaded programs are due to dataraces. There have been many efforts to develop static and dynamic mechanisms to automatically find the data races. Most of the prior work has focused on finding the data races and eliminating the false positives.

In this paper, we instead focus on a dynamic analysis technique to automatically classify the data races into two categories - the dataraces that are potentially benign and the data races that are potentially harmful. A harmful data race is a real bug that needs to be fixed. This classification is needed to focus the triaging effort on those data races that are potentially harmful. Without prioritizing the data races we have found that there are too many data races to triage. Our second focus is to automatically provide to the developer a reproducible scenario of the data race, which allows the developer to understand the different effects of a harmful data race on a program's execution.

To achieve the above, we record a multi-threaded program's execution in a replay log. The replay log is used to replay the multi-threaded program, and during replay we find the data races using a happens-before based algorithm. To automatically classify if a data race that we find is potentially benign or potentially harmful, were play the execution twice for a given data race - one for each possible order between the conflicting memory operations. If the two replays for the two orders produce the same result, then we classify the data race to be potentially benign. We discuss our experiences in using our replay based dynamic data race checker on several Microsoft applications.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
16
M. Hicks, J. S. Foster, and P. Pratikakis. Inferring locking for atomic sections. In Proceedings of the ACM SIGPLAN Workshop on Languages, Compilers, and Hardware Support for Transactional Computing (TRANSACT), June 2006.
17
18
19
20
21
 
22
23
24
25
26
27
28
29
30
 
31
M. Ronsse and K. de Bosschere. Non-intrusive on-the-fly data race detection using execution replay. In Proceedings of Automated and Algorithmic Debugging, Nov 2000.
32
33
34
 
35
N. Sterling. Warlock - a static data race analysis tool. In Proceedings of the USENIX Winter Technical Conference, pages 97--106, 1993.
36
37
38

CITED BY  13

Collaborative Colleagues:
Satish Narayanasamy: colleagues
Zhenghao Wang: colleagues
Jordan Tigani: colleagues
Andrew Edwards: colleagues
Brad Calder: colleagues