Heap Reference Analysis for Functional Programs

In this paper, we consider a first order functional language without imperative features and propose a method to release dead objects so that they can be collected by the garbage collector. This is done by detecting unused references to objects and setting them to null. If all references to the object are nullified, then the dead objects may become unreachable and may be claimed by garbage collector. We propose three analyses to obtain the information required for nullification: liveness analysis, which computes live references at each program point (i.e. the references used by the program beyond the program point), sharing analysis, which computes alternate ways to access live references and accessibility analysis which ensures that the references used by the nullification statement itself exist and do not cause a dereferencing exception. An earlier paper [6] outlined the basic method and provided details of the liveness analysis. This paper brings the theoretical aspects of the method to completion.

As our analyses are interprocedural in scope, the effect of function calls on the heap must be modeled precisely. Most program analyses are either not scalable because they analyze the same function more than once or imprecise because they make overly safe worst-case assumptions about the effect of a function on the heap. For a better balance between scalability and precision, one can compute context independent summaries of the effect of functions on the heap and then use this summary at particular calling context of the function [7][8][9]. We do this by using a variable to represent an unknown context of the function being analyzed and setting up constraints expressing the effect of the function with respect to the variable. The set of constraints is viewed as a set of CFGs and the solution of these constraints is a set of finite state machines approximating the languages defined by the CFGs. The solution, which is a summary of the function parameterized with respect to a calling context, is used to analyze function calls.

The main contributions of the paper are as follows. We identify the analysis required to find nullable references at each program point. As part of the analyses, we show how context independent summaries of functions can be obtained by setting up a set of constraints and solving them by viewing them as a CFG. Finally we show how the result can be used for safe insertion of nullifying statements in the program.

Figure 1(a) shows an example program. The label π of an expression e denotes the program point just before the evaluation of e. The heap memory can be viewed as a (possibly unconnected) directed acyclic graph called memory graph 1during any instant in the execution of the program. The elements of root set are the entry points for the memory graph. The nodes in the memory graph are the cons cells allocated in the heap. There are three kind of edges in the memory graph: (1) Entry edges from an element of the root set to a heap node, (define (append lst1 lst2) (if (null? lst1) lst2 (cons (car lst1) (append (cdr lst1) lst2))))

(let z ←(cons (cons 4 (cons 5 nil)) (cons 6 nil)) in (let y ← (cons 3 nil) in πa :(let w ← (append y z) in πb :(car (car (cdr w)))))) (2) edges from the car field of a heap node to another, and (3) edges from the cdr field of a heap node to another. Elements of the basic data types and the 0-ary constructor nil form the leaf nodes of the graph. All data is assumed to be boxed, i.e. stored in heap cells and accessed through references. The edges in the graph are also called links. The edges shown by thick arrows are those which will be dereferenced beyond π b . These edges are live at π b . Edges that are not live can be nullified by the compiler by inserting suitable statements. These edges are shown with a × in the figure. If an object becomes unreachable due to nullification of such edges, it can be collected by the garbage collector. Note that an edge need not be nullified if nullifying some other edges makes it unreachable from the root set.

To find out all nullable edges in a memory graph, we need the following analyses:

-For every program point π, liveness analysis finds out all the edges in the memory graph that can be potentially dereferenced along some path from π to exit. For the progr

…(Full text truncated)…