Collaborative Technique for Concurrency Bug Detection.
Saved in:
| Title: | Collaborative Technique for Concurrency Bug Detection. |
|---|---|
| Authors: | Wu, Zhendong wuzhendong@nudt.edu.cn, Lu, Kai kailu@nudt.edu.cn, Wang, Xiaoping xiaopingwang@nudt.edu.cn, Zhou, Xu zhouxu@nudt.edu.cn |
| Source: | International Journal of Parallel Programming. Apr2015, Vol. 43 Issue 2, p260-285. 26p. |
| Subjects: | Debugging, Computer system failure prevention, Coding theory, Multicore processors, Threads (Computer programs) |
| Abstract: | Concurrency bugs hidden in deployed software can cause severe failures and real-world disasters. They are notoriously difficult to detect during in-house testing due to huge and non-deterministic interleaving space. Unfortunately, the multicore technology trend worsens this problem. Unlike previous work that detects particular concurrency bugs (e.g., data races and atomicity violations), we target harmful concurrency bugs that cause program failures. In order to detect harmful concurrency bugs effectively and efficiently, we propose an innovative, collaborative approach called ColFinder. First, ColFinder statically analyzes the program to identify potential concurrency bugs. ColFinder then uses static program slicing to get smaller programs with respect to potential concurrency bugs. Finally, ColFinder dynamically controls thread scheduler to force multiple threads access the same memory location, verifying whether the potential concurrency bug will cause program failure. If a failure occurs, a harmful concurrency bug is detected. We have implemented ColFinder as a prototype tool and have experimented on a number of real-world concurrent programs. The probability of bug manifestation in these programs is only 0.64 % averagely during native execution. It is significantly raised to 90 % with ColFinder. The runtime overhead imposed by many previous approaches is always more than 10 $$\times $$ . The overhead of ColFinder is more acceptable, with an average of 79 %. Additionally, to our knowledge, this is the first technique that introduces program slicing to reduce the time of bug manifestation, with an average of 33 %. [ABSTRACT FROM AUTHOR] |
| Copyright of International Journal of Parallel Programming is the property of Springer Nature and its content may not be copied or emailed to multiple sites without the copyright holder's express written permission. Additionally, content may not be used with any artificial intelligence tools or machine learning technologies. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.) | |
| Database: | Engineering Source |
| FullText | Links: – Type: pdflink Text: Availability: 0 |
|---|---|
| Header | DbId: egs DbLabel: Engineering Source An: 101005206 AccessLevel: 6 PubType: Academic Journal PubTypeId: academicJournal PreciseRelevancyScore: 0 |
| IllustrationInfo | |
| Items | – Name: Title Label: Title Group: Ti Data: Collaborative Technique for Concurrency Bug Detection. – Name: Author Label: Authors Group: Au Data: <searchLink fieldCode="AR" term="%22Wu%2C+Zhendong%22">Wu, Zhendong</searchLink><i> wuzhendong@nudt.edu.cn</i><br /><searchLink fieldCode="AR" term="%22Lu%2C+Kai%22">Lu, Kai</searchLink><i> kailu@nudt.edu.cn</i><br /><searchLink fieldCode="AR" term="%22Wang%2C+Xiaoping%22">Wang, Xiaoping</searchLink><i> xiaopingwang@nudt.edu.cn</i><br /><searchLink fieldCode="AR" term="%22Zhou%2C+Xu%22">Zhou, Xu</searchLink><i> zhouxu@nudt.edu.cn</i> – Name: TitleSource Label: Source Group: Src Data: <searchLink fieldCode="JN" term="%22International+Journal+of+Parallel+Programming%22">International Journal of Parallel Programming</searchLink>. Apr2015, Vol. 43 Issue 2, p260-285. 26p. – Name: Subject Label: Subjects Group: Su Data: <searchLink fieldCode="DE" term="%22Debugging%22">Debugging</searchLink><br /><searchLink fieldCode="DE" term="%22Computer+system+failure+prevention%22">Computer system failure prevention</searchLink><br /><searchLink fieldCode="DE" term="%22Coding+theory%22">Coding theory</searchLink><br /><searchLink fieldCode="DE" term="%22Multicore+processors%22">Multicore processors</searchLink><br /><searchLink fieldCode="DE" term="%22Threads+%28Computer+programs%29%22">Threads (Computer programs)</searchLink> – Name: Abstract Label: Abstract Group: Ab Data: Concurrency bugs hidden in deployed software can cause severe failures and real-world disasters. They are notoriously difficult to detect during in-house testing due to huge and non-deterministic interleaving space. Unfortunately, the multicore technology trend worsens this problem. Unlike previous work that detects particular concurrency bugs (e.g., data races and atomicity violations), we target harmful concurrency bugs that cause program failures. In order to detect harmful concurrency bugs effectively and efficiently, we propose an innovative, collaborative approach called ColFinder. First, ColFinder statically analyzes the program to identify potential concurrency bugs. ColFinder then uses static program slicing to get smaller programs with respect to potential concurrency bugs. Finally, ColFinder dynamically controls thread scheduler to force multiple threads access the same memory location, verifying whether the potential concurrency bug will cause program failure. If a failure occurs, a harmful concurrency bug is detected. We have implemented ColFinder as a prototype tool and have experimented on a number of real-world concurrent programs. The probability of bug manifestation in these programs is only 0.64 % averagely during native execution. It is significantly raised to 90 % with ColFinder. The runtime overhead imposed by many previous approaches is always more than 10 $$\times $$ . The overhead of ColFinder is more acceptable, with an average of 79 %. Additionally, to our knowledge, this is the first technique that introduces program slicing to reduce the time of bug manifestation, with an average of 33 %. [ABSTRACT FROM AUTHOR] – Name: AbstractSuppliedCopyright Label: Group: Ab Data: <i>Copyright of International Journal of Parallel Programming is the property of Springer Nature and its content may not be copied or emailed to multiple sites without the copyright holder's express written permission. Additionally, content may not be used with any artificial intelligence tools or machine learning technologies. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract.</i> (Copyright applies to all Abstracts.) |
| PLink | https://search.ebscohost.com/login.aspx?direct=true&site=eds-live&db=egs&AN=101005206 |
| RecordInfo | BibRecord: BibEntity: Identifiers: – Type: doi Value: 10.1007/s10766-014-0304-y Languages: – Code: eng Text: English PhysicalDescription: Pagination: PageCount: 26 StartPage: 260 Subjects: – SubjectFull: Debugging Type: general – SubjectFull: Computer system failure prevention Type: general – SubjectFull: Coding theory Type: general – SubjectFull: Multicore processors Type: general – SubjectFull: Threads (Computer programs) Type: general Titles: – TitleFull: Collaborative Technique for Concurrency Bug Detection. Type: main BibRelationships: HasContributorRelationships: – PersonEntity: Name: NameFull: Wu, Zhendong – PersonEntity: Name: NameFull: Lu, Kai – PersonEntity: Name: NameFull: Wang, Xiaoping – PersonEntity: Name: NameFull: Zhou, Xu IsPartOfRelationships: – BibEntity: Dates: – D: 01 M: 04 Text: Apr2015 Type: published Y: 2015 Identifiers: – Type: issn-print Value: 08857458 Numbering: – Type: volume Value: 43 – Type: issue Value: 2 Titles: – TitleFull: International Journal of Parallel Programming Type: main |
| ResultId | 1 |
