EECS 583 Class 9 Classic Optimization

Transcription

1 EECS 583 Class 9 Classic Optimization University of Michigan September 28, 2016

2 Generalizing Dataflow Analysis Transfer function» How information is changed by something (BB)» OUT = GEN + (IN KILL) /* forward analysis */» IN = GEN + (OUT KILL) /* backward analysis */ Meet function» How information from multiple paths is combined» IN = Union(OUT(predecessors)) /* forward analysis */» OUT = Union(IN(successors)) /* backward analysis */ Generalized dataflow algorithm» while (change) Ÿ change = false Ÿ for each BB apply meet function apply transfer functions if any changes à change = true - 1 -

3 What About All Path Problems? Up to this point» Any path problems (maybe relations) Ÿ Definition reaches along some path Ÿ Some sequence of branches in which def reaches Ÿ Lots of defs of the same variable may reach a point» Use of Union operator in meet function All-path: Definition guaranteed to reach» Regardless of sequence of branches taken, def reaches» Can always count on this» Only 1 def can be guaranteed to reach» Availability (as opposed to reaching) Ÿ Available definitions Ÿ Available expressions (could also have reaching expressions, but not that useful) - 2 -

4 Reaching vs Available Definitions 1:r1 = r2 + r3 2:r6 = r4 r5 1,2 reach 1,2 available 1,2 reach 1,2 available 3:r4 = 4 4:r6 = 8 5:r6 = r2 + r3 6:r7 = r4 r5 1,2,3,4 reach 1 available 1,3,4 reach 1,3,4 available - 3 -

5 Available Definition Analysis (Adefs) A definition d is available at a point p if along all paths from d to p, d is not killed Remember, a definition of a variable is killed between 2 points when there is another definition of that variable along the path» r1 = r2 + r3 kills previous definitions of r1 Algorithm» Forward dataflow analysis as propagation occurs from defs downwards» Use the Intersect function as the meet operator to guarantee the all-path requirement» GEN/KILL/IN/OUT similar to reaching defs Ÿ Initialization of IN/OUT is the tricky part - 4 -

6 Compute GEN/KILL Sets for each BB (Adefs) Exactly the same as reaching defs!!! for each basic block in the procedure, X, do GEN(X) = 0 KILL(X) = 0 for each operation in sequential order in X, op, do for each destination operand of op, dest, do G = op K = {all ops which define dest op} GEN(X) = G + (GEN(X) K) KILL(X) = K + (KILL(X) G) endfor endfor endfor - 5 -

7 Compute IN/OUT Sets for all BBs (Adefs) U = universal set of all operations in the Procedure IN(0) = 0 OUT(0) = GEN(0) for each basic block in procedure, W, (W!= 0), do IN(W) = 0 OUT(W) = U KILL(W) change = 1 while (change) do change = 0 for each basic block in procedure, X, do old_out = OUT(X) IN(X) = Intersect(OUT(Y)) for all predecessors Y of X OUT(X) = GEN(X) + (IN(X) KILL(X)) if (old_out!= OUT(X)) then change = 1 endif endfor endfor - 6 -

8 Available Expression Analysis (Aexprs) An expression is a RHS of an operation» r2 = r3 + r4, r3+r4 is an expression An expression e is available at a point p if along all paths from e to p, e is not killed An expression is killed between 2 points when one of its source operands are redefined» r1 = r2 + r3 kills all expressions involving r1 Algorithm» Forward dataflow analysis as propagation occurs from defs downwards» Use the Intersect function as the meet operator to guarantee the all-path requirement» Looks exactly like adefs, except GEN/KILL/IN/OUT are the RHS s of operations rather than the LHS s - 7 -

9 Computation of Aexpr GEN/KILL Sets We can also formulate the GEN/KILL slightly differently so you do not need to break up instructions like r2 = r for each basic block in the procedure, X, do GEN(X) = 0 KILL(X) = 0 for each operation in sequential order in X, op, do K = 0 for each destination operand of op, dest, do K += {all ops which use dest} endfor if (op not in K) G = op else G = 0 GEN(X) = G + (GEN(X) K) KILL(X) = K + (KILL(X) G) endfor endfor - 8 -

10 Class Problem - Aexprs Calculation 1: r1 = r6 * r9 2: r2 = r : r5 = r3 * r4 4: r1 = r : r3 = r3 * r4 6: r8 = r3 * 2 7: r7 = r3 * r4 8: r1 = r : r7 = r1-6 10: r8 = r : r1 = r3 * r4 12: r3 = r6 * r9-9 -

11 Dataflow Analyses in 1 Slide Liveness OUT = Union(IN(succs)) IN = GEN + (OUT KILL) Reaching Definitions/DU/UD IN = Union(OUT(preds)) OUT = GEN + (IN KILL) Bottom-up dataflow Any path Keep track of variables/registers Uses of variables à GEN Defs of variables à KILL Available Expressions Top-down dataflow Any path Keep track of instruction IDs Defs of variables à GEN Defs of variables à KILL Available Definitions IN = Intersect(OUT(preds)) OUT = GEN + (IN KILL) Top-down dataflow All path Keep track of instruction IDs Expressions of variables à GEN Defs of variables à KILL IN = Intersect(OUT(preds)) OUT = GEN + (IN KILL) Top-down dataflow All path Keep track of instruction IDs Defs of variables à GEN Defs of variables à KILL

12 Some Things to Think About Liveness and rdefs are basically the same thing» All dataflow is basically the same with a few parameters Ÿ Meaning of gen/kill src vs dest, variable vs operation Ÿ Backward / Forward Ÿ All paths / some paths (must/may) Ÿ What other dataflow analysis problems can be formulated? Dataflow can be slow» How to implement it efficiently? Ÿ Forward analysis DFS order Ÿ Backward analysis PostDFS order» How to represent the info? Predicates» Throw a monkey wrench into this stuff» So, how are predicates handled?

13 Code Optimization

14 Code Optimization Make the code run faster on the target processor» Other objectives: Power, code size Classes of optimization» 1. Classical (machine independent) Ÿ Reducing operation count (redundancy elimination) Ÿ Simplifying operations Ÿ Generally good for any kind of machine» 2. Machine specific Ÿ Peephole optimizations Ÿ Take advantage of specialized hardware features» 3. Parallelism enhancing Ÿ Increasing parallelism (ILP or TLP) Ÿ Possibly increase instructions

15 A Tour Through the Classical Optimizations For this class Go over concepts of a small subset of the optimizations» What it is, why its useful» When can it be applied (set of conditions that must be satisfied)» How it works» Give you the flavor but don t want to beat you over the head Challenges» Register pressure?» Parallelism verses operation count

16 Dead Code Elimination Remove any operation whose result is never consumed Rules» X can be deleted Ÿ no stores or branches» DU chain empty or dest register not live This misses some dead code» Especially in loops» Critical operation Ÿ store or branch operation» Any operation that does not directly or indirectly feed a critical operation is dead» Trace UD chains backwards from critical operations» Any op not visited is dead r1 = 3 r2 = 10 r4 = r4 + 1 r7 = r1 * r4 r2 = 0 r3 = r3 + 1 r3 = r2 + r1 store (r1, r3)

17 Local Constant Propagation Forward propagation of moves of the form» rx = L (where L is a literal)» Maximally propagate Consider 2 ops, X and Y in a BB, X is before Y» 1. X is a move» 2. src1(x) is a literal» 3. Y consumes dest(x)» 4. There is no definition of dest(x) between X and Y» 5. No danger betw X and Y Ÿ When dest(x) is a Macro reg, BRL destroys the value r1 = 5 r2 = _x r3 = 7 r4 = r4 + r1 r1 = r1 + r2 r1 = r1 + 1 r3 = 12 r8 = r1 - r2 r9 = r3 + r5 r3 = r2 + 1 r10 = r3 r1 Note, ignore operation format issues, so all operations can have literals in either operand position

18 Global Constant Propagation Consider 2 ops, X and Y in different BBs» 1. X is a move» 2. src1(x) is a literal» 3. Y consumes dest(x)» 4. X is in a_in(bb(y))» 5. Dest(x) is not modified between the top of BB(Y) and Y» 6. No danger betw X and Y Ÿ When dest(x) is a Macro reg, BRL destroys the value r1 = r1 + r2 r1 = 5 r2 = _x r8 = r1 * r2 r7 = r1 r2 r9 = r1 + r2-17 -

19 Constant Folding Simplify 1 operation based on values of src operands» Constant propagation creates opportunities for this All constant operands» Evaluate the op, replace with a move Ÿ r1 = 3 * 4 à r1 = 12 Ÿ r1 = 3 / 0 à??? Don t evaluate excepting ops!, what about floating-point?» Evaluate conditional branch, replace with BRU or noop Ÿ if (1 < 2) goto BB2 à BRU BB2 Ÿ if (1 > 2) goto BB2 à convert to a noop Algebraic identities» r1 = r2 + 0, r2 0, r2 0, r2 ^ 0, r2 << 0, r2 >> 0 Ÿ r1 = r2» r1 = 0 * r2, 0 / r2, 0 & r2 Ÿ r1 = 0» r1 = r2 * 1, r2 / 1 Ÿ r1 = r2-18 -

20 Class Problem r1 = 0 r2 = 10 r3 = 0 Optimize this applying 1. constant propagation 2. constant folding r4 = 1 r7 = r1 * 4 r6 = 8 if (r3 > 0) r2 = 0 r6 = r6 * r7 r3 = r2 / r6 r3 = r4 r3 = r3 + r2 r1 = r6 r2 = r2 + 1 r1 = r1 + 1 if (r1 < 100) store (r1, r3)

21 Forward Copy Propagation Forward propagation of the RHS of moves» r1 = r2»» r4 = r1 + 1 à r4 = r2 + 1 Benefits» Reduce chain of dependences» Eliminate the move Rules (ops X and Y)» X is a move» src1(x) is a register» Y consumes dest(x)» X.dest is an available def at Y» X.src1 is an available expr at Y r1 = r2 r3 = r4 r2 = 0 r6 = r3 + 1 r5 = r2 + r3-20 -

22 CSE Common Subexpression Elimination Eliminate recomputation of an expression by reusing the previous result» r1 = r2 * r3» à r100 = r1»» r4 = r2 * r3 à r4 = r100 Benefits» Reduce work» Moves can get copy propagated Rules (ops X and Y)» X and Y have the same opcode» src(x) = src(y), for all srcs» expr(x) is available at Y» if X is a load, then there is no store that may write to address(x) along any path between X and Y r1 = r2 * r6 r3 = r4 / r7 r2 = r2 + 1 r6 = r3 * 7 r5 = r2 * r6 r8 = r4 / r7 r9 = r3 * 7 if op is a load, call it redundant load elimination rather than CSE

23 Class Problem r4 = r1 r6 = r15 r2 = r3 * r4 r8 = r2 + r5 r9 = r3 r7 = load(r2) if (r2 > r8) Optimize this applying 1. dead code elimination 2. forward copy propagation 3. CSE r5 = r9 * r4 r11 = r2 r12 = load(r11) if (r12!= 0) r3 = load(r2) r10 = r3 / r6 r11 = r8 store (r11, r7) store (r12, r3)

24 Loop Invariant Code Motion (LICM) Move operations whose source operands do not change within the loop to the loop preheader» Execute them only 1x per invocation of the loop» Be careful with memory operations!» Be careful with ops not executed every iteration r8 = r2 + 1 r7 = r8 * r4 r1 = 3 r5 = &A r4 = load(r5) r7 = r4 * 3 r3 = r2 + 1 r1 = r1 + r7 store (r1, r3)

25 LICM (2) Rules» X can be moved» src(x) not modified in loop body» X is the only op to modify dest(x)» for all uses of dest(x), X is in the available defs set» for all exit BB, if dest(x) is live on the exit edge, X is in the available defs set on the edge» if X not executed on every iteration, then X must provably not cause exceptions» if X is a load or store, then there are no writes to address(x) in loop r8 = r2 + 1 r7 = r8 * r4 r1 = 3 r5 = &A r4 = load(r5) r7 = r4 * 3 r3 = r2 + 1 r1 = r1 + r7 Homework 2 eliminates the last rule. You can also ignore the executed on every iteration rule for SpecLICM. store (r1, r3)

26 Global Variable Migration Assign a global variable temporarily to a register for the duration of the loop» Load in preheader» Store at exit points Rules» X is a load or store» address(x) not modified in the loop» if X not executed on every iteration, then X must provably not cause an exception» All memory ops in loop whose address can equal address(x) must always have the same address as X r8 = load(r5) r7 = r8 * r4 r4 = load(r5) r4 = r4 + 1 store(r5,r7) store(r5, r4)

27 Induction Variable Strength Reduction Create basic induction variables from derived induction variables Induction variable» BIV (i++) Ÿ 0,1,2,3,4,...» DIV (j = i * 4) Ÿ 0, 4, 8, 12, 16,...» DIV can be converted into a BIV that is incremented by 4 Issues» Initial and increment vals» Where to place increments r5 = r4-3 r4 = r4 + 1 r6 = r4 << 2 r7 = r4 * r9-26 -

28 Induction Variable Strength Reduction (2) Rules» X is a *, <<, + or operation» src1(x) is a basic ind var» src2(x) is invariant» No other ops modify dest(x)» dest(x)!= src(x) for all srcs» dest(x) is a register Transformation» Insert the following into the preheader Ÿ new_reg = RHS(X)» If opcode(x) is not add/sub, insert to the bottom of the preheader Ÿ new_inc = inc(src1(x)) opcode(x) src2(x)» else Ÿ new_inc = inc(src1(x))» Insert the following at each update of src1(x) Ÿ new_reg += new_inc» Change X à dest(x) = new_reg r5 = r4-3 r4 = r4 + 1 r6 = r4 << 2 r7 = r4 * r9-27 -

29 Class Problem r1 = 0 r2 = 0 Optimize this applying induction var str reduction r5 = r5 + 1 r11 = r5 * 2 r10 = r r12 = load (r10+0) r9 = r1 << 1 r4 = r9-10 r3 = load(r4+4) r3 = r3 + 1 store(r4+0, r3) r7 = r3 << 2 r6 = load(r7+0) r13 = r2-1 r1 = r1 + 1 r2 = r2 + 1 r13, r12, r6, r10 liveout

30 ILP Optimization Traditional optimizations» Redundancy elimination» Reducing operation count ILP (instruction-level parallelism) optimizations» Increase the amount of parallelism and the ability to overlap operations» Operation count is secondary, often trade parallelism for extra instructions (avoid code explosion) ILP increased by breaking dependences» True or flow = read after write dependence» False or (anti/output) = write after read, write after write

31 Back Substitution Generation of expressions by compiler frontends is very sequential» Account for operator precedence» Apply left-to-right within same precedence Back substitution» Create larger expressions Ÿ Iteratively substitute RHS expression for LHS variable» Note may correspond to multiple source statements» Enable subsequent optis Optimization» Re-compute expression in a more favorable manner y = a + b + c d + e f; r9 = r1 + r2 r10 = r9 + r3 r11 = r10 - r4 r12 = r11 + r5 r13 = r12 r6 Subs r12: r13 = r11 + r5 r6 Subs r11: r13 = r10 r4 + r5 r6 Subs r10 r13 = r9 + r3 r4 + r5 r6 Subs r9 r13 = r1 + r2 + r3 r4 + r5 r6

32 Tree Height Reduction Re-compute expression as a balanced binary tree» Obey precedence rules» Essentially re-parenthesize» Combine literals if possible Effects» Height reduced (n terms) Ÿ n-1 (assuming unit latency) Ÿ ceil(log2(n))» Number of operations remains constant» Cost Ÿ Temporary registers live longer» Watch out for Ÿ Always ok for integer arithmetic Ÿ Floating-point may not be!! original: r9 = r1 + r2 r10 = r9 + r3 r11 = r10 - r4 r12 = r11 + r5 r13 = r12 r6 after back subs: r13 = r1 + r2 + r3 r4 + r5 r6 r1 + r2 r3 r4 r5 r6 + + r13 final code: t1 = r1 + r2 t2 = r3 r4 t3 = r5 r6 t4 = t1 + t2 r13 = t4 + t3-31 -

33 Class Problem Assume: + = 1, * = 3 operand arrival times 0 r1 0 r2 0 r3 1 r4 2 r5 0 r6 r10 = r1 * r2 r11 = r10 + r3 r12 = r11 + r4 r13 = r12 r5 r14 = r13 + r6 Back susbstitute Re-express in tree-height reduced form Account for latency and arrival times

34 Optimizing Unrolled Loops loop: r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop Unroll = replicate loop body n-1 times. Hope to enable overlap of operation execution from different iterations Not possible! unroll 3 times loop: iter1 iter2 iter3 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop

35 Register Renaming on Unrolled Loop loop: iter1 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 loop: iter1 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 iter2 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 iter2 r11 = load(r2) r13 = load(r4) r15 = r11 * r13 r6 = r6 + r15 r2 = r2 + 4 r4 = r4 + 4 iter3 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop iter3 r21 = load(r2) r23 = load(r4) r25 = r21 * r23 r6 = r6 + r25 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop

36 Register Renaming is Not Enough! loop: iter1 iter2 iter3 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 r11 = load(r2) r13 = load(r4) r15 = r11 * r13 r6 = r6 + r15 r2 = r2 + 4 r4 = r4 + 4 r21 = load(r2) r23 = load(r4) r25 = r21 * r23 r6 = r6 + r25 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop Still not much overlap possible Problems» r2, r4, r6 sequentialize the iterations» Need to rename these 2 specialized renaming optis» Accumulator variable expansion (r6)» Induction variable expansion (r2, r4)

37 Accumulator Variable Expansion loop: iter1 iter2 iter3 r16 = r26 = 0 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r2 + 4 r4 = r4 + 4 r11 = load(r2) r13 = load(r4) r15 = r11 * r13 r16 = r16 + r15 r2 = r2 + 4 r4 = r4 + 4 r21 = load(r2) r23 = load(r4) r25 = r21 * r23 r26 = r26 + r25 r2 = r2 + 4 r4 = r4 + 4 if (r4 < 400) goto loop r6 = r6 + r16 + r Accumulator variable» x = x + y or x = x y» where y is loop variant!! Create n-1 temporary accumulators Each iteration targets a different accumulator Sum up the accumulator variables at the end May not be safe for floatingpoint values

38 Induction Variable Expansion loop: iter1 iter2 iter3 r12 = r2 + 4, r22 = r2 + 8 r14 = r4 + 4, r24 = r4 + 8 r16 = r26 = 0 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r2 = r r4 = r r11 = load(r12) r13 = load(r14) r15 = r11 * r13 r16 = r16 + r15 r12 = r r14 = r r21 = load(r22) r23 = load(r24) r25 = r21 * r23 r26 = r26 + r25 r22 = r r24 = r if (r4 < 400) goto loop r6 = r6 + r16 + r Induction variable» x = x + y or x = x y» where y is loop invariant!! Create n-1 additional induction variables Each iteration uses and modifies a different induction variable Initialize induction variables to init, init+step, init+2*step, etc. Step increased to n*original step Now iterations are completely independent!!

39 Better Induction Variable Expansion loop: iter1 iter2 r16 = r26 = 0 r1 = load(r2) r3 = load(r4) r5 = r1 * r3 r6 = r6 + r5 r11 = load(r2+4) r13 = load(r4+4) r15 = r11 * r13 r16 = r16 + r15 With base+displacement addressing, often don t need additional induction variables» Just change offsets in each iterations to reflect step» Change final increments to n * original step iter3 r21 = load(r2+8) r23 = load(r4+8) r25 = r21 * r23 r26 = r26 + r25 r2 = r r4 = r if (r4 < 400) goto loop r6 = r6 + r16 + r

40 Homework Problem loop: r1 = load(r2) r5 = r6 + 3 r6 = r5 + r1 r2 = r2 + 4 if (r2 < 400) goto loop Optimize the unrolled loop Renaming Tree height reduction Ind/Acc expansion loop: r1 = load(r2) r5 = r6 + 3 r6 = r5 + r1 r2 = r2 + 4 r1 = load(r2) r5 = r6 + 3 r6 = r5 + r1 r2 = r2 + 4 r1 = load(r2) r5 = r6 + 3 r6 = r5 + r1 r2 = r2 + 4 if (r2 < 400) goto loop