Using likely invariants for automated software fault localization

@inproceedings{Sahoo2013UsingLI,
  title={Using likely invariants for automated software fault localization},
  author={Swarup Kumar Sahoo and John Criswell and Chase Geigle and Vikram S. Adve},
  booktitle={ASPLOS '13},
  year={2013}
}
We propose an automatic diagnosis technique for isolating the root cause(s) of software failures. We use likely program invariants, automatically generated using correct inputs that are close to the fault-triggering input, to select a set of candidate program locations which are possible root causes. We then trim the set of candidate root causes using software-implemented dynamic backwards slicing, plus two new filtering heuristics: dependence filtering, and filtering via multiple failing… 

Figures and Tables from this paper

Learning Likely Invariants to Explain Why a Program Fails
TLDR
This work aims to help programmers understand a bug by automatically generating likely invariants which are violated in the failed tests by automatically creating a predicate "explaining" the cause of the bug.
Explaining Software Failures by Cascade Fault Localization
TLDR
This article proposes a cascade fault localization method to help speed up this labor-intensive process via a combination of weakest precondition computation and constraint solving, and produces a cause tree, where each node is a potential cause of the failure and each edge represents a casual relationship between two causes.
A Hybrid Algorithm for Error Trace Explanation
TLDR
This work presents a new technique for automatic error localization, which formally unifies prior approaches based on computing interpolants and minimal unsatisfiable cores of failing executions by automatically reducing an error trace to its essential components.
What Gives? A Hybrid Algorithm for Error Trace Explanation
TLDR
This work presents a new technique for automatic error localization, which formally unifies prior approaches based on computing interpolants and minimal unsatisfiable cores of failing executions by automatically reducing an error trace to its essential components.
MIMIC: locating and understanding bugs by analyzing mimicked executions
TLDR
This work presents MIMIC, a novel automated debugging technique that combines and extends the previous input generation and anomaly detection techniques and synthesizes multiple passing and failing executions similar to an observed failure and uses these executions to detect anomalies in behavior that may explain the failure.
A Survey on Software Fault Localization
TLDR
A comprehensive overview of a broad spectrum of fault localization techniques, each of which aims to streamline the fault localization process and make it more effective by attacking the problem in a unique way is provided.
A learning-to-rank based fault localization approach using likely invariants
TLDR
This work proposes Savant, a new fault localization approach that employs a learning-to-rank strategy, using likely invariant diffs and suspiciousness scores as features, to rank methods based on their likelihood to be a root cause of a failure.
Failure sketching: a technique for automated root cause diagnosis of in-production failures
TLDR
Gist, a prototype for failure sketching that relies on hardware watchpoints and a new hardware feature for extracting control flow traces (Intel Processor Trace), is built and it is shown that Gist can build failure sketches with low overhead for failures in systems like Apache, SQLite, and Memcached.
Design and Analysis of Novel Kernel Measure for Software Fault Localization
TLDR
The main contribution for this work is to first introduce the block hit-miss function which relates block vectors of execution sequences of software code over sample runs performed and the decision vector which denotes fault or error free output.
Automatic fault location for data structures
TLDR
This work combines specification-based data structure verification with automatic detection of faulty program statements that corrupt data structures and automatically locates faulty code responsible for data structure corruption.
...
...

References

SHOWING 1-10 OF 52 REFERENCES
Algorithms for Automatically Computing the Causal Paths of Failures
TLDR
An automated debugging technique that explains a failure by computing its causal path leading from the root cause to the failure is proposed and two algorithms aiming at efficiency are proposed.
Practical fault localization for dynamic web applications
TLDR
A uniquely powerful tool for localizing faults in PHP applications that automatically generates tests that expose failures, and automatically localizes the faults responsible for those failures, thus overcoming the limitation of previous fault-localization techniques that a test suite be available upfront.
Anomaly-based bug prediction, isolation, and validation: an automated approach for software debugging
TLDR
Compared to state-of-art debugging techniques, the proposed approach pinpoints the defect locations more accurately and presents the user with a much smaller code set to analyze.
Dynamically discovering likely program invariants to support program evolution
TLDR
This paper describes techniques for dynamically discovering invariants, along with an instrumenter and an inference engine that embody these techniques, and reports on the application of the engine to two sets of target programs.
Dynamic Analysis for Diagnosing Integration Faults
TLDR
A set of case studies are presented that illustrate the adequacy of BCT to analyze both regression testing failures and rare field failures, showing that BCT automatically filters out most of the false alarms and provides useful information to understand the causes of failures in 69 percent of the case studies.
Simplifying and Isolating Failure-Inducing Input
TLDR
The delta debugging algorithm generalizes and simplifies the failing test case to a minimal test case that still produces the failure, and isolates the difference between a passing and a failingTest case.
Locating faulty code using failure-inducing chops
TLDR
This paper presents a new approach that integrates the potential of delta debugging algorithm with the benefit of forward and backward dynamic program slicing to narrow down the search for faulty code.
An empirical study of reported bugs in server software with implications for automated bug diagnosis
TLDR
It is found that nearly 82% of bug symptoms can be reproduced deterministically by re-running with the same set of inputs at the production site, and very few input requests are needed to reproduce most failures.
Locating faults through automated predicate switching
TLDR
By forcibly switching a predicate's outcome at runtime and altering the control flow, the program state can not only be inexpensively modified, but in addition it is often possible to bring the program execution to a successful completion (i.e., program produces the desired output).
Effective and efficient localization of multiple faults using value replacement
TLDR
This work generalizes Value Replacement so that it can also perform effectively in the presence of multiple faults, and improves scalability by describing two techniques that significantly improve the efficiency of Value Replacement.
...
...