12/18/2015© 2002-08 hal perkins & uw cset-1 cse p 501 – compilers analysis &...
TRANSCRIPT
![Page 1: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/1.jpg)
04/21/23 © 2002-08 Hal Perkins & UW CSE T-1
CSE P 501 – Compilers
Analysis & Optimizations & Loops
Hal PerkinsWinter 2008
![Page 2: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/2.jpg)
Agenda Dataflow analysis example – live
variables Loop optimizations
Dominators – discovering loops Loop invariant calculations Loop transformations
A quick look at some memory hierarchy issues
Largely based on material in Appel ch. 10, 17, 18,21; similar material in other books
04/21/23 © 2002-08 Hal Perkins & UW CSE T-2
![Page 3: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/3.jpg)
Live Variables
Recall that two variables can be assigned to the same register if they are not alive at the same time
We would like to analyze code to decide when variables are “live”
Def. A variable is live if it holds a value that may be needed in the future
04/21/23 © 2002-08 Hal Perkins & UW CSE T-3
![Page 4: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/4.jpg)
Example (1 stmt per block) Code
a := 0L: b := a+1
c := c+ba := b*2if a < N goto
Lreturn c
04/21/23 © 2002-08 Hal Perkins & UW CSE T-4
1: a:= 0
2: b:=a+1
3: c:=c+b
4: a:=b+2
5: a < N
6: return c
![Page 5: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/5.jpg)
Live Ranges b: 2 -> 3, 3 -> 4 a: 1 -> 2, and
4 -> 5 -> 2,but not 2 -> 3 -> 4
c: live on entry; live throughout
Liveness analysis flows from the future to the past
04/21/23 © 2002-08 Hal Perkins & UW CSE T-5
1: a:= 0
2: b:=a+1
3: c:=c+b
4: a:=b+2
5: a < N
6: return c
![Page 6: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/6.jpg)
Liveness Analysis
A variable is live on an edge if there is a path from that edge to a use that does not go through any definition
In a block, a variable is Live-in if it is live on any in-edge Live-out if it is live on any out-edge
04/21/23 © 2002-08 Hal Perkins & UW CSE T-6
![Page 7: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/7.jpg)
Liveness Analysis Sets For each block b
use[b] = variable used in b before any def def[b] = variable defined in b & not killed in[b] = variables live on entry to b out[b] = variables live on exit from b
Note: slightly different from definitions for same problem in last week’s slides
04/21/23 © 2002-08 Hal Perkins & UW CSE T-7
![Page 8: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/8.jpg)
Dataflow equation Given the preceding definitions, we
havein[b] = use[b] (out[b] – def[b])
out[b] = ssucc[b] in[s] Algorithm
Set in[b] = out[b] = Update in, out until no change
Evaluation order: back to front is best given information flow
04/21/23 © 2002-08 Hal Perkins & UW CSE T-8
![Page 9: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/9.jpg)
Calculation
04/21/23 © 2002-08 Hal Perkins & UW CSE T-9
1: a:= 0
2: b:=a+1
3: c:=c+b
4: a:=b+2
5: a < N
6: return c
![Page 10: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/10.jpg)
Liveness & Register Allocation
Liveness information is used to construct an interference graph
If two variables are live at the same point in the program, they interfere, and cannot be in the same register
Graph coloring starts with this information
04/21/23 © 2002-08 Hal Perkins & UW CSE T-10
![Page 11: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/11.jpg)
Liveness in Larger Programs This example treated individual
instructions as nodes Only information discovered was
where operands were defined and used
In general: Nodes are basic blocks (faster, smaller
problem, less overhead) Most of the time, need to pay attention to
semantics of specific operations
04/21/23 © 2002-08 Hal Perkins & UW CSE T-11
![Page 12: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/12.jpg)
A Few Transformations (1)
Common subexpression elimination If x op y is calculated at a point where
it is available, the recalculation can be dropped
Constant propagation If t := c and c is a constant, a later
use of t can be replaced by c
04/21/23 © 2002-08 Hal Perkins & UW CSE T-12
![Page 13: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/13.jpg)
A Few Transformations (2) Copy propagation
If t := y and the definition of t is later used where y has not been redefined, can replace t with y
Dead code elimination If x := exp and x is not live out, then this
can be deleted IF it doesn’t have side effects, and IF
deleting it doesn’t change program semantics
04/21/23 © 2002-08 Hal Perkins & UW CSE T-13
![Page 14: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/14.jpg)
Faster Dataflow Analysis Besides working with basic blocks,
there are some other ways to speed things up Pick the right order to process blocks
Depends on whether information flows forwards or backwards
Can calculate def-use chains to link uses to define points (but SSA is the more general way to do this)
Use worklist algorithms to recalculate only things that have changed instead of redoing complete analysis
04/21/23 © 2002-08 Hal Perkins & UW CSE T-14
![Page 15: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/15.jpg)
Tranformations & Analysis
Transformations and optimizations change the information in the analysis
Examples If a:=b op c is removed as dead code, a
previous assignment b:=… (or c:=…) might become dead
Eliminating one common subexpression might expose another
04/21/23 © 2002-08 Hal Perkins & UW CSE T-15
![Page 16: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/16.jpg)
Transformation & Analysis
Brute force strategy Perform global analysis Do as many dataflow-based
optimizations as possible Repeat until no more changes found
But this can require lots of recalculation if transformations cascade badly
04/21/23 © 2002-08 Hal Perkins & UW CSE T-16
![Page 17: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/17.jpg)
Example
Suppose we discover that this statement is useless
x := a0 + a1 + a2 + … + an What happens if we eliminate it?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-17
![Page 18: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/18.jpg)
What we discovered What we really
discovered is thatx := tnm1 + anis dead
When this is eliminated the next pass discovers that tnm1 := … is dead
etc…
t1 := a0 + a1t2 := t1 + a2t3 := t2 + a3…tnm1 :=
tnm2 + anm1x := tnm1 + an
04/21/23 © 2002-08 Hal Perkins & UW CSE T-18
![Page 19: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/19.jpg)
Analysis Strategies (1)
Cutoff: quit after some small (fixed) number of rounds (e.g., 3) Assumes additional rounds unlikely to
do much good Do cascading analysis that
remains valid after transformations Value numbering is an example of
this
04/21/23 © 2002-08 Hal Perkins & UW CSE T-19
![Page 20: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/20.jpg)
Analysis Strategies (2)
Incremental dataflow analysis When optimizer changes something,
tweak the analysis information to reflect the new situation
04/21/23 © 2002-08 Hal Perkins & UW CSE T-20
![Page 21: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/21.jpg)
Incremental Liveness Analysis
Example: suppose we delete a:= b op c a is no longer defined here; if it was
live-out, it is now live-in at this point b and c are no longer used here; if
they are not live-out at this point, they are no longer live-in
04/21/23 © 2002-08 Hal Perkins & UW CSE T-21
![Page 22: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/22.jpg)
Alias Analysis
So far we have (mostly) assumed simple variables – i.e., compiler temporaries or local scalar variables Names are unambiguous Behavior of external variables (i.e,
memory locations) not analyzed i.e., we store or load from memory without
considering how locations may interact
04/21/23 © 2002-08 Hal Perkins & UW CSE T-22
![Page 23: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/23.jpg)
Aliases
A variable or memory location may have multiple names or aliases Call-by-reference parameters Variables whose address is taken (&x) Expressions that dereference pointers
(p.x, *p) Expressions involving subscripts (a[i]) Variables in nested scopes
04/21/23 © 2002-08 Hal Perkins & UW CSE T-23
![Page 24: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/24.jpg)
Aliases vs Optimizations
Example:p.x := 5; q.x := 7; a := p.x;
Does reaching definition analysis show that the definition of p.x reaches a?
(Or: do p and q refer to the same variable?)
(Or: can p and q refer to the same thing?)
04/21/23 © 2002-08 Hal Perkins & UW CSE T-24
![Page 25: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/25.jpg)
Aliases vs Optimizations
Examplevoid f(int *p, int *q) { *p = 1; *q = 2; return *p;}
How do we account for the possibility that p and q might refer to the same thing?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-25
![Page 26: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/26.jpg)
Types and Aliases (1)
In Java, ML, MiniJava, and others, if two variables have incompatible types they cannot be names for the same location Also helps that programmer cannot
create arbitrary pointers to storage in these languages
04/21/23 © 2002-08 Hal Perkins & UW CSE T-26
![Page 27: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/27.jpg)
Types and Aliases (2) Strategy: Divide memory locations into
alias classes based on type information (every type, array, record field is a class)
Implication: need to propagate type information from the semantics pass to optimizer Not normally true of a minimally typed IR
Items in different alias classes cannot refer to each other
04/21/23 © 2002-08 Hal Perkins & UW CSE T-27
![Page 28: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/28.jpg)
Aliases and Flow Analysis Idea: Base alias classes on points
where a value is created Every new/malloc and each local or
global variable whose address is taken is an alias class
Pointers can refer to values in multiple alias classes (so each memory reference is to a set of alias classes)
Use to calculate “may alias” information (e.g., p “may alias” q at program point s)
04/21/23 © 2002-08 Hal Perkins & UW CSE T-28
![Page 29: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/29.jpg)
Using “may-alias” information
Treat each alias class as a “variable” in dataflow analysis problems
Example: framework for available expressions Given statement s: M[a]:=b,
gen[s] = { }kill[s] = { M[x] | a may alias x at
s }
04/21/23 © 2002-08 Hal Perkins & UW CSE T-29
![Page 30: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/30.jpg)
May-Alias Analysis Without alias
analysis, #2 kills M[t] since x and t might be related
If analysis determines that “x may-alias t” is false, M[t] is still available at #3; can eliminate the common subexpression and use copy propagation
Code1: u := M[t]2: M[x] := r3: w := M[t]4: b := u+w
04/21/23 © 2002-08 Hal Perkins & UW CSE T-30
![Page 31: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/31.jpg)
Loops
Much of he execution time of programs is spent here
worth considerable effort to make loops go faster
want to figure out how to recognize loops and figure out how to “improve” them
04/21/23 © 2002-08 Hal Perkins & UW CSE T-31
![Page 32: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/32.jpg)
What’s a Loop?
In a control flow graph, a loop is a set of nodes S such that: S includes a header node h From any node in S there is a path of
directed edges leading to h There is a path from h to any node in S There is no edge from any node
outside S to any node in S other than h
04/21/23 © 2002-08 Hal Perkins & UW CSE T-32
![Page 33: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/33.jpg)
Entries and Exits
In a loop An entry node is one with some
predecessor outside the loop An exit node is one that has a
successor outside the loop Corollary of preceding definitions:
A loop may have multiple exit nodes, but only one entry node
04/21/23 © 2002-08 Hal Perkins & UW CSE T-33
![Page 34: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/34.jpg)
Reducible Flow Graphs In a reducible flow graph, any two loops
are either nested or disjoint Roughly, to discover if a flow graph is
reducible, repeatedly delete edges and collapse together pairs of nodes (x,y) where x is the only predecessor of y
If the graph can be reduced to a single node it is reducible Caution: this is the “powerpoint” version of
the definition – see a good compiler book for the careful details
04/21/23 © 2002-08 Hal Perkins & UW CSE T-34
![Page 35: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/35.jpg)
Example: Is this Reducible?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-35
![Page 36: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/36.jpg)
Example: Is this Reducible?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-36
![Page 37: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/37.jpg)
Reducible Flow Graphs in Practice Common control-flow constructs yield
reducible flow graphs if-then[-else], while, do, for, break(!)
A C function without goto will always be reducible
Many dataflow analysis algorithms are very efficient on reducible graphs, but
We don’t need to assume reducible control-flow graphs to handle loops
04/21/23 © 2002-08 Hal Perkins & UW CSE T-37
![Page 38: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/38.jpg)
Finding Loops in Flow Graphs
We use dominators for this Recall
Every control flow graph has a unique start node s0
Node x dominates node y if every path from s0 to y must go through x
A node x dominates itself
04/21/23 © 2002-08 Hal Perkins & UW CSE T-38
![Page 39: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/39.jpg)
Calculating Dominator Sets
D[n] is the set of nodes that dominate n D[s0] = { s0 } D[n] = { n } ( ppred[n] D[p] )
Set up an iterative analysis as usual to solve this Except initially each D[n] must be all
nodes in the graph – updates make these sets smaller if changed
04/21/23 © 2002-08 Hal Perkins & UW CSE T-39
![Page 40: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/40.jpg)
Immediate Dominators Every node n has a single immediate
dominator idom(n) idom(n) differs from n idom(n) dominates n idom(n) does not dominate any other
dominator of n Fact (er, theorem): If a dominates n
and b dominates n, then either a dominates b or b dominates a idom(n) is unique
04/21/23 © 2002-08 Hal Perkins & UW CSE T-40
![Page 41: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/41.jpg)
Dominator Tree
A dominator tree is constructed from a flowgraph by drawing an edge form every node in n to idom(n) This will be a tree. Why?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-41
![Page 42: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/42.jpg)
Example
04/21/23 © 2002-08 Hal Perkins & UW CSE T-42
![Page 43: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/43.jpg)
Back Edges & Loops
A flow graph edge from a node n to a node h that dominates n is a back edge
For every back edge there is a corresponding subgraph of the flow graph that is a loop
04/21/23 © 2002-08 Hal Perkins & UW CSE T-43
![Page 44: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/44.jpg)
Natural Loops If h dominates n and n->h is a back
edge, then the natural loop of that back edge is the set of nodes x such that h dominates x There is a path from x to n not containing h
h is the header of this loop Standard loop optimizations can cope
with loops whether they are natural or not
04/21/23 © 2002-08 Hal Perkins & UW CSE T-44
![Page 45: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/45.jpg)
Inner Loops
Inner loops are more important for optimization because most execution time is expected to be spent there
If two loops share a header, it is hard to tell which one is “inner” Common way to handle this is to merge
natural loops with the same header
04/21/23 © 2002-08 Hal Perkins & UW CSE T-45
![Page 46: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/46.jpg)
Inner (nested) loops
Suppose A and B are loops with headers a and b a b b is in A
Then The nodes of B are a proper subset of A B is nested in A, or B is the inner loop
04/21/23 © 2002-08 Hal Perkins & UW CSE T-46
![Page 47: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/47.jpg)
Loop-Nest Tree Given a flow graph G
1. Compute the dominators of G2. Construct the dominator tree3. Find the natural loops (thus all loop-
header nodes)4. For each loop header h, merge all
natural loops of h into a single loop: loop[h]
5. Construct a tree of loop headers s.t. h1 is above h2 if h2 is in loop[h1]
04/21/23 © 2002-08 Hal Perkins & UW CSE T-47
![Page 48: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/48.jpg)
Loop-Nest Tree details
Leaves of this tree are the innermost loops
Need to put all non-loop nodes somewhere Convention: lump these into the root
of the loop-nest tree
04/21/23 © 2002-08 Hal Perkins & UW CSE T-48
![Page 49: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/49.jpg)
Example
04/21/23 © 2002-08 Hal Perkins & UW CSE T-49
![Page 50: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/50.jpg)
Loop Preheader
Often we need a place to park code right before the beginning of a loop
Easy if there is a single node preceding the loop header h But this isn’t the case in general
So insert a preheader node p Include an edge p->h Change all edges x->h to be x->p
04/21/23 © 2002-08 Hal Perkins & UW CSE T-50
![Page 51: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/51.jpg)
Loop-Invariant Computations
Idea: If x := a1 op a2 always does the same thing each time around the loop, we’d like to hoist it and do it once outside the loop
But can’t always tell if a1 and a2 will have the same value Need a conservative (safe)
approximation
04/21/23 © 2002-08 Hal Perkins & UW CSE T-51
![Page 52: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/52.jpg)
Loop-Invariant Computations d: x := a1 op a2 is loop-invariant if for
each ai ai is a constant, or All the definitions of ai that reach d are
outside the loop, or Only one definition of ai reaches d, and that
definition is loop invariant Use this to build an iterative algorithm
Base cases: constants and operands defined outside the loop
Then: repeatedly find definitions with loop-invariant operands
04/21/23 © 2002-08 Hal Perkins & UW CSE T-52
![Page 53: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/53.jpg)
Hoisting Assume that d: x := a1 op a2 is loop
invariant. We can hoist it to the loop preheader if d dominates all loop exits where x is
live-out, and There is only one definition of x in the
loop, and x is not live-out of the loop preheader
Need to modify this if a1 op a2 could have side effects or raise an exception
04/21/23 © 2002-08 Hal Perkins & UW CSE T-53
![Page 54: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/54.jpg)
Hoisting: Possible? Example 1
L0: t := 0L1: i := i + 1
t := a op bM[i] := tif i < n goto
L1L2: x := t
Example 2L0: t := 0L1: if i ≥ n goto
L2 i := i + 1t := a op bM[i] := tgoto L1
L2: x := t
04/21/23 © 2002-08 Hal Perkins & UW CSE T-54
![Page 55: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/55.jpg)
Hoisting: Possible? Example 3
L0: t := 0L1: i := i + 1
t := a op bM[i] := tt := 0M[j] := tif i < n goto
L1L2: x := t
Example 4L0: t := 0L1: M[j] := t
i := i + 1t := a op bM[i] := t if i < n goto
L1L2: x := t
04/21/23 © 2002-08 Hal Perkins & UW CSE T-55
![Page 56: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/56.jpg)
Induction Variables
Suppose inside a loop Variable i is incremented or
decremented Variable j is set ot i*c+d where c and d
are loop-invariant Then we can calculate j’s value
without using i Whenever i is incremented by a,
increment j by c*a
04/21/23 © 2002-08 Hal Perkins & UW CSE T-56
![Page 57: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/57.jpg)
Example Original
s := 0i := 0
L1: if i ≥ n goto L2
j := i*4k := j+ax := M[k]s := s+xi := i+1goto L1
L2:
Do Induction-variable
analysis to discover i and j are related induction variables
Strength reduction to replace *4 with an addition
Induction-variable elimination to replace i ≥ n
Assorted copy propagation
04/21/23 © 2002-08 Hal Perkins & UW CSE T-57
![Page 58: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/58.jpg)
Result Original
s := 0i := 0
L1: if i ≥ n goto L2
j := i*4k := j+ax := M[k]s := s+xi := i+1goto L1
L2:
Transformeds := 0k’ = ab = n*4c = a+b
L1: if k’ ≥ c goto L2
x := M[k’]s := s+xk’ := k’+4goto L1
L2:
04/21/23 © 2002-08 Hal Perkins & UW CSE T-58
Details are somewhat messy – see your favorite compiler book
![Page 59: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/59.jpg)
Loop Unrolling
If the body of a loop is small, most of the time is spent in the “increment and test” code
Idea: reduce overhead by unrolling – put two or more copies of the loop body inside the loop
04/21/23 © 2002-08 Hal Perkins & UW CSE T-59
![Page 60: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/60.jpg)
Loop Unrolling
Basic idea: Given loop L with header node h and back edges si->h1. Copy the nodes to make loop L’ with
header h’ and back edges si’->h’2. Change all backedges in L from si->h
to si->h’3. Change all back edges in L’ from si’-
>h’ to si’->h
04/21/23 © 2002-08 Hal Perkins & UW CSE T-60
![Page 61: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/61.jpg)
Unrolling Algorithm Results Before
L1: x := M[i]s := s + xi := i + 4
if i<n goto L1 else L2
L2:
AfterL1: x := M[i]
s := s + xi := i + 4if i<n goto L1’
else L2L1’: x := M[i]
s := s + xi := i + 4
if i<n goto L1 else L2L2:
04/21/23 © 2002-08 Hal Perkins & UW CSE T-61
![Page 62: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/62.jpg)
Hmmmm….
Not so great – just code bloat But: use induction variables and
various loop transformations to clean up
04/21/23 © 2002-08 Hal Perkins & UW CSE T-62
![Page 63: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/63.jpg)
After Some Optimizations Before
L1: x := M[i]s := s + xi := i + 4if i<n goto L1’
else L2L1’: x := M[i]
s := s + xi := i + 4
if i<n goto L1 else L2L2:
AfterL1: x := M[i]
s := s + xx := M[i+4]s := s + xi := i + 8if i<n goto L1
else L2L2:
04/21/23 © 2002-08 Hal Perkins & UW CSE T-63
![Page 64: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/64.jpg)
Still Broken
But in a different, better(?) way Good code, but only correct if
original number of loop iterations was even
Fix: add an epilogue to handle the “odd” leftover iteration
04/21/23 © 2002-08 Hal Perkins & UW CSE T-64
![Page 65: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/65.jpg)
Fixed Before
L1: x := M[i]s := s + xx := M[i+4]s := s + xi := i + 8
if i<n goto L1 else L2
L2:
Afterif i<n-8 goto L1
else L2L1: x := M[i]
s := s + xx := M[i+4]s := s + xi := i + 8if i<n-8 goto L1
else L2L2: x := M[i]
s := s+xi := i+4if i < n goto L2
else L3L3:
04/21/23 © 2002-08 Hal Perkins & UW CSE T-65
![Page 66: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/66.jpg)
Postscript
This example only unrolls the loop by a factor of 2
More typically, unroll by a factor of K Then need an epilogue that is a loop
like the original that iterates up to K-1 times
04/21/23 © 2002-08 Hal Perkins & UW CSE T-66
![Page 67: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/67.jpg)
Memory Heirarchies One of the great triumphs of computer
design Effect is a large, fast memory Reality is a series of progressively
larger, slower, cheaper stores, with frequently accessed data automatically staged to faster storage (cache, main storage, disk)
Programmer/compiler typically treats it as one large store. Bug or feature?
04/21/23 © 2002-08 Hal Perkins & UW CSE T-67
![Page 68: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/68.jpg)
Memory Issues Byte load/store is often slower than whole
(physical) word load/store Unaligned access is often extremely slow
Temporal locality: accesses to recently accessed data will usually find it in the (fast) cache
Spatial locality: accesses to data near recently used data will usually be fast “near” = in the same cache block
But – accesses to blocks that map to the same cache block will cause thrashing
04/21/23 © 2002-08 Hal Perkins & UW CSE T-68
![Page 69: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/69.jpg)
Data Alignment Data objects (structs) often are similar
in size to a cache block (≈ 8 words) Better if objects don’t span blocks
Some strategies Allocate objects sequentially; bump to
next block boundary if useful Allocate objects of same common size in
separate pools (all size-2, size-4, etc.) Tradeoff: speed for some wasted space
04/21/23 © 2002-08 Hal Perkins & UW CSE T-69
![Page 70: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/70.jpg)
Instruction Alignment Align frequently executed basic blocks on
cache boundaries (or avoid spanning cache blocks)
Branch targets (particularly loops) may be faster if they start on a cache line boundary
Try to move infrequent code (startup, exceptions) away from hot code
Optimizing compiler should have a basic-block ordering phase (& maybe even loader)
04/21/23 © 2002-08 Hal Perkins & UW CSE T-70
![Page 71: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/71.jpg)
Loop Interchange Watch for bad cache patterns in inner
loops; rearrange if possible Example
for (i = 0; i < m; i++) for (j = 0; j < n; j++) for (k = 0; k < p; k++) a[i,k,j] = b[i,j-1,k] + b[i,j,k] + b[i,j+1,k]
b[i,j+1,k] is reused in the next two iterations, but will have been flushed from the cache by the k loop
04/21/23 © 2002-08 Hal Perkins & UW CSE T-71
![Page 72: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/72.jpg)
Loop Interchange Solution for this example: interchange
j and k loopsfor (i = 0; i < m; i++) for (k = 0; k < p; k++) for (j = 0; j < n; j++) a[i,k,j] = b[i,j-1,k] + b[i,j,k] + b[i,j+1,k]
Now b[i,j+1,k] will be used three times on each cache load
Safe because loop iterations are independent
04/21/23 © 2002-08 Hal Perkins & UW CSE T-72
![Page 73: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/73.jpg)
Loop Interchange Need to construct a data-dependency
graph showing information flow between loop iterations
For example, iteration (j,k) depends on iteration (j’,k’) if (j’,k’) computes values used in (j,k) or stores values overwritten by (j,k) If there is a dependency and loops are
interchanged, we could get different results – so can’t do it
04/21/23 © 2002-08 Hal Perkins & UW CSE T-73
![Page 74: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/74.jpg)
Blocking Consider matrix multiply
for (i = 0; i < n; i++) for (j = 0; j < n; j++) { c[i,j] = 0.0; for (k = 0; k < n; k++) c[i,j] = c[i,j] + a[i,k]*b[k,j] }
If A, B fit in the cache together, great! If they don’t, then every b[k,j] reference will be a
cache miss Loop interchange (i<->j) won’t help; then every
a[i,k] reference would be a miss
04/21/23 © 2002-08 Hal Perkins & UW CSE T-74
![Page 75: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/75.jpg)
Blocking
Solution: reuse rows of A and columns of B while they are still in the cache
Assume the cache can hold 2*c*n matrix elements (1 < c < n)
Calculate c c blocks of C using c rows of A and c columns of B
04/21/23 © 2002-08 Hal Perkins & UW CSE T-75
![Page 76: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/76.jpg)
Blocking
Calculating c c blocks of Cfor (i = i0; i < i0+c; i++) for (j = j0; j < j0+c; j++) { c[i,j] = 0.0; for (k = 0; k < n; k++) c[i,j] = c[i,j] + a[i,k]*b[k,j] }
04/21/23 © 2002-08 Hal Perkins & UW CSE T-76
![Page 77: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/77.jpg)
Blocking Then nest this inside loops that
calculate successive c c blocksfor (i0 = 0; i0 < n; i0+=c) for (j0 = 0; j0 < n; j0+=c) for (i = i0; i < i0+c; i++) for (j = j0; j < j0+c; j++) { c[i,j] = 0.0; for (k = 0; k < n; k++) c[i,j] = c[i,j] + a[i,k]*b[k,j] }
04/21/23 © 2002-08 Hal Perkins & UW CSE T-77
![Page 78: 12/18/2015© 2002-08 Hal Perkins & UW CSET-1 CSE P 501 – Compilers Analysis & Optimizations & Loops Hal Perkins Winter 2008](https://reader035.vdocuments.us/reader035/viewer/2022062805/5697bfc61a28abf838ca7182/html5/thumbnails/78.jpg)
Parallelizing Code
This is only a taste of how we can rearrange loops. There is a whole class of transformations that attempt to discover loops that can be vectorized or done in parallel, which we won’t get to. Look for more in the Dragon Book or other sources.
04/21/23 © 2002-08 Hal Perkins & UW CSE T-78