32
Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs Jeffrey D. Ullman Stanford University Flow Graph Theory

Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

  • Upload
    cisco

  • View
    39

  • Download
    0

Embed Size (px)

DESCRIPTION

Flow Graph Theory. Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs. Jeffrey D. Ullman Stanford University. Roadmap. Proper ordering of nodes of a flow graph speeds up the iterative algorithms: “ depth-first ordering .” - PowerPoint PPT Presentation

Citation preview

Page 1: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

Depth-First OrderingEfficiency of Iterative AlgorithmsReducible Flow Graphs

Jeffrey D. UllmanStanford University

Flow Graph Theory

Page 2: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

2

Roadmap1. Proper ordering of nodes of a flow graph

speeds up the iterative algorithms: “depth-first ordering.”

2. “Normal” flow graphs have a surprising property --- “reducibility” --- that simplifies several matters.

3. Outcome: few iterations “normally” needed.

Page 3: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

3

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). Constructs a Depth-First Spanning Tree:

Root = entry. Tree edges are the edges along which we first visit

the node at the head.

Page 4: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

4

Example: DFST

1

53

42

Page 5: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

5

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.

Page 6: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

6

Example: DF Order

1

35

24

Page 7: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

7

Four Kinds of Edges1. Tree edges.2. Forward edges (node to proper descendant).3. Retreating edges (node to ancestor).

Includes a self-loop.4. Cross edges (between two nodes, neither of

which is an ancestor of the other.

Page 8: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

8

A Little Magic Of these edges, only retreating edges go from

high to low in DF order. Example of proof: You must retreat from the head of

a tree edge before you can retreat from its tail. Also surprising: all cross edges go right to left in

the DFST. Assuming we add children of any node from the left.

Page 9: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

9

Example: Non-Tree Edges

1

35

24

Retreating

Forward

Cross

Page 10: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

10

Roadmap1. “Normal” flow graphs are “reducible.”2. “Dominators” needed to explain

reducibility.3. In reducible flow graphs, loops have single

entry points, and retreating edges are independent of the DFST chosen (and called “back” edges).

4. Leads to relationship between DF order and efficient iterative algorithm.

Page 11: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

11

Dominators Node d dominates node n if every path from

the entry to n goes through d. Text has a forward-intersection iterative

algorithm for finding dominators. Quick observations:

1. Every node dominates itself.2. The entry dominates every node.

Page 12: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

12

Example: Dominators

1

35

24

{1,5}

{1,4}

{1,2,3}

{1,2}

{1}

Page 13: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

13

Common Dominator 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.

Page 14: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

14

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.

Backedge

Head reached beforetail in any DFST

Search must reach thetail before retreatingfrom the head, so tail isa descendant of the head

Note: We assume allnodes are reachablefrom the entry, or elsethey can be deletedfrom the flow graph.

Page 15: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

15

Example: Back Edges

1

35

24

{1,5}

{1,4}

{1,2,3}

{1,2}

{1}

Page 16: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

16

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: Remove all back edges from the flow graph and check that the result is acyclic.

Hint why it works: All cycles must include some retreating edge in every DFST. In particular, the edge that enters the first node of

the cycle that is visited.

Page 17: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

17

DFST on a Cycle

Depth-first searchreaches here first

Search must reachthese nodes beforeleaving the cycle

So this is aretreating edge

Page 18: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

18

Example: Remove Back Edges

1

35

24

Page 19: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

19

Example: Remove Back Edges

1

35

24

Remaining graph is acyclic.

Page 20: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

20

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.

Page 21: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

21

Example: Nonreducible Graph

A

CB

In any DFST, oneof these edges willbe a retreating edge.

A

B

C

A

B

C

But no heads dominate their tails, so deletingback edges leaves the cycle.

Page 22: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

22

Why Care About Back/Retreating Edges?1. Proper ordering of nodes during iterative

algorithm assures number of passes limited by the number of “nested” back edges.

2. Depth of nested loops upper-bounds the number of nested back edges.

Page 23: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

23

DF Order and Retreating Edges

Suppose that for a RD 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 at the tail of a retreating edge, it is too late to propagate d from OUT to IN. The IN at the head has already been computed for

that round.

Page 24: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

24

Example: DF Order

1

35

24d d

d

d

d

d

d dd

d

Definition d isGen’d by node 2not killed anywhere.

The first pass

The second pass

Page 25: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

25

Depth of a Flow Graph The depth of a flow graph with a given DFST and

DF-order 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.

Page 26: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

26

Example: Depth = 2

increasing

retreating

increasingincreasing

retreating

Pass 1 Pass 2 Pass 3

Page 27: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

27

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.

Page 28: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

28

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.

Page 29: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

29

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.

Page 30: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

30

Example: Nested Loops

3 nested while-loops; depth = 3.

3 nested repeat-loops; depth = 1

Page 31: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

31

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.

Theorem: two natural loops are either disjoint, identical, or one is contained (nested) within the other.

Thus, for reducible flow graphs, the nesting structure of loops is well defined.

Page 32: Depth-First Ordering Efficiency of Iterative Algorithms Reducible Flow Graphs

32

Example: Natural Loops

1

35

24

Natural loopof 3 -> 2

Natural loopof 5 -> 1