Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations," pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York (1981).  Home/Search   Document Not in Database   Summary   Related Articles   Check

....mentioned in Section 1.1, which provides quantitative data on how well our algorithm works in practice and how much of an advance it is over previous techniques. 2. ASSUMPTIONS AND TERMINOLOGY We assume that the reader is familiar with the standard definitions of control and data dependence [9, 14, 4]. We assume that programs are represented using a set of controlflow graphs (CFGs) one for each procedure. Predicate nodes in CFGs have two or more outgoing edges (looppredicates and if predicates have exactly two, whereas switch predicates have one for each case label and for the default ....

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proc. ACM Symp. on Principles of Programming Languages, pages 207--218, Jan. 1981.

....so that array accesses reuse smaller blocks of data that fit into the cache. Compilers typically employ advanced static analysis techniques to determine when and how to perform a transformation. The static techniques perform data dependence analysis to determine the access patterns in programs [63]. The static analysis needs to determine when the transformation is legal. If the compiler is unable to determine the legality then it cannot perform the optimization. An advantage of data prefetching is that compilers can be more aggressive in determining opportunities because legality is not a ....

David J. Kuck, R.H. Kuhn, David Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proceedings of the Eigth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 207--218, Williamsburg, VA, January 1981.

....that are known to be correct. There are two relatively standard approaches for converting sequential imperative programs into equivalent concurrent programs, Tomasulo s algorithm [117, 57, 104, 83, 105] and compiler based program restructuring based on a technique called scalar expansion [68]. Each of these techniques presents the architect with a set of tradeoffs. In particular, Tomasulo s algorithm guarantees the elimination of register storage dependences, and is relatively easily extended to speculate across predictable dependences, but does so at the cost of partially ....

....is also a du web, since it is a connected set. The du webs for variables partial sum and sum are shown in Figure 10. Given the du chains for a register r, the du webs can be efficiently calculated by computing the connected components (e.g. using depth first search) on the graph of du chains [68]. Similarly, the def def chains relation for the register r is the subset of the reaching defs relation that relates the definitions of r to other definitions of r. For example, 4 is a def def chain for variable j in Figure 7. The use def chains for a variable r are the subset of the reaching ....

[Article contains additional citation context not shown here]

David J. Kuck, R. H. Kuhn, David A. Padua, B. Leasure, and Michael Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth Annual ACM Symposium on Principles of Programming Languages, pages 207--218, Williamsburg, VA, January 1981.

....In section 7 we outhne several unresolved issues to be investigated in future work. 2 Data Dependence A data dependence exists between two statements S1 and S2 if there is a path from S1 to S2 and both statements access the same location in memory. There are four types of data dependence [8, 9]: True (flow) dependence S1 writes a memory location that S2 later reads. Anti dependence S1 reads a memory location that S2 later writes. Output dependence S1 writes a memory location that S2 later writes. Input dependence S1 reads a memory location that S2 later reads. Compile time ....

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. J. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth A CM Symposium on the Principles of Programming Languages, Wilhamsburg, VA, Jan. 1981.

....statement. 3.1 Program Information This section describes some information regarding the source program recorded by Parafrase 2 and the Paradigm compiler, and terms that we shall use in later discussions. Dependence Information The builddep pass in Parafrase 2 builds a data dependence graph [46] that keeps the information regarding all data dependences in a program. Each dependence is labeled as a flow, anti, or output dependence. Associated with each dependence edge representing a dependence from statement S1 to statement S2, both nested in n loops, is a direction vector (d 1 ; d 2 ; ....

D. J. Kuck, R. H. Kuhn, B. Leasure, D. A. Padua, and M. J. Wolfe. Dependence graphs and compiler optimizations. In Proc. Eighth ACM Symposium on Principles of Programming Languages, pages 207--218, January 1981.

....are, e.g. 29] 30] 33] Roughly speaking, a program slice is a subset of the program statements which (potentially) a#ect the values computed at some program point and or variable, referred to as a slicing criterion. Program slices are usually computed from a program dependence graph [14] [23]. Program dependencies can be traversed backwards or forwards (from the slicing criterion) which is known as backward or forward slicing, respectively. A survey on program slicing can be found, e.g. in [34] Many (online) partial evaluation schemes follow a common pattern: given a program and a ....

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimization. In Proc. of the 8th Symp. on the Principles of Programming Languages (POPL'81), SIGPLAN Notices, pages 207--218, 1981.

....[13, 21, 24, 25, 29] Roughly speaking, a program slice consists of those program statements which are (potentially) related with the values computed at some program point and or variable, referred to as a slicing criterion. Program slices are usually computed from a program dependence graph [10, 19] that makes explicit both the data and control dependences for each operation in a program. Program dependences can be traversed backwards or forwards (from the slicing criterion) which is known as backward or forward slicing, respectively. Additionally, slices can be dynamic or static, depending ....

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimization. In Proc. of the 8th Symp. on the Principles of Programming Languages (POPL'81), SIGPLAN Notices, pages 207-218, 1981.

....Microprocessors and Minicomputers in Instrumentation, Control, and Simula tion [16] both describe attempts at a diagrammatic representation for signal processing 12 algorithms. There is also some precedent for general diagrammatic languages, as in De pendence Graphs and Compiler Optimization [17]. None of these diagrammatic languages has appealed to a large programming community these languages have only been used in the small groups in which they were developed. A diagrammatic representation has greater difficulty denoting constructs such as conditional and loop expressions than a ....

D. J. Kuck, P. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimization. In Conference Record of the 8th A CM Symposium on the Principles of Programming Languages, pages 207-218, Association for Computing Machinery, January 1981.

....0 Q sC [NCLK STRIDE, Q= 0 STRIDE : NCLK, NCLK : 0, Q NCLK ; if (NCLK STRIDE) STRIDE : NCLK, NCLK : 0, Q ; STRIDE : NCLK, NCLK : 0, Q NCLK = STRIDE MAX CLK Figure 4: PAU entry state transition diagram an event such as a cache miss. The STRIDE field is a distance vector [3, 14], specifying the distance between the occurrence of events in the iteration space. The NCLKS field maintains the age of the entry symbolizing a window. Four state bits, INIT, TRANSIENT, ACTIVE and VALID, are used by the PAU to manage entries. The 0 field is a saturating counter that provides an ....

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. J. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth Annual ACM Symposium on the Principles of Programming Languages, Jan. 1981.

....this, a vector compiler can perform a series of transformations to mold the loop into a vectorizable form. The first is scalar expansion, which allocates a new element in a temporary array for each iteration of the loop [5] Loop fission is then used to divide the statements into separate loops [15]. The result of these transformations is shown in Figure 2 2(b) The first loop is vectorizable, but the second must be executed sequentially. Figure 2 2(c) shows the loop from the perspective of SLP. After unrolling, the four statements corresponding to the first statement in the original loop ....

D.J. Kuck, R.H. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In Proceedings of the 8th ACM Symposium on Priciples of Programming Languages, pages 207--218, Williamsburg, VA, Jan 1981.

....for straight line loops. Existing software pipelining techniques rely on conservative dependence analysis techniques, in which the dependence relationship between two node instances is determined by considering the iteration difference only [16] and is usually represented by data dependence graphs [17] or its extensions [18, 19] The above property holds for these representation techniques. In our work, we assume a similar memory dependence 7 x is live x is live x=a 1 x=b 2 z = f(x) x=a 1 t=b 2 x=t z=f(x) x=g( t=g( x=t t=g( a) b) Fig. 5. Copy operations used to overcome false dependences ....

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In SIGACT-SIGPLAN Symposium on Principles of Programming Languages, pages 207--218, 1981.

....loop body, and E is a set of arcs E = d ij S i , S j V representing dependence relations between statements of the loop. Between each pair of statements S i and S j , where S i precedes S j in the sequential execution of the loop, some data dependences are defined in the literature [KKPL81]. In our model only flow dependences are of concern [ChCh87] Statement S j is flow dependent on statement S i if S j uses a variable that S i can modify. Anti and output dependences due to the reuse of variables can be removed by assigning different variable names to different versions of ....

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure and M. Wolfe, "Dependence Graphs and Compiler Optimiza-tions", Proc. of the 8th ACM Symposium on Principles of Programming Languages Williamsburg, January 1981.

....procedures but also concurrency issues in the program. The SDN can be used as an underlaying representation to develop software engineering tools for occam 2 programs. 1 Introduction Program dependence representations are useful in program optimazation, vectorization, and parallelization [5, 13, 17] and also in developing software engineering tools [2, 4, 6, 8, 12] Recently, a number of program dependence representations have been presented for representing programs from different viewpoints. Ferrante et al. 5] presented a dependence representation called the program dependence graph (PDG) ....

D. Kuck, R.Kuhn, B. Leasure, D. Padua, M. Wolfe "Dependence Graphs and Compiler Optimizations, " Conference Record of the 8th Annual ACM Symposium on Principles of Programming Languages, pp.207-208, 1981.

....S j is said to be data dependent on S i (denoted S i d S j ) if S i is executed in the sequential execution before S j , both statements access the same scalar variable or element of a structured variable, and at least one statement writes the variable. Some data dependences are defined [KKPL81]: flow dependence appears when S j reads a variable that S i can write; antidependence appears when S i reads a variable that can be written by S j ; output dependence appears when both statements write the same variable. The statement S i is called the statement source and S j the statement ....

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure and M. Wolfe, "Dependence Graphs and Compiler Optimizations", Proc. of the 8th ACM Symposium on Principles of Programming Languages Williamsburg, January 1981.

....belong to different policies cooperate, the information must be transferred between them. A single piece of information transferred between rules is called a tag. Tags can be real, i.e. in the packet, or virtual, i.e. outside of the packet (see 2 Fig. 1) 1 A tag causes a data dependence [Kuc 81] between policy rules. Tags can be categorized into the following two. 1. Labels: A tag may be used for selecting a rule from a policy. This type of tag is called a label. A label connects one rule to another (i.e. the label assigned by one rule specifies the next rule to be applied) DSCPs ....

....default forwarding or best effort forwarding. Note that the two policies are ordered by the concatenation, and the two rules in these policies are connected by DSCP. The concatenation specifies a control dependence between the policies, and the DSCP specifies a data dependence (a flow dependence [Kuc 81] between them. Rules in the queuing policy in the concatenation may be as follows. # Rule Q1: if (DSCP is EF ) Scheduling Priority = 6; # Set an attribute for the scheduler. Enqueue; # Put the packet into a queue # until the scheduler pulls it off. 3 A set of primitive building ....

Kuck, D. J., Kuhn, R. H., Padua, D. H., Leasure, B., and Wolfe, M., "Dependence Graphs and Compiler Optimizations", 8th ACM Symposium on Principles of Programming Languages (POPL 81), pp. 207--218, 1981.

....or cannot make use of the available information to better schedule the instructions. The research presented in this thesis deals primarily with the last example. Chapter 2: Research Framework 26 There is wide body of literature which discusses compile time memory disambiguation techniques [Kuck81, Poly87]. Originally these techniques were used to facilitate the parallelization and vectorization of loops. Recent research shows that a simplified subset of them can be used to exploit instruction level parallelism on scalar processors [Goff93] This research is orthogonal to the work presented in this ....

....is loop unrolling. Loop unrolling creates artificial dependences due to naive reuse of registers. Register renaming is used to eliminate artificial dependences. Kuck discusses techniques such as scalar expansion and variable renaming that can eliminate antidependences and output dependences [Kuck81]. Techniques to eliminate dependences were implemented in the Bulldog and Cydra 5 compilers [Fish84] Mahlke discusses the effect on performance of renaming registers in an unrolled loop [Mahl92] To minimize conflicts and increase ILP, all register uses in the unrolled loop are assigned unique ....

Kuck, D. J., R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe, "Dependence graphs and compiler optimizations", Proceedings of the SIGPLAN `81 Symposium on Principles of Programming Languages, Jan 1981, pp. 207-281.

....in part by NSF grant DCR 8502884 and the Cornell NSF Supercomputing Center. 1 Existing high level language compilers for parallel machines do not provide the needed support for exploiting parallelism in microcode. Important advances in parallelizing ordinary code have been achieved [1] 4] [9]. Interesting work has also been done in the development of environments for supporting parallel computation [5] 15] However, this work has dealt with coarse grained parallelism and has provided support in con guring pre optimized modules into coherent concurrent systems. Because the ....

D.Kuck, R.Kuhn, D.Padua, B.Leasure and M.Wolfe. Dependence Graphs and Compiler Optimizations. Proceedings of POPL 81, ACM, pp. 207-218 (1981).

....use for cache memory. Section 7 presents some experimental results obtained using our algorithm on an IBM RS 6000. 2 General Framework 2.1 Data Dependencies In this paper we use the standard definitions for data dependencies. For details on the various definitions and loop transformations see [3, 10, 11, 14, 15]. The reason for using the framework of data dependence analysis, introduced initially for vectorization, is that vectorization and locality optimization have much in common. In the first problem, the issue is to detect whether a specific memory location is referenced at least twice in order to ....

Kuck D, Kuhn R, Leasure B, Wolfe, MJ. Dependence graphs and compiler optimizations, Proceedings of the Eighth Symposium on the Principles of Programming Languages, January 1981.

....bounds. This section presents modulo unrolling, a technique which enables the static promotion of all array accesses whose index expressions are affine functions of enclosing (c) b) a) for = 0 to 99 do endfor A[0] A[4] A[8] A[1] A[5] A[9] A[2] A[6] A[10] A[3] A[7] A[11] Tile 0 Tile 1 Tile 2 Tile 3 Unrolling Modulo for i = 0 to 99 step 4 do endfor A[ i 1] A[ i 2] A[ i 3] A[ i 0] A[ Figure 3. Example of array static promotion. a) shows the original code. b) shows the distribution of array A a Raw ....

....purposes by researchers. Some techniques for software pipeline [8] uses symbolic loop unrolling internally to decide the software pipeline schedule. Unrolling has been studied as a method to increase ILP by Weiss [14] and Davidson [5] Loop unrolling is typically combined with register renaming [11, 7] to increase ILP further by removing anti and output dependences. While RAWCC uses unrolling primarily for static promotion, it nevertheless obtains the benefit of the increased ILP as well. We have implemented renaming in our compiler using conventional techniques to fully exploit the benefits of ....

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In Proceedings of the ACM Symposium on Principles of Programming Languages, Jan 1981.

No context found.

# D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure, and M. Wolfe, "Dependence Graphs and Compiler Optimizations," Proc. Eighth ACM Symp. Principles of Programming Languages, pp. 207--218, Jan. 1981.

....not depend in any way upon the execution ordering of the data accesses from different iterations. In order to determine whether or not the execution order of the data accesses affects the semantics of the loop, the data dependence relations between the statements in the loop body must be analyzed [6, 17, 24, 34, 37]. There are three possible types of dependences between two statements that access the same memory location: flow (read after write) anti (write after read) and output (write after write) Flow dependences express a fundamental relationship about the data flow in the program. Anti and output ....

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proceedings of the 8th ACM Symposium on Principles of Programming Languages, pages 207--218, January 1981.

.... none of them has all of these properties (a comparison to previous work is contained in Section 4) 2 Preliminaries In order to guarantee the semantics of a loop, the parallel execution schedule for its iterations must respect the data dependence relations between the statements in the loop body [22, 15, 3, 32, 35]. There are three possible types of dependences between two statements that access the same memory location: flow (read after write) anti (write after read) and output (write after write) Flow dependences express a fundamental relationship about the data flow in the program. Anti and output ....

D. J. Kuck, R. H. Kuhn, B. Leasure, D. A. Padua, and M. Wolfe. Dependence graphs and compiler optimizations. In Proc. of 8th ACM Symp. Princip. Prog. Lang., pp. 207--218, Jan. 1981.

No context found.

Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations," pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York (1981).

No context found.

Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations, " pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), (1981).

No context found.

Kuck, D. J., Kahn, R. H., Padua, D. A., Leasure, B., and Wolfe, M. Dependence graphs and compiler optimizations. In Proceedings of the Eighth Annual ACM Symposium on Principles of Programming Languages (Jan. 1981), pp. 207--218.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eight ACM Symposium on the Principles of Programming Languages, 1981.

No context found.

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimization. In Proc. of the 8th Symp. on the Principles of Programming Languages (POPL'81), SIGPLAN Notices, pages 207--218, 1981.

No context found.

D.J. Kuck, R.H. Kuhn, D.A. Padua, B. Leasure and M. Wolfe, "Dependence Graphs and Compiler Optimiza-tions", Proc. of the 8th ACM Symposium on Principles of Programming Languages Williamsburg, January 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. J. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth Annual ACM Symposium on the Principles of Programming Languages, pages 207--218, Williamsburg, VA, January 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, D. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proceedings of the ACM Symposium on Principles of Programming Languages, 1981.

No context found.

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe, "Dependence Graphs and Compiler Optimizations," Conference Record of the 8th Annual ACM Symposium on Principles of Programming Languages, January 1981, pp.207--218.

No context found.

Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations, " pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York, NY (1981).

No context found.

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proc. ACM Symp. on Principles of Programming Languages, pages 207--218, Jan. 1981.

No context found.

Kuck, D. J., Kuhn, R. H., Padua, D. H., Leasure, B., and Wolfe, M., "Dependence Graphs and Compiler Optimizations", 8th ACM Symposium on Principles of Programming Languages (POPL 81), pp. 207--218, 1981.

No context found.

David J. Kuck, R. H. Kuhn, David A. Padua, B. Leasure, and Michael Wolfe. Dependence graphs and compiler optimizations. In ACM Symposium on Principles of Programming Languages (POPL), pages 207--218, Williamsburg, VA, January 1981.

No context found.

Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations," pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York, NY (1981).

No context found.

D. J. Kuck et al., \Dependence Graphs and Compiler Optimizations", in Proceedings of the 8th ACM Symposium on Principles of Programming Languages (POPL '81) (Williamsburg, Virginia, Jan. 1981.

No context found.

Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., "Dependence graphs and compiler optimizations," pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), (1981).

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In Proc. of the 8th ACM Symposium on Principles of Programming Languages, pages 207--218, 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In ACM Symposium on Principles of Programming Languages (POPL), pages 207--218, Williamsburg, Virginia, January 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In Proc. of the 8th ACM Symposium on Principles of Programming Languages, pages 207--218, 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proc. ACM Symp. on Principles of Prog. Langs., pages 207--218, Jan. 1981.

No context found.

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe. Dependence graphs and compiler optimizations. In Proc. ACM Symp. on Principles of Programming Languages (POPL), pages 207--218, Jan. 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. Wolfe. Dependence Graphs and Compiler Optimizations. In Proc. of the 8th ACM Symposium on Principles of Programming Languages, pages 207--218, 1981.

No context found.

D. J. Kuck, R. Kuhn, B. Leasure, D. Padua, and M. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth Annual Symposium on Principles of Programming Languages. ACM, January 1981.

No context found.

D. J. Kuck, R. H. Kuhn, B. Leasure, D. A. Padua, and M. Wolfe. Dependence graphs and compiler optimizations. In Proceedings of the ACM Symposium on Principles of Programming Languages, pages 207--218. ACM Press, 1981.

No context found.

Kuck81. Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., Dependence graphs and compiler optimizations, pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York, NY (1981).

No context found.

Kuck81. Kuck, D.J., Kuhn, R.H., Leasure, B., Padua, D.A., and Wolfe, M., Dependence graphs and compiler optimizations, pp. 207-218 in Conference Record of the Eighth ACM Symposium on Principles of Programming Languages, (Williamsburg, VA, January 26-28, 1981), ACM, New York, NY (1981).

No context found.

D. J. Kuck, R. H. Kuhn, D. A. Padua, B. Leasure, and M. Wolfe, "Dependence graphs and compiler optimizations," in Proceedings of the 8th ACM Symposium of Principles of Programming Languages, pp. 207--218, ACM, 1981.

No context found.

D. Kuck, R. Kuhn, D. Padua, B. Leasure, and M. J. Wolfe. Dependence graphs and compiler optimizations. In Conference Record of the Eighth AnnualACM Symposiumon the Principles of ProgrammingLanguages, Williamsburg, VA, January 1981.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC