A comparison of tree- and line-oriented observational slicing

Abstract

Observation-based slicing and its generalization observational slicing are recentlyintroduced, language-independent dynamic slicing techniques. They both construct slices based on the dependencies observed during program execution, rather than static or dynamic dependence analysis. The original implementation of the observation-based slicing algorithm used lines of source code as its program representation. A recent variation, developed to slice modelling languages (such as Simulink), used an XML representation of an executable model. We ported the XML slicer to source code by constructing a tree representation of traditional source code through the use of srcML. This work compares the tree-and line-based slicers using four experiments involving twenty different programs, ranging from classic benchmarks to million-line production systems. The resulting slices are essentially the same size for the majority of the programs and are often identical. However, structural constraints imposed by the tree representation sometimes force the slicer to retain enclosing control structures. It can also "bog down" trying to delete single-token subtrees. This occasionally makes the tree-based slices larger and the tree-based slicer slower than a parallelised version of the line-based slicer. In addition, a Java versus C comparison finds that the two languages lead to similar slices, but Java code takes noticeably longer to slice. The initial experiments suggest two improvements to the tree-based slicer: the addition of a size threshold, for ignoring small subtrees, and subtree replacement. The former enables the slicer to run 3.4 times faster while producing slices that are only about 9% larger. At the same time the subtree replacement reduces size by about 8-12% and allows the tree-based slicer to produce more natural slices.

Evaluating lexical approximation of program dependence

“…However, accepting deletions of source code lines based on purely dynamic observation has its own benefits, such as being able to handle dependencies that no static slicers can cope with (Binkley et al, 2015), slicing multi-lingual systems (Binkley et al, 2015), and slicing languages with highly unconventional program semantics such as Picture Description Language (Yoo et al, 2017). While MOBS and ORBS uses deletions of source code lines, a later variant (Gold et al, 2017;Binkley et al, 2019) represents source code as a tree structure and the proceeds to delete subtrees. Binkley et al (2014a) also introduced a parallel ORBS.…”

MOAD: Modeling Observation-Based Approximate Dependency

“…The most closely related dynamic slicing approach is observational slicing. As benchmarks we consider the slices produced by two observational slicing implementations W-ORBS [11] and T-ORBS [13], [14]. While these two are expected to produce more accurate slices than MOAD, they are also expected to take longer to do so.…”

“…A recent variation of W-ORBS, T-ORBS [13], [14] works with a tree-based representation. T-ORBS performs a breadthfirst tree traversal using a work list.…”

“…Observation Based Slicing (ORBS) [11]- [14] was designed to overcome these issues. ORBS applies speculative deletions iteratively to the program under analysis, and observes whether the latest applied deletion is viable (i.e., the code compiles after deletion) and is unrelated to the slicing criteria (i.e., the variable of interest shows the same behaviour after deletion with respect to a test suite).…”

PyGGI 2.0: language independent genetic improvement framework

“…In our case studies, we utilise the srcML parser. The tree representation of srcML has been used to perform various program analysis tasks [3][4][5]10]. By using the srcML as an intermediate representation, users of PyGGI can easily implement GI techniques for multiple languages, without having to deal with multiple parsers.…”