ACM Home Page
Please provide us with feedback. Feedback
Healing data races on-the-fly
Full text PdfPdf (261 KB)
Source
International Symposium on Software Testing and Analysis archive
Proceedings of the 2007 ACM workshop on Parallel and distributed systems: testing and debugging table of contents
London, United Kingdom
SESSION: Formal and healing table of contents
Pages: 54 - 64  
Year of Publication: 2007
ISBN:978-1-59593-748-3
Authors
Bohuslav Krena  Brno University of Technology, Czech Republic
Zdenek Letko  Brno University of Technology, Czech Republic
Rachel Tzoref  Haifa University Campus, Haifa, Israel
Shmuel Ur  Haifa University Campus, Haifa, Israel
Tomáš Vojnar  Brno University of Technology, Czech Republic
Sponsors
ACM: Association for Computing Machinery
SIGSOFT: ACM Special Interest Group on Software Engineering
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 7,   Downloads (12 Months): 72,   Citation Count: 5
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/1273647.1273658
What is a DOI?

ABSTRACT

Testing of concurrent software is extremely difficult. Despite all the progress in the testing and verification technology, concurrent bugs, the most common of which are deadlocks and races, make it to the field. This paper describes a set of techniques, implemented in a tool called ConTest, allowing concurrent programs to self-heal at run-time. Concurrent bugs have the very desirable property for healing that some of the interleaving produce correct results while in others bugs manifest. Healing concurrency problems is about limiting, or changing the probability of interleaving, such that bugs will be seen less. When healing concurrent programs, if a deadlock does not result from limiting the interleaving, we are sure that the result of the healed program could have been in the original program and therefore no new functional bug has been introduced. In this initial work which deals with different types of data races, we suggest three types of healing mechanisms: (1) changing the probability of interleaving by introducing sleep or yield statements or by changing thread priorities, (2) removing interleaving using synchronisation commands like locking and unlocking certain mutexes or waits and notifies, and (3) removing the result of "bad interleaving" by replacing the value of variables by the one that "should" have been taken. We also classify races according to the relevant healing strategies to apply.


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
C. Artho, K. Havelund, and A. Biere. High-level Data Races. In Proc. of VVEIS'03, Angers, France, 2003.
 
3
C. Artho, K. Havelund, and A. Biere. Using Block-Local Atomicity to Detect Stale-Value Concurrency Errors. In Proc. of ATVA'04, LNCS 3299, 2004. Springer.
4
 
5
6
 
7
W. Beaton and J. d. Rivieres. Eclipse Platform Technical Overview. Technical report, The Eclipse Foundation, 2006.
 
8
T. P. e. a. Brian Goetz. Java Concurrency in Practice. Addison-Wesley, 2006.
 
9
10
 
11
J. Choi, K. Lee, A. Loginov, R. O'Callahan, V. Sarkar, and M. Sridharan. Efficient and Precise Data Race Detection for Multithreaded Object-Oriented Programs, 2002.
 
12
13
14
15
 
16
17
18
 
19
T. Elmas, S. Qadeer, and S. Tasiran. Goldilocks: Efficiently computing the happens-before relation using locksets. Proceedings of the Workshop on Formal Approaches to Testing and Runtime Verification, 2006.
20
 
21
 
22
T. A. Henzinger, R. Jhala, R. Majumdar, and G. Sutre. Software Verification with Blast. In Proc. of 10th SPIN Workshop, LNCS 2648, 2003. Springer.
 
23
24
25
 
26
 
27
R. Nagpaly, K. Pattabiramanz, D. Kirovski, and B. Zorn. ToleRace: Tolerating and Detecting Races. In Proc. of STMCS'07, 2007.
 
28
R. Netzer and B. Miller. Detecting Data Races in Parallel Program Executions. In Advances in Languages and Compilers for Parallel Computing, 1990 Workshop, 1990. MIT Press.
29
30
 
31
32
33
34
35
 
36
37
38
 
39
L. Wang and S. D. Stoller. Run-time Analysis for Atomicity. In Proc. of RV'03, ENTCS 89(2), 2003. Elsevier.
40


Collaborative Colleagues:
Bohuslav Krena: colleagues
Zdenek Letko: colleagues
Rachel Tzoref: colleagues
Shmuel Ur: colleagues
Tomáš Vojnar: colleagues