Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
10.1145/3106237.3106292acmconferencesArticle/Chapter ViewAbstractPublication PagesfseConference Proceedingsconference-collections
research-article

Reproducing concurrency failures from crash stacks

Published: 21 August 2017 Publication History
  • Get Citation Alerts
  • Abstract

    Reproducing field failures is the first essential step for understanding, localizing and removing faults. Reproducing concurrency field failures is hard due to the need of synthesizing a test code jointly with a thread interleaving that induce the failure in the presence of limited information from the field. Current techniques for reproducing concurrency failures focus on identifying failure-inducing interleavings, leaving largely open the problem of synthesizing the test code that manifests such interleavings. In this paper, we present ConCrash, a technique to automatically generate test codes that reproduce concurrency failures that violate thread-safety from crash stacks, which commonly summarize the conditions of field failures. ConCrash efficiently explores the huge space of possible test codes to identify a failure-inducing one by using a suitable set of search pruning strategies. Combined with existing techniques for exploring interleavings, ConCrash automatically reproduces a given concurrency failure that violates the thread-safety of a class by identifying both a failure-inducing test code and corresponding interleaving. In the paper, we define the ConCrash approach, present a prototype implementation of ConCrash, and discuss the experimental results that we obtained on a known set of ten field failures that witness the effectiveness of the approach.

    References

    [1]
    Gautam Altekar and Ion Stoica. 2009. ODR: Output-Deterministic Replay for Multicore Debugging. In Proceedings of the Symposium on Operating Systems Principles (SOSP ’09). ACM, 193–206.
    [2]
    Shay Artzi, Sunghun Kim, and Michael D. Ernst. 2008. ReCrash: Making Software Failures Reproducible by Preserving Object States. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP ’08). Springer, 542–565.
    [3]
    Jonathan Bell, Nikhil Sarda, and Gail Kaiser. 2013. Chronicler: Lightweight Recording to Reproduce Field Failures. In Proceedings of the International Conference on Software Engineering (ICSE ’13). IEEE Computer Society, 362–371.
    [4]
    Nicolas Bettenburg, Sascha Just, Adrian Schröter, Cathrin Weiss, Rahul Premraj, and Thomas Zimmermann. 2008. What Makes a Good Bug Report?. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’16). ACM, 308–318.
    [5]
    Francesco A. Bianchi, Alessandro Margara, and Mauro Pezzè. 2017. A Survey of Recent Trends in Testing Concurrent Software Systems. IEEE Transactions on Software Engineering (2017).
    [6]
    D. Brodeur and T. Fors. 2002. Capturing Snapshots of a Debuggee’s State during a Debug Session. (July 4 2002). https://www.google.com/patents/US20020087950 US Patent App. 09/963,085.
    [7]
    Yan Cai and W. K. Chan. 2012. MagicFuzzer: Scalable Deadlock Detection for Large-Scale Applications. In Proceedings of the International Conference on Software Engineering (ICSE ’12). IEEE Computer Society, 606–616.
    [8]
    Yan Cai, Shangru Wu, and W. K. Chan. 2014. ConLock: a Constraint-Based Approach to Dynamic Checking on Deadlocks in Multithreaded Programs. In Proceedings of the International Conference on Software Engineering (ICSE ’14). ACM, 491–502.
    [9]
    Satish Chandra, Stephen J. Fink, and Manu Sridharan. 2009. Snugglebug: A Powerful Approach to Weakest Preconditions. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’09). ACM, 363–374.
    [10]
    Ning Chen and Sunghun Kim. 2015. STAR: Stack Trace Based Automatic Crash Reproduction via Symbolic Execution. IEEE Transactions on Software Engineering 41, 2 (2015), 198–220.
    [11]
    Ankit Choudhary, Shan Lu, and Michael Pradel. 2017. Efficient Detection of Thread Safety Violations via Coverage-Guided Generation of Concurrent Tests. In Proceedings of the International Conference on Software Engineering (ICSE ’17). ACM, 266–277.
    [12]
    Leonardo De Moura and Nikolaj Bjørner. 2008. Z3: An Efficient SMT Solver. In Proceedings of the International Conference on Tools and Algorithms for Construction and Analysis of Systems (TACAS/ETAPS ’08). Springer, 337–340.
    [13]
    Juergen Dingel and Hongzhi Liang. 2004. Automating Comprehensive Safety Analysis of Concurrent Programs Using Verisoft and TXL. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’12). ACM, 13–22.
    [14]
    Mahdi Eslamimehr and Jens Palsberg. 2014. Sherlock: Scalable Deadlock Detection for Concurrent Programs. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’14). ACM, 353–365.
    [15]
    Azadeh Farzan, P. Madhusudan, Niloofar Razavi, and Francesco Sorrentino. 2012. Predicting Null-pointer Dereferences in Concurrent Programs. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’12). ACM, 1–11.
    [16]
    Cormac Flanagan and Stephen N. Freund. 2004. Atomizer: A Dynamic Atomicity Checker for Multithreaded Programs. In Proceedings of the Symposium on Principles of Programming Languages (POPL ’04). ACM, 256–267.
    [17]
    Cormac Flanagan, Stephen N. Freund, and Jaeheon Yi. 2008. Velodrome: A Sound and Complete Dynamic Atomicity Checker for Multithreaded Programs. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’08). ACM, 293–303.
    [18]
    G. Fraser and A. Gargantini. 2009. Experiments on the Test Case Length in Specification Based Test Case Generation. In 2009 ICSE Workshop on Automation of Software Test (AST ’13). 18–26.
    [19]
    Brian Goetz and Tim Peierls. 2006. Java Concurrency in Practice. Pearson Education.
    [20]
    Maurice P. Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ACM Transactions on Programming Languages and Systems 12, 3 (1990), 463–492.
    [21]
    Jeff Huang, Peng Liu, and Charles Zhang. 2010. LEAP: Lightweight Deterministic Multi-processor Replay of Concurrent Java Programs. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’10). ACM, 207–216.
    [22]
    Jeff Huang, Qingzhou Luo, and Grigore Rosu. 2015. GPredict: Generic Predictive Concurrency Analysis. In Proceedings of the International Conference on Software Engineering (ICSE ’15). ACM, 847–857.
    [23]
    Jeff Huang, Charles Zhang, and Julian Dolby. 2013. CLAP: Recording Local Executions to Reproduce Concurrency Failures. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’13). ACM, 141–152.
    [24]
    Yanyan Jiang, Tianxiao Gu, Chang Xu, Xiaoxing Ma, and Jian Lu. 2014. CARE: Cache Guided Deterministic Replay for Concurrent Java Programs. In Proceedings of the International Conference on Software Engineering (ICSE ’14). ACM, 457–467.
    [25]
    Wei Jin and Alessandro Orso. 2012. BugRedux: Reproducing Field Failures for In-house Debugging. In Proceedings of the International Conference on Software Engineering (ICSE ’12). IEEE Computer Society, 474–484.
    [26]
    Shan Lu, Weihang Jiang, and Yuanyuan Zhou. 2007. A Study of Interleaving Coverage Criteria. In Proceedings of the European Software Engineering Conference held jointly with the ACM SIGSOFT International Symposium on Foundations of Software Engineering (ESEC-FSE ’07). ACM, 533–536.
    [27]
    Shan Lu, Soyeon Park, Eunsoo Seo, and Yuanyuan Zhou. 2008. Learning from Mistakes: A Comprehensive Study on Real World Concurrency Bug Characteristics. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’08). ACM, 329–339.
    [28]
    Nuno Machado, Brandon Lucia, and Luís Rodrigues. 2015. Concurrency Debugging with Differential Schedule Projections. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’15). ACM, 586–595.
    [29]
    Nuno Machado, Brandon Lucia, and Luís Rodrigues. 2016. Production-guided Concurrency Debugging. In Proceedings of the Symposium on Principles and Practice of Parallel Programming (PPoPP ’16). ACM, 29:1–29:12.
    [30]
    Roman Manevich, Manu Sridharan, Stephen Adams, Manuvir Das, and Zhe Yang. 2004. PSE: Explaining Program Failures via Postmortem Static Analysis. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’12). ACM, 63–72.
    [31]
    Daniel Marino, Madanlal Musuvathi, and Satish Narayanasamy. 2009. LiteRace: Effective Sampling for Lightweight Data-race Detection. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’09). ACM, 134–143.
    [32]
    Adrian Nistor, Qingzhou Luo, Michael Pradel, Thomas R. Gross, and Darko Marinov. 2012. BALLERINA: Automatic Generation and Clustering of Efficient Random Unit Tests for Multithreaded Code. In Proceedings of the International Conference on Software Engineering (ICSE ’12). IEEE Computer Society, 727–737.
    [33]
    Robert O’Callahan and Jong-Deok Choi. 2003. Hybrid Dynamic Data Race Detection. In Proceedings of the Symposium on Principles and Practice of Parallel Programming (PPOPP ’03). ACM, 167–178.
    [34]
    Peter Ohmann and Ben Liblit. 2013. Lightweight Control-Flow Instrumentation and Postmortem Analysis in Support of Debugging. In Proceedings of the International Conference on Automated Software Engineering (ASE ’13). IEEE Computer Society, 378–388.
    [35]
    Carlos Pacheco, Shuvendu K. Lahiri, Michael D. Ernst, and Thomas Ball. 2007. Feedback-Directed Random Test Generation. In Proceedings of the International Conference on Software Engineering (ICSE ’07). ACM, 75–84.
    [36]
    Chang-Seo Park and Koushik Sen. 2008. Randomized Active Atomicity Violation Detection in Concurrent Programs. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’08). ACM, 135–145.
    [37]
    Soyeon Park, Shan Lu, and Yuanyuan Zhou. 2009. CTrigger: Exposing Atomicity Violation Bugs from their Hiding Places. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’09). ACM, 25–36.
    [38]
    Michael Pradel and Thomas R. Gross. 2012. Fully Automatic and Precise Detection of Thread Safety Violations. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’12). ACM, 521–530.
    [39]
    Jeremias Rössler, Andreas Zeller, Gordon Fraser, Cristian Zamfir, and George Candea. 2013. Reconstructing Core Dumps. In Proceedings of the International Conference on Software Testing, Verification and Validation (ICST ’13). IEEE Computer Society, 114–123.
    [40]
    Malavika Samak and Murali Krishna Ramanathan. 2014. Multithreaded Test Synthesis for Deadlock Detection. In Proceedings of the Conference on Object-Oriented Programming Systems and Applications (OOPSLA ’14). ACM, 473–489.
    [41]
    Malavika Samak and Murali Krishna Ramanathan. 2015. Synthesizing Tests for Detecting Atomicity Violations. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’15). ACM, 131–142. ESEC/FSE’17, September 04-08, 2017, Paderborn, Germany Francesco A. Bianchi, Mauro Pezzè, and Valerio Terragni
    [42]
    Malavika Samak, Murali Krishna Ramanathan, and Suresh Jagannathan. 2015. Synthesizing Racy Tests. In Proceedings of the Conference on Programming Language Design and Implementation (PLDI ’15). ACM, 175–185.
    [43]
    Malavika Samak, Omer Tripp, and Murali Krishna Ramanathan. 2016. Directed Synthesis of Failing Concurrent Executions. In Proceedings of the Conference on Object-Oriented Programming Systems and Applications (OOPSLA ’16). ACM, 430–446.
    [44]
    Stefan Savage, Michael Burrows, Greg Nelson, Patrick Sobalvarro, and Thomas E. Anderson. 1997. Eraser: A Dynamic Data Race Detector for Multithreaded Programs. ACM Transactions on Computer Systems 15, 4 (1997), 391–411.
    [45]
    Sebastian Steenbuck and Gordon Fraser. 2013. Generating Unit Tests for Concurrent Classes. In Proceedings of the International Conference on Software Testing, Verification and Validation (ICST ’13). IEEE Computer Society, 144–153.
    [46]
    Lin Tan, Chen Liu, Zhenmin Li, Xuanhui Wang, Yuanyuan Zhou, and Chengxiang Zhai. 2014. Bug Characteristics in Open Source Software. 19, 6 (Dec. 2014), 1665– 1705.
    [47]
    Valerio Terragni and Shing-Chi Cheung. 2016. Coverage-driven Test Code Generation for Concurrent Classes. In Proceedings of the International Conference on Software Engineering (ICSE ’16). ACM, 1121–1132.
    [48]
    Valerio Terragni, Shing-Chi Cheung, and Charles Zhang. 2015. RECONTEST: Effective Regression Testing of Concurrent Programs. In Proceedings of the International Conference on Software Engineering (ICSE ’15). ACM, 246–256.
    [49]
    USI Università della Svizzera italiana. 2017. ConCrash. (2017). http://star.inf.usi. ch/star/software/concrash/
    [50]
    Willem Visser, Corina S. Pˇasˇareanu, and Sarfraz Khurshid. 2004. Test Input Generation with Java PathFinder. In Proceedings of the International Symposium on Software Testing and Analysis (ISSTA ’04). ACM, 97–107.
    [51]
    Chao Wang, Mahmoud Said, and Aarti Gupta. 2011. Coverage Guided Systematic Concurrency Testing. In Proceedings of the International Conference on Software Engineering (ICSE ’11). ACM, 221–230.
    [52]
    Dasarath Weeratunge, Xiangyu Zhang, and Suresh Jagannathan. 2010. Analyzing Multicore Dumps to Facilitate Concurrency Bug Reproduction. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’10). ACM, 155–166.
    [53]
    Rongxin Wu. 2014. Diagnose Crashing Faults on Production Software. In Proceedings of the ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE ’14). ACM, 771–774.
    [54]
    Rongxin Wu, Xiao Xiao, Shing-Chi Cheung, Hongyu Zhang, and Charles Zhang. 2016. Casper: An Efficient Approach to Call Trace Collection. In Proceedings of the Symposium on Principles of Programming Languages (POPL ’16). ACM, 678–690.
    [55]
    Rongxin Wu, Hongyu Zhang, Shing-Chi Cheung, and Sunghun Kim. 2014. CrashLocator: Locating Crashing Faults Based on Crash Stacks. In Proceedings of the International Symposium on Software Testing and Analysis (ISSTA ’14). ACM, 204–214.
    [56]
    Jie Yu, Satish Narayanasamy, Cristiano Pereira, and Gilles Pokam. 2012. Maple: A Coverage-driven Testing Tool for Multithreaded Programs. In Proceedings of the Conference on Object-Oriented Programming Systems and Applications (OOPSLA ’12). ACM, 485–502.
    [57]
    Cristian Zamfir and George Candea. 2010. Execution Synthesis: A Technique for Automated Software Debugging. In Proceedings of the ACM SIGOPS EuroSys European Conference on Computer Systems (EuroSys ’10). ACM, 321–334.
    [58]
    Wei Zhang, Junghee Lim, Ramya Olichandran, Joel Scherpelz, Guoliang Jin, Shan Lu, and Thomas Reps. 2011. ConSeq: Detecting Concurrency Bugs Through Sequential Errors. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’11). ACM, 251–264.
    [59]
    Wei Zhang, Chong Sun, and Shan Lu. 2010. ConMem: Detecting Severe Concurrency Bugs Through an Effect-oriented Approach. In Proceedings of the International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’10). ACM, 179–192.

    Cited By

    View all
    • (2024)How Well Industry-Level Cause Bisection Works in Real-World: A Study on Linux KernelCompanion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering10.1145/3663529.3663828(62-73)Online publication date: 10-Jul-2024
    • (2022)SIFT: A Tool for Property Directed Symbolic Execution of Multithreaded Software2022 IEEE Conference on Software Testing, Verification and Validation (ICST)10.1109/ICST53961.2022.00049(433-443)Online publication date: Apr-2022
    • (2021)RAProducer: efficiently diagnose and reproduce data race bugs for binaries via trace analysisProceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3460319.3464831(593-606)Online publication date: 11-Jul-2021
    • Show More Cited By

    Recommendations

    Comments

    Information & Contributors

    Information

    Published In

    cover image ACM Conferences
    ESEC/FSE 2017: Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering
    August 2017
    1073 pages
    ISBN:9781450351058
    DOI:10.1145/3106237
    Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

    Sponsors

    Publisher

    Association for Computing Machinery

    New York, NY, United States

    Publication History

    Published: 21 August 2017

    Permissions

    Request permissions for this article.

    Check for updates

    Author Tags

    1. Concurrency
    2. Debugging
    3. Software Crashes
    4. Test Generation

    Qualifiers

    • Research-article

    Conference

    ESEC/FSE'17
    Sponsor:

    Acceptance Rates

    Overall Acceptance Rate 112 of 543 submissions, 21%

    Contributors

    Other Metrics

    Bibliometrics & Citations

    Bibliometrics

    Article Metrics

    • Downloads (Last 12 months)17
    • Downloads (Last 6 weeks)3
    Reflects downloads up to 10 Aug 2024

    Other Metrics

    Citations

    Cited By

    View all
    • (2024)How Well Industry-Level Cause Bisection Works in Real-World: A Study on Linux KernelCompanion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering10.1145/3663529.3663828(62-73)Online publication date: 10-Jul-2024
    • (2022)SIFT: A Tool for Property Directed Symbolic Execution of Multithreaded Software2022 IEEE Conference on Software Testing, Verification and Validation (ICST)10.1109/ICST53961.2022.00049(433-443)Online publication date: Apr-2022
    • (2021)RAProducer: efficiently diagnose and reproduce data race bugs for binaries via trace analysisProceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3460319.3464831(593-606)Online publication date: 11-Jul-2021
    • (2021)Statically driven generation of concurrent tests for thread‐safe classesSoftware Testing, Verification and Reliability10.1002/stvr.177431:4Online publication date: 4-May-2021
    • (2020)VulcanProceedings of the 18th International Conference on Mobile Systems, Applications, and Services10.1145/3386901.3388916(391-403)Online publication date: 15-Jun-2020
    • (2020)Good things come in threesProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering10.1145/3324884.3416643(211-223)Online publication date: 21-Dec-2020
    • (2020)Search-Based Crash Reproduction and Its Impact on DebuggingIEEE Transactions on Software Engineering10.1109/TSE.2018.287766446:12(1294-1317)Online publication date: 1-Dec-2020
    • (2020)Well-informed Test Case Generation and Crash Reproduction2020 IEEE 13th International Conference on Software Testing, Validation and Verification (ICST)10.1109/ICST46399.2020.00054(424-426)Online publication date: Oct-2020
    • (2020)Search‐based crash reproduction using behavioural model seedingSoftware Testing, Verification and Reliability10.1002/stvr.173330:3Online publication date: 12-Apr-2020
    • (2019)Coverage-Driven Test Generation for Thread-Safe Classes via Parallel and Conflict Dependencies2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST)10.1109/ICST.2019.00034(264-275)Online publication date: Apr-2019
    • Show More Cited By

    View Options

    Get Access

    Login options

    View options

    PDF

    View or Download as a PDF file.

    PDF

    eReader

    View online with eReader.

    eReader

    Media

    Figures

    Other

    Tables

    Share

    Share

    Share this Publication link

    Share on social media