Joe D. Warren

Bio: Joe D. Warren is an academic researcher from Cornell University. The author has contributed to research in topics: Control flow graph & Program Dependence Graph. The author has an hindex of 3, co-authored 3 publications receiving 2645 citations. Previous affiliations of Joe D. Warren include Rice University.

The program dependence graph and its use in optimization

Abstract: In this paper we present an intermediate program representation, called the program dependence graph (PDG), that makes explicit both the data and control dependences for each operation in a program. Data dependences have been used to represent only the relevant data flow relationships of a program. Control dependences are introduced to analogously represent only the essential control flow relationships of a program. Control dependences are derived from the usual control flow graph. Many traditional optimizations operate more efficiently on the PDG. Since dependences in the PDG connect computationally related parts of the program, a single walk of these dependences is sufficient to perform many optimizations. The PDG allows transformations such as vectorization, that previously required special treatment of control dependence, to be performed in a manner that is uniform for both control and data dependences. Program transformations that require interaction of the two dependence types can also be easily handled with our representation. As an example, an incremental approach to modifying data dependences resulting from branch deletion or loop unrolling is introduced. The PDG supports incremental optimization, permitting transformations to be triggered by one another and applied only to affected dependences.

The program Dependence Graph and its Use in Optimization

Abstract: In this paper we present an intermediate program representation, called a program dependence graph or PDG, which summarizes not only the data dependences of each operation but also summarizes the control dependences of the operations. Data dependences represent only the relevant data flow relationships of the program. Analagously, control dependences represent only the relevant control flow relationships of the program, in contrast to the usual control flow graph. The PDG allows transformations such as vectorization, which previously required special treatuent of control dependence, to be performed in a manner which is uniform for both control and data dependences. Program transformations which require interaction of the two can also be easily handled by the representation. As an example, a new incremental approach to modifying data dependences resulting from branch deletion is introduced. Another value of our representation is that many traditional optimizations operate more efficiently on the PDG. Since dependences in the PDG connect computationally relevant parts of the program, a single walk of these dependences is sufficient to perform many optimizations.

A hierarchical basis for reordering transformations

Abstract: In this paper, we propose a new dependence baaed program representation. This representation is the union of two previously separate concepts: loop carried dependence and hierarchical abstraction. The resulting form has the property that all information necessary to reorder the set of all executions of the statements contained in a given loop exists in the representation of that loop. Thus, this representation provides an ideal basis for reordering transformations such as vectorisation and loop fusion. As evidence of this, we give efficient algorithms for these two transformations based on this representation.

The program dependence graph and its use in optimization

Abstract: In this paper we present an intermediate program representation, called the program dependence graph (PDG), that makes explicit both the data and control dependences for each operation in a program. Data dependences have been used to represent only the relevant data flow relationships of a program. Control dependences are introduced to analogously represent only the essential control flow relationships of a program. Control dependences are derived from the usual control flow graph. Many traditional optimizations operate more efficiently on the PDG. Since dependences in the PDG connect computationally related parts of the program, a single walk of these dependences is sufficient to perform many optimizations. The PDG allows transformations such as vectorization, that previously required special treatment of control dependence, to be performed in a manner that is uniform for both control and data dependences. Program transformations that require interaction of the two dependence types can also be easily handled with our representation. As an example, an incremental approach to modifying data dependences resulting from branch deletion or loop unrolling is introduced. The PDG supports incremental optimization, permitting transformations to be triggered by one another and applied only to affected dependences.

Program slicing

Abstract: Program slicing is a decomposition technique that slides program components not relevant to a chosen computation, referred to as a slicing criterion. The remaining components form an executable program called a slice that computes a projection of the original programpsilas semantics. Using examples coupled with fundamental principles, a tutorial introduction to program slicing is presented. Then applications of program slicing are surveyed, ranging from its first use as a debugging technique to current applications in property verification using finite state models. Finally, a summary of research challenges for the slicing community is discussed.

Efficiently computing static single assignment form and the control dependence graph

Abstract: In optimizing compilers, data structure choices directly influence the power and efficiency of practical program optimization. A poor choice of data structure can inhibit optimization or slow compilation to the point that advanced optimization features become undesirable. Recently, static single assignment form and the control dependence graph have been proposed to represent data flow and control flow properties of programs. Each of these previously unrelated techniques lends efficiency and power to a useful class of program optimizations. Although both of these structures are attractive, the difficulty of their construction and their potential size have discouraged their use. We present new algorithms that efficiently compute these data structures for arbitrary control flow graphs. The algorithms use {\em dominance frontiers}, a new concept that may have other applications. We also give analytical and experimental evidence that all of these data structures are usually linear in the size of the original program. This paper thus presents strong evidence that these structures can be of practical use in optimization.

Interprocedural slicing using dependence graphs

Abstract: The notion of a program slice, originally introduced by Mark Weiser, is useful in program debugging, automatic parallelization, and program integration. A slice of a program is taken with respect to a program point p and a variable x; the slice consists of all statements of the program that might affect the value of x at point p. This paper concerns the problem of interprocedural slicing—generating a slice of an entire program, where the slice crosses the boundaries of procedure calls. To solve this problem, we introduce a new kind of graph to represent programs, called a system dependence graph, which extends previous dependence representations to incorporate collections of procedures (with procedure calls) rather than just monolithic programs. Our main result is an algorithm for interprocedural slicing that uses the new representation. (It should be noted that our work concerns a somewhat restricted kind of slice: rather than permitting a program to b e sliced with respect to program point p and an arbitrary variable, a slice must be taken with respect to a variable that is defined or used at p.)The chief difficulty in interprocedural slicing is correctly accounting for the calling context of a called procedure. To handle this problem, system dependence graphs include some data dependence edges that represent transitive dependences due to the effects of procedure calls, in addition to the conventional direct-dependence edges. These edges are constructed with the aid of an auxiliary structure that represents calling and parameter-linkage relationships. This structure takes the form of an attribute grammar. The step of computing the required transitive-dependence edges is reduced to the construction of the subordinate characteristic graphs for the grammar's nonterminals.

A Survey of Program Slicing Techniques.

Abstract: A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest Such a point of interest is referred to as a slicing criterion, and is typically specified by a location in the program in combination with a subset of the program’s variables 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 Static slices are computed without making assumptions regarding a program’s input, whereas the computation of dynamic slices relies on a specific test case This survey presents an overview of program slicing, including the various general approaches used to compute slices, as well as the specific techniques used to address a variety of language features such as procedures, unstructured control flow, composite data types and pointers, and concurrency Static and dynamic slicing methods for each of these features are compared and classified in terms of their accuracy and efficiency Moreover, the possibilities for combining solutions for different features are investigated Recent work on the use of compiler-optimization and symbolic execution techniques for obtaining more accurate slices is discussed The paper concludes with an overview of the applications of program slicing, which include debugging, program integration, dataflow testing, and software maintenance