DOCSLIB.ORG

UNIT VI CODE OPTIMIZATION Introduction:  Code Optimization Is Required to Produce an Efficient Target Code

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

UNIT-VI COMPILER DESIGN UNIT VI CODE OPTIMIZATION Introduction: Code Optimization is required to produce an efficient target code. Elimination of unnecessary instructions in object code or the replacement of one sequence of instruction by a faster sequence of instructions that does the same thing is usually called code improvement or code optimization. In code optimization, we need to take care of the semantic equivalence of the source program. The improvement over the program efficiency must be achieved without changing the algorithm of the program. Code becomes inefficient because of two factors: such as, Programmer & Compiler. Code optimization can be performed in different phases of a compiler. Such as, In Front end: Programmer can make use of efficient algorithm In ICG phase: Apply Transformations on loops, procedure calls and address calculation. In Code generation: Use registers, Select appropriate instructions and apply peephole optimization. Types of optimization: Optimization is of two types such as, Machine Dependent optimization and Machine independent optimization. The machine dependent optimization is based on characteristics of the target machine (the instruction set used and addressing modes used for the instructions) to generate efficient target code. The machine independent optimization is based on the characteristics of the programming languages for appropriate programming structure and usage of efficient arithmetic properties in order to reduce execution time. 1 | P a g e UNIT-VI COMPILER DESIGN Machine dependant optimization can be achieved by Allocating sufficient number of resources to improve the execution efficiency of the program and by using immediate instruction wherever necessary. Machine independent code optimization can be achieved by analysing the code and using alternative equivalent source code that will produce minimum amount of target code. Or using appropriate program structure in order to improve the efficiency of the code. Eliminating unreachable code etc. Semantic Preserving Transformations: Semantic preserving transformation means the ways in which a compiler can improve a program without changing the function it computes. Several such techniques are, o Common sub-expression elimination o Copy Propagation o Dead Code elimination o Constant folding o Strength Reduction o Loop optimization Common sub-expression elimination: The common sub expression is an expression appearing repeatedly in the program which is computed previously. Then if the operands of this sub expression do not get changed at all then result of such sub expression is used instead of recomputing it each time. t1=4*I; t1=4*I; t2=a[t1] t2=a[t1] t3=4*j t3=4*j t4=4*I Can be written as t5=n; t5=n; t6=b[t1]+t5 t6=b[t4]+t5 2 | P a g e UNIT-VI COMPILER DESIGN Copy Propagation In compiler theory, copy propagation is the process of replacing the occurrences of targets of direct assignments with their values. A direct assignment is an instruction of the form x = y, which simply assigns the value of y to x. Example 1: y = x z = 3 + y copy propagation would yield z=3+x Example 2: x=pi; área= x * r * r; can be written as, área=pi*r*r Dead Code Elimination A variable is said to be live in a program if the value contained into it is used subsequently. On the other hand, the variable is said to be dead at a point in a program if the value contained into it is never been used. The code containing such a variable is called as dead code and hence can be eliminated. Example 1: i=j; … X=i+10 Optimization can be done by eliminating the assignment statement i=j. Example 2: i=0 if(i=1) { a=x+5; } 3 | P a g e UNIT-VI COMPILER DESIGN Here, the statement in the if block is called as dead code which can be eliminated. Because the condition never gets true and the statement will never get executed. Constant Folding: In the folding technique the computation of constant is done at compile time instead of execution time. E.g length=(22/7)*d; Here, folding is implied by performing the computation 22/7 at compile time instead of execution time. Strength Reduction: The strength of certain operators is higher than others. For instance strength of * (multiplication) Is higher than + (addition). In strength reduction technique the higher strength operators can be replaced by lower strength operators. Example: for (i=1;i<=50;i++) { count=i*7; } This code can be replace by using strength reduction as follows Temp=7; for(i=1;i<=50;i++) { count=temp; temp=temp+7; } 4 | P a g e UNIT-VI COMPILER DESIGN Loop Optimization: Code optimization can be done in loops in a program. Specially inner loop is a place where program spends large amount of time. Hence if number of instructions are less in inner loop then the running time of the program will get decreased to a large extent. Hence loop optimization is a technique in which code optimization performed in inner loops. The loop optimization is carried out using following methods. o Code motion( Loop invariant method) o strength reduction o Loop unrolling o Loop fusion Code motion: Code motion is a technique which moves the code outside the loop. Hence the name. If there lies some expression in the loop whose result remains unchanged even after executing the loop several times, then such an expression should be placed just before the loop.(outside the loop) E.g. while(i<=max-1) { sum = sum + a[i]; } Here, the above loop can be optimized by using the statement max-1 outside the loop. Strength Reduction: The strength of certain operators is higher than others. For instance strength of * (multiplication) Is higher than + (addition). In strength reduction technique the higher strength operators can be replaced by lower strength operators. 5 | P a g e UNIT-VI COMPILER DESIGN Example: for (i=1;i<=50;i++) { count=i*7; } This code can be replace by using strength reduction as follows Temp=7; for(i=1;i<=50;i++) { count=temp; temp=temp+7; } Loop Unrolling In this method the number of jumps and tests can be reduced by writing the code multiple times. Int i=1; While(i<=100) Int i=1; { While(i<=100) A[i]=b[i]; { i++; A[i]=b[i]; Can be written as A[i]=b[i]; i++; i++; } } Here, the same code present inside the loop is written twice so as to minimize number of jumps to the while condition. In this case, the number of condition check is reduced by 50%. 6 | P a g e UNIT-VI COMPILER DESIGN Loop fusion or loop Jamming: In loop fusion or loop jamming, several loops are merged if they have same number of iterations and they use same indices. This eliminates test of one loop. Example: for(i=0;i<10;i++) for(i=0;i<10;i++) for(j=0;j<10;j++) { X[i,j]=0; for(j=0;j<10;j++) for(i=0;i<10;i++) X[i,j]=0; X[i,j]=1; X[i,j]=1; } Procedure Inline: When we define a procedure, normally the compiler makes a copy of that definition in the memory and when a call to that procedure is made, the compiler jumps to these copied instructions. When the control returns from the procedure, the execution resumes from the next line in the calling function. Hence, if we make a call to that procedure multiple times, then the control is transferred multiple times to refer the same copy of the definition If the procedure contains less lines of code, then these frequent jumps will increase the performance overhead of the program. (slows down the execution) Hence the solution is make the procedure inline. The inline procedure is a function type of procedure whose code is copied in place of the procedure call. The inline specifies that the compiler should insert the complete body at the place of function call. In this way we can minimize frequent jumps but it may increase memory requirements of the program.(Hence, only small functions are preferred to make inline). 7 | P a g e UNIT-VI COMPILER DESIGN Example: inline function in C++ programming. #include<iostream.h> inline int sum(int x, int y) { return(x+y); } void main() { int a,b; a=10;b=20; cout<<“The sum is:”<<sum(a,b); } Instruction scheduling: The order of three-address code affects the cost of the object code being generated. i.e. by changing the order in which computations are done, we can obtain the object code with minimum cost. Code optimization can be achieved by scheduling the instructions in proper order. This technique is called as instruction scheduling. For example: consider the expression (a+b)+(e+(c-d)) Mov R0,a t1=a+b ADD R0,b Mov R0,c Mov R1,c t2=c- d Sub R0,d t2=c-d Sub R1,d t3=e+t2 Mov R1,e t3=e+t2 t4=t1+t3 Mov t1,R0 t1=a+b Add R1,R0 t4=t1+t3 Move Ro,e Mov R0,a Add R1,R0 Add R0,b Mov R0,t1 Scheduled Add R0,R1 Add R0,R1 Mov t4,R0 Move t4,R0 8 | P a g e UNIT-VI COMPILER DESIGN Interprocedural Optimization (IPO): In this technique, collection of optimization techniques are used to improve the performance of the program that contain many frequently used functions or blocks. IPO eliminates duplicate calculations, inefficient use of memory and simplifies loops. IPO may re-order the routines for better memory utilization. The compiler tests for branches that are never taken and removes the code in that branch.
Recommended publications
  • CS153: Compilers Lecture 19: Optimization

    CS153: Compilers Lecture 19: Optimization

    CS153: Compilers Lecture 19: Optimization Stephen Chong https://www.seas.harvard.edu/courses/cs153 Contains content from lecture notes by Steve Zdancewic and Greg Morrisett Announcements •HW5: Oat v.2 out •Due in 2 weeks •HW6 will be released next week •Implementing optimizations! (and more) Stephen Chong, Harvard University 2 Today •Optimizations •Safety •Constant folding •Algebraic simplification • Strength reduction •Constant propagation •Copy propagation •Dead code elimination •Inlining and specialization • Recursive function inlining •Tail call elimination •Common subexpression elimination Stephen Chong, Harvard University 3 Optimizations •The code generated by our OAT compiler so far is pretty inefficient. •Lots of redundant moves. •Lots of unnecessary arithmetic instructions. •Consider this OAT program: int foo(int w) { var x = 3 + 5; var y = x * w; var z = y - 0; return z * 4; } Stephen Chong, Harvard University 4 Unoptimized vs. Optimized Output .globl _foo _foo: •Hand optimized code: pushl %ebp movl %esp, %ebp _foo: subl $64, %esp shlq $5, %rdi __fresh2: movq %rdi, %rax leal -64(%ebp), %eax ret movl %eax, -48(%ebp) movl 8(%ebp), %eax •Function foo may be movl %eax, %ecx movl -48(%ebp), %eax inlined by the compiler, movl %ecx, (%eax) movl $3, %eax so it can be implemented movl %eax, -44(%ebp) movl $5, %eax by just one instruction! movl %eax, %ecx addl %ecx, -44(%ebp) leal -60(%ebp), %eax movl %eax, -40(%ebp) movl -44(%ebp), %eax Stephen Chong,movl Harvard %eax,University %ecx 5 Why do we need optimizations? •To help programmers… •They write modular, clean, high-level programs •Compiler generates efficient, high-performance assembly •Programmers don’t write optimal code •High-level languages make avoiding redundant computation inconvenient or impossible •e.g.
  • Strength Reduction of Induction Variables and Pointer Analysis – Induction Variable Elimination

    Strength Reduction of Induction Variables and Pointer Analysis – Induction Variable Elimination

    Loop optimizations • Optimize loops – Loop invariant code motion [last time] Loop Optimizations – Strength reduction of induction variables and Pointer Analysis – Induction variable elimination CS 412/413 Spring 2008 Introduction to Compilers 1 CS 412/413 Spring 2008 Introduction to Compilers 2 Strength Reduction Induction Variables • Basic idea: replace expensive operations (multiplications) with • An induction variable is a variable in a loop, cheaper ones (additions) in definitions of induction variables whose value is a function of the loop iteration s = 3*i+1; number v = f(i) while (i<10) { while (i<10) { j = 3*i+1; //<i,3,1> j = s; • In compilers, this a linear function: a[j] = a[j] –2; a[j] = a[j] –2; i = i+2; i = i+2; f(i) = c*i + d } s= s+6; } •Observation:linear combinations of linear • Benefit: cheaper to compute s = s+6 than j = 3*i functions are linear functions – s = s+6 requires an addition – Consequence: linear combinations of induction – j = 3*i requires a multiplication variables are induction variables CS 412/413 Spring 2008 Introduction to Compilers 3 CS 412/413 Spring 2008 Introduction to Compilers 4 1 Families of Induction Variables Representation • Basic induction variable: a variable whose only definition in the • Representation of induction variables in family i by triples: loop body is of the form – Denote basic induction variable i by <i, 1, 0> i = i + c – Denote induction variable k=i*a+b by triple <i, a, b> where c is a loop-invariant value • Derived induction variables: Each basic induction variable i defines
  • Lecture Notes on Peephole Optimizations and Common Subexpression Elimination

    Lecture Notes on Peephole Optimizations and Common Subexpression Elimination

    Lecture Notes on Peephole Optimizations and Common Subexpression Elimination 15-411: Compiler Design Frank Pfenning and Jan Hoffmann Lecture 18 October 31, 2017 1 Introduction In this lecture, we discuss common subexpression elimination and a class of optimiza- tions that is called peephole optimizations. The idea of common subexpression elimination is to avoid to perform the same operation twice by replacing (binary) operations with variables. To ensure that these substitutions are sound we intro- duce dominance, which ensures that substituted variables are always defined. Peephole optimizations are optimizations that are performed locally on a small number of instructions. The name is inspired from the picture that we look at the code through a peephole and make optimization that only involve the small amount code we can see and that are indented of the rest of the program. There is a large number of possible peephole optimizations. The LLVM com- piler implements for example more than 1000 peephole optimizations [LMNR15]. In this lecture, we discuss three important and representative peephole optimiza- tions: constant folding, strength reduction, and null sequences. 2 Constant Folding Optimizations have two components: (1) a condition under which they can be ap- plied and the (2) code transformation itself. The optimization of constant folding is a straightforward example of this. The code transformation itself replaces a binary operation with a single constant, and applies whenever c1 c2 is defined. l : x c1 c2 −! l : x c (where c =
  • Generalizing Loop-Invariant Code Motion in a Real-World Compiler

    Generalizing Loop-Invariant Code Motion in a Real-World Compiler

    Imperial College London Department of Computing Generalizing loop-invariant code motion in a real-world compiler Author: Supervisor: Paul Colea Fabio Luporini Co-supervisor: Prof. Paul H. J. Kelly MEng Computing Individual Project June 2015 Abstract Motivated by the perpetual goal of automatically generating efficient code from high-level programming abstractions, compiler optimization has developed into an area of intense research. Apart from general-purpose transformations which are applicable to all or most programs, many highly domain-specific optimizations have also been developed. In this project, we extend such a domain-specific compiler optimization, initially described and implemented in the context of finite element analysis, to one that is suitable for arbitrary applications. Our optimization is a generalization of loop-invariant code motion, a technique which moves invariant statements out of program loops. The novelty of the transformation is due to its ability to avoid more redundant recomputation than normal code motion, at the cost of additional storage space. This project provides a theoretical description of the above technique which is fit for general programs, together with an implementation in LLVM, one of the most successful open-source compiler frameworks. We introduce a simple heuristic-driven profitability model which manages to successfully safeguard against potential performance regressions, at the cost of missing some speedup opportunities. We evaluate the functional correctness of our implementation using the comprehensive LLVM test suite, passing all of its 497 whole program tests. The results of our performance evaluation using the same set of tests reveal that generalized code motion is applicable to many programs, but that consistent performance gains depend on an accurate cost model.
  • A Tiling Perspective for Register Optimization Fabrice Rastello, Sadayappan Ponnuswany, Duco Van Amstel

    A Tiling Perspective for Register Optimization Fabrice Rastello, Sadayappan Ponnuswany, Duco Van Amstel

    A Tiling Perspective for Register Optimization Fabrice Rastello, Sadayappan Ponnuswany, Duco van Amstel To cite this version: Fabrice Rastello, Sadayappan Ponnuswany, Duco van Amstel. A Tiling Perspective for Register Op- timization. [Research Report] RR-8541, Inria. 2014, pp.24. hal-00998915 HAL Id: hal-00998915 https://hal.inria.fr/hal-00998915 Submitted on 3 Jun 2014 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. A Tiling Perspective for Register Optimization Łukasz Domagała, Fabrice Rastello, Sadayappan Ponnuswany, Duco van Amstel RESEARCH REPORT N° 8541 May 2014 Project-Teams GCG ISSN 0249-6399 ISRN INRIA/RR--8541--FR+ENG A Tiling Perspective for Register Optimization Lukasz Domaga la∗, Fabrice Rastello†, Sadayappan Ponnuswany‡, Duco van Amstel§ Project-Teams GCG Research Report n° 8541 — May 2014 — 21 pages Abstract: Register allocation is a much studied problem. A particularly important context for optimizing register allocation is within loops, since a significant fraction of the execution time of programs is often inside loop code. A variety of algorithms have been proposed in the past for register allocation, but the complexity of the problem has resulted in a decoupling of several important aspects, including loop unrolling, register promotion, and instruction reordering.
  • Efficient Symbolic Analysis for Optimizing Compilers*

    Efficient Symbolic Analysis for Optimizing Compilers*

    Efficient Symbolic Analysis for Optimizing Compilers? Robert A. van Engelen Dept. of Computer Science, Florida State University, Tallahassee, FL 32306-4530 [email protected] Abstract. Because most of the execution time of a program is typically spend in loops, loop optimization is the main target of optimizing and re- structuring compilers. An accurate determination of induction variables and dependencies in loops is of paramount importance to many loop opti- mization and parallelization techniques, such as generalized loop strength reduction, loop parallelization by induction variable substitution, and loop-invariant expression elimination. In this paper we present a new method for induction variable recognition. Existing methods are either ad-hoc and not powerful enough to recognize some types of induction variables, or existing methods are powerful but not safe. The most pow- erful method known is the symbolic differencing method as demonstrated by the Parafrase-2 compiler on parallelizing the Perfect Benchmarks(R). However, symbolic differencing is inherently unsafe and a compiler that uses this method may produce incorrectly transformed programs without issuing a warning. In contrast, our method is safe, simpler to implement in a compiler, better adaptable for controlling loop transformations, and recognizes a larger class of induction variables. 1 Introduction It is well known that the optimization and parallelization of scientific applica- tions by restructuring compilers requires extensive analysis of induction vari- ables and dependencies
  • Using Static Single Assignment SSA Form

    Using Static Single Assignment SSA Form

    Using Static Single Assignment SSA form Last Time B1 if (. ) B1 if (. ) • Basic definition, and why it is useful j j B2 x ← 5 B3 x ← 3 B2 x0 ← 5 B3 x1 ← 3 • How to build it j j B4 y ← x B4 x2 ← !(x0,x1) Today y ← x2 • Loop Optimizations – Induction variables (standard vs. SSA) – Loop Invariant Code Motion (SSA based) CS502 Using SSA 1 CS502 Using SSA 2 Loop Optimization Classical Loop Optimizations Loops are important, they execute often • typically, some regular access pattern • Loop Invariant Code Motion regularity ⇒ opportunity for improvement • Induction Variable Recognition repetition ⇒ savings are multiplied • Strength Reduction • assumption: loop bodies execute 10depth times • Linear Test Replacement • Loop Unrolling CS502 Using SSA 3 CS502 Using SSA 4 Other Loop Optimizations Loop Invariant Code Motion Other Loop Optimizations • Build the SSA graph semi-pruned • Scalar replacement • Need insertion of !-nodes: If two non-null paths x →+ z and y →+ z converge at node z, and nodes x • Loop Interchange and y contain assignments to t (in the original program), then a !-node for t must be inserted at z (in the new program) • Loop Fusion and t must be live across some basic block Simple test: • Loop Distribution If, for a statement s ≡ [x ← y ⊗ z], none of the operands y,z refer to a !-node or definition inside the loop, then • Loop Skewing Transform: assign the invariant computation a new temporary name, t ← y ⊗ z, move • Loop Reversal it to the loop pre-header, and assign x ← t. CS502 Using SSA 5 CS502 Using SSA 6 Loop Invariant Code
  • Loop Transformations and Parallelization

    Loop Transformations and Parallelization

    Loop transformations and parallelization Claude Tadonki LAL/CNRS/IN2P3 University of Paris-Sud [email protected] December 2010 Claude Tadonki Loop transformations and parallelization C. Tadonki – Loop transformations Introduction Most of the time, the most time consuming part of a program is on loops. Thus, loops optimization is critical in high performance computing. Depending on the target architecture, the goal of loops transformations are: improve data reuse and data locality efficient use of memory hierarchy reducing overheads associated with executing loops instructions pipeline maximize parallelism Loop transformations can be performed at different levels by the programmer, the compiler, or specialized tools. At high level, some well known transformations are commonly considered: loop interchange loop (node) splitting loop unswitching loop reversal loop fusion loop inversion loop skewing loop fission loop vectorization loop blocking loop unrolling loop parallelization Claude Tadonki Loop transformations and parallelization C. Tadonki – Loop transformations Dependence analysis Extract and analyze the dependencies of a computation from its polyhedral model is a fundamental step toward loop optimization or scheduling. Definition For a given variable V and given indexes I1, I2, if the computation of X(I1) requires the value of X(I2), then I1 ¡ I2 is called a dependence vector for variable V . Drawing all the dependence vectors within the computation polytope yields the so-called dependencies diagram. Example The dependence vectors are (1; 0); (0; 1); (¡1; 1). Claude Tadonki Loop transformations and parallelization C. Tadonki – Loop transformations Scheduling Definition The computation on the entire domain of a given loop can be performed following any valid schedule.A timing function tV for variable V yields a valid schedule if and only if t(x) > t(x ¡ d); 8d 2 DV ; (1) where DV is the set of all dependence vectors for variable V .
  • Code Optimizations Recap Peephole Optimization

    Code Optimizations Recap Peephole Optimization

    7/23/2016 Program Analysis Recap https://www.cse.iitb.ac.in/~karkare/cs618/ • Optimizations Code Optimizations – To improve efficiency of generated executable (time, space, resources …) Amey Karkare – Maintain semantic equivalence Dept of Computer Science and Engg • Two levels IIT Kanpur – Machine Independent Visiting IIT Bombay [email protected] – Machine Dependent [email protected] 2 Peephole Optimization Peephole optimization examples… • target code often contains redundant Redundant loads and stores instructions and suboptimal constructs • Consider the code sequence • examine a short sequence of target instruction (peephole) and replace by a Move R , a shorter or faster sequence 0 Move a, R0 • peephole is a small moving window on the target systems • Instruction 2 can always be removed if it does not have a label. 3 4 1 7/23/2016 Peephole optimization examples… Unreachable code example … Unreachable code constant propagation • Consider following code sequence if 0 <> 1 goto L2 int debug = 0 print debugging information if (debug) { L2: print debugging info } Evaluate boolean expression. Since if condition is always true the code becomes this may be translated as goto L2 if debug == 1 goto L1 goto L2 print debugging information L1: print debugging info L2: L2: The print statement is now unreachable. Therefore, the code Eliminate jumps becomes if debug != 1 goto L2 print debugging information L2: L2: 5 6 Peephole optimization examples… Peephole optimization examples… • flow of control: replace jump over jumps • Strength reduction
  • Compiler-Based Code-Improvement Techniques

    Compiler-Based Code-Improvement Techniques

    Compiler-Based Code-Improvement Techniques KEITH D. COOPER, KATHRYN S. MCKINLEY, and LINDA TORCZON Since the earliest days of compilation, code quality has been recognized as an important problem [18]. A rich literature has developed around the issue of improving code quality. This paper surveys one part of that literature: code transformations intended to improve the running time of programs on uniprocessor machines. This paper emphasizes transformations intended to improve code quality rather than analysis methods. We describe analytical techniques and specific data-flow problems to the extent that they are necessary to understand the transformations. Other papers provide excellent summaries of the various sub-fields of program analysis. The paper is structured around a simple taxonomy that classifies transformations based on how they change the code. The taxonomy is populated with example transformations drawn from the literature. Each transformation is described at a depth that facilitates broad understanding; detailed references are provided for deeper study of individual transformations. The taxonomy provides the reader with a framework for thinking about code-improving transformations. It also serves as an organizing principle for the paper. Copyright 1998, all rights reserved. You may copy this article for your personal use in Comp 512. Further reproduction or distribution requires written permission from the authors. 1INTRODUCTION This paper presents an overview of compiler-based methods for improving the run-time behavior of programs — often mislabeled code optimization. These techniques have a long history in the literature. For example, Backus makes it quite clear that code quality was a major concern to the implementors of the first Fortran compilers [18].
  • Redundant Computation Elimination Optimizations

    Redundant Computation Elimination Optimizations

    Redundant Computation Elimination Optimizations CS2210 Lecture 20 CS2210 Compiler Design 2004/5 Redundancy Elimination ■ Several categories: ■ Value Numbering ■ local & global ■ Common subexpression elimination (CSE) ■ local & global ■ Loop-invariant code motion ■ Partial redundancy elimination ■ Most complex ■ Subsumes CSE & loop-invariant code motion CS2210 Compiler Design 2004/5 Value Numbering ■ Goal: identify expressions that have same value ■ Approach: hash expression to a hash code ■ Then have to compare only expressions that hash to same value CS2210 Compiler Design 2004/5 1 Example a := x | y b := x | y t1:= !z if t1 goto L1 x := !z c := x & y t2 := x & y if t2 trap 30 CS2210 Compiler Design 2004/5 Global Value Numbering ■ Generalization of value numbering for procedures ■ Requires code to be in SSA form ■ Crucial notion: congruence ■ Two variables are congruent if their defining computations have identical operators and congruent operands ■ Only precise in SSA form, otherwise the definition may not dominate the use CS2210 Compiler Design 2004/5 Value Graphs ■ Labeled, directed graph ■ Nodes are labeled with ■ Operators ■ Function symbols ■ Constants ■ Edges point from operator (or function) to its operands ■ Number labels indicate operand position CS2210 Compiler Design 2004/5 2 Example entry receive n1(val) i := 1 1 B1 j1 := 1 i3 := φ2(i1,i2) B2 j3 := φ2(j1,j2) i3 mod 2 = 0 i := i +1 i := i +3 B3 4 3 5 3 B4 j4:= j3+1 j5:= j3+3 i2 := φ5(i4,i5) j3 := φ5(j4,j5) B5 j2 > n1 exit CS2210 Compiler Design 2004/5 Congruence Definition ■ Maximal relation on the value graph ■ Two nodes are congruent iff ■ They are the same node, or ■ Their labels are constants and the constants are the same, or ■ They have the same operators and their operands are congruent ■ Variable equivalence := x and y are equivalent at program point p iff they are congruent and their defining assignments dominate p CS2210 Compiler Design 2004/5 Global Value Numbering Algo.
  • Autotuning for Automatic Parallelization on Heterogeneous Systems

    Autotuning for Automatic Parallelization on Heterogeneous Systems

    Autotuning for Automatic Parallelization on Heterogeneous Systems Zur Erlangung des akademischen Grades eines Doktors der Ingenieurwissenschaften von der KIT-Fakultät für Informatik des Karlsruher Instituts für Technologie (KIT) genehmigte Dissertation von Philip Pfaffe ___________________________________________________________________ ___________________________________________________________________ Tag der mündlichen Prüfung: 24.07.2019 1. Referent: Prof. Dr. Walter F. Tichy 2. Referent: Prof. Dr. Michael Philippsen Abstract To meet the surging demand for high-speed computation in an era of stagnat- ing increase in performance per processor, systems designers resort to aggregating many and even heterogeneous processors into single systems. Automatic paral- lelization tools relieve application developers of the tedious and error prone task of programming these heterogeneous systems. For these tools, there are two aspects to maximizing performance: Optimizing the execution on each parallel platform individually, and executing work on the available platforms cooperatively. To date, various approaches exist targeting either aspect. Automatic parallelization for simultaneous cooperative computation with optimized per-platform execution however remains an unsolved problem. This thesis presents the APHES framework to close that gap. The framework com- bines automatic parallelization with a novel technique for input-sensitive online autotuning. Its first component, a parallelizing polyhedral compiler, transforms implicitly data-parallel program parts for multiple platforms. Targeted platforms then automatically cooperate to process the work. During compilation, the code is instrumented to interact with libtuning, our new autotuner and second com- ponent of the framework. Tuning the work distribution and per-platform execu- tion maximizes overall performance. The autotuner enables always-on autotuning through a novel hybrid tuning method, combining a new efficient search technique and model-based prediction.