Backward Trace Slicing for Conditional Rewrite Theories

Science of Computer Programming

et al. 2014

Self Cite

Understanding the behavior of software is important for the existing software to be improved. In this paper, we present a trace slicing technique that is suitable for analyzing complex, textually-large computations in rewriting logic, which is a general framework efficiently implemented in the Maude language that seamlessly unifies a wide variety of logics and models of concurrency. Given a Maude execution trace T and a slicing criterion for the trace (i.e., a piece of information that we want to observe in the final computation state), we traverse T from back to front and the backward dependence of the observed information is incrementally computed at each execution step. At the end of the traversal, a simplified trace slice is obtained by filtering out all the irrelevant data that were found not to influence the data of interest. By narrowing the size of the trace, the slicing technique favors better inspection and debugging activities since most tedious and irrelevant inspections that are routinely performed during diagnosis and bug localization can be eliminated automatically. Moreover, cutting down the execution trace can expose opportunities for further improvement, which we illustrate by means of several examples.

Section: Example 416mentioning

confidence: 94%

Section: The Julienne Systemmentioning

confidence: 99%

See 1 more Smart Citation

Using conditional trace slicing for improving Maude programs

Science of Computer Programming

et al. 2014

Self Cite

“…Trace slicing [1,2,3,4,5] is a transformation technique for RWL theories that can drastically reduce the size and complexity of entangled, textually-large execution traces by focusing on selected computation aspects. This is done by uncovering data dependences among related parts of the trace w.r.t.…”

Section: Enhancing Trace Slicingmentioning

confidence: 99%

Combining Runtime Checking and Slicing to Improve Maude Error Diagnosis

Lecture Notes in Computer Science

et al. 2015

Self Cite

Abstract. This paper introduces the idea of using assertion checking for enhancing the dynamic slicing of Maude computation traces. Since trace slicing can greatly simplify the size and complexity of the analyzed traces, our methodology can be useful for improving the diagnosis of erroneous Maude programs. The proposed methodology is based on (i) a logical notation for specifying two types of user-defined assertions that are imposed on execution runs: functional assertions and system assertions; (ii) a runtime checking technique that dynamically tests the assertions and is provably safe in the sense that all errors flagged are definite violations of the specifications; and (iii) a mechanism based on equational least general generalization that automatically derives accurate criteria for slicing from falsified assertions.

“…In [4,5], an incremental, backward trace slicer was presented that generates a trace slice of an execution trace T by tracing back a set of symbols of interest along (an instrumented version of) T , while data that are not required to produce the target symbols are simply discarded. This can be very helpful in debugging since any information that is not strictly needed to deliver a critical part of the result is discarded, which helps answer the question of what program components might affect a 'selected computation".…”

Section: Introductionmentioning

confidence: 99%

Parametric Exploration of Rewriting Logic Computations

EPiC Series in Computing

et al.

Self Cite

This paper presents a parameterized technique for the inspection of Rewriting Logic computations that allows the non-deterministic execution of a given rewrite theory to be followed up in different ways. Starting from a selected state in the computation tree, the exploration is driven by a user-defined, inspection criterion that specifies the exploration mode. By selecting different inspection criteria, one can automatically derive useful debugging facilities such as program steppers and more sophisticated dynamic trace slicers that facilitate the detection of control and data dependencies across the computation tree. Our methodology, which is implemented in the Anima graphical tool, allows users to capture the impact of a given criterion, validate input data, and detect improper program behaviors.