Pruning dynamic slices with confidence

Zhang, Xiangyu; Gupta, Neelam; Gupta, Rajiv

doi:10.1145/1133981.1134002

Cited by 117 publications

(72 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Some techniques combine statistics and program slicing, e.g., [16], [17], [18], [19]. This kind of techniques requires a fine-grain association between the program source code, on which the slicing is usually done, and program execution traces.…”

Section: Related Workmentioning

confidence: 99%

Fault localization in embedded software based on a single cyclic trace

Amiar

Delahaye

Falcone

et al. 2013

2013 IEEE 24th International Symposium on Software Reliability Engineering (ISSRE)

View full text Add to dashboard Cite

Abstract-Locating faults in embedded software, especially in microcontrollers, is still difficult. Quite recently, it became possible to recover execution traces from microcontrollers using specific hardware probes. However, the collected traces contain a huge volume of low-level data. Consequently, manual analysis is difficult and our industrial partners call for automatic and more effective fault-localization methods for embedded software.This paper presents a new approach to automatically locate faults in embedded programs given a single faulty execution trace. Our approach exploits the cyclic nature of embedded programs and uses several adapted spectrum-based methods in order to find faults on a single execution, rather than a set of multiple failing and passing executions. Our approach is implemented in the tool CoMET and evaluated on several faulty programs. The evaluation shows that our single-trace faultlocalization method using Ochiai [1] allows engineers to find a fault by inspecting less than 5% of the program in most cases, and it confirms the interest of automatic fault localization for microcontrollers.

show abstract

Section: Related Workmentioning

confidence: 99%

Fault localization in embedded software based on a single cyclic trace

Amiar

Delahaye

Falcone

et al. 2013

2013 IEEE 24th International Symposium on Software Reliability Engineering (ISSRE)

View full text Add to dashboard Cite

show abstract

“…Static slicing [52] identifies a subset of program statements that may influence the value of a variable at a program location. Dynamic slicing [53][54][55] finds the statements that actually do influence a variable value in a particular execution. Relevant Slicing [56,57] is similar to dynamic slicing, but additionally finds statements that can potentially influence a variable value in an execution, if a predicate were to evaluate to a different outcome.…”

Section: Related Workmentioning

confidence: 99%

Isolating bugs in multithreaded programs using execution suppression

et al. 2011

Self Cite

View full text Add to dashboard Cite

SUMMARYMemory-related program failures in multithreaded programs can be caused by a variety of bugs. Concurrency bugs can occur due to unexpected or incorrect thread interleavings during execution. Other kinds of memory bugs, such as buffer overflows and uninitialized reads, may also occur in multithreaded as well as single-threaded programs. Most prior techniques for isolating these bugs are specialized, addressing only one type of concurrency bug or certain types of other memory bugs. The memory corruption caused by these bugs can also undergo significant propagation during program execution. When a program failure finally occurs due to memory corruption, the true root cause of the failure may be effectively concealed as significant portions of memory may have become corrupted. We propose a general framework that can isolate the root cause of any failure in a multithreaded program that involves memory corruption and reveals at least a subset of this memory corruption. This includes three important types of concurrency bugs-data races, atomicity violations, and order violations-as well as other kinds of memory bugs. To account for propagation of memory corruption, our approach uses a dynamic technique called 'execution suppression' that iteratively reveals memory corruption in a failing execution to isolate the true root cause of the failure.

show abstract

“…However, slicing tends to produce fat slices containing not only the failure inducing dependencies but also benign dependencies. Although various techniques have been proposed to prune dynamic slices [18,19], without using a reference execution to exclude benign chains, inspecting pruned slices still requires non-trivial human effort. Dicing [20] aggregates slices from multiple executions.…”

Section: Related Workmentioning

confidence: 99%

Algorithms for Automatically Computing the Causal Paths of Failures

Sumner¹,

Zhang²

2009

Fundamental Approaches to Software Engineering

Self Cite

View full text Add to dashboard Cite

Abstract.We have proposed an automated debugging technique that explains a failure by computing its causal path leading from the root cause to the failure. Given a failing execution, the technique first searches for a dynamic patch. Fine-grained execution comparison between the failing run and the patched run is performed to isolate the causal path. The comparison is enabled by precisely aligning the two executions. We herein propose and study two algorithms aiming at efficiency. We also evaluate the effectiveness and cost of our technique on a set of real bugs, including requirement bugs in which no a single or small set of statements can be blamed as the root cause. In such cases, understanding a failure is more important.

show abstract

Pruning dynamic slices with confidence

Cited by 117 publications

References 19 publications

Fault localization in embedded software based on a single cyclic trace

Fault localization in embedded software based on a single cyclic trace

Isolating bugs in multithreaded programs using execution suppression

Algorithms for Automatically Computing the Causal Paths of Failures

Contact Info

Product

Resources

About