Shifting garbage collection overhead to compile time

  title={Shifting garbage collection overhead to compile time},
  author={Jeffrey M. Barth},
  journal={Commun. ACM},
This paper discusses techniques which enable automatic storage reclamation overhead to be partially shifted to compile time. The paper assumes a transaction oriented collection scheme, as proposed by Deutsch and Bobrow, the necessary features of which are summarized. Implementing the described optimizations requires global flow analysis to be performed on the source program. It is shown that at compile time certain program actions that affect the reference counts of cells can be deduced. This… 

Figures from this paper

Compile-Time Garbage Collection by Necessity Analysis

This paper gives a brief overview of an analysis technique for determining at compile-time whether heap cells are still needed at a particular point in the execution of a functional program. This

Implementation and analysis of compile-time gargage collection

We have proposed a method to detect the generation of garbage cells, by analyzing a source text of functional programming languages.15) The garbage cells whose generation is expected are reclaimed

Static Analysis for Optimizing Reference Counting

Compile-time concurrent marking write barrier removal

It is demonstrated that a large fraction of write barriers in the snapshot-at-the-beginning style of concurrent marking are unnecessary, and may be eliminated by static analysis.

Compile-Time Garbage Collection for Lazy Functional Languages

In this paper, it is shown how information obtained by static analysis can be used to annotate lazy functional programs for compile-time garbage collection. Three different methods for compile-time

Minimizing reference count updating with deferred and anchored pointers for functional data structures

Reference counting can be an attractive form of dynamic storage management. It recovers storage promptly and (with a garbage stack instead of a free list) it can be made "real-time"—i.e., all

Compiler-directed storage reclamation using object lifetime analysis

An operational semantics for a parallel, non-strict language in order to precisely define when it is safe to deallocate an object is formulated and the effectiveness of the compiler at verifying and inserting deallocation commands in several medium-sized Id programs is discussed.

Concurrent garbage collection on stock hardware

It is believed that the modification of Brooks' forwarding pointers can successfully off-load much of the cost of memory management to, otherwise unused, dead-time.

Compile-time optimisation of store usage in lazy functional programs

In this thesis, it is shown how to guarantee that the process of compile-time garbage avoidance will terminate, and both of the described approaches to the optimisation of store usage make use of the information obtained by usage counting analysis.

The one-bit reference count

A significant feature of the hybrid scheme is a small cache of references to nodes whose implemented counts “ought to be higher” which prevents the loss of logical count information in simple manipulations of uniquely referenced structures.



An efficient, incremental, automatic garbage collector

This paper describes a new way of solving the storage reclamation problem for a system such as Lisp that allocates storage automatically from a heap, and does not require the programmer to give any

Object code optimization

Methods of analyzing the control flow and data flow of programs during compilation are applied to transforming the program to improve object time efficiency and implementation of these and other optimizations in OS/360 FORTRAN H are described.

An empirical study of list structure in Lisp

Pointers to atoms are found to obey, roughly, Zipf's law, which governs word frequencies in natural languages; pointers to lists usually point to a location physically nearby in memory.

A note on the confinement problem

A set of examples attempts to stake out the boundaries of the problem by defining a program during its execution so that it cannot transmit information to any other program except its caller.

The enforcement of security policies for computation

This paper defines security policies and protection mechanisms precisely and bridges the gap between them with the concept of soundness: whether a protection mechanism enforces a policy.

Security Kernel validation in practice

The technique used to carry out the first step of the proof of the correctness of a security kernel on a PDP-11/45 is described: validating a formal specification of the program with respect to axioms for a secure system.

A comment on the confinement problem

An approach to proving that an operating system enforces confinement, by preventing borrowed programs from writing information in storage in violation of a formally stated security policy, is presented.

Depth-First Search and Linear Graph Algorithms

The value of depth-first search or “backtracking” as a technique for solving problems is illustrated by two examples. An improved version of an algorithm for finding the strongly connected components

Making computers keep secrets.

Massachusetts Institute of Technology. Dept. of Electrical Engineering. Thesis. 1973. Ph.D.

The Art of Computer Programming

The arrangement of this invention provides a strong vibration free hold-down mechanism while avoiding a large pressure drop to the flow of coolant fluid.