Program Slicing Research Articles

Competent Dependence Graph Acclimatize as Intermediate Representation to Effectuate the Best Slicing Technique for Object Oriented Programs

Objective: The main objective of this paper is to propose a Program Slicing Technique that includes more number of features than available in any other slicing technique. Methods: Numerous slicing techniques have been originated for enhancing the outcropping of Program Slicing. Simultaneously varied intermediate representation for representing the important features and dependencies of statements of a program on one another has been created for the easiness of creating the slicing technique. Unvaried part in varied techniques while concentrating on one good feature to be interpolated was overlooking some other important features. The flawed areas of the Available techniques have been found and based on the solution to overcome them, the technique is proposed that will consist of all important features with taking care of their flawed areas. Findings: Intermediate representation of a program accompanied by an algorithm is proposed to surpass the existing graphs by covering their flawed areas and by including more number of features than available in any other existing representation or technique. Conclusion: From the case studies it is concluded that the important features like Fault localization, Change Impact Analysis, Better Visualization etc can be achieved with a single technique. Added advantage is the complexity is reduced, accuracy and efficiency in terms of space and time is improved.

A precise monadic dynamic slicing method

Dynamic program slicing is useful in software debugging, testing and maintenance, because it can extract more precise results than those obtained by static slicing. In this paper, we propose a precise approach for dynamic program slicing, monadic dynamic slicing, which is based on modular monadic semantics. Firstly, we abstract the computation of dynamic slicing as an object of independent language, dynamic slice-monad transformer. Then we discuss and illustrate a modular monadic dynamic slice algorithm in detail. In this monadic algorithm, dynamic slices are computed on abstract syntax directly, without the need to explicitly construct intermediate structures such as dependence graphs, or to record an execution history. Finally, we address the implementation and complexity analysis of this algorithm. We conclude that the monadic approach has excellent flexibility, combinability and parallelizability properties.

Prioritizing Change-Impact Analysis via Semantic Program-Dependence Quantification

Software is constantly changing. To ensure the quality of this process, when preparing to change a program, developers must first identify the main consequences and risks of modifying the program locations they intend to change. This activity is called change-impact analysis. However, existing impact analysis suffers from two major problems: coarse granularity and large size of the resulting impact sets. Finer-grained analyses such as slicing give more detailed impact sets which, however, are also even larger in size. While various impact-set reduction approaches have been proposed at different levels of granularity, the challenge persists as very-large impact sets are still produced, impeding the adoption of impact analysis due to the great costs of inspecting those impact sets. To address these challenges, we present a novel dynamic-analysis technique called SensA which combines sensitivity analysis and execution differencing. SensA not only provides fine-grained (statement-level) impact sets but also prioritizes potential impacts via semantic-dependence quantification for program slices. We evaluated the benefits of impact prioritization using SensA with respect to static and dynamic forward slicing via an extensive empirical study of open-source Java applications and three case studies. Our results show that SensA can offer much better cost-effectiveness than slicing in assisting developers with impact inspection and fault cause-effect understanding.

Assertion-based analysis via slicing withABETS(system description)

AbstractWe presentABETS, an assertion-based, dynamic analyzer that helps diagnose errors in Maude programs.ABETSuses slicing to automatically create reduced versions of both a run's execution trace and executed program, reduced versions in which any information that is not relevant to the bug currently being diagnosed is removed. In addition,ABETSemploys runtime assertion checking to automate the identification of bugs so that whenever an assertion is violated, the system automatically infers accurate slicing criteria from the failure. We summarize the main services provided byABETS, which also include a novel assertion-based facility for program repair that generates suitable program fixes when a state invariant is violated. Finally, we provide an experimental evaluation that shows the performance and effectiveness of the system.

Editorial

This issue contains two papers that have a number of significant differences but also some common themes. The differences include the problem addressed (debugging vs. notions of test coverage for regression testing) and the type of entity analysed (model vs. source code). However, one thing that they do have in common is that they both explore alternatives regarding what is observed or monitored. They thus fit into a significant tranche of work that investigates different notions of observation and how these affect software engineering problems. Our first paper, Simulink fault localization: an iterative statistical debugging approach, by Bing Liu, Lucia, Shiva Nejati, Lionel C. Briand and Thomas Bruckmann, looks at debugging based on Simulink models (recommended by Tse). Simulink is widely used in the development of embedded systems, with code being auto-generated from a Simulink model. The motivation for the work described in this paper is that developers deal with Simulink models, and test such models, and so there is a need for debugging techniques that operate at this level. The authors adapt spectrum-based debugging techniques for use with Simulink, leading to what they call the SimFL technique. This ranks blocks from the model according to how ‘suspicious’ they are — based on passing and failing tests. One issue that has to be considered, when reasoning about testing or debugging, is what one considers to be an output. A Simulink model will typically contain multiple blocks, with outputs from some blocks acting as inputs to others. The authors observe that the developer might note that some such outputs are correct, while others are faulty. The authors propose a method that generates a dynamic slice for each output considered; the spectrum-based approach utilizes these slices. The authors also take advantage of the hierarchical nature of Simulink models to produce an iterative version of their approach (iSimFL). The results of empirical studies, using three industrial systems, were promising, with developer only having to consider between 1.3% and 4.4% of model blocks for iSimFL. The second paper, UCov: a user-defined coverage criterion for test case intent verification, by Rawad Abou Assi, Wes Masri and Fadi Zaraket, introduces a new notion of test coverage (recommended by Harman). Most traditional coverage criteria are based on particular syntactic features of a program or model. The authors argue that instead one might consider a notion of intent, as expressed as test requirements. When the system under test is run with a test input there is a resultant execution trace and test requirements refer to properties of this execution trace. Test requirements can refer to structural aspects, such as branches followed, and also behavioural aspects, such as properties of the values of program variables. The authors argue that a potential advantage of using test requirements is that this might be more robust to changes and so suitable for regression testing. For example, the approach is capable of discovering situations in which a test case is still valid for software that has changed but no longer satisfies the corresponding test requirement. The authors propose that if a test case finds a fault then the tester should add a new test requirement that represents why the test case found the fault. If this is done and a later change leads to the test requirement not being satisfied, then the tester can be warned and there is the potential to add a new test case that does satisfy the intent.

Property Based Dynamic Slicing of Object Oriented Programs

Slicing is used for program analysis. It the process of extracting the statements of a program that are relevant to a given computation. Static slicing generates slices for all possible execution of a program helping in program understanding, verification, maintenance and testing. Dynamic slices are smaller in size as they extract slices for a given execution of a program and helps in interactive applications like debugging and testing. With the wide spread use of object oriented software, there are many papers on Dynamic Slicing of object oriented programs but few papers only address in details about the most basic features of Object Oriented Programming that is class definition, Object creation, accessing object through reference, invoking methods of a class , polymorphism, inheritance etc. From last three decades many algorithms have been designed to slice a program with respect to the syntax of the program. The real world object oriented programs consists of thousands of lines of code. Traditional Syntax based slices for program variables used at many places in a program are generally large even for dynamic slices. Recently, some work has been done to get slices based on abstract/concrete properties of program variables. For smooth debugging and testing, the slice will be small if any particular property is being considered (semantics based). Most of the semantics based slicing algorithms have focused on finding static slices on the abstract properties by using SSA as intermediate representation and extract slices by storing an execution trace of a program. To the best of our knowledge generating dynamic slices based on abstract/Concrete properties of program variables is scarcely reported in literature. In this paper we present an algorithm for generating dynamic abstract slices of object oriented programs addressing all key object oriented features.

Skalpel: A constraint-based type error slicer for Standard ML

Compilers for languages with type inference algorithms often produce confusing type error messages and give a single error location which is sometimes far away from the real location of the error. Attempts at solving this problem often (1) fail to include the multiple program points which make up the type error; (2) report tree fragments which do not correspond to any place in the user program; and (3) give incorrect type information/diagnosis which can be highly confusing. We present Skalpel, a type error slicing tool which solves these problems by giving the programmer all and only the information involved with a type error to significantly aid in diagnosis and repair of type errors. Skalpel relies on a simple and general constraint system, a sophisticated constraint generator which is linear in program size, and a constraint solver which is terminating. Skalpel's constraint system can elegantly and efficiently handle intricate features such as SML's open. We also show that the Skalpel tool is general enough to deal not only with one source code file and one single error, but highlights all and only the possible locations of the error(s) in all affected files and produces all the culprit multiple program slices.

Forward Dynamic Slicing of Web Applications

We present a technique to compute dynamic slices for web applications using forward slicing approach. In our work, we have considered JSP (JavaServer Pages) based web applications. The slicing technique can efficiently be applied using an intermediate representation of a web application. We have proposed a graph called Web Dependence Graph (WDG) as the intermediate representation to correctly represent web applications. We have named our technique Web Application Forward Dynamic Slicing (WAFDS) Algorithm. The WAFDS algorithm first constructs the WDG. Then, the web application is executed for a given input, specified in slicing criteria, and the nodes in WDG resembling the executed statements are marked. Finally, the WDG is traversed in forward direction only along the marked nodes. The traversal is started from the desired point specified in the slicing criterion. The statements corresponding to the traversed marked nodes constitute the required dynamic slice for the given slicing criterion. During traversal along the marked nodes, the dynamic slice at each node is computed. Thus, for a given slicing criterion, the dynamic slice can be obtained in O(1) time.

A bug reproduction approach based on directed model checking and crash traces

AbstractReproducing a bug that caused a system to crash is an important task for uncovering the causes of the crash and providing appropriate fixes. In this paper, we propose a novel crash reproduction approach that combines directed model checking and backward slicing to identify the program statements needed to reproduce a crash. Our approach, named JCHARMING (Java CrasH Automatic Reproduction by directed Model checkING), uses information found in crash traces combined with static program slices to guide a model checking engine in an optimal way. We show that JCHARMING is efficient in reproducing bugs from 10 different open source systems. Overall, JCHARMING is able to reproduce 80% of the bugs used in this study in an average time of 19 min. Copyright © 2016 John Wiley & Sons, Ltd.

A Graph-Based Dynamic Slicing of Distributed Aspect-Oriented Software

Distributed computing has become very popular these days due to its speed, accuracy and fault tolerance capability. In this pa-per, we have considered the distributed Aspect-Oriented Programs (AOPs) where message passing and synchronization are handled by Aspects. In this paper, we present a parallel dynamic slicing algorithm for distributed AOPs. We introduce parallelism into our slicing algorithm to make the slice computation process much faster. Our algorithm is implemented on our developed tool, called DDG generator, to generate the required intermediate graphs for distributed AOPs. The proposed slicing technique is compared with one related existing technique using three case studies. The experimental results show that our proposed slicing algorithm generates precise slices in less time as compared to the existing algorithm.

A new approach to analyzing coevolving longitudinal networks in international relations

Previous models of international conflict have suffered two shortfalls. They tend not to embody dynamic changes, focusing rather on static slices of behavior over time across a single relational dimension. These models have also been empirically evaluated in ways that assumed the independence of each country, when in reality they are searching for the interdependence among all countries. A number of approaches are available now for analyzing relational data such as international conflict in a network context and a number of these can even handle longitudinal relational data, but none are developed to the point of exploring how networks can coevolve over time. We illustrate a solution to the limitations of existing approaches and apply this novel, dynamic, network based approach to study the dependencies among the ebb and flow of daily international interactions using a newly developed, and openly available, database of events among nations.

Lightweight control-flow instrumentation and postmortem analysis in support of debugging

Debugging is difficult and costly. As a programmer looks for a bug, it would be helpful to see a complete trace of events leading to the point of failure. Unfortunately, full tracing is simply too slow to use after deployment, and may even be impractical during testing. We aid post-deployment debugging by giving programmers additional information about program activity shortly before failure. We use latent information in post-failure memory dumps, augmented by low-overhead, tunable run-time tracing. Our results with a realistically-tuned tracing scheme show low enough overhead (0–5 %) to be used in production runs. We demonstrate several potential uses of this enhanced information, including a novel postmortem static slice restriction technique and a reduced view of potentially-executed code. Experimental evaluation shows our approach to be very effective. For example, our analyses shrink stack-sensitive interprocedural static slices by 53–78 % in larger applications.

Static Program Slicing- An Efficient Approach for Prioritization of Test Cases for Regression Testing

Testing is performed after modification of the program or software; it classified the existing test cases into re-used test cases and affected test cases after modification of the code. Test case prioritization is an approach of arranging the existing test cases in manner that most affected test cases (that generated maximum number of faults) test first after the other one. There are many techniques used for prioritization test cases at the time of regression testing. This paper present a new approach for prioritization of test cases using static executable program slices for regression testing. Program slicing is a process to classify the program into number of parts based on various types of dependencies between program statements. This paper presents an overview of basic concept of generating static program slices and on the basis of these programs slices prioritization of test cases at the time of regression testing Keywordstesting, Program dependency, static program slices, test cases prioritization and execution history

Dynamic slicing of concurrent specification languages

The formulation of the first adaptation of dynamic program slicing for CSP.The definition of the notion of dynamic slice and dynamic slicing criterion for CSP.The proof that the slices produced with our technique are complete but not correct.The implementation of the first dynamic slicer for CSP based on tracks.A set of benchmarks to test the tool and its performance. Dynamic slicing is a technique to extract the part of the program (called slice) that influences or is influenced, in a particular execution, by a given point of interest in the source code (called slicing criterion). Since a single execution is considered, the technique often uses a trace of this execution to analyze data and control dependencies. In this work we present the first formulation and implementation of dynamic slicing in the context of CSP. Most of the ideas presented can be directly applied to other concurrent specification languages such as Promela or CCS, but we center the discussion and the implementation on CSP. We base our technique on a new data structure to represent CSP computations called track. A track is a data structure which represents the sequence of expressions that have been evaluated during the computation, and moreover, it is labeled with the location of these expressions in the specification. The implementation of a dynamic slicer for CSP is useful for debugging, program comprehension, and program specialization, and it is also interesting from a theoretical perspective because CSP introduces difficulties such as heavy concurrency and non-determinism, synchronizations, frequent absence of data dependence, etc.

Prioritized static slicing and its application to fault localization

Static slicing is a popular program analysis used in software engineering to find which parts of a program affect other parts. Unfortunately, static slicing often produces large and imprecise results because of its conservative nature. Dynamic slicing can be an alternative in some cases, but it requires detailed runtime information that can be hard or impossible to obtain or re-create. This is often the case when users report bugs in deployed software. In this paper, we significantly improve the precision of static slicing through PrioSlice, a novel technique that exploits the insight that not all statements in a static slice are equally likely to affect another statement such as a failing point. PrioSlice first computes a probabilistic model of the dependencies in the program. In this model, some data dependencies are more likely to occur than others and control dependencies are less likely than data dependencies to propagate effects (e.g., errors). PrioSlice then traverses the program backwards, like static slicing, but in an order defined by the computed dependence probabilities. Our study of fault localization on various Java subjects indicates that PrioSlice can help localize faults much more effectively than existing static-slicing approaches.

The load slice core microarchitecture

Driven by the motivation to expose instruction-level parallelism (ILP), microprocessor cores have evolved from simple, in-order pipelines into complex, superscalar out-of-order designs. By extracting ILP, these processors also enable parallel cache and memory operations as a useful side-effect. Today, however, the growing off-chip memory wall and complex cache hierarchies of many-core processors make cache and memory accesses ever more costly. This increases the importance of extracting memory hierarchy parallelism (MHP), while reducing the net impact of more general, yet complex and power-hungry ILP-extraction techniques. In addition, for multi-core processors operating in power- and energy-constrained environments, energy-efficiency has largely replaced single-thread performance as the primary concern. Based on this observation, we propose a core microarchitecture that is aimed squarely at generating parallel accesses to the memory hierarchy while maximizing energy efficiency. The Load Slice Core extends the efficient in-order, stall-on-use core with a second in-order pipeline that enables memory accesses and address-generating instructions to bypass stalled instructions in the main pipeline. Backward program slices containing address-generating instructions leading up to loads and stores are extracted automatically by the hardware, using a novel iterative algorithm that requires no software support or recompilation. On average, the Load Slice Core improves performance over a baseline in-order processor by 53% with overheads of only 15% in area and 22% in power, leading to an increase in energy efficiency (MIPS/Watt) over in-order and out-of-order designs by 43% and over 4.7×, respectively. In addition, for a power- and area-constrained many-core design, the Load Slice Core outperforms both in-order and out-of-order designs, achieving a 53% and 95% higher performance, respectively, thus providing an alternative direction for future many-core processors.

Are Slice-Based Cohesion Metrics Actually Useful in Effort-Aware Post-Release Fault-Proneness Prediction? An Empirical Study

Background . Slice-based cohesion metrics leverage program slices with respect to the output variables of a module to quantify the strength of functional relatedness of the elements within the module. Although slice-based cohesion metrics have been proposed for many years, few empirical studies have been conducted to examine their actual usefulness in predicting fault-proneness. Objective . We aim to provide an in-depth understanding of the ability of slice-based cohesion metrics in effort-aware post-release fault-proneness prediction, i.e. their effectiveness in helping practitioners find post-release faults when taking into account the effort needed to test or inspect the code. Method . We use the most commonly used code and process metrics, including size, structural complexity, Halstead's software science, and code churn metrics, as the baseline metrics. First, we employ principal component analysis to analyze the relationships between slice-based cohesion metrics and the baseline metrics. Then, we use univariate prediction models to investigate the correlations between slice-based cohesion metrics and post-release fault-proneness. Finally, we build multivariate prediction models to examine the effectiveness of slice-based cohesion metrics in effort-aware post-release fault-proneness prediction when used alone or used together with the baseline code and process metrics. Results . Based on open-source software systems, our results show that: 1) slice-based cohesion metrics are not redundant with respect to the baseline code and process metrics; 2) most slice-based cohesion metrics are significantly negatively related to post-release fault-proneness; 3) slice-based cohesion metrics in general do not outperform the baseline metrics when predicting post-release fault-proneness; and 4) when used with the baseline metrics together, however, slice-based cohesion metrics can produce a statistically significant and practically important improvement of the effectiveness in effort-aware post-release fault-proneness prediction. Conclusion . Slice-based cohesion metrics are complementary to the most commonly used code and process metrics and are of practical value in the context of effort-aware post-release fault-proneness prediction.

Assessing the use of slicing-based visualizing techniques on the understanding of large metamodels

ContextMetamodels are cornerstones of various metamodeling activities. Such activities consist of, for instance, transforming models into code or comparing metamodels. These activities thus require a good understanding of a metamodel and/or its parts. Current metamodel editing tools are based on standard interactive visualization features, such as physical zooms. ObjectiveHowever, as soon as metamodels become large, navigating through large metamodels becomes a tedious task that hinders their understanding. So, a real need to support metamodel comprehension appears. MethodIn this work we promote the use of model slicing techniques to build interactive visualization tools for metamodels. Model slicing is a model comprehension technique inspired by program slicing. We show how the use of Kompren, a domain-specific language for defining model slicers, can ease the development of such interactive visualization features. ResultsWe specifically make four main contributions. First, the proposed interactive visualization techniques permit users to focus on metamodel elements of interest, which aims at improving the understandability. Second, these proposed techniques are developed based on model slicing, a model comprehension technique that involves extracting a subset of model elements of interest. Third, we develop a metamodel visualizer, called Explen, embedding the proposed interactive visualization techniques. Fourth, we conducted experiments. showing that Explen significantly outperforms EcoreTools, in terms of time, correctness, and navigation effort, on metamodeling tasks. ConclusionThe results of the experiments, in favor of Explen, show that improving metamodel understanding can be done using slicing-based interactive navigation features.

Variable Data-Flow Graph for Lightweight Program Slicing and Visualization

To understand the behavior of a program, developers often need to read source code fragments in various modules. Systemdependence-graph-based (SDG) program slicing is a good candidate for supporting the investigation of data-flow paths among modules, as SDG is capable of showing the data-dependence of focused program elements. However, this technique has two problems. First, constructing SDG requires heavyweight analysis, so SDG is not suitable for daily uses. Second, the results of SDG-based program slicing are difficult to visualize, as they contain many vertices. In this research, we proposed variable dataflow graphs (VDFG) for use in program slicing techniques. In contrast to SDG, VDFG is created by lightweight analysis because several approximations are used. Furthermore, we propose using the fractal value to visualize VDFG-based program slice in order to reduce the graph complexity for visualization purposes. We performed three experiments that demonstrate the accuracy of VDFG program slicing with fractal value, the size of a visualized program slice, and effectiveness of our tool for source code reading. key words: Static Analysis, Program Slicing, Variable Data-Flow Graph, Visualization

An Ameliorated Methodology for the Abstraction of Object Oriented Features from Software Requirements Specification

The Business Process (BP) requirements is specified in the form of software requirements specification (SRS). This SRS serves as a base for software development. The software needs to be developed in a syllogized software development life cycle (SDLC) stages. The SRS which denote the requirements of BP is used as input to the analysis stage from which the paradigm dependent components are to be abstracted. Hither to the components are abstracted manually with the exception of hiatuses of semi-automated methods for few of the components. The SRS is construed with reference to the specific paradigm through which the design is to be developed. Unfortunately, no complete automated methodology exists for the abstraction of all paradigm dependent components. The automated methodology eliminates the possible human errors which would have ripple effect to damage the entire software. This paper develops an innovative, unique methodology to resurrect the SRS statements as modular statements. Further develops an automated methodology for abstraction of control and data flow graphs. Further it develops an automated methodology for abstraction of useful components required for the class diagram. The class diagram emphasizes both structural and behavioral aspects. This facility is effectively used to abstract object class attributes, object methods, visibility, signature, return type etc. Information systems are developed through software projects which use the specific software requirements specification (SRS) provided for them as the base. The SRS contains details of the information system through which appropriate software can be developed. The information systems are also viewed perceptively with different pragmatics like work, work process or usecase. The usecase is one of the prime perspective views whose sum forms the information system. In this paper, an attempt is made to abstract object class, object class attributes, object methods, interrelationships between object classes and starting with/ending with actor from unformatted, unstructured SRS text. This is achieved through our own developed classing and slicing techniques to identify respectively the class structure & object methods. Then usecase is developed through the interrelationships between object methods of different classes and start with or end with the actor. The stages involve moulding the SRS, designing control flow graph for the SRS & data flow table for the SRS statements, developing appropriate classing and slicing criteria, creating actor & actors’ interface attributes table, create slicing criteria for each usecase and then slice relevant statements for each usecase. Here, we have attempted to use Weiser modified algorithm1 to abstract exact usecase. The slicing criterion is obtained through the intersection of actor's interface attributes and the referenced/defined attributes present between two consecutive actors. Attempts have been made to resolve synonyms & heteronyms present in the SRS. The correctness & completeness of the proposed methodology depends on the realization of actor & actors’ interface attributes.