Program Slicing Research Articles

Extracting Business Rule from existing COBOL programs for Redevelopment

The paper describes an industrial business study carried out to regain the business knowledge embedded in a legacy COBOL application. The aim of this work was to extract out the information required to re- implement the Legacy programs in a new client/server environment. The progress solution is in four step. Firstly, the programs were restructured, secondly the programs were sliced into business logic modules, third the business modules were subjected to a multi view analysis and finally the views were integrated into a unified documentation describing the data, decision and procedural flow of each program slice.

Performance of Static Slicing Algorithms for Petri Nets

Performance of Static Slicing Algorithms for Petri Nets

Automatic self-gated 4D-MRI construction from free-breathing 2D acquisitions applied on liver images.

MRI slice reordering is a necessary step when three-dimensional (3D) motion of an anatomical region of interest has to be extracted from multiple two-dimensional (2D) dynamic acquisition planes, e.g., for the construction of motion models used for image-guided radiotherapy. Existing reordering methods focus on obtaining a spatially coherent reconstructed volume for each time. However, little attention has been paid to the temporal coherence of the reconstructed volumes, which is of primary importance for accurate 3D motion extraction. This paper proposes a fully automatic self-sorting four-dimensional MR volume construction method that ensures the temporal coherence of the results. First, a pseudo-navigator signal is extracted for each 2D dynamic slice acquisition series. Then, a weighted graph is created using both spatial and motion information provided by the pseudo-navigator. The volume at a given time point is reconstructed following the shortest paths in the graph starting that time point of a reference slice chosen based on its pseudo-navigator signal. The proposed method is evaluated against two state-of-the-art slice reordering algorithms on a prospective dataset of 12 volunteers using both spatial and temporal quality metrics. The automated end-exhale extraction showed results closed to the median value of the manual operators. Furthermore, the results of the validation metrics show that the proposed method outperforms state-of-the-art methods in terms of both spatial and temporal quality. Our approach is able to automatically detect the end-exhale phases within one given anatomical position and cope with irregular breathing.

Automatic Testing of Program Slicers

Program slicing is a technique to extract the part of a program (the slice) that influences or is influenced by a set of variables at a given point (the slicing criterion). Computing minimal slices is undecidable in the general case, and obtaining the minimal slice of a given program is normally computationally prohibitive even for very small programs. Therefore, no matter what program slicer we use, in general, we cannot be sure that our slices are minimal. This is probably the fundamental reason why no benchmark collection of minimal program slices exists. In this work, we present a method to automatically produce quasi-minimal slices. Using our method, we have produced a suite of quasi-minimal slices for Erlang that we have later manually proved they are minimal. We explain the process of constructing the suite, the methodology and tools that were used, and the results obtained. The suite comes with a collection of Erlang benchmarks together with different slicing criteria and the associated minimal slices.

Research and implementation of a non-supporting 3D printing method based on 5-axis dynamic slice algorithm

Abstract Conventional three-dimensional (3D) printing technology generates objects and parts layer by layer by depositing material along the Z-axis direction. However, when it comes to overhanging structures in the printing process, the conventional printing process needs the creation of additional supporting structures. So, this technique requires additional materials and increases the effective printing time. To overcome these issues, this paper proposes a novel 5-axis dynamic slicing algorithm to achieve non-supporting material printing (NSMP). The original model is sliced by a series of dynamic planes calculated by the skeleton extraction; the 5-axis printing G-code generated from the sliced layers can control the 5-axis printer to complete NSMP. Finally, a comparison between traditional 3D printing and 5-axis printing is presented to test the utility of this strategy.

Scenario Oriented Program Slicing for Large-Scale Software Through Constraint Logic Programming and Program Transformation

Program slicing, as a technique of program decomposition, is widely used in the field of program testing, model checking, software verification, symbolic execution, and other fields. However, the traditional approaches of program slicing tend to produce too large slices and the static program analyses are hard to be precise enough. Scenario-oriented program slicing, which considers the actual usage of software, gives a more precise perspective of program slicing. In this paper, we propose an approach of scenario-oriented program slicing, which combines constraint logic programming and program transformation. According to the observation that the output of a program transformation is a semantically equivalent program where the properties of interest are preserved, we can apply a sequence of transformations, more powerful than those needed for program specialization, refining the slicing to the desired degree of precision. And constraint logic programming has been shown to be a powerful, flexible formalism to reason about the correctness of programs. The novel contributions of this paper are as follows: 1) converting the problem of program slicing into program transformation and retrieval; 2) presenting a set of constraint handling rules for scenario-oriented program slicing in constraint logical programming programs; and 3) deriving a scenario-oriented program slicing algorithm. The method of scenario-oriented program slicing has been implemented and we have demonstrated its effectiveness and efficiency on three open source software projects in GitHub.

Source code-based context-sensitive dynamic slicing of web applications

Web applications are broadly utilised for spreading business around the globe. To meet the necessities of the huge numbers of users or customers, the web applications must have better quality and robustness than any other applications where the number of users is limited. Program slicing is found to be useful in improving program understanding, analysis, testing and maintenance. This paper presents a context-sensitive slicing technique for web applications. In this paper, a new intermediate representation called web dependence graph (WDG) is proposed for representing all dependencies that may present in a web application. We have proposed a context-sensitive web slicing (CSWS) algorithm for computation of slices of a given web application using the WDG. A tool is developed for automatic generation of the WDG for a given web application and computation of slices. During our literature survey, we noticed that majority of the automatic graph generation tools are mainly based on byte-code whereas our tool uses the dependency analysis from the source code of the given program. Using our tool WDG, we compared the performance of our proposed CSWS algorithm for slicing with other closely related slicing techniques.

Dynamic Slicing of Aspect-Oriented Software: An UML-based Approach

In this paper, we propose a technique to compute the dynamic slice of UML models for aspect-oriented software. The UML architectural model for aspect-oriented software represents the 'core' components, 'aspectual' components and the relationship between them. Firstly, we construct aspect-oriented model dependence graph (AOMDG) as an intermediate representation of the UML model for aspect-oriented software. AOMDG is a combination of aspect-class dependence graph (ACDG) and aspect-sequence dependence graph (ASDG). ACDG is constructed by using a set of class and set of aspect class diagrams and ASDG is constructed by using a set of sequence and aspect sequence diagrams from the UML architectural model. Then, we propose an algorithm to compute the dynamic slice by traversing AOMDG by marking and unmarking the nodes for a particular scenario during run-time.

Conditioned Slicing of Interprocedural Programs

Program slicing is a technique to decompose programs depending on control flow and data flow amongst several lines of code in a program. Conditioned slicing is a generalization of static slicing and dynamic slicing. A variable, the desired program point, and a condition of interest form a slicing criterion for conditioned slicing. This paper proposes an approach to calculate conditioned slices for programs containing multiple procedures. The approach is termed Node-Marking Conditioned Slicing (NMCS) algorithm. In this approach, first and foremost step is to build an intermediate symbolization of a given program code and the next step is to develop an algorithm for finding out conditioned slices. The dependence graph, termed System Dependence Graph (SDG), is used to symbolize intermediate presentation. After constructing SDG, the NMCS algorithm chooses nodes that satisfy a given condition by the process of marking and unmarking. The algorithm also finds out conditioned slices for every variable at every statement during the process. NMCS algorithm employs a stack to save call context of a method. Few edges in SDG are labeled to identify the statement that calls a method. The proposed algorithm is implemented, and its performance is tested with several case study projects.

A Feature Based Methodology for Variable Requirements Reverse Engineering

In the past years, software reverse engineering dealt with source code understanding. Nowadays, it is levered to software requirements abstract level, supported by feature model notations, language independent, and simpler than the source code reading. The recent relevant approaches face the following insufficiencies: lack of a complete integrated methodology, adapted feature model, feature patterns recognition, and Graph based slicing. This work aims to provide some solutions to the above challenges through an integrated methodology. The following results are unique. Elementary and configuration features are specified in a uniform way by introducing semantics specific attributes. The reverse engineering supports feature pattern recognition and requirements feature model graph-based slicing. The slicing criteria are rich enough to allow answering questions of software requirements maintainers. A comparison of this proposed methodology, based on effective criteria, with the similar works, seems to be valuable and competitive: the enrichment of the feature model and feature pattern recognition were never approached and the proposed slicing technique is more general, effective, and practical.

Source code-based context-sensitive dynamic slicing of web applications

Source code-based context-sensitive dynamic slicing of web applications

Statistical Multiplexing and Traffic Shaping Games for Network Slicing

Next generation wireless architectures are expected to enable slices of shared wireless infrastructure which are customized to specific mobile operators/services. Given infrastructure costs and the stochastic nature of mobile services' spatial loads, it is highly desirable to achieve efficient statistical multiplexing amongst such slices. We study a simple dynamic resource sharing policy which allocates a 'share' of a pool of (distributed) resources to each slice-Share Constrained Proportionally Fair (SCPF). We give a characterization of SCPF's performance gains over static slicing and general processor sharing. We show that higher gains are obtained when a slice's spatial load is more 'imbalanced' than, and/or 'orthogonal' to, the aggregate network load, and that the overall gain across slices is positive. We then address the associated dimensioning problem. Under SCPF, traditional network dimensioning translates to a coupled share dimensioning problem, which characterizes the existence of a feasible share allocation given slices' expected loads and performance requirements. We provide a solution to robust share dimensioning for SCPF-based network slicing. Slices may wish to unilaterally manage their users' performance via admission control which maximizes their carried loads subject to performance requirements. We show this can be modeled as a 'traffic shaping' game with an achievable Nash equilibrium. Under high loads, the equilibrium is explicitly characterized, as are the gains in the carried load under SCPF vs. static slicing. Detailed simulations of a wireless infrastructure supporting multiple slices with heterogeneous mobile loads show the fidelity of our models and range of validity of our high load equilibrium analysis.

Sharing bus lanes: a new lanes multiplexing-based method using a dynamic time slice policy

Dedicated bus lanes (DBLs) can only be used by buses in principle, so there is an intermittent waste of road resources. Coupled with increasingly serious traffic congestion, how to fully exploit the relatively surplus road resources of DBLs under the premise of guaranteeing bus priority is an issue that is worth studying. The authors propose a dynamic time slice policy for the time division multiplexing (TDM) method to share dedicated bus lanes. First, the TDM method is outlined to present the basic mechanism of the dynamic time slice policy. Subsequently, models for predicting the travel times of approaching vehicles and lane-borrowing vehicles based on TDM are established. Then, a lane-borrowing discriminative model is proposed to determine whether low-priority vehicles have the right to use the DBL at the current moment, and the time slices of DBL multiplexing are allocated based on vehicles of different types. Furthermore, to increase the operability of the method in engineering applications, a spatiotemporal control strategy for TDM is designed. Finally, the dynamic time slice policy is applied to a DBL through simulations and practical traffic experiments. The results prove the feasibility of the dynamic time slice policy.

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.

Editor's Foreword to “Static Backward Slicing of Non-Deterministic Programs and Systems”

Editor's Foreword to “Static Backward Slicing of Non-Deterministic Programs and Systems”

Static Backward Slicing of Non-deterministic Programs and Systems

A theory of slicing non-deterministic programs and systems is developed. Non-deterministic programs and systems are represented as non-deterministic program graphs (NDPGs) that allow arbitrary non-deterministic branching to be expressed. Structural and semantic relationships that must exist between an NDPG and (1) its non-termination insensitive (weak) slices and (2) its non-termination sensitive (strong) slices are defined. Weak and strong commitment closure are introduced. These are the NDPG equivalents of being closed under non-termination sensitive and non-termination insensitive control dependence; properties defined on subsets of vertices of the equivalent deterministic structure: the control flow graph. It is proved that if a subset of the vertices of an NDPG is both data dependence closed and (weak/strong) commitment closed, then the resulting induced graph will, indeed, satisfy our structural and semantic requirements. O ( n 3 ) algorithms for computing minimal data and weak/strong commitment closed sets are given. The resulting induced graphs are thus guaranteed to be weak and strong slices, respectively. It is demonstrated, with examples, that programs written in Dijkstra's non-deterministic guarded command language (DNGCL) can be converted to NDPGs to which our slicing algorithms can then be applied. It is proved that the resulting slices (NDPGs) can always be converted back to valid DNGCL programs, highlighting the applicability of our approach to slicing at the source code level.

Slicing from formal semantics: Chisel—a tool for generic program slicing

We describe Chisel, a tool that synthesizes a program slicer directly from a given algebraic specification of a programming language operational semantics \(\mathcal {S}\). \(\mathcal {S}\) is assumed to be a rewriting logic specification, given in Maude, while the program is a ground term of this specification. Chisel takes \(\mathcal {S}\) and synthesizes language constructs, i.e., instructions, that produce features relevant for slicing, e.g., data dependency. We implement syntheses adjusted to each feature as model checking properties over an abstract representation of \(\mathcal {S}\). The syntheses results are used by a traditional interprocedural slicing algorithm that we parameterize by the synthesized language features. We present the tool on two language paradigms: high-level, imperative and low-level, assembly languages. Computing program slices for these languages allows for extracting traceability properties in standard compilation chains and makes our tool fitting for the validation of embedded system designs. Chisel’s slicing benchmark evaluation is based on benchmarks used in avionics.

A Proposed Java Static Slicing Approach

<p>Program slicing is to abstract a part of source code depending on the point of interest. It used widely in maintenance, debugging and testing. There are many slicing techniques such as static, dynamic, and amorphous. In this paper, we choose to develop a new approach applying static slicing on Java programs. The new approach simplifies the data dependency using arrays. A new Tool called Java Multi-Slicing Tool (JavaMST) has been introduced to apply this approach.</p><p>JavaMST presents new ways to slice any simple java code segment, it allows you to extract the variables and its direct and indirect dependencies from the code, using backward, forward or both slicing techniques to produce the needed code. This tool is a simple tool designed to deal with simple java code segments. JavaMST can be run under any operating system and does not require a specialized platforms or plug-ins. Therefore, it is useful to be used for educational purposes.</p>

Static slicing of Use Case Maps requirements models

Requirements specification is a crucial stage in many software development life cycles. As requirements specifications evolve, they often become more complex. The development of methods to assist the comprehension and maintenance of requirements specifications has gained much attention in the past 20 years. However, there is much room for improvement for model-based specifications. The Use Case Maps (UCM) language, part of the ITU-T Z.151 User Requirements Notation standard, is a visual modeling notation that aims to describe requirements at a high level of abstraction. A UCM specification is used to integrate and capture both functional aspects (based on causal scenarios representing behavior) and architectural aspects (actors and system components responsible for scenario activities). As UCM models evolve and grow, they rapidly become hard to understand and to maintain. In this paper, we propose a static slicing technique to enhance the comprehension of UCM models. The developed slicing approach is implemented within the jUCMNav tool. We validate the proposed approach using a mock system and three publicly available UCM specifications. The results suggest that, on average, the models can be reduced by about 70% through slicing without losing information required for comprehension and maintenance activities. A small experiment involving 9 participants also suggests that the understandability of UCM specifications and comprehension speed have both improved substantially by using jUCMNav’s new slicing feature.

Hybrid Genetic Algorithm for Improving Fault Localization

Finding faults in a program correctly is crucial in software maintenance. In this light, many techniques have been proposed such as program slicing, code coverage, program state and mutation analysis. While all these techniques give us good insight on fault localization, but it appears that these techniques are made based on the assumption that the faults are caused by a single fault. However, in a reality, one fault could also possibly caused by multiple faults. This requires a technique which is specifically designed to handle multiple faults. With this regards, application of mutation analysis to localize faults might generate a vast number of mutants. As a result, these will lead to difficulty in choosing important mutants that are capable of localizing faults. Therefore, there is a need for a technique which able to localize a fault effectively with less number of mutants generated. Genetic algorithm (GA) is well known in finding an optimal solution to a problem while local search is capable of removing duplication. Since both had their own advantage, we have combined both techniques to enhance multiple localization of software fault. The result of the experiment shows that our technique able to detect multiple faults in various java programs but there is a need for improvement especially in prioritize fault that occurs simultaneously.