1. Partial Redundancy Elimination

2. Partial-Redundancy Elimination Minimize the number of expression evaluations By moving around the places where an expression is evaluated and keeping the result in a temporary variable when necessary, we often can reduce the number of evaluations of this expression along many of the execution paths, while not increasing that number along any path

3. The Sources of Redundancy Common subexpressions Loop-invariant expressions Partially redundant expressions

4. Common Subexpressions a = b + cb = 7 d = b + c e = b + c t = b + c a = t b = 7 t = b + c d = t e = t

5. Loop-Invariant Expressions a = b + c a = t t = b + c

6. Partially Redundant Expressions a = b + c d = b + c t = b + c a = t t = b + c d = t

7. Can All Redundancy Be Eliminated? It is not possible to eliminate all redundant computations along every path, unless we are allowed to change the control flow graph by creating new blocks and duplicating blocks A critical edge is an edge leading from a node with more than one successor to a node with more than one predecessor Block duplication can be used to isolate the path where redundancy is found

8. Block Creation a = b + c d = b + c … t = b + c a = t t = b + c … d = t

9. Block Duplication a = b + c B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 d = b + c a = b + c t = a d = t B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 d = b + c B’ 4 B’ 6

10. The Lazy-Code-Motion Problem Three properties desirable from the partial redundancy elimination algorithm All redundant computations of expressions that can be eliminated without block duplication are eliminated The optimized program does not perform any computation that is not in the original program execution Expressions are computed at the latest possible time

11. Lazy Code Motion The values of expressions found to be redundant are usually held in registers until they are used Computing a value as late as possible minimizes its lifetime  the duration between the time the value is defined and the time it is last used Minimizing the lifetime of a value in turn minimizes the usage of a register

12. Full Redundancy An expression e in block B is redundant if along all paths reaching B, e has been evaluated and the operands of e have not been redefined subsequently Let S be the set of blocks, each containing expression e, that renders e in B redundant The set of edges leaving the blocks in S must necessarily form a cutset, which if removed, disconnects B from the entry of the program No operands of e are redefined along the paths that lead from the blocks in S to B

13. Partial Redundancy If an expression e in block B is only partial redundant, the lazy code motion algorithm attempts to render e fully redundant in B by placing additional copies of the expressions in the flow graph If the attempt is successful, the optimized flow graph will also have a set of blocks S, each containing e, and whose outgoing edges are a cutset between the entry and B

14. Anticipation of Expressions To ensure that no extra operations are executed, copies of an expression must be placed only at program points where the expression is anticipated (very busy) An expression e is anticipated at point p if all paths leading from p eventually compute the value of e using the values of operands that are available at p

15. Earliest Places of Expressions Consider an acyclic path B 1  B 2  …  B n Suppose e is evaluated only in blocks B 1 and B n, and the operands of e are not redefined in blocks along the path. There are incoming edges that join the path and there are outgoing edges that exit the path Expression e is not anticipated at the entry of B i iff there exists an outgoing edge leaving B j, i  j < n, that leads to an execution path that does not use the value of e

16. Earliest Placement of Expressions Anticipation limits how early an expression can be placed B 1  …  B j  …  B n …

17. Earliest Placement of Expressions We can create a cutset that includes the edge B i-1  B i and that renders e redundant in B n if e is either available or anticipated at the entry of B i If e is anticipated but not available at the entry of B i, we must place a copy of e along the incoming edge

18. Earliest Placement of Expressions The introduced expressions may themselves be partially redundant with other instances of the same expression Such partial redundancy may be eliminated by moving these computations further up

19. An Example a = b + cB2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 d = b + c e = b + c * *

20. Latest Placement of Expressions We have a choice of where to place the copies of e, since there are usually several cutsets in the flow graph that satisfy all the requirements Computation is introduced along the incoming edges to the path so the expression is computed as close to the use as possible without introducing redundancy

21. Summary Anticipation limits how early an expression can be placed The earlier an expression is placed, the more redundancy can be removed Among all solutions that eliminate the same redundancies, the one that computes the expressions the latest minimizes the lifetime of the register holding the values of the expressions involved

22. The Lazy-Code-Motion Algorithm Find all the expressions anticipated at each program point using a backward analysis Find all the expressions available at each program point using a forward analysis. Find all the expressions postponable at each program point using a forward analysis Find all the expressions used at each program point using a backward analysis

23. Preprocessing Assume that initially every statement is in a basic block of its own, and we only introduce new computations of expressions at the beginning of blocks To ensure that this simplification does not reduce the effectiveness of the technique, we insert a new block between the source and the destination of an edge if the destination has more than one predecessor This also takes care of all critical edges

24. e-use and e-kill Sets e-use B is the set of expressions computed in B e-kill B is the set of expressions any of whose operands are defined in B

25. The Running Example c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c

26. Anticipated Expressions DirectionBackwards Transfer f B ( x ) = e _ use B  ( x – e _ kill B ) function BoundaryIN[EXIT] =  Meet(  )  EquationsIN[ B ] = f B (OUT[ B ]) OUT[ B ] =  s, succ ( B ) IN[ S ] InitializationIN[B] = U

27. Anticipated Expressions c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c

28. Available Expressions Direction Forwards Transfer f B ( x ) = ( anticipated[B].in  x ) – e _ kill B function Boundary OUT[ENTRY] =  Meet(  )  Equations OUT[ B ] = f B (IN[ B ]) IN[ B ] =  P, pred ( B ) OUT[ P ] Initialization OUT[B] = U

29. Available Expressions c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c

30. Available Expressions B1B1 B2B2 B3B3 B4B4 a = b + c d = b + c

31. Earliest Placement With the earliest placement strategy, the set of expressions placed at block B, i.e., earliest [ B ], is defined as the set of anticipated expressions that are not yet available earliest [ B ] = anticipated [ B ]. in – available [ B ]. in

32. Earliest Placement c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c  

33. Postponable Expressions c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c

34. Postponable Expressions Direction Forwards Transfer f B ( x ) = ( earliest[B]  x ) – e _ use B function Boundary OUT[ENTRY] =  Meet(  )  Equations OUT[ B ] = f B (IN[ B ]) IN[ B ] =  P, pred ( B ) OUT[ P ] Initialization OUT[B] = U

35. Postponable Expressions c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c

36. Latest Placement Expression e may be placed at the beginning of a block B only if e is in B’s earliest or postponable set upon entry In addition, B is in the postponement frontier of e if one of the following holds: e is in e_use B e cannot be postponed to one of its successors, i.e., e is not in the earliest or postponable set upon entry to that successor

37. Latest Placement latest [ B ] = ( earliest [ B ]  postponable [ B ]. in )  ( e_use B   (  S, succ ( B ) ( earliest [ S ]  postponable [ S ]. in )))

38. Latest Placement c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c  

39. Used Expressions Direction Backwards Transfer f B ( x ) = ( e _ use B  x ) – latest[B] function Boundary IN[EXIT] =  Meet(  )  Equations IN[ B ] = f B (OUT[ B ]) OUT[ B ] =  s, succ ( B ) IN[ S ] Initialization IN[B] = 

40. Used Expressions c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c  

41. Transformation For each expression, say x + y, computed by the program, do the following: Create a new temporary, say t, for x + y For all blocks B such that x + y is in latest[B]  used[B].out, add t = x + y at the beginning of B For all blocks B such that x + y is in e _ use B  (  latest[B]  used[B].out ), replace every original x + y by t

42. Transformation B1B1 B2B2 B3B3 B4B4 b = a = b + c e = b + c d = b + c

43. Transformation c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 t = b + c a = b + c d = b + c B8B8 B9B9 B 10 B 11 e = b + c   t = b + c

44. Transformation c = 2 B2B2 B3B3 B1B1 B4B4 B5B5 B6B6 B7B7 t = b + c a = t d = t B8B8 B9B9 B 10 B 11 e = t   t = b + c