300 likes | 308 Views
Summary of worklist algorithm for reaching definitions & using lattices in fixed point computation. Explore monotonicity, termination guarantees, and examples.
E N D
Recap • Let’s do a recap of what we’ve seen so far • Started with worklist algorithm for reaching definitions
Worklist algorithm for reaching defns 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 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);
Generalized algorithm using lattices 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 do let new_info := m(n.outgoing_edges[i]) t 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);
Next step: removed outer join • Wanted to remove the outer join, while still providing termination guarantee • To do this, we re-expressed our algorithm more formally • We first defined a “global” flow function F, and then expressed our algorithm as a fixed point computation
Fixedpoint view • We want to find a fixed point of F, that is to say a map m such that m = F(m) • Define ?, which is ? lifted to be a map: ? = e. ? • Compute F(?), then F(F(?)), then F(F(F(?))), ... until the result doesn’t change anymore
Guarantees • If F is monotonic and height of lattice is finite: iterative algorithm terminates • If F is monotonic, the fixed point we find is the least fixed point. • Any questions so far?
What about if we start at top? • What if we start with >: F(>), F(F(>)), F(F(F(>))) • We get the greatest fixed point • Why do we prefer the least fixed point? • More precise
Graphically y 10 10 x
Graphically y 10 10 x
Graphically y 10 10 x
Another example: constant prop • Set D = in x := N Fx := n(in) = out in x := y op z Fx := y op z(in) = out
Another example: constant prop • Set D = 2 { x ! N | x 2 Vars Æ N 2 Z } in x := N Fx := n(in) = in – { x ! * } [ { x ! N } out in x := y op z Fx := y op z(in) = in – { x ! * } [ { x ! N | ( y ! N1 ) 2 in Æ ( z ! N2 ) 2 in Æ N = N1 op N2 } out
Another example: constant prop in Fx := *y(in) = x := *y out in F*x := y(in) = *x := y out
Another example: constant prop in Fx := *y(in) = in – { x ! * } [ { x ! N | 8 z 2 may-point-to(x) . (z ! N) 2 in } x := *y out in F*x := y(in) = in – { z ! * | z 2 may-point(x) } [ { z ! N | z 2 must-point-to(x) Æ y ! N 2 in } [ { z ! N | (y ! N) 2 in Æ (z ! N) 2 in } *x := y out
Another example: constant prop in *x := *y + *z F*x := *y + *z(in) = out in x := f(...) Fx := f(...)(in) = out
Another example: constant prop in *x := *y + *z F*x := *y + *z(in) = Fa := *y;b := *z;c := a + b; *x := c(in) out in x := f(...) Fx := f(...)(in) = ; out
Another example: constant prop in s: if (...) out[0] out[1] in[0] in[1] merge out
Lattice • (D, v, ?, >, t, u) =
Lattice • (D, v, ?, >, t, u) = (2 { x ! N | x 2 Vars Æ N 2 Z } , ¶, D, ;, Å, [)
Example x := 5 v := 2 w := 3 y := x * 2 z := y + 5 x := x + 1 w := v + 1 w := w * v
Back to lattice • (D, v, ?, >, t, u) = (2 { x ! N | x 2 Vars Æ N 2 Z } , ¶, D, ;, Å, [) • What’s the problem with this lattice?
Back to lattice • (D, v, ?, >, t, u) = (2 { x ! N | x 2 Vars Æ N 2 Z } , ¶, D, ;, Å, [) • What’s the problem with this lattice? • Lattice is infinitely high, which means we can’t guarantee termination
Better lattice • Suppose we only had one variable
Better lattice • Suppose we only had one variable • D = {?, > } [ Z • 8 i 2 Z . ?v i Æ i v> • height = 3
For all variables • Two possibilities • Option 1: Tuple of lattices • Given lattices (D1, v1, ?1, >1, t1, u1) ... (Dn, vn, ?n, >n, tn, un) create: tuple lattice Dn =
For all variables • Two possibilities • Option 1: Tuple of lattices • Given lattices (D1, v1, ?1, >1, t1, u1) ... (Dn, vn, ?n, >n, tn, un) create: tuple lattice Dn = ((D1£ ... £ Dn), v, ?, >, t, u) where ? = (?1, ..., ?n) > = (>1, ..., >n) (a1, ..., an) t (b1, ..., bn) = (a1t1 b1, ..., antn bn) (a1, ..., an) u (b1, ..., bn) = (a1u1 b1, ..., anun bn) height = height(D1) + ... + height(Dn)
For all variables • Option 2: Map from variables to single lattice • Given lattice (D, v, ?, >, t, u) and a set V, create: map lattice V ! D = (V ! D, v, ?, >, t, u)
Back to example in Fx := y op z(in) = x := y op z out
Back to example in Fx := y op z(in) = in [ x ! in(y) op in(z) ] where a op b = x := y op z out