Dates

1 / 29

# Dates

## Dates

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

1. Dates • Midterm: Nov 6 • Final out Dec 4, due Dec 11 • Project meetings: Oct 24, Nov 14, Nov 28 • Final project presentation: Dec 12

2. d0 Back to example 1: x := ... 2: y := ... 3: y := ... 4: p := ... if(...) d1 = Fa(d0) d1 d2 = Fb(d1) d2 d3 = Fc(d2) d3 d4 = Fd(d3) d4 d9 = Ff(d4) d5 = Fe(d4) d9 d5 d10 = Fj(d9) d6 = Fg(d5) ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... d6 d10 d11 = Fk(d10) d7 = Fh(d6) d7 d11 d12 = Fl(d11) d8 = Fi(d7) d12 d8 d13 = Fm(d12, d8) merge ... x ... ... y ... 8: y := ... d13 How to find solutions for di? d14 = Fn(d13) d14 d15 = Fo(d14) d15 d16 = Fp(d15) d16

3. How to find solutions for di? • This is a forward problem • given information flowing in to a node, can determine using the flow function the info flow out of the node • To solve, simply propagate information forward through the control flow graph, using the flow functions • What are the problems with this approach?

4. d0 First problem 1: x := ... 2: y := ... 3: y := ... 4: p := ... if(...) d1 = Fa(d0) d1 d2 = Fb(d1) d2 d3 = Fc(d2) d3 d4 = Fd(d3) d4 d9 = Ff(d4) d5 = Fe(d4) d9 d5 d10 = Fj(d9) d6 = Fg(d5) ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... d6 d10 d11 = Fk(d10) d7 = Fh(d6) d7 d11 d12 = Fl(d11) d8 = Fi(d7) d12 d8 d13 = Fm(d12, d8) merge ... x ... ... y ... 8: y := ... d13 What about the incoming information? d14 = Fn(d13) d14 d15 = Fo(d14) d15 d16 = Fp(d15) d16

5. First problem • What about the incoming information? • d0 is not constrained • so where do we start? • Need to constrain d0 • Two options: • explicitly state entry information • have an entry node whose flow function sets the information on entry (doesn’t matter if entry node has an incoming edge, its flow function ignores any input)

6. Entry node out = { x ! s | x 2 Formals } s: entry out

7. d0 = Fentry() d0 Second problem 1: x := ... 2: y := ... 3: y := ... 4: p := ... if(...) d1 = Fa(d0) d1 d2 = Fb(d1) d2 d3 = Fc(d2) d3 d4 = Fd(d3) d4 d9 = Ff(d4) d5 = Fe(d4) d9 d5 d10 = Fj(d9) d6 = Fg(d5) ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... d6 d10 d11 = Fk(d10) d7 = Fh(d6) d7 d11 d12 = Fl(d11) d8 = Fi(d7) d12 d8 d13 = Fm(d12, d8) Which order to process nodes in? merge ... x ... ... y ... 8: y := ... d13 d14 = Fn(d13) d14 d15 = Fo(d14) d15 d16 = Fp(d15) d16

8. Second problem • Which order to process nodes in? • Sort nodes in topological order • each node appears in the order after all of its predecessors • Just run the flow functions for each of the nodes in the topological order • What’s the problem now?

9. Second problem, prime • When there are loops, there is no topological order! • What to do? • Let’s try and see what we can do

10. 1: x := ... 2: y := ... 3: y := ... 4: p := ... ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... ... x ... ... y ... 8: y := ...

11. 1: x := ... 2: y := ... 3: y := ... 4: p := ... ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... ... x ... ... y ... 8: y := ...

12. Worklist algorithm • Initialize all di to the empty set • Store all nodes onto a worklist • while worklist is not empty: • remove node n from worklist • apply flow function for node n • update the appropriate di, and add nodes whose inputs have changed back onto worklist

13. Worklist algorithm let m: map from edge to computed value at edge let worklist: work list of nodes for each edge e in CFG do m(e) := ; for each node n do worklist.add(n) while (worklist.empty.not) do let n := worklist.remove_any; let info_in := m(n.incoming_edges); let info_out := F(n, info_in); for i := 0 .. info_out.length-1 do if (m(n.outgoing_edges[i])  info_out[i]) m(n.outgoing_edges[i]) := info_out[i]; worklist.add(n.outgoing_edges[i].dst);

14. Issues with worklist algorithm

15. Two issues with worklist algorithm • Ordering • In what order should the original nodes be added to the worklist? • What order should nodes be removed from the worklist? • Does this algorithm terminate?

16. Order of nodes • Topological order assuming back-edges have been removed • Reverse depth-first post-order • Use an ordered worklist

17. 1: x := ... 2: y := ... 3: y := ... 4: p := ... ... x ... 5: x := ... ... y ... ... x ... 6: x := ... 7: *p := ... ... x ... ... y ... 8: y := ...

18. Termination • Why is termination important? • Can we stop the algorithm in the middle and just say we’re done... • No: we need to run it to completion, otherwise the results are not safe...

19. Termination • Assuming we’re doing reaching defs, let’s try to guarantee that the worklist loop terminates, regardless of what the flow function F does while (worklist.empty.not) do let n := worklist.remove_any; let info_in := m(n.incoming_edges); let info_out := F(n, info_in); for i := 0 .. info_out.length-1 do if (m(n.outgoing_edges[i])  info_out[i]) m(n.outgoing_edges[i]) := info_out[i]; worklist.add(n.outgoing_edges[i].dst);

20. Termination • Assuming we’re doing reaching defs, let’s try to guarantee that the worklist loop terminates, regardless of what the flow function F does while (worklist.empty.not) do let n := worklist.remove_any; let info_in := m(n.incoming_edges); let info_out := F(n, info_in); for i := 0 .. info_out.length-1 do let new_info := m(n.outgoing_edges[i]) [ info_out[i]; if (m(n.outgoing_edges[i])  new_info]) m(n.outgoing_edges[i]) := new_info; worklist.add(n.outgoing_edges[i].dst);

21. Structure of the domain • We’re using the structure of the domain outside of the flow functions • In general, it’s useful to have a framework that formalizes this structure • We will use lattices

22. Background material

23. Relations • A relation over a set S is a set R µ S £ S • We write a R b for (a,b) 2 R • A relation R is: • reflexive iff 8 a 2 S . a R a • transitive iff 8 a 2 S, b 2 S, c 2 S . a R b Æ b R c ) a R c • symmetric iff 8 a, b 2 S . a R b ) b R a • anti-symmetric iff 8 a, b, 2 S . a R b ):(b R a)

24. Relations • A relation over a set S is a set R µ S £ S • We write a R b for (a,b) 2 R • A relation R is: • reflexive iff 8 a 2 S . a R a • transitive iff 8 a 2 S, b 2 S, c 2 S . a R b Æ b R c ) a R c • symmetric iff 8 a, b 2 S . a R b ) b R a • anti-symmetric iff 8 a, b, 2 S . a R b ):(b R a) 8 a, b, 2 S . a R b Æ b R a ) a = b

25. Partial orders • An equivalence class is a relation that is: • A partial order is a relation that is:

26. Partial orders • An equivalence class is a relation that is: • reflexive, transitive, symmetric • A partial order is a relation that is: • reflexive, transitive, anti-symmetric • A partially ordered set (a poset) is a pair (S,·) of a set S and a partial order · over the set • Examples of posets: (2S, µ), (Z, ·), (Z, divides)

27. Lub and glb • Given a poset (S, ·), and two elements a 2 S and b 2 S, then the: • least upper bound (lub) is an element c such thata · c, b · c, and 8 d 2 S . (a · d Æ b · d) ) c · d • greatest lower bound (glb) is an element c such thatc · a, c · b, and 8 d 2 S . (d · a Æ d · b) ) d · c

28. Lub and glb • Given a poset (S, ·), and two elements a 2 S and b 2 S, then the: • least upper bound (lub) is an element c such thata · c, b · c, and 8 d 2 S . (a · d Æ b · d) ) c · d • greatest lower bound (glb) is an element c such thatc · a, c · b, and 8 d 2 S . (d · a Æ d · b) ) d · c • lub and glb don’t always exists:

29. Lub and glb • Given a poset (S, ·), and two elements a 2 S and b 2 S, then the: • least upper bound (lub) is an element c such thata · c, b · c, and 8 d 2 S . (a · d Æ b · d) ) c · d • greatest lower bound (glb) is an element c such thatc · a, c · b, and 8 d 2 S . (d · a Æ d · b) ) d · c • lub and glb don’t always exists: