Automated atomicity-violation fixing

Guoliang Jin, Linhai Song, Wei Zhang, Shan Lu, Ben Liblit

Research output: Chapter in Book/Report/Conference proceedingConference contribution

128 Citations (Scopus)

Abstract

Fixing software bugs has always been an important and time-consuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to non-deterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches. We present AFix, a tool that automates the whole process of fixing one common type of concurrency bug: single-variable atomicity violations. AFix starts from the bug reports of existing bug-detection tools. It augments these with static analysis to construct a suitable patch for each bug report. It further tries to combine the patches of multiple bugs for better performance and code readability. Finally, AFix's run-time component provides testing customized for each patch. Our evaluation shows that patches automatically generated by AFix correctly eliminate six out of eight real-world bugs and significantly decrease the failure probability in the other two cases. AFix patches never introduce new bugs and usually have similar performance to manually-designed patches.

Original languageEnglish (US)
Title of host publicationPLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation
Pages389-400
Number of pages12
DOIs
StatePublished - Jul 7 2011
Event32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI'11 - San Jose, CA, United States
Duration: Jun 4 2011Jun 8 2011

Publication series

NameProceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

Other

Other32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI'11
CountryUnited States
CitySan Jose, CA
Period6/4/116/8/11

Fingerprint

Static analysis
Software engineering
Testing

All Science Journal Classification (ASJC) codes

  • Software

Cite this

Jin, G., Song, L., Zhang, W., Lu, S., & Liblit, B. (2011). Automated atomicity-violation fixing. In PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation (pp. 389-400). (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). https://doi.org/10.1145/1993498.1993544
Jin, Guoliang ; Song, Linhai ; Zhang, Wei ; Lu, Shan ; Liblit, Ben. / Automated atomicity-violation fixing. PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation. 2011. pp. 389-400 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).
@inproceedings{7e266c003c324bad8cc11f224703da48,
title = "Automated atomicity-violation fixing",
abstract = "Fixing software bugs has always been an important and time-consuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to non-deterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches. We present AFix, a tool that automates the whole process of fixing one common type of concurrency bug: single-variable atomicity violations. AFix starts from the bug reports of existing bug-detection tools. It augments these with static analysis to construct a suitable patch for each bug report. It further tries to combine the patches of multiple bugs for better performance and code readability. Finally, AFix's run-time component provides testing customized for each patch. Our evaluation shows that patches automatically generated by AFix correctly eliminate six out of eight real-world bugs and significantly decrease the failure probability in the other two cases. AFix patches never introduce new bugs and usually have similar performance to manually-designed patches.",
author = "Guoliang Jin and Linhai Song and Wei Zhang and Shan Lu and Ben Liblit",
year = "2011",
month = "7",
day = "7",
doi = "10.1145/1993498.1993544",
language = "English (US)",
isbn = "9781450306638",
series = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",
pages = "389--400",
booktitle = "PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation",

}

Jin, G, Song, L, Zhang, W, Lu, S & Liblit, B 2011, Automated atomicity-violation fixing. in PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pp. 389-400, 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI'11, San Jose, CA, United States, 6/4/11. https://doi.org/10.1145/1993498.1993544

Automated atomicity-violation fixing. / Jin, Guoliang; Song, Linhai; Zhang, Wei; Lu, Shan; Liblit, Ben.

PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation. 2011. p. 389-400 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

TY - GEN

T1 - Automated atomicity-violation fixing

AU - Jin, Guoliang

AU - Song, Linhai

AU - Zhang, Wei

AU - Lu, Shan

AU - Liblit, Ben

PY - 2011/7/7

Y1 - 2011/7/7

N2 - Fixing software bugs has always been an important and time-consuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to non-deterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches. We present AFix, a tool that automates the whole process of fixing one common type of concurrency bug: single-variable atomicity violations. AFix starts from the bug reports of existing bug-detection tools. It augments these with static analysis to construct a suitable patch for each bug report. It further tries to combine the patches of multiple bugs for better performance and code readability. Finally, AFix's run-time component provides testing customized for each patch. Our evaluation shows that patches automatically generated by AFix correctly eliminate six out of eight real-world bugs and significantly decrease the failure probability in the other two cases. AFix patches never introduce new bugs and usually have similar performance to manually-designed patches.

AB - Fixing software bugs has always been an important and time-consuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to non-deterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches. We present AFix, a tool that automates the whole process of fixing one common type of concurrency bug: single-variable atomicity violations. AFix starts from the bug reports of existing bug-detection tools. It augments these with static analysis to construct a suitable patch for each bug report. It further tries to combine the patches of multiple bugs for better performance and code readability. Finally, AFix's run-time component provides testing customized for each patch. Our evaluation shows that patches automatically generated by AFix correctly eliminate six out of eight real-world bugs and significantly decrease the failure probability in the other two cases. AFix patches never introduce new bugs and usually have similar performance to manually-designed patches.

UR - http://www.scopus.com/inward/record.url?scp=79959893225&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=79959893225&partnerID=8YFLogxK

U2 - 10.1145/1993498.1993544

DO - 10.1145/1993498.1993544

M3 - Conference contribution

AN - SCOPUS:79959893225

SN - 9781450306638

T3 - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

SP - 389

EP - 400

BT - PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation

ER -

Jin G, Song L, Zhang W, Lu S, Liblit B. Automated atomicity-violation fixing. In PLDI'11 - Proceedings of the 2011 ACM Conference on Programming Language Design and Implementation. 2011. p. 389-400. (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). https://doi.org/10.1145/1993498.1993544