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

  title={Minimizing reference count updating with deferred and anchored pointers for functional data structures},
  author={Henry G. Baker},
  journal={ACM SIGPLAN Notices},
  • H. Baker
  • Published 1 September 1994
  • Computer Science
  • ACM SIGPLAN Notices
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 accesses can be performed in constant time. Its major drawbacks are its inability to reclaim cycles, its count storage, and its count update overhead. Update overhead is especially irritating for functional (read-only) data where updates may dirty pristine cache lines and pages. 

An on-the-fly reference-counting garbage collector for java

A novel reference-counting algorithm suitable for a multiprocessor system that does not require any synchronized operation in its write barrier (not even a compare-and-swap type of synchronization) and allows eliminating a large fraction of thereference-count updates, thus, drastically reducing the reference- Counting traditional overhead.

Concurrent deferred reference counting with constant-time overhead

The approach combines ideas from referencing counting and hazard pointers in a novel way to implement concurrent reference counting with wait-free, constant-time overhead and is significantly safer than manual techniques since objects are reclaimed automatically.

Counting immutable beans: reference counting optimized for purely functional programming

This work proposes a new mechanism for efficiently reclaiming memory used by nonshared values, reducing stress on the global memory allocator and describes an approach for minimizing the number of reference counts updates using borrowed references and a heuristic for automatically inferring borrow annotations.

Hard Real-Time Reference Counting without External Fragmentation ?

This paper proposes a technique to adapt the automatic memory manager to be fully predictable in both execution time and memory usage, and shows how this technique can be implemented in Java.

Compiler optimizations for nondeferred reference: counting garbage collection

This paper presents a series of optimizations that target the stack and substantially enhance the throughput of nondeferred RC collection, including a new static analysis and optimization called RC subsumption that significantly reduces the overhead of maintaining the stack contribution to reference counts.

Decreasing Memory Overhead in Hard Real-Time Garbage Collection

A new technique, Real-Time Reference Counting (RTRC), is presented that overcomes the current problems and makes automatic memory management attractive also for hard real-time applications.

Dynamic pointer tracking and its applications

This work proposes a technique to compute the precise points-to sets through dynamic pointer tracking and demonstrates how different memory properties can be easily tracked using the dynamic points- to sets opening newer possibilities.

“Use-once” variables and linear objects: storage management, reflection and multi-threading

Programming languages should have 'use-once' variables in addition to the usual 'multiple-use' variables, which are bound to linear objects and allow for the safe/controlled use of reified language implementation objects like single-use continuations.

Meaning of Other Abbreviations: Clear: Clearing Dirty Marks. Reinforce: Reinforcing Connict Slots. Consolidate: Consolidating Thread Buuers. Update: Updating Reference Counters. X: Incrementing Reference Counters Due to Undetermined Slots. Reclaim: Reclaiming Garbage Objects. Figure 17: Timing Diagr

step m 1 h 1 Clear h 2 reinforce h 3 h 4 Consolidate m 2 m 3 Update rb fix reclaim Update step m 1 m 2 m 3 14] Damien Doligez and Xavier Leroy. A concurrent generational garbage collector for a



Shifting garbage collection overhead to compile time

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

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

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.

Reference escape analysis: optimizing reference counting based on the lifetime of references

A compile-time analysis is presented called re~erence escape analysis for higher-order functional languages that determines whether the lifetime of a reference ezceeds the Lifetime of the environment in which the reference was created.

Compiler support for garbage collection in a statically typed language

This work extends the compiler to emit tables describing live pointers, and values derived from pointers, at each program location where collection may occur, and concludes that the approach is practical.

Real-time concurrent collection on stock multiprocessors

A copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commercial uniprocessor and shared-memory multiprocessors, and requires no change to compilers is designed and implemented.

Stop-and-Copy and One-Bit Reference Counting

Generational reference counting: a reduced-communication distributed storage reclamation scheme

The generational reference counting algorithm is presented, the algorithm is proved correct, and some refinements that make it more efficient are discussed, which may provide a significant saving in overall execution time on machines in which message passing is expensive.

Garbage collection of strings and linked data structures in real time

  • K. Nilsen
  • Computer Science
    Softw. Pract. Exp.
  • 1988
The addition of certain information to a string descriptor and enhancements to existing copying garbage collection algorithms that permit linked data structures and strings to be allocated and garbage collected from a shared region of memory in real time are described.

CONS should not CONS its arguments, part II: Cheney on the M.T.A.

This Scheme proposes solving the tail-recursion problem in the same manner as Standard ML of New Jersey, by allocating all frames in the (garbage-collected) heap.