Ron Cytron

Efficiently computing static single assignment form and the control dependence graph

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.

An efficient method of computing static single assignment form

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 where 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 a new algorithm that efficiently computes these data structures for arbitrary control flow graph We also give analytical and experimental evidence that they are usually {em linear} in the size of the original program. This paper thus presents strong evidence that these structures can be of {em practical} use in optimization.

An overview of the PTRAN analysis system for multiprocessing

PTRAN (Parallel TRANslator) is a system for automatically restructuring sequential FORTRAN programs for execution on parallel architectures. This paper describes PTRAN-A: the currently operational analysis phase of PTRAN. The analysis is both broad and deep, incorporating interprocedural information into dependence analysis. The system is organized around a persistent database of program and procedure information. PTRAN incorporates several new, fast algorithms in a pragmatic design.

Automatic construction of sparse data flow evaluation graphs

In this paper, we present an algorithm that constructs sparse evaluation graphs for forward or backward monotone data flow problems. The sparse graph combines information as early as possible, yet directly connects nodes that generate and use information. This allows problems from the large, general class of monotone data flow problems to err joy the advantages of solutions based on Static Single Assignment (SSA) form.

An overview for the PTRAN analysis system for multiprocessing

PTRAN (Parallel TRANslator) is a system for automatically restructuring sequential FORTRAN programs for execution on parallel architectures. This paper describes PTRAN-A: the currently operational analysis phase of PTRAN. The analysis is both broad and deep, incorporating interprocedural information into dependence analysis. The system is organized around a persistent database of program and procedure information. PTRAN incorporates several new, fast algorithms in a pragmatic design.

Minimum distance: a method for partitioning recurrences for multiprocessors

Parallel execution of nonvectorizable uniform recurrences is considered. When naively scheduled, such recurrences could create unacceptable communication and synchronization on a multiprocessor. The minimum-distance method partitions such recurrences into totally independent computations without increasing redundancy or perturbing numerical stability. The independent computations are well suited for execution on a multiprocessor, but they may not utilize all available processors. How extra processors can be applied to the independent computations is addressed. The methods are especially attractive for multiprocessors comprised of clusters. >

Automatic generation of DAG parallelism

We present an algorithm for automatically generating a nested, fork-join parallel program from a sequential program represented in terms of control and data dependences. This algorithm embodies two techniques for dealing with data dependences: the rst implicitly satis es such dependences by reducing parallelism, and the second eliminates some dependences by introducing private variables. This algorithm has been implemented in the PTRAN system [ABC*87]. Previous work on automatic generation of parallelism focused on vectorization, relying on a datadependence-based and loop-based representation as input [Kuc78] [Wol82] [AK87]. This work is welldeveloped and includes automatic generation of synchronization for loop iterations [Mid86]. Previous work has applied privatization in the form of scalar expansion for vectorization [Wol78]. Other work has fully renamed a program so as to obviate privatization [CF87b]. Our work extends automatic parallelization in the following ways:

Code motion of control structures in high-level languages

One trend among programmers is the increased use of abstractions. Through encapsulation techniques, abstractions extend the repertory of data structures and their concomitant operations that are processed directly by a compiler. For example, a compiler might not offer sets or set operations in its base language, but abstractions allow a programmer to define sets in terms of constructs already recognized by the compiler. In particular, abstractions can allow new constructs to be defined in terms of other abstractions. Although significant power is gained through the use of layered abstractions, object code quality suffers as increasingly less of a programs data structures and operations are exposed to the optimization phase of a compiler. Multiple references to abstractions are also inefficient, since the interaction between abstractions is often complex yet hidden from a compiler. Abstractions are most flexible when they are cast in general terms; a specific invocation is then tailored by the abstraction to obtain the appropriate code. A sequence of references to such abstractions can be inefficient due to functional redundancy that cannot be detected at compile-time. By integrating the references, the offending segments of code can be moved to a more advantageous position. Although procedure integration materializes abstracted constructs, the abstractions can still be ineligible for optimization using current techniques; in particular, abstractions often involve loops and conditional branches that can obscure code that would otherwise be eligible for code motion.

Compact representations for control dependence

Recently the Program Dependence Graph (PDG) has been shown useful as a basis for solving a variety of problems, including optimization [FOW87], vectorization [BB89], translation to dataflow machines [OBM90], code generation for VLIW machines [GS87a, GS87b], program transformation [Se189, CF89], merging versions of programs [HPR87], and automatic detection and management of parallelism [ABC*87, ABC*88, CFS89]. The edges of the PDG consist of control dependence and data dependence edges. The data dependence edges represent the essential data flow relationships of a program [Kuc?‘~]. In this paper, we examine the control dependence aspect of the PDG, which summarizes essential control flow relationships in a program. Informally, for nodes X and Y in CFG, Y is control dependent on X if during execution, X can directly affect whether Y is executed. We improve the space and time required to compute those aspects of control dependence used by m9st algorithms, We assume ‘a control flow graph CFG is augmented wit,h an entry node (START), an exit node (STOP), and an edge from START to STOP. An example control flow graph is shown in Figure 1 and its control dependence graph is given in Figure 2. Let 1V and E be the number of nodes and edges respectively in CFG. Multiple outgoing edges from a node in CFG are assumed to be distinctly labelled.’ We further assume that for any node X in CFG there exists a path from START to X and a path from X to STOP. To define control dependence formally, we first recall the notion of postdominance [FOW87]. Let X and Y be nodes in CFG. If X # Y appears ou every path from Y to STOP, then X postdominates Y, denoted X >> Y. We write X >> Y if X = Y or X >> Y. The immediate postdominator of Y is the closest postdominator of Y on any path from Y to STOP.

Automatic Generation of Nested, Fork-Join Parallelism

This paper presents an efficient algorithm that automatically generates a parallel program from a dependence-based representation of a sequential program. The resulting parallel program consists of nested fork-join constructs, composed from the loops and statements of the sequential program. Data dependences are handled by two techniques. One technique implicitly satisfies them by sequencing, thereby reducing parallelism. Where increased parallelism results, the other technique eliminates them by privatization: the introduction of process-specific private instances of variables. Additionally, the algorithm determines when copying values of such instances in and out of nested parallel constructs results in greater parallelism. This is the first algorithm for automatically generating parallelism for such a general model. The algorithm generates as much parallelism as is possible in our model while minimizing privatization.