1 / 27

Efficient Project Management Tool

A tool for managing project proposals and ensuring concrete results within 3 weeks, with features for implementation and reading/presentation projects.

gevangelista
Download Presentation

Efficient Project Management Tool

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Project • Project proposal due today (lots of projects have already sent theirs in!) • I want some concrete results in 3 weeks! • for implementation projects, a tool that limps along • for reading/presentation projects, having read 75% of your papers

  2. 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

  3. 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

  4. 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

  5. Another example: constant prop in s: if (...) out[0] out[1] in[0] in[1] merge out

  6. Lattice • (D, v, ?, >, t, u) =

  7. Lattice • (D, v, ?, >, t, u) = (2 A , ¶, A, ;, Å, [) where A = { x ! N | x 2 Vars Æ N 2 Z }

  8. Example x := 5 v := 2 w := 3 y := x * 2 z := y + 5 x := x + 1 w := v + 1 w := w * v

  9. Back to lattice • (D, v, ?, >, t, u) = (2 A , ¶, A, ;, Å, [) where A = { x ! N | x 2 Vars Æ N 2 Z } • What’s the problem with this lattice?

  10. Back to lattice • (D, v, ?, >, t, u) = (2 A , ¶, A, ;, Å, [) where A = { x ! N | x 2 Vars Æ N 2 Z } • What’s the problem with this lattice? • Lattice is infinitely high, which means we can’t guarantee termination

  11. Better lattice • Suppose we only had one variable

  12. Better lattice • Suppose we only had one variable • D = {?, > } [ Z • 8 i 2 Z . ?v i Æ i v> • height = 3

  13. 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 =

  14. 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)

  15. 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)

  16. Back to example in Fx := y op z(in) = x := y op z out

  17. 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

  18. General approach to domain design • Simple lattices: • boolean logic lattice • powerset lattice • incomparable set: set of incomparable values, plus top and bottom (eg const prop lattice) • two point lattice: just top and bottom • Use combinators to create more complicated lattices • tuple lattice constructor • map lattice constructor

  19. May vs Must • Has to do with definition of computed info • Set of x ! y must-point-to pairs • if we compute x ! y, then, then during program execution, x must point to y • Set of x! y may-point-to pairs • if during program execution, it is possible for x to point to y, then we must compute x ! y

  20. May vs must

  21. May vs must

  22. Direction of analysis • Although constraints are not directional, flow functions are • All flow functions we have seen so far are in the forward direction • In some cases, the constraints are of the form in = F(out) • These are called backward problems. • Example: live variables • compute the set of variables that may be live

  23. Example: live variables • Set D = • Lattice: (D, v, ?, >, t, u) =

  24. Example: live variables • Set D = 2 Vars • Lattice: (D, v, ?, >, t, u) = (2Vars, µ, ; ,Vars, [, Å) in Fx := y op z(out) = x := y op z out

  25. Example: live variables • Set D = 2 Vars • Lattice: (D, v, ?, >, t, u) = (2Vars, µ, ; ,Vars, [, Å) in Fx := y op z(out) = out – { x } [ { y, z} x := y op z out

  26. Example: live variables x := 5 y := x + 2 y := x + 10 x := x + 1 ... y ...

  27. Example: live variables x := 5 y := x + 2 y := x + 10 x := x + 1 ... y ...

More Related