Kildall's Lattice Framework for Dataflow Analysis

Contents

Motivation

 Recall that while we would like to compute the meet-over-all-paths (MOP) solution to a dataflow problem, direct computation of that solution (by computing and combining solution for every path) is usually not possible. Therefore, dataflow problems are usually solved by finding a solution to a set of equations that define two dataflow facts (n.before and n.after) for each CFG node n.

Three important questions are:

  1. How do we know that a solution to the equations exists?
  2. If there is more than one solution, which one do we want?
  3. How does the equation solution relate to MOP solution?

The answers are provided by the framework first defined by Kildall. The next section provides background on lattices; the section after that presents Kildall's framework.

Background

Partially ordered sets

Definition:

Below are some examples of sets with orderings; some are partially ordered sets and some are not.

Example 1: The set S is the set of English words, and the ordering ⊆ is substring (i.e., w1 ⊆ w2 iff w1 is a substring of w2). Here is a picture of some words and their ordering (having an edge w1 → w2 means w1 > w2). 

                         candy                  then
                         /    \                /    \
                         v     v              v      v
                annual  and   can            the   hen
                     \   |    /                \   /
                      \  |   /                  v v
                       v v  v                    he
                         an
                         |
                         v
                         a
Note that the "substring" ordering does have the three properties required of a partial order:
  1. It is reflexive (since every word is a substring of itself).
  2. It is anti-symmetric (since if two words are substrings of each other, then they must be the same).
  3. It is transitive (since a substring of a substring of a word is also a substring of the word).

Example 2: S is the set of English words, and the ordering ⊆ is "is shorter than or equal to in length". 

                candy
                  |
                  v
           ____ then
          /    /  |  \
          v   v   v   v
         can and the hen
           \  \   /   /
            \  \ /   /
             v v v   v
               an
                |
                v
                a
Does this ordering have the three properties?
  1. Reflexive: yes.
  2. Anti-Symmetric: NO (Counter-example: "and" and "the" have the same length, but are not the same word.)
  3. Transitive: yes.
Two out of three isn't good enough -- this is not a poset.

Example 3: S is the set of integers, and the ordering ⊆ is "less than or equal to". This is a poset (try verifying each of the three properties).

Example 4: S is the set of integers and the ordering ⊆ is "less than". This is not a poset, because the ordering is not reflexive.

Example 5: S is the set of all sets of letters and the ordering is subset. This is a poset.

Lattices

Definition:

The join of two elements x and y is defined to be the element z such that:
  1. x ⊆ z, and
  2. y ⊆ z, and
  3. for all w such that x ⊆ w and y ⊆ w, w ⊇ z.
The first two rules say that z actually is an upper bound for x and y, while the third rule says that z is the least upper bound. Pictorially: 
        z
       / \              z is the least upper bound of x and y
      v   v
      y   x 

       z  w
       |\/|
       |/\|             z is NOT the least upper bound of x and y
       vv vv            (they have NO least upper bound)
       y  z
The idea for the meet operation is similar, with the reverse orderings.

Examples:

Complete lattices

 Definition:

Note: Every finite lattice (i.e., S is finite) is complete.

Examples:

Note: Every complete lattice has a greatest element, "Top" (written as a capital T) and a least element "Bottom" (written as an upside-down capital T). They are the least-upper and the greatest-lower bounds of the entire underlying set S.

Monotonic functions

Definition:

Examples

Consider the lattice L whose elements are sets of letters, and whose ordering ⊆ is subset.
  1. Function f is the function that adds the letter a to its input: Function f is monotonic (if s1 is a subset of s2, then f(s1) will be a subset of f(s2)).

  2. Function f is: Function f is not monotonic. Counter example: x = {a,b}, y = {a,b,c,d}, f(x)={a,b}, f(y) = empty-set. We see that x ⊆ y, but f(x) is not ⊆ f(y).

  3. Function f is the function that removes the letter a from its input: Function f is monotonic. (Note: monotonic does not mean "for all x, x ⊆ f(x)). This function is an example in which f(x) may be smaller than x, but this function is monotonic.)

Fixed points

Definition:

Examples:

Let L be the lattice whose elements are sets of letters (as above). Here are the fixed points for the functions we considered above:
  1. f(S) = S union {a}
    This function has many fixed points: all sets that contain 'a'.
  2. f(S) = if sizeof(S) ≤ 3 then S else empty-set
    The fixed points for this function are all sets of size less than or equal to 3
  3. f(S) = S - {a}
    The fixed points for this function are all sets that do not contain 'a'.
As an example of a function that has no fixed point, consider the lattice of integers with the usual "less than or equal to" ordering. The function: f(x) = x+1 has no fixed point.

Here is an important theorem about lattices and monotonic functions:

Theorem:

Examples

L is our usual lattice of sets of letters.
  1. f(S) = S U {a}
    Recall that f is monotonic. The greatest fixed point of f is the set of all letters: {a, b, ..., z}. The least fixed point is {a}. Other fixed points are any set of letters that contains a.

  2. f(S) = if size(S) ≤ 3 then S else {}
    Recall that this function f is not monotonic. It has no greatest fixed point. It does have a least fixed point (the empty set). Other fixed points are sets of letters with size ≤ 3.

Creating new lattices from old ones

We can create new lattices from old ones using cross-product: if L1, L2, ..., Ln are lattices, then so is the cross-product of L1, L2, ..., Ln (which we can write as: L1 x L2 x ... x Ln). The elements of the cross-product are tuples of the form:

such that value ek belongs to lattice Lk

The ordering is element-wise: <e1, e2, ..., en> ⊆ <e1', e2', ..., en'> iff:

If L1, L2, ..., Ln are complete lattices, then so is their cross-product. The top element is the tuple that contains the top elements of the individual lattices: <top of L1, top of L2, ... , top of Ln>, and the bottom element is the tuple that contains the bottom elements of the individual lattices: <bottom of L1, bottom of L2, ... , bottom of Ln>.

Summary of lattice theory

Kildall's Lattice Framework for Dataflow Analysis

Recall that our informal definition of a dataflow problem included:

and that our goal is to solve a given instance of the problem by computing "before" and "after" sets for each node of the control-flow graph. A problem is that, with no additional information about the domain D, the operator ⌈⌉ , and the dataflow functions fn, we can't say, in general, whether a particular algorithm for computing the before and after sets works correctly (e.g., does the algorithm always halt? does it compute the MOP solution? if not, how does the computed solution relate to the MOP solution?).

Kildall addressed this issue by putting some additional requirements on D, ⌈⌉ , and fn. In particular he required that:

  1. D be a complete lattice L such that for any instance of the dataflow problem, L has no infinite descending chains.
  2. ⌈⌉ be the lattice's meet operator.
  3. All fn be distributive, a stronger property than monotonicity: Function f is distributive iff for all x,y in L: f(x meet y) = f(x) meet f(y).
He also required (essentially) that the iterative algorithm initialize n.after (for all nodes n other than the enter node) to the lattice's "top" value. (Kildall's algorithm is slightly different from the iterative algorithm presented here, but computes the same result.)

Given these properties, Kildall showed that:

It is interesting to note that, while his theorems are correct, the example dataflow problem that he uses (constant propagation) does not satisfy his requirements; in particular, the dataflow functions for constant propagation are not distributive (though they are monotonic). This means that the solution computed by the iterative algorithm for constant propagation will not, in general be the MOP solution. Below is an example to illustrate this: 
         1: enter
           |
	   v
	 2: if (...)
	/        \
       v          v
   3: a = 2     4: a = 3
       |          |
       v          v
   5: b = 3     6: b = 2
         \     /
	  v   v
        7: x = a + b
            |
	    v
	8: print(x)
The MOP solution for the final print statement is the set {(x,5)}, since x is assigned the value 5 on both paths to that statement. However, the greatest solution to the set of equations for this program (the result computed using the iterative algorithm) finds that x is not constant at the print statement. This is because the equations require that n.before be the meet of m.after for all predecessors m; in particular, they require that the "before" set for node 7 (x = a + b) be empty since the "after" sets of the two predecessors are {(a,2), (b,3)} and {(a,3), (b,2)}, and the meet operator is intersection. Given that 7.before is empty, the equations also require that 7.after (and 8.before) be empty, since that value is defined to be f7( 7.before ), and f7 only determines that x is constant after node 7 if both a and b are constant before node 7.

In 1977, a paper by Kam and Ullman (Acta Informatica 7, 1977) extended Kildall's results to show that, given monotonic dataflow functions:

To show that the iterative algorithm computes the greatest solution to the set of equations, we can "transform" the set of equations into a single, monotonic function L → L (for a complete lattice L) as follows:

Consider the right-hand side of each equation to be a "mini-function". For example, for the two equations:

The two mini-functions, g11 and g12 are:

Define the function that corresponds to all of the equations to be:

Where the (...)s are replaced with the appropriate arguments to those mini-functions. In other words, function f takes one argument that is a tuple of values. It returns a tuple of values, too. The returned tuple is computed by applying the mini-functions associated with each of the dataflow equations to the appropriate inputs (which are part of the tuple of values that is the argument to function f).

Note that every fixed point of f is a solution to the set of equations! We want the greatest solution. (i.e., the greatest fixed point) To guarantee that this solution exists we need to know that:

  1. the type of f is L→L, where L is a complete lattice
  2. f is monotonic

To show (1), note that the each individual value in the tuple is an element of a complete lattice. (That is required by Kildall's framework.) So since cross product (tupling) preserves completeness, the tuple itself is an element of a complete lattice.

To show (2), note that the mini-functions that define each n.after value are monotonic (since those are the dataflow functions, and we've required that they be monotonic). It is easy to show that the mini-functions that define each n.before value are monotonic, too.

For a node n with k predecessors, the equation is:

and the corresponding mini-function is: We can prove that these mini-functions are monotonic by induction on k.

base case k=1

base case k=2

Induction Step

Assume that for all k < n

Now we must show the same thing for k=n

Given that all the mini-functions are monotonic, it is easy to show that f (the function that works on the tuples that represent the nodes' before and after sets) is monotonic; i.e., given two tuples:

    t1 = <e1, e2, ..., en>, and
    t2 = <e1', e2', ..., en'>
such that: t1 ⊆ t2, we must show f(t1) ⊆ f(t2). Recall that, for a cross-product lattice, the ordering is element-wise; thus, t1 ⊆ t2 means: ek ⊆ ek', for all k. We know that all of the mini-functions g are monotonic, so for all k, gk(ek) ⊆ gk(ek'). But since the ordering is element-wise, this is exactly what it means for f to be monotonic!

We now know:

Therefore:

This is not quite what the iterative algorithm does, but it is not hard to see that it is equivalent to one that does just this: initialize all n.before and n.after to top, then on each iteration, compute all of the "mini-functions" (i.e., recompute n.before and n.after for all nodes) simultaneously, terminating when there is no change. The actual iterative algorithm presented here is an optimization in that it only recomputes n.before and n.after for a node n when the "after" value of some predecessor has changed.

Return to Dataflow Analysis table of contents.

Go to the previous section.

Go to the next section.