Software Bug Triage via Back-Propagation and Under-Approximation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software testing methods face challenges in efficiently identifying and isolating the root causes of errors in complex software code, particularly with 'possible error' classifications where static verification is inconclusive, requiring manual review and resource-intensive debugging.
Innovation Solution
An automated software testing tool employing static verification analysis and back-propagation techniques to identify potential error causes by traversing execution paths and using under-approximation to reduce false positives, providing users with likely causes of errors.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If static verification is used to classify code into categories, then code can be identified as having possible errors, but manual review and debugging are still required which increases time and resource consumption
Solution Approach 1:
The system performs preliminary static verification analysis to classify code into categories (good, safe, correct, errors, not accessible, possible error) before actual execution. This preliminary classification identifies potential error locations in advance, allowing developers to focus manual review only on specific problematic sections rather than reviewing entire codebases, thereby reducing overall debugging time while maintaining detection accuracy
Solution Approach 2:
The patent introduces an intermediary automated analysis layer between static verification and manual debugging. This intermediary system uses back-propagation techniques to trace error causes through execution paths and identify specific code sections that are likely causes of errors, serving as a mediator that filters and prioritizes issues for manual review, thus reducing the time developers spend on debugging without sacrificing detection precision
2Reliability
If manual review is performed on possible error code points, then accurate error identification is achieved, but resource consumption and complexity increase
Solution Approach 1:
The patent segments the codebase into distinct categories (good, safe, correct, errors, not accessible, possible error) based on static verification results. This segmentation isolates problematic code sections from the rest of the codebase, allowing automated tools to focus analysis on specific segments rather than the entire codebase, thereby maintaining high error identification accuracy while reducing the complexity of the overall testing process
Solution Approach 2:
An automated intermediary analysis system is introduced that uses back-propagation through execution paths to identify likely error causes. This intermediary automatically processes possible error code points, tracing back through the code to identify specific sections that are probable causes of errors. This automation reduces the need for manual review of every possible error, maintaining reliability while reducing process complexity
3Quantity of substance
If comprehensive static verification is performed, then more errors are detected, but false positives increase requiring additional manual verification
Solution Approach 1:
The system implements feedback loops where static verification results are analyzed, and back-propagation techniques are used to trace error causes. The system provides feedback by identifying specific code sections that are likely causes of detected errors, allowing for verification and refinement of findings. This feedback mechanism helps distinguish true positives from false positives by providing contextual information about error causes, maintaining high error detection quantity while reducing false positive impact
Solution Approach 2:
An automated intermediary analysis layer is introduced between static verification and final error reporting. This intermediary uses back-propagation to trace execution paths and identify specific code sections that are likely causes of detected errors. By adding this intermediary verification step, the system can filter out false positives while maintaining comprehensive error detection, as the intermediary provides additional contextual analysis to confirm whether detected errors are genuine issues
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A software testing tool may use static verification analysis techniques to locate points (lines/events) in computer code at which an error may be present and points (lines/events) in the computer code that may be the underlying cause of the located error points. In one implementation, a device may perform a static verification analysis of computer code to locate a point in the code that causes an error in the execution of the computer code (520). The static analysis may be performed by analyzing a first set of possible execution paths of the computer code based on an over-approximation of states. The device may back-propagate, from the located point, through a second set of possible execution paths, where the second set of possible execution paths is obtained based on an under-approximation of the states that were over- approximated (530). Based on the back-propagation, the device may determine potential causes of the error (540). Additionally, in some implementations, empiric analysis techniques, based on semantic information for the computer code, may also be performed. The empiric analysis techniques may be used to assist in classifying the potential causes of the error.