Statistical Debugging and Automated Program Failure Triage

Recent years have seen great advances in software engineering and programming languages. Unfortunately, software is still far from bug-free, even for those deployed. Static analysis is a good approach to eliminating numerous bugs, but its conservative nature of analysis unavoidably constrains its capacity. Dynamic analysis, on the other hand, utilizes program runtime execution data, which complements static approaches. This thesis describes three dynamic techniques that leverage program runtime data to improve software quality. First, we present a statistical debugging algorithm, called S OBER, which automatically localizes software faults without any prior knowledge of the program semantics. This statistical debugging alleviates the high cost associated with manual debugging. Featuring a similar rationale to hypothesis testing, SOBER quantifies the fault relevance of each predicate in a principled way. We systematically evaluate S OBER under the same setting as previous studies, and compare S OBER with other seven algorithms. The result clearly demonstrates the advantages of SOBER over existing approaches. Second, we discuss automated program failure triage, which is a closely related problem with automated debugging. Recent software systems usually feature an automated failure reporting component, with which a huge number of failures are collected from software end-users. In order to effectively leverage the valuable program failure data, the collected failures need to be first triaged, i.e., to locate the most severe failures, and to assign them to appropriate developers. Lying in the center of failure triage is failure indexing, which tries to group failures due to the fault together. In this thesis, we propose a statistical debugging-based approach to program failure triage, called R-PROXIMITY, which better indexes failures and facilitates failure assignment than existing approaches. Finally, we describe a program dynamic slicing-based approach to failure indexing, which complements R-PROXIMITY. R-PROXIMITY is a quality failure indexing tool, but its effectiveness relies on a sufficient number of correct executions, which may or may not be available in practice. The proposed dynamic slicing-based approach does not require any correct executions, and hence perfectly complements R-PROXIMITY . All the three techniques are subject to three mid-sized programs grep, gzip, and flex, and the result validates their advancement of the state of the art.

[1]  Yuanyuan Zhou,et al.  Have things changed now?: an empirical study of bug characteristics in modern open source software , 2006, ASID '06.

[2]  Armando Fox,et al.  Capturing, indexing, clustering, and retrieving system history , 2005, SOSP '05.

[3]  Yuanyuan Zhou,et al.  Automatic On-line Failure Diagnosis at the End-User Site , 2006, HotDep.

[4]  L. McLaughlin Automated bug tracking: the promise and the pitfalls , 2004, IEEE Software.

[5]  Gail C. Murphy,et al.  Automatic bug triage using text categorization , 2004, SEKE.

[6]  Bin Wang,et al.  Automated support for classifying software failure reports , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[7]  Philip S. Yu,et al.  GPLAG: detection of software plagiarism by program dependence graph analysis , 2006, KDD '06.

[8]  M. Kendall Rank Correlation Methods , 1949 .

[9]  Sougata Mukherjea,et al.  Toward visual debugging: integrating algorithm animation capabilities within a source-level debugger , 1994, TCHI.

[10]  Zoubin Ghahramani,et al.  A new approach to data driven clustering , 2006, ICML.

[11]  James R. Larus,et al.  Righting software , 2004, IEEE Software.

[12]  J. Marden Analyzing and Modeling Rank Data , 1996 .

[13]  Brad A. Myers,et al.  Designing the whyline: a debugging interface for asking questions about program behavior , 2004, CHI.

[14]  H. Cleve,et al.  Locating causes of program failures , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[15]  Dawson R. Engler,et al.  Proceedings of the 5th Symposium on Operating Systems Design and Implementation Cmc: a Pragmatic Approach to Model Checking Real Code , 2022 .

[16]  Christian Böhm,et al.  Robust information-theoretic clustering , 2006, KDD '06.

[17]  Jeffrey S. Chase,et al.  Correlating Instrumentation Data to System States: A Building Block for Automated Diagnosis and Control , 2004, OSDI.

[18]  Anish Arora,et al.  Book Review: Verification of Sequential and Concurrent Programs by Krzysztof R. Apt and Ernst-Riidiger Olderog (Springer-Verlag New York, 1997) , 1998, SIGA.

[19]  Yannis Smaragdakis,et al.  JCrasher: an automatic robustness tester for Java , 2004, Softw. Pract. Exp..

[20]  Mary Lou Soffa,et al.  Jazz: A Tool for Demand-Driven Structural Testing , 2005, CC.

[21]  Wei Liu,et al.  iWatcher: simple, general architectural support for software debugging , 2004, IEEE Micro.

[22]  Gregg Rothermel,et al.  Empirical Studies of a Safe Regression Test Selection Technique , 1998, IEEE Trans. Software Eng..

[23]  Mary Jean Harrold,et al.  Debugging in Parallel , 2007, ISSTA '07.

[24]  Hsin Pan,et al.  Heuristics for Automatic Localization of Software Faults , 1992 .

[25]  Bogdan Korel,et al.  Application of Dynamic Slicing in Program Debugging , 1997, AADEBUG.

[26]  Thomas A. Henzinger,et al.  Software Verification with BLAST , 2003, SPIN.

[27]  Helen J. Wang,et al.  Strider: a black-box, state-based approach to change and configuration management and support , 2003, Sci. Comput. Program..

[28]  G. Casella,et al.  Statistical Inference , 2003, Encyclopedia of Social Network Analysis and Mining.

[29]  Sriram K. Rajamani,et al.  Automatically validating temporal safety properties of interfaces , 2001, SPIN '01.

[30]  Zhenmin Li,et al.  PR-Miner: automatically extracting implicit programming rules and detecting violations in large software code , 2005, ESEC/FSE-13.

[31]  Iris Vessey,et al.  Expertise in Debugging Computer Programs , 1984 .

[32]  Michael D. Ernst,et al.  Eclat: Automatic Generation and Classification of Test Inputs , 2005, ECOOP.

[33]  James M. Rehg,et al.  Active learning for automatic classification of software behavior , 2004, ISSTA '04.

[34]  Shriram Krishnamurthi,et al.  Automated Fault Localization Using Potential Invariants 1 , 2003 .

[35]  M. Levandowsky,et al.  Distance between Sets , 1971, Nature.

[36]  Sudheendra Hangal,et al.  Tracking down software bugs using automatic anomaly detection , 2002, ICSE '02.

[37]  Mary Jean Harrold,et al.  Empirical evaluation of the tarantula automatic fault-localization technique , 2005, ASE.

[38]  Klaus Havelund,et al.  Model Checking Programs , 2004, Automated Software Engineering.

[39]  Patrick J. F. Groenen,et al.  Modern Multidimensional Scaling: Theory and Applications , 2003 .

[40]  Vipin Kumar,et al.  Introduction to Data Mining , 2022, Data Mining and Machine Learning Applications.

[41]  Chao Liu,et al.  A probabilistic approach to spatiotemporal theme pattern mining on weblogs , 2006, WWW '06.

[42]  Chao Liu,et al.  Statistical Debugging: A Hypothesis Testing-Based Approach , 2006, IEEE Transactions on Software Engineering.

[43]  Steven P. Reiss,et al.  Fault localization with nearest neighbor queries , 2003, 18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings..

[44]  Dawson R. Engler,et al.  Bugs as deviant behavior: a general approach to inferring errors in systems code , 2001, SOSP.

[45]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[46]  Benjamin Livshits,et al.  DynaMine: finding common error patterns by mining software revision histories , 2005, ESEC/FSE-13.

[47]  Andreas Zeller,et al.  Simplifying and Isolating Failure-Inducing Input , 2002, IEEE Trans. Software Eng..

[48]  Zhendong Su,et al.  HDD: hierarchical delta debugging , 2006, ICSE.

[49]  Yang Meng Tan,et al.  LCLint: a tool for using specifications to check code , 1994, SIGSOFT '94.

[50]  John T. Stasko,et al.  Visualization of test information to assist fault localization , 2002, ICSE '02.

[51]  Takeo Kanade,et al.  Discriminative cluster analysis , 2006, ICML.

[52]  G. Rothermel,et al.  An empirical study of fault localization for end-user programmers , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[53]  Xifeng Yan,et al.  CloSpan: Mining Closed Sequential Patterns in Large Datasets , 2003, SDM.

[54]  Gregg Rothermel,et al.  Supporting Controlled Experimentation with Testing Techniques: An Infrastructure and its Potential Impact , 2005, Empirical Software Engineering.

[55]  Deepayan Chakrabarti,et al.  Evolutionary clustering , 2006, KDD '06.

[56]  Alessandro Orso,et al.  Applying classification techniques to remotely-collected program execution data , 2005, ESEC/FSE-13.

[57]  Manu Sridharan,et al.  PSE: explaining program failures via postmortem static analysis , 2004, SIGSOFT '04/FSE-12.

[58]  Chao Liu,et al.  SOBER: statistical model-based bug localization , 2005, ESEC/FSE-13.

[59]  Janusz W. Laski,et al.  Dynamic Program Slicing , 1988, Inf. Process. Lett..

[60]  Andreas Zeller,et al.  Visualizing Memory Graphs , 2001, Software Visualization.

[61]  Gregg Rothermel,et al.  An empirical investigation of the relationship between spectra differences and regression faults , 2000 .

[62]  Edmund M. Clarke,et al.  Model Checking , 1999, Handbook of Automated Reasoning.

[63]  Xiangyu Zhang,et al.  Dynamic slicing long running programs through execution fast forwarding , 2006, SIGSOFT '06/FSE-14.

[64]  Alex Aiken,et al.  Cooperative Bug Isolation , 2007 .

[65]  Gail C. Murphy,et al.  Who should fix this bug? , 2006, ICSE.

[66]  Roland Mittermeir,et al.  Spreadsheet Debugging , 2003, ArXiv.

[67]  Chao Liu,et al.  Failure proximity: a fault localization-based approach , 2006, SIGSOFT '06/FSE-14.

[68]  William R. Bush,et al.  A static analyzer for finding dynamic programming errors , 2000 .

[69]  Xiangyu Zhang,et al.  Locating faulty code using failure-inducing chops , 2005, ASE.

[70]  Sarfraz Khurshid,et al.  Korat: automated testing based on Java predicates , 2002, ISSTA '02.

[71]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[72]  Xiangyu Zhang,et al.  Locating faults through automated predicate switching , 2006, ICSE.

[73]  David E. Evans,et al.  Static detection of dynamic memory errors , 1996, PLDI '96.

[74]  Joseph Robert Horgan,et al.  Fault localization using execution slices and dataflow tests , 1995, Proceedings of Sixth International Symposium on Software Reliability Engineering. ISSRE'95.

[75]  Fei Li,et al.  Argus: Online Statistical Bug Detection , 2006, FASE.

[76]  Yuanyuan Zhou,et al.  SafeMem: exploiting ECC-memory for detecting memory leaks and memory corruption during production runs , 2005, 11th International Symposium on High-Performance Computer Architecture.

[77]  Yuriy Brun,et al.  Finding latent code errors via machine learning over program executions , 2004, Proceedings. 26th International Conference on Software Engineering.

[78]  Eugene H. Spafford,et al.  Debugging with dynamic slicing and backtracking , 1993, Softw. Pract. Exp..

[79]  Michael I. Jordan,et al.  Bug isolation via remote program sampling , 2003, PLDI.

[80]  Andreas Zeller,et al.  Isolating cause-effect chains from computer programs , 2002, SIGSOFT FSE.

[81]  Stephen McCamant,et al.  Predicting problems caused by component upgrades , 2003, ESEC/FSE-11.

[82]  Michael I. Jordan,et al.  Scalable statistical bug isolation , 2005, PLDI '05.