A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest, referred to as a slicing criterion. The task of computing program slices is called program slicing. The original definition of a program slice was presented by Weiser in 1979. Since then, various slightly different notions of program slices have been proposed, as well as a number of methods to compute them. An important distinction is that between a static and a dynamic slice. The former notion is computed without making assumptions regarding a program's input, whereas the latter relies on some specific test case. Procedures, arbitrary control flow, composite datatypes and pointers, and interprocess communication each require a specific solution. We classify static and dynamic slicing methods for each of these features, and compare their accuracy and efficiency. Moreover, the possibilities for combining solutions for different features are investigated....

Static program slicing is an established method for analyzing sequential programs, especially for program understanding, debugging and testing. Until now, there was no slicing method for threaded programs which handles interference correctly. We present such a method which also calculates more precise static slices. This paper extends the well known structures of the control flow graph and the program dependence graph for threaded programs with interference. This new technique does not require serialization of threaded programs.

We introduce the notion of a slice of a distributed computation. A slice of a distributed computation with respect to a global predicate is a computation which captures those and only those consistent cuts of the original computation which satisfy the global predicate. We show that a slice exists for a global predicate iff the predicate is a regular predicate. We then give an efficient algorithm for computing the slice and show applications of slicing to testing and debugging of distributed programs. 1.

Program slicing is a viable method to restrict the focus of a task to specific sub-components of a program. Examples of applications include debugging, testing, program comprehension, restructuring, downsizing, and parallelization. This paper discusses different statement deletion based slicing methods, together with algorithms and applications to software engineering.

. This paper extends the notion of slicing, which was originally proposed and studied for sequential programs, to concurrent programs and presents a graph-theoretical approach to slicing concurrent programs. In addition to the usual control and data dependences proposed and studied for sequential programs, the paper introduces three new types of primary program dependences in concurrent programs, named the selection dependence, synchronization dependence, and communication dependence. The paper also propose a new program representation for concurrent programs, named the Process Dependence Net (PDN), which is an arc-classified digraph to explicitly represent the five types of primary program dependences in the programs. As a result, various notions about slicing concurrent programs can be formally defined based on the representation, and the problem of slicing a concurrent program can be simply reduced to a vertex reachability problem in its PDN representation. 1. Introd...

A dynamic program slice is an executable part of a program whose behavior is identical, for the same program input, to that of the original program with respect to a variable(s) of interest at some execution position. In the existing dynamic slicing tools dynamic slices are represented in a textual form, i.e., a dynamic slice is displayed to programmers in the form of highlighted statements or in the form of a subprogram. Although dynamic slicing does narrow the size of the program, it is still up to the programmer to analyze the text of a dynamic slice and identify a faulty part in the program. The textual representation of a dynamic slice does not provide much guidance in program debugging and understanding of program behavior, which frequently is a major factor in efficient debugging. During dynamic slice computation different types of information are computed and then discarded after computation of the dynamic slice. In this paper we propose new dynamic slicing related features that exploit this information to improve the process of program debugging. These features were implemented in our dynamic slicing tool that can be used for program debugging. 1.

This paper surveys the program dependence analysis technique for parallel and/or distributed programs and its applications from the viewpoint of software engineering. We present primary program dependences which may exist in a parallel and/or distributed program, a general approach to define, analyze, and represent these program dependences formally, and applications of an explicit program dependence based representation for parallel and/or distributed programs in various software engineering activities. We also suggest some research problems on this direction.

Abstract. We generalize the notion of slice introduced in our earlier paper [6]. A slice of a distributed computation with respect to a global predicate is the smallest computation that contains all consistent cuts of the original computation that satisfy the predicate. We prove that slice exists for all global predicates. We also establish that it is, in general, NP-complete to compute the slice. An optimal algorithm to compute slices for special cases of predicates is provided. Further, we present an efficient algorithm to graft two slices, that is, given two slices, either compute the smallest slice that contains all consistent cuts that are common to both slices or compute the smallest slice that contains all consistent cuts that belong to at least one of the slices. We give application of slicing in general and grafting in particular to global property evaluation of distributed programs. Finally, we show that the results pertaining to consistent global checkpoints [14, 18] can be derived as special cases of computation slicing. 1

Program slicing is an effective technique for narrowing the focus of attention to the relevant parts of a program during the debugging process. However, imprecision is a problem in static slices since they are based on all executions that reach a given program point rather than the specific execution under which the program is being debugged. Dynamic slices are precise but require a large amount of run time overhead due to the tracing information that is collected during the program's execution. We present a general approach for improving the precision and quality of static slices by incorporating dynamic information in static slicing, enabling the computation of hybrid slices. The technique exploits dynamic information that is readily available during debugging, namely breakpoint information and the dynamic call graph. The precision of static slicing is improved in hybrid slicing by more accurately estimating the potential paths taken by the program. The breakpoints and call/return po...

Program slicing is a technique to identify statements that may influence the computations at other statements. Precise slicing has been shown to be undecidable for concurrent programs. This work presents the first context-sensitive approach to slice concurrent programs accurately. It extends the well known structures of the control flow graph and the (interprocedural) program dependence graph for concurrent programs with interference. This new technique does not require serialization or inlining.