Download Presentation
## Loops

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -

**Loops**Guo, Yao**Content**• Concepts: • Dominators • Depth-First Ordering • Back edges • Graph depth • Reducibility • Natural Loops • Efficiency of Iterative Algorithms “Advanced Compiler Techniques”**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”**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”**Example: Dominators**1 2 4 3 5 “Advanced Compiler Techniques”**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”**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”**Example: Dominators**{1} 1 2 {1,2} 4 {1,4} 3 5 {1,2,3} {1,5} “Advanced Compiler Techniques”**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”**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”**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”**Example: DF Order**1 2 4 3 5 “Advanced Compiler Techniques”**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”**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”**Retreating**Forward Cross Example: Non-Tree Edges 1 2 4 3 5 “Advanced Compiler Techniques”**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”**Example: Back Edges**{1} 1 2 {1,2} 4 {1,4} 3 5 {1,2,3} {1,5} “Advanced Compiler Techniques”**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”**Example: Remove Back Edges**1 2 4 3 5 “Advanced Compiler Techniques”**Example: Remove Back Edges**1 2 4 3 5 Remaining graph is acyclic. “Advanced Compiler Techniques”**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”**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”**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”**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”**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”**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”**retreating**retreating increasing increasing increasing Example: Depth = 2 1 -> 4 ->7 - - -> 3 -> 10 ->17 - - -> 6 -> 18 -> 20 “Advanced Compiler Techniques”**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”**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”**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”**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”**Example: Nested Loops**3 nested while- loops; depth = 3. 3 nested repeat- loops; depth = 1 “Advanced Compiler Techniques”**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”**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”**Natural loop**of 5 -> 1 Natural loop of 3 -> 2 Example: Natural Loops 1 2 4 3 5 “Advanced Compiler Techniques”**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”**Next Time**• Single Static Assignment (SSA) • Readings: Cytron'91, Chow'97 “Advanced Compiler Techniques”