Lecture 36: Code Optimization

Transcription

1 troduction to Code Optimization n istheusualterm, but isgrosslymisnamed, sincecode timizers is not optimal in any reasonable sense. Pront would be more appropriate. e basic block 2 * x t + x > 0 goto L2 Basic-Block Example graphs (CFGs) plification ing -assignment form (SSA) xpression elimination (CSE) tion imination imizations (3) to be executed without (2) having been executed e nge (3) to w := 3 * x nate (2) as well? :49: CS164: Lecture #36 2 0:49: CS164: Lecture #36 4 Lecture 36: Code Optimization otes by R. Bodik and G. Necula] Basic Blocks k is a maximal sequence of instructions with: (except at the first instruction), and (except in the last instruction) mp into a basic block, except at the beginning. mp within a basic block, except at end. e, each instruction in a basic block is executed after all ding instructions have been executed :49: CS164: Lecture #36 1 0:49: CS164: Lecture #36 3

2 Control-Flow Graphs: Example A Classification of Optimizations 1 1 x 1 goto L The body of a method (or procedure) can be represented as a CFG There is one initial node All return nodes are terminal es like C and Java there are three granularities of optimizations: Apply to a basic block in isolation. timizations: Apply to a control-flow graph (single func- ) in isolation. ocedural optimizations: Apply across function boundaries. ers do (1), many do (2) and very few do (3) expense: (2) and (3) typically require superlinear time. handle that when limited to a single function, but gets for larger program. generally don t implement fanciest known optimizations: rd to implement (esp., hard to get right), some require a ation time. aximum improvement with minimum cost. :49: CS164: Lecture #36 6 0:49: CS164: Lecture #36 8 Control-Flow Graphs (CFGs) w graph is a directed graph with basic blocks as nodes dge from block A to block B if the execution can flow instruction in A to the first instruction in B: struction in A can be a jump to the label of B. ion can fall through from the end of block A to the of block B. Optimization Overview n seeks to improve a program s utilization of some ren time (most often) messages sent ower used, etc. n should not depart from the programming language s semantics of a particular program is deterministic, optist not change the answer. r hand, some program behavior is undefined (e.g., what n an unchecked rule in C is violated), and in those cases, may cause differences in results. :49: CS164: Lecture #36 5 0:49: CS164: Lecture #36 7

3 al Optimization: Constant Folding Single Assignment Form n constants can be computed at compile time. = becomes x := 4. < 0 jump L becomes a no-op. constant folding be dangerous? zations are simplified if each assignment is to a tempos not appeared already in the basic block. e code can be rewritten to be in (static) single assignform: y x a x := a + y a1 := x x1 := a1 * x b := x1 + a1 d a1 are fresh temporaries. :49: CS164: Lecture # :49: CS164: Lecture #36 12 ptimizations: Algebraic Simplification ents can be deleted 0 1 ents can be simplified or converted to use faster op- Simplified x := 0 y := y * y x := x << 3 t := x << 4; x := t - x hines << is faster than *; but not on all!) ptimization: Unreachable code elimination that are not reachable from the entry point of the CFG nated. uch basic blocks occur? reachable code makes the program smaller (sometimes due to instruction-cache effects, but this is probably y large effect.) :49: CS164: Lecture #36 9 0:49: CS164: Lecture #36 11

4 Copy Propagation pears in a block, can replace all subsequent uses of w x. Dead Code Elimination ement w := rhs appears in a basic block and w does not here else in the program, we say that the statement is n be eliminated; it does not contribute to the program s b:=z+y a := b x:=2*b make the program smaller or faster but might enable ations. For example, if a is not used after this stated not assign to it. is not used anywhere else) y b := z + y b := z + y a := b a x := 2 * b x := 2 * b used SSA here? b:=13 x:=2*13 iately enables constant folding. timization, as described, won t work unless the block is nment form. :49: CS164: Lecture # :49: CS164: Lecture #36 16 xpression (CSE) Elimination in Basic Blocks expression is an expression that appears multiple times nd side in contexts where the operands have the same case (so that the expression will yield the same value). the basic block on the left is in single assignment form. Example of Copy Propagation and Constant Folding a := 5 a := 5 a := 5 a := 5 x := 2 * 5 x := 10 x := 10 x := 10 y := x + 6 y := y := 16 y := 16 t := x * y t := 10 * y t := 10 * 16 t := 160 z z x := y + z w := x o assignments have the same right-hand side, we can econd instance of that right-hand side with the variassigned the first instance. se the assumption of single assignment here? :49: CS164: Lecture # :49: CS164: Lecture #36 15

5 An Example: Initial Code An Example: Copy propagation :49: CS164: Lecture # :49: CS164: Lecture #36 20 Applying Local Optimizations Example II: Algebraic simplification ples show, each local optimization does very little by timizations interact: performing one optimization entimizing compilers repeatedly perform optimizations vement is possible, or it is no longer cost effective. :49: CS164: Lecture # :49: CS164: Lecture #36 19

6 ple: Common Subexpression Elimination n Example: Dead code elimination nal form. :49: CS164: Lecture # :49: CS164: Lecture #36 24 An Example: Constant folding An Example: Copy propagation :49: CS164: Lecture # :49: CS164: Lecture #36 23

7 eephole optimization examples: Global Optimization for pattern variables. L: movl movl not the target of a jump., %@a; %@b %@b is dead. mov hack: we reuse the valueias both the immediate value t from ra. On the PDP11, the program counter is r7. ptimizations, peephole optimizations need to be applied get maximum effect. ization refers to program optimizations that encompass ic blocks in a function. the term galactic optimization to refer to going beyond ndaries, but it hasn t caught on; we call it just interpromization.) n t use the usual assumptions about basic blocks, global requires global flow analysis to see where values can nd get used. question is: When can local optimizations (from the last applied across multiple basic blocks? :49: CS164: Lecture # :49: CS164: Lecture #36 28 ole Optimizations on Assembly Code tions presented before work on intermediate code. imization is a technique for improving assembly code hole is a short subsequence of (usually contiguous) in-, either continguous, or linked together by the fact operate on certain registers that no intervening inmodify. izer replaces the sequence with another equivalent, but ) better one. phole optimizations as replacement rules n j1;...; jm us additional constraints. The j s are the improved veri s. Problems: blem: what to do with pointers? Problem is aliasing: two he same variable: lt, *t may change even if local variable t does not and assign to *t. anguage design: rules about overlapping parameters in and the restrict keyword in C. e a special case (address calculation): is A[i] the same Sometimes the compiler can tell, depending on what it out i and j. globals variables and calls? not exactly jumps, because they (almost) always return. fy global variables used by caller :49: CS164: Lecture # :49: CS164: Lecture #36 27

8 Issues ness condition is not trivial to check Conservative Program Analyses optimization requires P to be true, then cludes paths around loops and through branches of concondition requires global analysis: an analysis of the l-flow graph for one method body. l for optimizations that depend on some property P at oint in program execution. erty P is typically undecidable, so program optimization aking conservative (but not cowardly) approximations ow that P is definitely true, we can apply the optimizan t know whether P is true, we simply don t do the opn. Since optimizations are not supposed to change the f a program, this is safe. rds, in analyzing a program for properties like P, it is ct (albeit non-optimal) to say don t know. to say it as seldom as possible. low analysis is a standard technique for solving problems haracteristics. :49: CS164: Lecture # :49: CS164: Lecture #36 32 imple Example: Copy Propagation Y := Z + W Y := 0 X := 4 A := 2 * 3X r assignments to X, it is valid to treat the red parts as in the same basic block. as one other block on the path to the bottom block we can no longer do so. to apply copy propagation to a variable x from an astementa: x :=... to a given use of x in statement B st assignment to x in every path from to B is A. :49: CS164: Lecture #36 29 decidability of Program Properties rem: Most interesting dynamic properties of a program able. E.g., program halt on all (some) inputs? (Halting Problem) sult of a function F always positive? (Consider x): x) turn 1 positive iff H halts.) operties are typically decidable (e.g., How many occurare there? ). es not apply in absence of loops 0:49: CS164: Lecture #36 31

9 le of Result of Constant Propagation Transfer Functions Express the analysis of a complicated program as a comsimple rules relating the change in information between tements push or transfer information from one statement to Y := Z + W X := 4 Y := 0 atement s, we end up with information about the value ately before and after s: A := 2 * X value of x before s = value of x after s alues of x we use come from an abstract domain, conalues we care about #,*, k values computed statically sis. stant propagation problem, we ll compute Cout from Cin, Cin from the Couts of predecessor statements, Cout(X, X,p n ). :49: CS164: Lecture # :49: CS164: Lecture #36 36 mple: Global Constant Propagation nt propagation is just the restriction of copy propagaants. ple, we ll consider doing it for a single variable (X). gram point (i.e., before or after any instruction), we of the following values with X Interpretation Using Analysis Results constant information, it is easy to perform the optiint immediately before a statement using x tells us that en replace x with c. e, leave it alone (the conservative option). we compute these properties x =...? a bottom) No value has reached here (yet) r c a constant) X definitely has the value c. a top) Don t know what, if any, constant value X has. :49: CS164: Lecture # :49: CS164: Lecture #36 35

10 Constant Propagation: Rule 2 p 1 X = c p 2 X =? p 3 X = d p n X =? Constant Propagation: Rule 4 p 1 p 2 p 3 p n s s, p i ) = c and Cout(X, p j ) = d with constants c d, then Cin(X, s) = * Cout(X, p j ) = # for all j, then Cin(X, s) = # :49: CS164: Lecture # :49: CS164: Lecture #36 40 Constant Propagation: Rule 1 Constant Propagation: Rule 3 p 1 X =? p 2 X =? p 3 p n X =? p 1 X = c p 2 p 3 X = c p n s s X = c out(x, p i ) = * for some i, then Cin(X, s) = * If Cout(X, p i ) = c for some i and Cout(X, p j ) = c or Cout(X, p j ) = # for all j, then Cin(X, s) = c :49: CS164: Lecture # :49: CS164: Lecture #36 39

11 Constant Propagation: Rule 5 s Constant Propagation: Rule 7 X := f(...) X =? Cout(X, s) = # if Cin(X, s) = # X := f(...)) = * for any function call, if? is not #. eans so far, no value of X gets here, because we don t this statement ever gets executed. :49: CS164: Lecture # :49: CS164: Lecture #36 44 stant Propagation: Computing Cout Constant Propagation: Rule 6 ate the out of one statement to the in of the succests, thus propagating information forward across CFG local rulesrelatingthein andout ofasinglestatement information across statements. X := c X =? X = c X, X := c) = c if c is a constant and? is not #. :49: CS164: Lecture # :49: CS164: Lecture #36 43

12 Propagation Algorithm r Example of the Propagation Algorithm rules, we employ a standard technique: iteration to a ts in the program with current approximations of the interest (X in our examples). l approximations to for the program entry point erywhere else. pply rules 1 8 every place they are applicable until nothuntil the program is at a fixed point with respect to all rules. ever about this, keeping a list of all nodes any of whose Cout values have changed since the last rule applica- Y := Z + W X := 4 A := 2 * X A < B Y := 0 :49: CS164: Lecture # :49: CS164: Lecture #36 48 Constant Propagation: Rule 8 An Example of the Algorithm Y :=... X = α X = α 3 3 Y := Z + W Y := ) = Cin(X, Y :=...) if X and Y are different variables. A := 2 * X A < B place X with 3 in the bottom block. :49: CS164: Lecture # :49: CS164: Lecture #36 47

13 Another Example of the Propagation Algorithm 3 3 Y := Z + W X := 4 Y := 0 A := 2 * X A < B Last modified: Mon Apr 23 10:49: CS164: Lecture #36 48

14 Another Example of the Propagation Algorithm Y := Z + W X := 4 Y := A := 2 * X A < B Last modified: Mon Apr 23 10:49: CS164: Lecture #36 48

15 Another Example of the Propagation Algorithm Y := Z + W X := 4 Y := A := 2 * X A < B * * * Last modified: Mon Apr 23 10:49: CS164: Lecture #36 48

16 Another Example of the Propagation Algorithm Y := Z + W X := 4 Y := 0 3 * 3 * A := 2 * X A < B * * * Here, we cannot replace X in two of the basic blocks. Last modified: Mon Apr 23 10:49: CS164: Lecture #36 48

17 Comments Termination s used a breadth-first approach to considering possible ly the rules, starting from the entry point. order in which one looks at statements is irrelevant. e changed the Cout values after the assignments to X mple. s necessary to avoid deciding on a final value too soon. allows us to tentatively propagate constant values through g out what happens in paths we haven t looked at yet. g repeat until nothing changes doesn t guarantee that othing changes. of lub explains why the algorithm terminates: art as # and only increase ructure of the lattice, therefore, each value can only wice. orithm is linear in program size. The number of steps ber of Cin and Cout values computed ber of program statements. :49: CS164: Lecture # :49: CS164: Lecture #36 52 A Third Example Ordering the Abstract Domain 3 3 plify the presentation of the analysis by ordering the < *. y, with lower meaning less than, Y := Z + W Y := 0 3 * 3 * * A := 2 * X X := 4 A < B annot replace X. 3 * 3 * # atical structure known as a lattice. ur rule for computing Cin is simply a least upper bound: = lub { Cout(x, p) such that p is a predecessor of s }. :49: CS164: Lecture # :49: CS164: Lecture #36 51

18 m Terminology: Live and Dead /*(1)*/ X = 4; /*(2)*/ Y := X /*(3)*/ X is dead (never used) at point (1), live at point (2), and not be live at point (3), depending on the rest of the Liveness Rule 1 p L(X) = true lly, a variable x is live at statement s if sts a statement s that uses x; path from s to s ; and has no intervening assignment to x x :=... is dead code (and may be deleted) if x is e assignment. s 2 L(X) =? s 3 L(X) = true s n L(X) =? = lub { Lin(x, s) such that p is a predecessor of s }. upper bound (lub) is the same as or. :49: CS164: Lecture # :49: CS164: Lecture #36 56 Liveness Analysis have been globally propagated, we would like to elimi- Computing Liveness ress liveness as a function of information transferred acent statements, just as in copy propagation simpler than constant propagation, since it is a boolean ue or false). lattice has two values, with false<true. Y := Z + W Y := 0 rsinthatlivenessdependsonwhatcomesafter astatefore we propagate information backwards through the from Lout (liveness information at the end of a stat-. A := 2 * X A < B propagation, is dead code (assuming this is the :49: CS164: Lecture # :49: CS164: Lecture #36 55

19 Liveness Rule 3 X := e L(X) = false L(X) =? ropagation Algorithm for Liveness all Lin and Lout values be false. ) = false if e does not use the previous value of X. ue at the program exit to true iff x is going to be used e.g., if it is global and we are analyzing only one procerepeatedly pick s where one of 1 4 does not hold and the appropriate rule, until there are no more violations. done, we can eliminate assignments to X if X is dead at ter the assignment. :49: CS164: Lecture # :49: CS164: Lecture #36 60 Liveness Rule 2 Liveness Rule 4...:=...X... L(X) = true L(X) =? s L(X) = α L(X) = α, s) = true if s uses the previous value of X. ut(x, s) = Lin(X, s) if s does not mention X. e applies to any other statement that uses the value of ts (e.g., X < 0). :49: CS164: Lecture # :49: CS164: Lecture #36 59

20 Termination φ Functions value can only change a bounded number of times: the in this case. is guaranteed lysis is computed, it is simple to eliminate dead code, ne so, we must recompute the liveness information. device to allow SSA notation in CFGs. ock, each variable is associated with one definition, in effect associate each variable with a set of possible one tries to introduce them in strategic places so as to e total number of φs. is device increases number of assignments in IL, regisn can remove many by assigning related IL registers to al register. ables us to extend such optimizations as CSE elimination ks to Global CSE Elimination. orm, easy to tell (conservatively) if two IL assignments same value: just see if they have the same right-hand me variables indicate the same values. :49: CS164: Lecture # :49: CS164: Lecture #36 64 xample of Liveness Computation SSA and Global Analysis Y := Z + W L(X) = false L(X) = false true L(X) = false true L(X) = false true Y := 0 L(X) = false true imizations, the single static assignment (SSA) form was it to a full CFG is requires a trick. we avoid two assignments to the temporary holding x onditional? : a A := 2 * X X := X * X X := 4 A < B L(X) = false L(X) = false true L(X) = false true L(X) = false L(X) = false true L(X) = false true b is x at this point? mall kludge known as φ functions evious example into this: : a b 1, x2) :49: CS164: Lecture # :49: CS164: Lecture #36 63

21 Invariant Code Motion Summary loop < N) = A[i] + j * x; does not change in the loop, we can rewrite this as x; < N) = A[i] + tmp; ample of invariant code motion out of a loop. that j*x does not change? all assignments tojandxthat apply at the point where s computed are outside the loop. angetbyobservingwheretheassignmentstothessase variables are. two kinds of analysis: propagation is a forward analysis: information is pushed ts to outputs. s a backwards analysis: information is pushed from outtowards inputs. ke use of essentially the same algorithm. ther analyses fall into these categories, and allow us to formulation: act domain (abstract relative to actual values); s relating information between consecutive program points single statement; and perations like least upper bound (or join) or greatest nd (or meet) to relate inputs and outputs of adjoining ts. :49: CS164: Lecture # :49: CS164: Lecture #36 68 Loops op is simplyaset of basic blocks,l, containingan entry that from the entry node of the entire CFG to a block in L essors of a node in L are also in L (except for e, which a predecessor outside L). e in L has a path in L back to e. ample, < N) = A[j] / A[i] de contains the test j < n and the rest of the loop is taining the assigment to A[j], which then loops back to Code Motion Caveat is not always appropriate. to be moved, has side effects, or might cause an excephange the results. is expensive, you will increase the time required for the en the loop is not executed. will see compilers rewrite loops like this: N) { reheader */ e (i < N) A[i] = A[i] + j * x; eader marks a spot where the compiler can insert a new d code moved out of the loop. :49: CS164: Lecture # :49: CS164: Lecture #36 67