 Download Download Presentation Loops

# Loops

Download Presentation ## Loops

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Loops Guo, Yao

2. Content • Concepts: • Dominators • Depth-First Ordering • Back edges • Graph depth • Reducibility • Natural Loops • Efficiency of Iterative Algorithms “Advanced Compiler Techniques”

3. Loops are Important! • Loops dominate program execution time • Needs special treatment during optimization • Loops also affect the running time of program analyses • e.g., A dataflow problem can be solved in just a single pass if a program has no loops “Advanced Compiler Techniques”

4. Dominators • Node ddominates node n if every path from the entry to n goes through d. • written as: d dom n • Quick observations: • Every node dominates itself. • The entry dominates every node. • Common Cases: • The test of a while loop dominates all blocks in the loop body. • The test of an if-then-else dominates all blocks in either branch. “Advanced Compiler Techniques”

5. Example: Dominators 1 2 4 3 5 “Advanced Compiler Techniques”

6. Dominator Tree • Immediate dominance: d idom n • d dom n, d n, no m s.t. d dom m and m dom n • Immediate dominance relationships form a tree 1 1 2 2 4 4 3 3 5 5 “Advanced Compiler Techniques”

7. Finding Dominators • A dataflow analysis problem: For each node, find all of its dominators. • Direction: forward • Confluence: set intersection • Boundary: OUT[Entry] = {Entry} • Initialization: OUT[B] = All nodes • Equations: • OUT[B] = IN[B] U {B} • IN[B] = p is a predecessor of B OUT[p] “Advanced Compiler Techniques”

8. Example: Dominators {1} 1 2 {1,2} 4 {1,4} 3 5 {1,2,3} {1,5} “Advanced Compiler Techniques”

9. Depth-First Search • Start at entry. • If you can follow an edge to an unvisited node, do so. • If not, backtrack to your parent (node from which you were visited). “Advanced Compiler Techniques”

10. Depth-First Spanning Tree • Root = entry. • Tree edges are the edges along which we first visit the node at the head. 1 4 2 5 3 “Advanced Compiler Techniques”

11. Depth-First Node Order • The reverse of the order in which a DFS retreats from the nodes. • Alternatively, reverse of postorder traversal of the tree. “Advanced Compiler Techniques”

12. Example: DF Order 1 2 4 3 5 “Advanced Compiler Techniques”

13. Four Kinds of Edges • Tree edges. • Advancing edges (node to proper descendant). • Retreating edges (node to ancestor, including edges to self). • Cross edges (between two nodes, neither of which is an ancestor of the other. “Advanced Compiler Techniques”

14. A Little Magic • Of these edges, only retreating edges go from high to low in DF order. • Most surprising: all cross edges go right to left in the DFST. • Assuming we add children of any node from the left. “Advanced Compiler Techniques”

15. Retreating Forward Cross Example: Non-Tree Edges 1 2 4 3 5 “Advanced Compiler Techniques”

16. Back Edges • An edge is a back edge if its head dominates its tail. • Theorem: Every back edge is a retreating edge in every DFST of every flow graph. • Converse almost always true, but not always. “Advanced Compiler Techniques”

17. Example: Back Edges {1} 1 2 {1,2} 4 {1,4} 3 5 {1,2,3} {1,5} “Advanced Compiler Techniques”

18. Reducible Flow Graphs • A flow graph is reducible if every retreating edge in any DFST for that flow graph is a back edge. • Testing reducibility: Take any DFST for the flow graph, remove the back edges, and check that the result is acyclic. “Advanced Compiler Techniques”

19. Example: Remove Back Edges 1 2 4 3 5 “Advanced Compiler Techniques”

20. Example: Remove Back Edges 1 2 4 3 5 Remaining graph is acyclic. “Advanced Compiler Techniques”

21. Why Reducibility? • Folk theorem: All flow graphs in practice are reducible. • Fact: If you use only while-loops, for-loops, repeat-loops, if-then(-else), break, and continue, then your flow graph is reducible. “Advanced Compiler Techniques”

22. A A B C In any DFST, one of these edges will be a retreating edge. C B Example: Nonreducible Graph A B C “Advanced Compiler Techniques”

23. Why Care About Back/Retreating Edges? • Proper ordering of nodes during iterative algorithm assures number of passes limited by the number of “nested” back edges. • Depth of nested loops upper-bounds the number of nested back edges. “Advanced Compiler Techniques”

24. DF Order and Retreating Edges • Suppose that for a Reaching Definitions analysis, we visit nodes during each iteration in DF order. • The fact that a definition d reaches a block will propagate in one pass along any increasing sequence of blocks. • When d arrives along a retreating edge, it is too late to propagate d from OUT to IN. “Advanced Compiler Techniques”

25. Example: DF Order d Suppose there is a definition of d in Block 2. 1 d d d 2 4 d d d d 3 5 d d “Advanced Compiler Techniques”

26. Depth of a Flow Graph • The depth of a flow graph is the greatest number of retreating edges along any acyclic path. • For RD, if we use DF order to visit nodes, we converge in depth+2 passes. • Depth+1 passes to follow that number of increasing segments. • 1 more pass to realize we converged. “Advanced Compiler Techniques”

27. retreating retreating increasing increasing increasing Example: Depth = 2 1 -> 4 ->7 - - -> 3 -> 10 ->17 - - -> 6 -> 18 -> 20 “Advanced Compiler Techniques”

28. Similarly . . . • AE also works in depth+2 passes. • Unavailability propagates along retreat-free node sequences in one pass. • So does LV if we use reverse of DF order. • A use propagates backward along paths that do not use a retreating edge in one pass. “Advanced Compiler Techniques”

29. In General . . . • The depth+2 bound works for any monotone framework, as long as information only needs to propagate along acyclic paths. • Example: if a definition reaches a point, it does so along an acyclic path. “Advanced Compiler Techniques”

30. However . . . • Constant propagation does not have this property. a = b L: a = b b = c c = 1 goto L b = c c = 1 “Advanced Compiler Techniques”

31. Why Depth+2 is Good • Normal control-flow constructs produce reducible flow graphs with the number of back edges at most the nesting depth of loops. • Nesting depth tends to be small. • A study by Knuth has shown that average depth of typical flow graphs =~2.75. “Advanced Compiler Techniques”

32. Example: Nested Loops 3 nested while- loops; depth = 3. 3 nested repeat- loops; depth = 1 “Advanced Compiler Techniques”

33. Natural Loops • A natural loop is defined by: • A single entry-point called header • a headerdominates all nodes in the loop • A back edge that enters the loop header • Otherwise, it is not possible for the flow of control to return to the header directly from the "loop" ; i.e., there really is no loop. “Advanced Compiler Techniques”

34. Find Natural Loops • The natural loop of a back edge a->b is {b} plus the set of nodes that can reach a without going through b. • Remove bfrom the flow graph, find all predecessors of a • Theorem: two natural loops are either disjoint, identical, or nested. “Advanced Compiler Techniques”

35. Natural loop of 5 -> 1 Natural loop of 3 -> 2 Example: Natural Loops 1 2 4 3 5 “Advanced Compiler Techniques”

36. Relationship b/w Loops • If two loops do not have the same header • they are either disjoint, or • one is entirely contained (nested within) the other • innermost loop: one that contains no other loop. • If two loops share the same header • Hard to tell which is the inner loop • Combine as one 1 2 3 4 “Advanced Compiler Techniques”

37. Next Time • Single Static Assignment (SSA) • Readings: Cytron'91, Chow'97 “Advanced Compiler Techniques”