Global Optimizations
|
|
- Tyrone Bates
- 5 years ago
- Views:
Transcription
1 Global Optimizations Avi Hayoun, Ben Eyal and Lior Zur-Lotan January 9, 2017 Contents 1 Global Optimizations Basic Blocks and Control-Flow graphs Control-Flow Graph Example Global CSE and CP Common Subexpression Elimination Copy Propagation Available Expressions analysis Example Analysis Initial state st iteration nd iteration rd iteration th iteration th iteration th iteration th iteration Last iteration Optimization Global Optimizations Global optimizations and analyses are performed in the context of a whole, single function - given an entire control ow graph of a function. 1.1 Basic Blocks and Control-Flow graphs A basic block is a sequence of IR instructions that has no goto instructions in it, except, maybe, as its last instruction. It has a single entry point (the rst instruction) and a single exit point (the last instruction). 1 Local Optimizations and analyses are performed in the context of single Basic 1 For the purpose of structuring the code of a given function into basic blocks, function calls are considered atomic instructions and not control-ow operators. 1
2 Blocks. A Control Flow graph is a directed graph, where nodes correspond to Basic Blocks. There's an edge between one block and another if execution control can move between the two (if there is a goto from the end of the rst to the beginning of the other). We also add 2 nodes: start (or Entry) and end (or Exit) Control-Flow Graph Example Consider the following IR: 1 x := y + 1; 2 3 t0 := call ReadInput; 4 ifz t0 goto LElse; 5 z := x + 1; 6 goto LFinish; 7 LElse: 8 z := y + 1; 9 LFinish; 10 w := y; 11 LLoop: 12 a := w + 1; 13 t0 := call ReadInput; 14 b := a >= t0 15 x := t0; 16 ifnz x goto LEnd: 17 ifz b goto LLoop: 18 LEnd: The CFG for the above code is: 2 Global CSE and CP Common Subexpression Elimination (CSE) and Copy Propagation (CP) are optimizations achieved by substituting expressions. 2.1 Common Subexpression Elimination This optimization searches for common arithmetic expressions between statements and, if possible, substitutes the second arithmetic operation with the result of the rst. For instance: Given the code 1 _t0 := x + 1; 2 y := _t0 * 2; 3 z := x + 1; 2
3 We can reuse _t0 and eliminate the second computation of x + 1, and we get: 1 _t0 := x + 1; 2 y := _t0 * 2; 3 z := _t0 On top of removing redundant computations CSE is used as a pre-step for other optimizations (e.g. Dead Code Elimination) 2.2 Copy Propagation This optimization means that we look for references to variables that were assigned to another variable (i.e. x := y). We replace the reference to one with the reference to the other. For instance, consider the following code: 1 x := _tmp0 + 1; 2 y := x; 3 w := y + 1; 4 z := x + 1; We can replace the x in z := x + 1 with y and get: 1 x := _tmp0 + 1; 2 y := x; 3 w := y + 1; 4 z := y + 1; 3
4 It may seem meaningless, but CP is used as a pre-step for other optimizations (e.g. CSE or Dead Code Elimination). It removed redundent assignments between variables that hide possible subexpressions or assignments from being removed. 2.3 Available Expressions analysis To perform global CSE or CP we must take the entire CFG and apply the Available Expressions analysis on it. Given a CFG we need to know which expression is stored in which variable at each point of the code. Because we are handling code that includes branching, we need to take code branching into account including, how to unite sets of available expressions from two branches. For this we dene 2 notions for each statement: ˆ IN[s] = set of (var, expression) pairs that are available right before executing s ˆ OUT [s] = set of (var, expression) pairs that are available right after executing s To calculate these sets, let s be a statement of the form "a := expr": ˆ $ OUT[s] = (IN[s] {(a, expr)}) \ {s' = (v, e) IN[s] USE(s ) DEF(s)\ (s' s v DEF(s))}$ ˆ $ IN[s] = {OUT[p] p CFG.Parents(s)}$ Reminder: DEF (s) - the variables possibly modied by statement s. USE(s) - the variables read by statement s. An algorithm for computing the IN and OUT sets for a CFG: 1 for var in CFG.vars: 2 for expression in CFG.expressions: 3 for block in CFG: 4 add (var, expression) to OUT[block] 5 OUT[Entry] = 6 while Not at fixed point: 7 block = choose SimpleBlock from CFG 8 for s=(var, expr) in block.statements: # Iterate block statements in order 9 IN[s] = Intersect(CFG.OUTs.Parents(s)) 10 OUT[s] = Union((var, expr), (IN[s])) \ {(v, e) pairs where v = var or var in e} If all every Basic Block is iterated (at any order) enough times, the algorithm will reach a xed point where the IN and OUT sets no longer change for any block and that's when the algorithm completes. 4
5 3 Example Lets take the IR from CFG example and run the Available Expressions analysis on it. We'll then use the analysis result to apply CP and CSE on the code. 5
6 Here's the CFG for the code, as a reminder: 6
7 3.1 Analysis Initial state Before the rst iteration (of the "while" loop) the sets look like this (we're using "{... }" to denote the set of all (var, expr) pairs): 7
8 st iteration After the rst iteration, the rst block's IN set is reduced (emptied) and the OUT set represents the expressions available to any following statement. 8
9 nd iteration We chose to iterate the left branch rst, but the order is meaningless as long as no block is starved. 9
10 rd iteration Now the right branch. 10
11 th iteration Done with the "if" blocks. 11
12 th iteration Analyzing the loop block, remember that the parents of this block are the one containing "w := y;" as well as the loop block itself. 12
13 th iteration After a single iteration in the loop block, we choose to move on the the block right below it. Entry z := x + 1; {(x, y + 1), (z, x + 1)} goto LFinish; x := y + 1; ifz t0 goto LElse; z := y + 1; {(x, y + 1), (z, y + 1)} w := y; {(x, y + 1), (w, y)} {(x, y+ 1), (w, y)} a := w + 1; {(a, w + 1), (x, y + 1), (w, y)} {(a, w + 1), (x, y + 1), (w, y)} b := a >= t0; {(a, w + 1), (b, a >= t0),(x, y + 1), (w, y)} x := t0; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifnz t0 goto LEnd; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifz b goto LLoop; {(a, w + 1), (b, a >= t0)} Exit 13
14 th iteration Going back to that loop. Entry z := x + 1; {(x, y + 1), (z, x + 1)} goto LFinish; x := y + 1; ifz t0 goto LElse; z := y + 1; {(x, y + 1), (z, y + 1)} w := y; {(x, y + 1), (w, y)} {(w, y)} a := w + 1; {(a, w + 1), (w, y)} {(a, w + 1), (w, y)} b := a >= t0; {(a, w + 1), (b, a >= t0),(w, y)} x := t0; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifnz t0 goto LEnd; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifz b goto LLoop; {(a, w + 1), (b, a >= t0)} Exit 14
15 3.1.9 Last iteration For consistancy with other analyses we also analyse the Exit block Entry z := x + 1; {(x, y + 1), (z, x + 1)} goto LFinish; x := y + 1; ifz t0 goto LElse; z := y + 1; {(x, y + 1), (z, y + 1)} w := y; {(x, y + 1), (w, y)} {(w, y)} a := w + 1; {(a, w + 1), (w, y)} {(a, w + 1), (w, y)} b := a >= t0; {(a, w + 1), (b, a >= t0),(w, y)} x := t0; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifnz t0 goto LEnd; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifz b goto LLoop; {(a, w + 1), (b, a >= t0)} {(a, w + 1), (b, a >= t0)} Exit 15
16 3.2 Optimization Now that we've completed the analysis, we can use the results to apply optimizations to the code. We'll start with CP (as a pre-step for CSE or Dead Code Eliminiation). From the results we can see that at line 12 (a := w + 1;) we can replace w with y. Now if we re-run Available Expressions analysis again, we'll get the following result: Entry z := x + 1; {(x, y + 1), (z, x + 1)} goto LFinish; x := y + 1; ifz t0 goto LElse; z := y + 1; {(x, y + 1), (z, x)} w := y; {(x, y + 1), (w, y)} {(w, y)} a := y+1; {(a, y + 1), (w, y)} {(a, y + 1), (w, y)} b := a >= t0; {(a, y + 1), (b, a >= t0),(w, y)} x := t0; {(a, y + 1), (b, a >= t0), (w, y), (x, t0)} ifnz t0 goto LEnd; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifz b goto LLoop; {(a, w + 1), (b, a >= t0)} {(a, y + 1), (b, a >= t0)} Exit 16
17 Running CSE on this result we see we can apply the optimization on line 8 (substituting z := y + 1; with z := x), resulting in: Entry z := x + 1; {(x, y + 1), (z, x + 1)} goto LFinish; x := y + 1; ifz t0 goto LElse; z := x; {(x, y + 1), (z, x)} w := y; {(x, y + 1), (w, y)} {(w, y)} a := y+1; {(a, y + 1), (w, y)} {(a, y + 1), (w, y)} b := a >= t0; {(a, y + 1), (b, a >= t0),(w, y)} x := t0; {(a, y + 1), (b, a >= t0), (w, y), (x, t0)} ifnz t0 goto LEnd; {(a, w + 1), (b, a >= t0), (w, y), (x, t0)} ifz b goto LLoop; {(a, w + 1), (b, a >= t0)} {(a, y + 1), (b, a >= t0)} Exit 17
18 In this instance CP didn't improve our CSE output, but if we run Liveness Analysis on the above CFG we'll see that the assignment at line 10 (w := y;) is now dead code, and can be removed since we don't read this assigned value of w anywhere (we substituted its read operation at line 12 with a read of y). After removing it we get this nal CFG: 18
Global Optimizations
Global Optimizations Avi Hayoun, Hodai Goldman and Lior Zur-Lotan January 31, 2016 Contents 1 Global Optimizations Global optimizations and analyses are performed in the context of a whole, single function
More informationData Flow Analysis. Agenda CS738: Advanced Compiler Optimizations. 3-address Code Format. Assumptions
Agenda CS738: Advanced Compiler Optimizations Data Flow Analysis Amey Karkare karkare@cse.iitk.ac.in http://www.cse.iitk.ac.in/~karkare/cs738 Department of CSE, IIT Kanpur Static analysis and compile-time
More informationIR Optimization. May 15th, Tuesday, May 14, 13
IR Optimization May 15th, 2013 Tuesday, May 14, 13 But before we talk about IR optimization... Wrapping up IR generation Tuesday, May 14, 13 Three-Address Code Or TAC The IR that you will be using for
More informationY-Combinator. Contents. 1 Introduction. Avi Hayoun, Hodai Goldman and Lior Zur-Lotan. November 24, Terms recap. 1.2 Y-Combinator notes
Y-Combinator Avi Hayoun, Hodai Goldman and Lior Zur-Lotan November 24, 2015 Contents 1 Introduction 1.1 Terms recap ˆ Higher-Order fucntion - a function that either takes or returns a function or both.
More informationData Flow Information. already computed
Data Flow Information Determine if Determine if a constant in loop modifies Determine if expression already computed Determine if not used later in program Data Flow Equations Local Information: Gen(B):
More informationWe can express this in dataflow equations using gen and kill sets, where the sets are now sets of expressions.
Available expressions Suppose we want to do common-subexpression elimination; that is, given a program that computes x y more than once, can we eliminate one of the duplicate computations? To find places
More informationData Flow Analysis. Program Analysis
Program Analysis https://www.cse.iitb.ac.in/~karkare/cs618/ Data Flow Analysis Amey Karkare Dept of Computer Science and Engg IIT Kanpur Visiting IIT Bombay karkare@cse.iitk.ac.in karkare@cse.iitb.ac.in
More informationCompiler Optimization and Code Generation
Compiler Optimization and Code Generation Professor: Sc.D., Professor Vazgen Melikyan 1 Course Overview Introduction: Overview of Optimizations 1 lecture Intermediate-Code Generation 2 lectures Machine-Independent
More informationInduction Variable Identification (cont)
Loop Invariant Code Motion Last Time Uses of SSA: reaching constants, dead-code elimination, induction variable identification Today Finish up induction variable identification Loop invariant code motion
More informationLecture 4 Introduction to Data Flow Analysis
Lecture 4 Introduction to Data Flow Analysis I. Structure of data flow analysis II. Example 1: Reaching definition analysis III. Example 2: Liveness analysis IV. Generalization What is Data Flow Analysis?
More informationLecture 2. Introduction to Data Flow Analysis
Lecture 2 Introduction to Data Flow Analysis I II III Example: Reaching definition analysis Example: Liveness Analysis A General Framework (Theory in next lecture) Reading: Chapter 9.2 Advanced Compilers
More informationLecture 3 Local Optimizations, Intro to SSA
Lecture 3 Local Optimizations, Intro to SSA I. Basic blocks & Flow graphs II. Abstraction 1: DAG III. Abstraction 2: Value numbering IV. Intro to SSA ALSU 8.4-8.5, 6.2.4 Phillip B. Gibbons 15-745: Local
More informationCOSE312: Compilers. Lecture 20 Data-Flow Analysis (2)
COSE312: Compilers Lecture 20 Data-Flow Analysis (2) Hakjoo Oh 2017 Spring Hakjoo Oh COSE312 2017 Spring, Lecture 20 June 6, 2017 1 / 18 Final Exam 6/19 (Mon), 15:30 16:45 (in class) Do not be late. Coverage:
More informationWe can express this in dataflow equations using gen and kill sets, where the sets are now sets of expressions.
Available expressions Suppose we want to do common-subexpression elimination; that is, given a program that computes x y more than once, can we eliminate one of the duplicate computations? To find places
More informationLanguages and Compiler Design II IR Code Optimization
Languages and Compiler Design II IR Code Optimization Material provided by Prof. Jingke Li Stolen with pride and modified by Herb Mayer PSU Spring 2010 rev.: 4/16/2010 PSU CS322 HM 1 Agenda IR Optimization
More informationCompiler Optimizations. Chapter 8, Section 8.5 Chapter 9, Section 9.1.7
Compiler Optimizations Chapter 8, Section 8.5 Chapter 9, Section 9.1.7 2 Local vs. Global Optimizations Local: inside a single basic block Simple forms of common subexpression elimination, dead code elimination,
More informationCPSC 320 Sample Solution, Playing with Graphs!
CPSC 320 Sample Solution, Playing with Graphs! September 23, 2017 Today we practice reasoning about graphs by playing with two new terms. These terms/concepts are useful in themselves but not tremendously
More informationA main goal is to achieve a better performance. Code Optimization. Chapter 9
1 A main goal is to achieve a better performance Code Optimization Chapter 9 2 A main goal is to achieve a better performance source Code Front End Intermediate Code Code Gen target Code user Machineindependent
More informationCompiler Construction 2009/2010 SSA Static Single Assignment Form
Compiler Construction 2009/2010 SSA Static Single Assignment Form Peter Thiemann March 15, 2010 Outline 1 Static Single-Assignment Form 2 Converting to SSA Form 3 Optimization Algorithms Using SSA 4 Dependencies
More informationCompiler Construction 2010/2011 Loop Optimizations
Compiler Construction 2010/2011 Loop Optimizations Peter Thiemann January 25, 2011 Outline 1 Loop Optimizations 2 Dominators 3 Loop-Invariant Computations 4 Induction Variables 5 Array-Bounds Checks 6
More informationMIT Introduction to Program Analysis and Optimization. Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology
MIT 6.035 Introduction to Program Analysis and Optimization Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Program Analysis Compile-time reasoning about run-time behavior
More informationWhy Global Dataflow Analysis?
Why Global Dataflow Analysis? Answer key questions at compile-time about the flow of values and other program properties over control-flow paths Compiler fundamentals What defs. of x reach a given use
More informationCS202 Compiler Construction
CS202 Compiler Construction April 17, 2003 CS 202-33 1 Today: more optimizations Loop optimizations: induction variables New DF analysis: available expressions Common subexpression elimination Copy propogation
More information7. Optimization! Prof. O. Nierstrasz! Lecture notes by Marcus Denker!
7. Optimization! Prof. O. Nierstrasz! Lecture notes by Marcus Denker! Roadmap > Introduction! > Optimizations in the Back-end! > The Optimizer! > SSA Optimizations! > Advanced Optimizations! 2 Literature!
More informationData Flow Analysis. Daqing Hou
Data Flow Analysis Daqing Hou Outline Basic blocks and control flow graph An example: reaching definitions Characteristics of DFA (Data Flow Analysis) Daqing Hou, Spring 2008 2 Example 100 unsigned int
More informationCompiler Design Spring 2017
Compiler Design Spring 2017 8.6 Live variables Dr. Zoltán Majó Compiler Group Java HotSpot Virtual Machine Oracle Corporation Live variables Foundations for several optimizations If a variable is not live,
More informationCalvin Lin The University of Texas at Austin
Loop Invariant Code Motion Last Time SSA Today Loop invariant code motion Reuse optimization Next Time More reuse optimization Common subexpression elimination Partial redundancy elimination February 23,
More informationCompiler Optimizations. Chapter 8, Section 8.5 Chapter 9, Section 9.1.7
Compiler Optimizations Chapter 8, Section 8.5 Chapter 9, Section 9.1.7 2 Local vs. Global Optimizations Local: inside a single basic block Simple forms of common subexpression elimination, dead code elimination,
More informationCompiler Construction 2016/2017 Loop Optimizations
Compiler Construction 2016/2017 Loop Optimizations Peter Thiemann January 16, 2017 Outline 1 Loops 2 Dominators 3 Loop-Invariant Computations 4 Induction Variables 5 Array-Bounds Checks 6 Loop Unrolling
More informationA shell can be used in one of two ways:
Shell Scripting 1 A shell can be used in one of two ways: A command interpreter, used interactively A programming language, to write shell scripts (your own custom commands) 2 If we have a set of commands
More informationCFG (Control flow graph)
CFG (Control flow graph) Class B T12 오지은 200814189 신승우 201011340 이종선 200811448 Introduction to CFG Algorithm to construct Control Flow Graph Statement of Purpose Q & A Introduction to CFG Algorithm to
More informationTour of common optimizations
Tour of common optimizations Simple example foo(z) { x := 3 + 6; y := x 5 return z * y } Simple example foo(z) { x := 3 + 6; y := x 5; return z * y } x:=9; Applying Constant Folding Simple example foo(z)
More informationEECS 583 Class 8 Classic Optimization
EECS 583 Class 8 Classic Optimization University of Michigan October 3, 2011 Announcements & Reading Material Homework 2» Extend LLVM LICM optimization to perform speculative LICM» Due Friday, Nov 21,
More informationLoop Optimizations. Outline. Loop Invariant Code Motion. Induction Variables. Loop Invariant Code Motion. Loop Invariant Code Motion
Outline Loop Optimizations Induction Variables Recognition Induction Variables Combination of Analyses Copyright 2010, Pedro C Diniz, all rights reserved Students enrolled in the Compilers class at the
More informationCalvin Lin The University of Texas at Austin
Loop Invariant Code Motion Last Time Loop invariant code motion Value numbering Today Finish value numbering More reuse optimization Common subession elimination Partial redundancy elimination Next Time
More informationLecture 6. Register Allocation. I. Introduction. II. Abstraction and the Problem III. Algorithm
I. Introduction Lecture 6 Register Allocation II. Abstraction and the Problem III. Algorithm Reading: Chapter 8.8.4 Before next class: Chapter 10.1-10.2 CS243: Register Allocation 1 I. Motivation Problem
More informationCSE Section 10 - Dataflow and Single Static Assignment - Solutions
CSE 401 - Section 10 - Dataflow and Single Static Assignment - Solutions 1. Dataflow Review For each of the following optimizations, list the dataflow analysis that would be most directly applicable. You
More informationData Flow Analysis. CSCE Lecture 9-02/15/2018
Data Flow Analysis CSCE 747 - Lecture 9-02/15/2018 Data Flow Another view - program statements compute and transform data So, look at how that data is passed through the program. Reason about data dependence
More informationLecture Notes: Dataflow Analysis Examples
Lecture Notes: Dataflow Analysis Examples 15-819O: Program Analysis Jonathan Aldrich jonathan.aldrich@cs.cmu.edu Lecture 3 1 Constant Propagation While zero analysis was useful for simply tracking whether
More informationLecture 6 Foundations of Data Flow Analysis
Lecture 6 Foundations of Data Flow Analysis I. Meet operator II. Transfer functions III. Correctness, Precision, Convergence IV. Efficiency ALSU 9.3 Phillip B. Gibbons 15-745: Foundations of Data Flow
More informationIntroduction. Data-flow Analysis by Iteration. CSc 553. Principles of Compilation. 28 : Optimization III
CSc 553 Principles of Compilation 28 : Optimization III Introduction Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2011 Christian Collberg Computing Data-Flow Info.
More informationAn Interactive Desk Calculator. Project P2 of. Common Lisp: An Interactive Approach. Stuart C. Shapiro. Department of Computer Science
An Interactive Desk Calculator Project P2 of Common Lisp: An Interactive Approach Stuart C. Shapiro Department of Computer Science State University of New York at Bualo January 25, 1996 The goal of this
More information1 of 5 5/11/2006 12:10 AM CS 61A Spring 2006 Midterm 2 solutions 1. Box and pointer. Note: Please draw actual boxes, as in the book and the lectures, not XX and X/ as in these ASCII-art solutions. Also,
More informationCode Optimization. Code Optimization
161 Code Optimization Code Optimization 162 Two steps: 1. Analysis (to uncover optimization opportunities) 2. Optimizing transformation Optimization: must be semantically correct. shall improve program
More informationShell Scripting. Todd Kelley CST8207 Todd Kelley 1
Shell Scripting Todd Kelley kelleyt@algonquincollege.com CST8207 Todd Kelley 1 If we have a set of commands that we want to run on a regular basis, we could write a script A script acts as a Linux command,
More informationAn example of optimization in LLVM. Compiler construction Step 1: Naive translation to LLVM. Step 2: Translating to SSA form (opt -mem2reg)
Compiler construction 2014 An example of optimization in LLVM Lecture 8 More on code optimization SSA form Constant propagation Common subexpression elimination Loop optimizations int f () { int i, j,
More informationIntermediate representation
Intermediate representation Goals: encode knowledge about the program facilitate analysis facilitate retargeting facilitate optimization scanning parsing HIR semantic analysis HIR intermediate code gen.
More informationFlow Analysis. Data-flow analysis, Control-flow analysis, Abstract interpretation, AAM
Flow Analysis Data-flow analysis, Control-flow analysis, Abstract interpretation, AAM Helpful Reading: Sections 1.1-1.5, 2.1 Data-flow analysis (DFA) A framework for statically proving facts about program
More informationLecture Compiler Middle-End
Lecture 16-18 18 Compiler Middle-End Jianwen Zhu Electrical and Computer Engineering University of Toronto Jianwen Zhu 2009 - P. 1 What We Have Done A lot! Compiler Frontend Defining language Generating
More informationIntroduction to Linux
Introduction to Linux The command-line interface A command-line interface (CLI) is a type of interface, that is, a way to interact with a computer. Window systems, punched cards or a bunch of dials, buttons
More informationCSE P 501 Compilers. SSA Hal Perkins Spring UW CSE P 501 Spring 2018 V-1
CSE P 0 Compilers SSA Hal Perkins Spring 0 UW CSE P 0 Spring 0 V- Agenda Overview of SSA IR Constructing SSA graphs Sample of SSA-based optimizations Converting back from SSA form Sources: Appel ch., also
More informationMIT Introduction to Dataflow Analysis. Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology
MIT 6.035 Introduction to Dataflow Analysis Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Dataflow Analysis Used to determine properties of program that involve multiple
More informationLiveness Analysis and Register Allocation. Xiao Jia May 3 rd, 2013
Liveness Analysis and Register Allocation Xiao Jia May 3 rd, 2013 1 Outline Control flow graph Liveness analysis Graph coloring Linear scan 2 Basic Block The code in a basic block has: one entry point,
More informationFunctions and Objects. Week 7: Symbolic Computation
Week 7: Symbolic Computation In the previous weeks, we've seen the essential elements of modern functional programming: Functions (rst class) Types (parametric) Pattern Matching Lists This week, we'll
More informationLecture 4. More on Data Flow: Constant Propagation, Speed, Loops
Lecture 4 More on Data Flow: Constant Propagation, Speed, Loops I. Constant Propagation II. Efficiency of Data Flow Analysis III. Algorithm to find loops Reading: Chapter 9.4, 9.6 CS243: Constants, Speed,
More informationLecture 6 Foundations of Data Flow Analysis
Review: Reaching Definitions Lecture 6 Foundations of Data Flow Analysis I. Meet operator II. Transfer functions III. Correctness, Precision, Convergence IV. Efficiency [ALSU 9.3] Phillip B. Gibbons 15-745:
More informationCS577 Modern Language Processors. Spring 2018 Lecture Optimization
CS577 Modern Language Processors Spring 2018 Lecture Optimization 1 GENERATING BETTER CODE What does a conventional compiler do to improve quality of generated code? Eliminate redundant computation Move
More informationMiddle End. Code Improvement (or Optimization) Analyzes IR and rewrites (or transforms) IR Primary goal is to reduce running time of the compiled code
Traditional Three-pass Compiler Source Code Front End IR Middle End IR Back End Machine code Errors Code Improvement (or Optimization) Analyzes IR and rewrites (or transforms) IR Primary goal is to reduce
More informationWhen we eliminated global CSE's we introduced copy statements of the form A:=B. There are many
Copy Propagation When we eliminated global CSE's we introduced copy statements of the form A:=B. There are many other sources for copy statements, such as the original source code and the intermediate
More informationMidterm 2. CMSC 430 Introduction to Compilers Fall Instructions Total 100. Name: November 21, 2016
Name: Midterm 2 CMSC 430 Introduction to Compilers Fall 2016 November 21, 2016 Instructions This exam contains 7 pages, including this one. Make sure you have all the pages. Write your name on the top
More informationControl Flow Analysis. Reading & Topics. Optimization Overview CS2210. Muchnick: chapter 7
Control Flow Analysis CS2210 Lecture 11 Reading & Topics Muchnick: chapter 7 Optimization Overview Control Flow Analysis Maybe start data flow analysis Optimization Overview Two step process Analyze program
More informationDataflow Analysis. Xiaokang Qiu Purdue University. October 17, 2018 ECE 468
Dataflow Analysis Xiaokang Qiu Purdue University ECE 468 October 17, 2018 Program optimizations So far we have talked about different kinds of optimizations Peephole optimizations Local common sub-expression
More informationCompiler Design. Fall Control-Flow Analysis. Prof. Pedro C. Diniz
Compiler Design Fall 2015 Control-Flow Analysis Sample Exercises and Solutions Prof. Pedro C. Diniz USC / Information Sciences Institute 4676 Admiralty Way, Suite 1001 Marina del Rey, California 90292
More informationIntermediate representations IR #1: CPS/L 3. Code example. Advanced Compiler Construction Michel Schinz
Intermediate representations Intermediate representations Advanced Compiler Construction Michel Schinz 2016 03 03 The term intermediate representation (IR) or intermediate language designates the data-structure(s)
More informationCOMP2100/2500 Lecture 17: Shell Programming II
[ANU] [DCS] [COMP2100/2500] [Description] [Schedule] [Lectures] [Labs] [Homework] [Assignments] [COMP2500] [Assessment] [PSP] [Java] [Reading] [Help] COMP2100/2500 Lecture 17: Shell Programming II Summary
More informationFall Compiler Principles Lecture 6: Intermediate Representation. Roman Manevich Ben-Gurion University of the Negev
Fall 2015-2016 Compiler Principles Lecture 6: Intermediate Representation Roman Manevich Ben-Gurion University of the Negev Tentative syllabus Front End Intermediate Representation Optimizations Code Generation
More informationLecture 8: Induction Variable Optimizations
Lecture 8: Induction Variable Optimizations I. Finding loops II. III. Overview of Induction Variable Optimizations Further details ALSU 9.1.8, 9.6, 9.8.1 Phillip B. Gibbons 15-745: Induction Variables
More informationMidterm 2. CMSC 430 Introduction to Compilers Fall Instructions Total 100. Name: November 11, 2015
Name: Midterm 2 CMSC 430 Introduction to Compilers Fall 2015 November 11, 2015 Instructions This exam contains 8 pages, including this one. Make sure you have all the pages. Write your name on the top
More informationsource constructs created by the operation. he complexity of these computations contributes to the complexity of the entire language translator specic
pecication Languages in Algebraic Compilers Eric Van Wyk 1 Oxford University Computing Laboratory Wolfson Building, Parks Road Oxford OX1 3QD, UK Abstract Algebraic compilers provide a powerful and convenient
More informationProgram analysis for determining opportunities for optimization: 2. analysis: dataow Organization 1. What kind of optimizations are useful? lattice al
Scalar Optimization 1 Program analysis for determining opportunities for optimization: 2. analysis: dataow Organization 1. What kind of optimizations are useful? lattice algebra solving equations on lattices
More informationCompiler Passes. Optimization. The Role of the Optimizer. Optimizations. The Optimizer (or Middle End) Traditional Three-pass Compiler
Compiler Passes Analysis of input program (front-end) character stream Lexical Analysis Synthesis of output program (back-end) Intermediate Code Generation Optimization Before and after generating machine
More informationCSE P 501 Compilers. Intermediate Representations Hal Perkins Spring UW CSE P 501 Spring 2018 G-1
CSE P 501 Compilers Intermediate Representations Hal Perkins Spring 2018 UW CSE P 501 Spring 2018 G-1 Administrivia Semantics/types/symbol table project due ~2 weeks how goes it? Should be caught up on
More informationControl Structures. Code can be purely arithmetic assignments. At some point we will need some kind of control or decision making process to occur
Control Structures Code can be purely arithmetic assignments At some point we will need some kind of control or decision making process to occur C uses the if keyword as part of it s control structure
More informationOptiCode: Machine Code Deobfuscation for Malware Analysis
OptiCode: Machine Code Deobfuscation for Malware Analysis NGUYEN Anh Quynh, COSEINC CONFidence, Krakow - Poland 2013, May 28th 1 / 47 Agenda 1 Obfuscation problem in malware analysis
More informationCS553 Lecture Generalizing Data-flow Analysis 3
Generalizing Data-flow Analysis Announcements Project 2 writeup is available Read Stephenson paper Last Time Control-flow analysis Today C-Breeze Introduction Other types of data-flow analysis Reaching
More information: Compiler Design. 9.6 Available expressions 9.7 Busy expressions. Thomas R. Gross. Computer Science Department ETH Zurich, Switzerland
252-210: Compiler Design 9.6 Available expressions 9.7 Busy expressions Thomas R. Gross Computer Science Department ETH Zurich, Switzerland Available expressions An expression a+b is available at a point
More informationbash Tests and Looping Administrative Shell Scripting COMP2101 Fall 2017
bash Tests and Looping Administrative Shell Scripting COMP2101 Fall 2017 Command Lists A command is a sequence of commands separated by the operators ; & && and ; is used to simply execute commands in
More informationPlan for Today. Concepts. Next Time. Some slides are from Calvin Lin s grad compiler slides. CS553 Lecture 2 Optimizations and LLVM 1
Plan for Today Quiz 2 How to automate the process of performance optimization LLVM: Intro to Intermediate Representation Loops as iteration spaces Data-flow Analysis Intro Control-flow graph terminology
More informationCPSC W1: Midterm 1 Sample Solution
CPSC 320 2017W1: Midterm 1 Sample Solution January 26, 2018 Problem reminders: EMERGENCY DISTRIBUTION PROBLEM (EDP) EDP's input is an undirected, unweighted graph G = (V, E) plus a set of distribution
More informationCS153: Compilers Lecture 23: Static Single Assignment Form
CS153: Compilers Lecture 23: Static Single Assignment Form Stephen Chong https://www.seas.harvard.edu/courses/cs153 Pre-class Puzzle Suppose we want to compute an analysis over CFGs. We have two possible
More informationCompiler Design. Fall Data-Flow Analysis. Sample Exercises and Solutions. Prof. Pedro C. Diniz
Compiler Design Fall 2015 Data-Flow Analysis Sample Exercises and Solutions Prof. Pedro C. Diniz USC / Information Sciences Institute 4676 Admiralty Way, Suite 1001 Marina del Rey, California 90292 pedro@isi.edu
More informationReview; questions Basic Analyses (2) Assign (see Schedule for links)
Class 2 Review; questions Basic Analyses (2) Assign (see Schedule for links) Representation and Analysis of Software (Sections -5) Additional reading: depth-first presentation, data-flow analysis, etc.
More informationLecture Notes on Intermediate Representation
Lecture Notes on Intermediate Representation 15-411: Compiler Design Frank Pfenning Lecture 9 September 24, 2009 1 Introduction In this lecture we discuss the middle end of the compiler. After the source
More informationThe Static Single Assignment Form:
The Static Single Assignment Form: Construction and Application to Program Optimizations - Part 3 Department of Computer Science Indian Institute of Science Bangalore 560 012 NPTEL Course on Compiler Design
More informationCompiler Structure. Data Flow Analysis. Control-Flow Graph. Available Expressions. Data Flow Facts
Compiler Structure Source Code Abstract Syntax Tree Control Flow Graph Object Code CMSC 631 Program Analysis and Understanding Fall 2003 Data Flow Analysis Source code parsed to produce AST AST transformed
More informationGoals of Program Optimization (1 of 2)
Goals of Program Optimization (1 of 2) Goal: Improve program performance within some constraints Ask Three Key Questions for Every Optimization 1. Is it legal? 2. Is it profitable? 3. Is it compile-time
More informationChapter 3 (part 3) Describing Syntax and Semantics
Chapter 3 (part 3) Describing Syntax and Semantics Chapter 3 Topics Introduction The General Problem of Describing Syntax Formal Methods of Describing Syntax Attribute Grammars Describing the Meanings
More informationThree-Address Code IR
Three-Address Code IR Announcements Programming Project 3 due tonight at 11:59PM. OH today after lecture. Ask questions on Piazzza! Ask questions via email! Programming Project 4 out, due Wednesday, August
More informationSearch. Krzysztof Kuchcinski. Department of Computer Science Lund Institute of Technology Sweden.
Search Krzysztof Kuchcinski Krzysztof.Kuchcinski@cs.lth.se Department of Computer Science Lund Institute of Technology Sweden January 12, 2015 Kris Kuchcinski (LTH) Search January 12, 2015 1 / 46 Search
More informationRegister allocation. Register allocation: ffl have value in a register when used. ffl limited resources. ffl changes instruction choices
Register allocation IR instruction selection register allocation machine code errors Register allocation: have value in a register when used limited resources changes instruction choices can move loads
More informationMachine-Independent Optimizations
Chapter 9 Machine-Independent Optimizations High-level language constructs can introduce substantial run-time overhead if we naively translate each construct independently into machine code. This chapter
More informationProgram Optimizations using Data-Flow Analysis
Program Optimizations using Data-Flow Analysis!Last time! Lattice theoretic framework for data-flow analysis!today! Dead-code elimination! Common sub-expression elimination (CSE)! Copy propagation! Constant
More informationHeap sort. Carlos Moreno uwaterloo.ca EIT
Carlos Moreno cmoreno @ uwaterloo.ca EIT-4103 http://xkcd.com/835/ https://ece.uwaterloo.ca/~cmoreno/ece250 Standard reminder to set phones to silent/vibrate mode, please! Last time, on ECE-250... Talked
More informationCSE 505 Graduate PL. Fall 2013
CSE 505 Graduate PL Fall 2013 Goals Since Day 1 Develop tools to rigorously study what programs mean. semantics equivalence, termination, determinism,... Develop tools for studying program behavior! inductive
More informationFoundations of Dataflow Analysis
Foundations of Dataflow Analysis 15-745 Optimizing Compilers Spring 2006 Peter Lee Ingredients of a dataflow analysis direction: forward or backward flow/transfer function combining ( meet ) operator dataflow
More informationSparse Conditional Constant Propagation
CS738: Advanced Compiler Optimizations Sparse Simple Constant Propagation (SSC) Sparse Conditional Constant Propagation Amey Karkare karkare@cse.iitk.ac.in Improved analysis time over Simple Constant Propagation
More informationCSC D70: Compiler Optimization Register Allocation
CSC D70: Compiler Optimization Register Allocation Prof. Gennady Pekhimenko University of Toronto Winter 2018 The content of this lecture is adapted from the lectures of Todd Mowry and Phillip Gibbons
More informationLoop Invariant Code Motion. Background: ud- and du-chains. Upward Exposed Uses. Identifying Loop Invariant Code. Last Time Control flow analysis
Loop Invariant Code Motion Loop Invariant Code Motion Background: ud- and du-chains Last Time Control flow analysis Today Loop invariant code motion ud-chains A ud-chain connects a use of a variable to
More informationLecture 21 CIS 341: COMPILERS
Lecture 21 CIS 341: COMPILERS Announcements HW6: Analysis & Optimizations Alias analysis, constant propagation, dead code elimination, register allocation Available Soon Due: Wednesday, April 25 th Zdancewic
More informationCSE443 Compilers. Dr. Carl Alphonce 343 Davis Hall
CSE443 Compilers Dr. Carl Alphonce alphonce@buffalo.edu 343 Davis Hall Phases of a compiler Target machine code generation Figure 1.6, page 5 of text B1 i = 1 B2 j = 1 B3 t1 = 10 * i t2 = t1 + j t3 = 8
More information