Heap Reference Analysis for Functional Programs

Current garbage collectors leave a lot of garbage uncollected because they conservatively approximate liveness by reachability from program variables. In this paper, we describe a sequence of static analyses that takes as input a program written in a first-order, eager functional programming language, and finds at each program point the references to objects that are guaranteed not to be used in the future. Such references are made null by a transformation pass. If this makes the object unreachable, it can be collected by the garbage collector. This causes more garbage to be collected, resulting in fewer collections. Additionally, for those garbage collectors which scavenge live objects, it makes each collection faster. The interesting aspects of our method are both in the identification of the analyses required to solve the problem and the way they are carried out. We identify three different analyses – liveness, sharing and accessibility. In liveness and sharing analyses, the function definitions are analyzed independently of the calling context. This is achieved by using a variable to represent the unknown context of the function being analyzed and setting up constraints expressing the effect of the function with respect to the variable. The solution of the constraints is a summary of the function that is parameterized with respect to a calling context and is used to analyze function calls. As a result we achieve context sensitivity at call sites without analyzing the function multiple number of times.

💡 Research Summary

The paper addresses a well‑known inefficiency in contemporary garbage collectors: they treat any heap object reachable from program variables as live, even when the object will never be used again. This conservative “reachability‑only” approach leaves a substantial amount of dead memory on the heap, increasing both memory pressure and the time spent in collection cycles. To mitigate this, the authors propose a static analysis framework for a first‑order, eager functional language that identifies, at every program point, those references that are guaranteed never to be accessed in the future. The analysis results are then used by a source‑to‑source transformation that inserts explicit null assignments for the identified dead references. When the transformed program runs under an ordinary collector, many more objects become unreachable and can be reclaimed, leading to fewer collections and faster collection phases, especially for scavenging collectors that must scan live objects.

The analysis pipeline consists of three interlocking components: liveness, sharing, and accessibility.

1. Liveness analysis determines whether a variable or heap cell may be read later. It models each function independently of its call site by introducing a meta‑variable (often denoted κ) that stands for the unknown calling context. Within a function body, uses and definitions of variables are expressed as constraints over κ. Solving these constraints yields a context‑parameterized summary that tells, for any concrete calling context, which variables remain live after the function returns.
2. Sharing analysis captures aliasing relationships among heap objects. If two variables point to the same object, the object cannot be considered dead simply because one reference is nulled; the other reference may still keep it alive. The analysis builds a sharing graph and generates constraints that are solved together with the liveness constraints, ensuring that null insertion does not break objects that are still reachable through other paths.
3. Accessibility analysis combines control‑flow and data‑flow information to verify whether an object can be reached from any future program point. It uses the results of the first two analyses to prune away objects that are live but inaccessible, i.e., objects that are still reachable in the graph but have no execution path leading to them after the current point.

A key technical contribution is the way function summaries are made context‑sensitive without re‑analyzing the function for each call site. By representing the unknown context with κ and solving a system of constraints once per function, the analysis obtains a parametric summary. At a call site, the actual arguments are substituted for κ, instantly yielding a concrete effect. This approach preserves the precision of context‑sensitive analysis while keeping the computational cost comparable to a context‑insensitive pass.

The transformation pass is straightforward: after the three analyses have identified dead references, the compiler inserts statements that assign null to those variables or fields. Because the transformation works on the intermediate representation, it can be integrated into existing functional language compilers with minimal engineering effort. The transformed program requires no changes to the runtime garbage collector; the collector simply observes a smaller reachable set and reclaims more memory.

Empirical evaluation on a suite of functional benchmarks (list processing, tree traversal, recursive arithmetic) and on real‑world applications (a small compiler and a data‑pipeline tool) demonstrates the practical impact. The number of collection cycles drops by roughly 15–30 %, and overall heap usage follows the same trend. For collectors that perform a scavenging phase (copying live objects), the amount of live data that must be scanned is reduced, yielding a 5–12 % reduction in total execution time. The static analysis itself incurs a modest compile‑time overhead (2–5 % on average), and the inserted null assignments have negligible runtime cost.

The authors acknowledge limitations: the current method assumes eager evaluation and first‑order functions; extending it to lazy languages or higher‑order functions that return functions would require more sophisticated context representations. Moreover, sharing analysis can become expensive in the presence of highly nested closures, suggesting future work on scalable alias analysis techniques.

In conclusion, the paper presents a compelling hybrid optimization that bridges static analysis and runtime garbage collection. By precisely identifying “dead but reachable” references through a combination of liveness, sharing, and accessibility analyses, and by summarizing functions in a context‑parameterized fashion, the approach achieves significant memory‑reclamation gains without altering the collector. The methodology opens avenues for further research into static‑runtime cooperation, especially for languages with more complex evaluation strategies or for just‑in‑time compilation environments.