Dynamic Slicing Technique Research Articles

Event-aware precise dynamic slicing for automatic debugging of Android applications

Dynamic slicing aims to find the program statements that affect the values computed at some point of interest (i.e., a particular statement or variable) under a given program input. It is an enabling technique for many software engineering tasks (e.g., program understanding and debugging). Due to Android’s event-driven nature, dynamic slicing for Android is more challenging than that for traditional Java programs. Its asynchronous events drive the execution of an app through inter-component communications. These non-deterministic user events often yield a large search space when applying existing dynamic slicing techniques, which introduce redundant statements into the resulting slice. We present ESDroid, an Event-aware dynamic Slicing technique for AnDroid applications. The novelty of our approach lies in the combination of segment-based delta debugging and backward dynamic slicing to narrow the search space to produce precise slices for Android. Our experiment across 38 apps shows that ESDroid can help with slicing buggy code from exception program points. We compare the effectiveness of ESDroid with the state-of-the-art dynamic slicing tools (AndroidSlicer and Mandoline). ESDroid outperforms both tools by reporting up to 72% fewer spurious statements than AndroidSlicer, and 50% fewer than Mandoline in the resulting slice (the number of instructions to be examined).

Computing Dynamic Slices of Feature-Oriented Programs with Aspect-Oriented Extensions

This paper proposes a technique to compute dynamic slices of feature-oriented programs with aspect-oriented extensions. The technique uses a dependence based intermediate program representation called composite feature-aspect dependence graph (CFADG) to represent feature-oriented software that contain aspects. The CFADG of a feature-oriented program is based on the selected features that are composed to form a software product and the selected aspects to be weaved. The proposed dynamic slicing technique has been named feature-aspect node marking dynamic slicing (FANMDS) algorithm. The proposed feature-aspect node marking dynamic slicing algorithm is based on marking and unmarking the executed nodes in the CFADG suitably during run-time. The advantage of the proposed approach is that no trace le is used to store the execution history. Also, the approach does not create any additional nodes during run-time.

Computing Dynamic Slices of Concurrent Feature-Oriented Programs

This paper proposes a dynamic slicing algorithm for concurrent feature-oriented programs. The algorithm is named concurrent feature-oriented node-marking dynamic slicing (CFNMDS) algorithm. The proposed dynamic slicing technique uses a dependence based intermediate representation named concurrent composite feature dependence graph (CCFDG). It is based on marking and unmarking of the executed nodes in CCFDG appropriately during runtime. Ten standard open source product lines have been taken to experiment the proposed CFNMDS algorithm. Jak codes and feature-oriented models have been developed for these product lines. The advantage of the proposed approach is that no trace file is used to store execution history of the program. Also, no extra nodes are created during runtime in the proposed approach. Creation of extra nodes leads to take more time for marking and unmarking process. Use of any extra file also leads to higher runtime overhead for input/output operations. This results in taking more time to compute the slices. So, it is necessary to compute dynamic slices in less time without using any trace file and extra nodes. Using the proposed approach, slices can be extracted in O(1) i.e., in constant time. The slice computation time for various combinations of features for each product line has also been measured.

A comparison of tree- and line-oriented observational slicing

Observation-based slicing and its generalization observational slicing are recently-introduced, 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.

Exoneration-based fault localization for SQL predicates

Spectrum-based fault localization (SFL) techniques automatically localize faults in program entities (statements, predicates, SQL clauses, etc.) by analyzing information collected from test executions. One application of SFL techniques is to find faulty SQL statements in database applications. However, prior techniques treated each SQL statement as one program entity, thus they could not find faulty elements inside SQL statements. Since SQL statements can be complex, identifying the faulty element within a faulty SQL statement is still time-consuming.In our previous paper, we developed a novel fault localization method based on row-based dynamic slicing and delta debugging techniques that can localize faults in individual clauses within SQL predicates. We call this technique exoneration-based fault localization because it can exonerate “innocent” elements and precisely identify the faulty element, whereas previous SFL techniques simply ranked all the elements in an SQL statement based on suspiciousness.This paper improves the exoneration-based fault localization technique with a new algorithm that considerably reduces the execution time. We also conducted an empirical study that compared nine existing SFL techniques with the exoneration-based technique in localizing faulty clauses in SQL predicates. Results indicate that the new exoneration-based technique surpasses the other techniques both in terms of effectiveness and efficiency.

Dynamic slicing of concurrent AspectJ programs: An explicit context‐sensitive approach

SummaryThis paper presents a context‐sensitive dynamic slicing technique for the concurrent and aspectized programs. To effectively represent the concurrent aspect‐oriented programs, we propose an intermediate graph called the multithreaded aspect‐oriented dependence graph (MAODG). The MAODG is a dynamic graph generated from the execution trace of a given program with respect to a particular set of values given as an input. Interference dependencies between the statements are shown by a distinguished edge called the interference dependence edge in the MAODG. Based on this intermediate representation, we propose a precise and accurate dynamic slicing algorithm for the concurrent aspect‐oriented programs implemented using AspectJ. The proposed dynamic slicing algorithm is implemented in a slicing tool developed using the ASM framework. Several open source programs are studied and evaluated using the proposed technique along with some existing techniques. The experimentation shows that our proposed slicing algorithm generates slices of the same or smaller size, as compared with the existing algorithms. Furthermore, we found that the slice computation time is significantly less in our proposed algorithm, as compared with the existing algorithms.

JSTrace: Fast reproducing web application errors

JavaScript has become the most popular language for client-side web applications. Due to JavaScript's highly-dynamic and event-driven features, it is challenging to diagnose web application errors. Record-replay techniques are used to reproduce errors in web applications. After a long run, these techniques will record a long event trace that triggers an error. Although the error-related events are few, they are interleaved with other massive error-irrelevant events. It is time-consuming to diagnose errors with long event traces.In this article, we present JSTrace, which effectively removes error-irrelevant events from the long event trace, and further facilitates error diagnosis. Based on fine-grained dependences of JavaScript and DOM instructions, we develop a novel dynamic slicing technique that can remove events irrelevant to the error. We further present rules to remove irrelevant events, which cannot be removed by dynamic slicing. In this process, many events and related instructions are removed without losing the error reproducing accuracy. Our evaluation on 13 real-world web application errors shows that the reduced event traces can faithfully reproduce errors with an average reduction rate of 97%. We further performed case studies on 4 real-world errors, and the result shows that JSTrace is useful to diagnose web application errors.

Dynamic Slicing of Petri Nets Based on Structural Dependency Graph and its Application in System Analysis

AbstractPetri net models are frequently complex and difficult to understand and modify. Slicing technology is very useful in analyzing programs, and has been widely used in specification level for model reduction. So it is necessary to explore slicing methods for Petri nets. This paper proposes a dynamic slicing technique for Petri nets based on the structural dependency graph (SDG). Firstly, the SDG is constructed from the slicing criterion by a backtracking algorithm. Secondly, based on the SDG and a given marking, the dynamic slice can be acquired. As a case study, the proposed method is applied to a control system, and a simulation tool is developed for validating this method and automatically generating the slice. The algorithms can be useful in automatically identifying the parts of the model that affect a state of interest, and provide the basic technical support for alleviating the difficulty of formal verification and analysis.

DYNAMIC SLICING OF ASPECT-ORIENTED UML COMMUNICATION DIAGRAM

Aspect-oriented Programming (AOP) is a recent programming paradigm that focuses on modular implementations of various crosscutting concerns. The typical features of AOP such as join-point, advice, introduction, aspects etc. make it difficult for applying slicing. Program slicing is a method to extort statements that are relevant to a particular variable. Program slicing, as initially defined by Weiser is based on static dataflow examination on the flow graph of the program. Program slicing has been applied in parallel processing, program debugging, program integration,program understanding , software testing and maintenance etc.In this paper, we proposed a technique for dynamic slicing of aspectoriented software based on the UML 2.0 Communication diagram. Here, we can use slicing at the architectural level to find the slicing of communication diagram at an earlier stage of software development. To represent the various unique features of AOP in UML diagrams is very difficult and complex in nature. For this purpose, we first draw the communication diagram for aspect-oriented program considering the classes, pointcuts, advices and aspects. Next, we have generated an intermediate representation from the communication diagram. Then, we proposed an edge marking dynamic slicing algorithm that traverses the intermediate representation and finds the slices for the communication diagram of the given problem scenario. The novelty in our approach is that we present the communication diagram for the aspect-oriented software. Also, we proposed an algorithm to find the slice from it. The advantage of using communication diagram is that it mainly focuses on the interaction between the objects involved in the problem scenario.

Kernelet: High-Throughput GPU Kernel Executions with Dynamic Slicing and Scheduling

Graphics processors, or GPUs, have recently been widely used as accelerators in shared environments such as clusters and clouds. In such shared environments, many kernels are submitted to GPUs from different users, and throughput is an important metric for performance and total ownership cost. Despite recently improved runtime support for concurrent GPU kernel executions, the GPU can be severely underutilized, resulting in suboptimal throughput. In this paper, we propose Kernelet, a runtime system to improve the throughput of concurrent kernel executions on the GPU. Kernelet embraces transparent memory management and PCI-e data transfer techniques, and dynamic slicing and scheduling techniques for kernel executions. With slicing, Kernelet divides a GPU kernel into multiple sub-kernels (namely slices ). Each slice has tunable occupancy to allow co-scheduling with other slices for high GPU utilization. We develop a novel Markov chain-based performance model to guide the scheduling decision. Our experimental results demonstrate up to 31 percent and 23 percent performance improvement on NVIDIA Tesla C2050 and GTX680 GPUs, respectively.

The Multi-Slice Method of Program Slicing for Fault Location

Program slicing is a program analysis and understanding of technology. Sequence fault localization refers to the use of specific methods for faults in the program. Currently, the research program fault positioning is more and more people's attention and gets some results which is the more mainstream software fault localization method. Program slicing technique currently used to locate the fault procedures, which primarily to take advantage of dynamic slicing technique. Based on the full analysis of the advantages and disadvantages on the basis of previous work, we propose a flexible slicing rule and give a new method based on the slicing rule.

Automated Dynamic Slicing based UML Modeling for Phylogenetic Classification

paper presents an efficient classification algorithm for categorizing evolutionary organisms using slicing techniques. Dynamic slicing excels in tracing out dependencies between executable statements. The nature of these dependencies aids in the determination of control statements in a program. Dynamic slicing technique imbibes the run time execution trace based on a slicing criterion. Dynamic slicing algorithms can trace both the backward and forward dependencies. The UML model is automatically generated from the source code to validate the forward and backward dynamic slicing algorithm. This paper shows the algorithmic implementation in NetBeans IDE 7.4. It provides a new platform for automated software engineering. The algorithm efficiently discovers the evolutionary relationship between organisms .Forward dynamic slicing algorithm helps in identifying the successors of the organisms and the backward dynamic slicing algorithm finds out the predecessors of the evolutionary organisms. Both the algorithms are based on dynamic slicing criterion at the run time execution trace. The integration of these phylogenetic algorithms deciphers the building complexity of the evolutionary organisms. It proves to have an advantageous classification encasement for jeopardized species.

A Dynamic Slicing Technique for UML Architectural Models

This paper proposes a technique for dynamic slicing of UML architectural models. The presence of related information in diverse model parts (or fragments) makes dynamic slicing of Unified Modeling Language (UML) models a complex problem. We first extract all relevant information from a UML model specifying a software architecture into an intermediate representation, which we call a Model Dependency Graph (MDG). For a given slicing criterion, our slicing algorithm traverses the constructed MDG to identify the relevant model parts that are directly or indirectly affected during the execution of a specified scenario. One novelty of our approach is computation of dynamic slice based on the structural and behavioral (interactions only) UML models as against independently processing separate UML models, and determining the implicit interdependencies among different model elements distributed across model views. We also briefly discuss a prototype tool named Archlice, which we have developed to implement our algorithm.

Integrated state-based dynamic slicing technique for UML models

The authors propose a technique for constructing dynamic slices of unified modelling language (UML) models using the state information. Given a software architecture specified using UML, the authors first construct an intermediate representation. The authors have named this intermediate representation model dependency graph (MDG). MDG combines information extracted from various sequence diagrams along with those from class and state-machine diagrams. The authors have named our proposed algorithm state-based dynamic slicing of UML models (SDSUM). Our SDSUM algorithm traverses the constructed MDG to identify the model elements that are either directly or indirectly involved during the execution of a specific scenario. Instead of processing each UML diagram independently and iteratively cross linking relevant information across different diagrams, our algorithm's novelty lies in constructing and analysing an integrated model for determining the implicit interdependencies among the different model elements distributed across various UML diagrams for computing a state-based dynamic slice. Consideration of state information of objects makes the computed dynamic slices more precise compared to traditional slicing. A case study has been presented to illustrate our approach.

Slicing UML architectural models

We propose a technique for static and dynamic slicing of UML models. For a software architecture specified using UML, we first transform the systems' architectural model into an intermediate representation which we have named Model Dependency Graph(MDG). MDG combines information available in various sequence diagrams along with the relevant information available in class diagrams into an integrated UML model. For a given slicing criterion, our slicing algorithm traverses the constructed MDG to identify the relevant model elements. Our algorithm's novelty lies in its computing a slice based on an integrated UML model as against independently processing separate UML diagrams, and determining the implicit interdependencies among the different model elements distributed across various UML diagrams.

Dynamic slicing of lazy functional programs based on redex trails

Tracing computations is a widely used methodology for program debugging. Lazy languages, however, pose new demands on tracing techniques because following the actual trace of a computation is generally useless. Typically, tracers for lazy languages rely on the construction of a redex trail, a graph that stores the reductions performed in a computation. While tracing provides a significant help for locating bugs, the task still remains complex. A well-known debugging technique for imperative programs is based on dynamic slicing, a method for finding the program statements that influence the computation of a value for a specific program input. In this work, we introduce a novel technique for dynamic slicing in first-order lazy functional languages. Rather than starting from scratch, our technique relies on (a slight extension of) redex trails. We provide a notion of dynamic slice and introduce a method to compute it from the redex trail of a computation. We also sketch the extension of our technique to deal with a functional logic language. A clear advantage of our proposal is that one can enhance existing tracers with slicing capabilities with a modest implementation effort, since the same data structure (the redex trail) can be used for both tracing and slicing.

Distributed dynamic slicing of Java programs

We propose a novel dynamic slicing technique for distributed Java programs. We first construct the intermediate representation of a distributed Java program in the form of a set of Distributed Program Dependence Graphs (DPDG). We mark and unmark the edges of the DPDG appropriately as and when dependencies arise and cease during run-time. Our algorithm can run parallely on a network of computers, with each node in the network contributing to the dynamic slice in a fully distributed fashion. Our approach does not require any trace files to be maintained. Another advantage of our approach is that a slice is available even before a request for a slice is made. This appreciably reduces the response time of slicing commands. We have implemented the algorithm in a distributed environment. The results obtained from our experiments show promise.