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

@article{Baker1994MinimizingRC,
  title={Minimizing reference count updating with deferred and anchored pointers for functional data structures},
  author={Henry G. Baker},
  journal={ACM SIGPLAN Notices},
  year={1994},
  volume={29},
  pages={38-43}
}
  • 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
TLDR
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.
An on-the-fly reference counting garbage collector for Java
TLDR
A novel reference counting algorithm suitable for a multiprocessor that does not require any synchronized operation in its write barrier (not even a compare-and-swap type of synchronization) and is efficient and may complete with any tracing algorithm.
Concurrent deferred reference counting with constant-time overhead
TLDR
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
TLDR
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 ?
Using automatic memory management eliminates many programming errors that are both hard to find and to correct. Automatic memory management has been used frequently in functional and object oriented
Compiler optimizations for nondeferred reference: counting garbage collection
TLDR
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
TLDR
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
TLDR
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
TLDR
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.
Autonomous garbage collection: resolving memory leaks in long-running server applications
We demonstrate the benefits of a garbage collection technique that requires neither programmer assistance nor rebuilding (compiling or linking) of target applications. That is, our approach
...
1
2
3
4
...

References

SHOWING 1-10 OF 61 REFERENCES
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
TLDR
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
TLDR
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
TLDR
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
TLDR
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.
CONS should not CONS its arguments, or, a lazy alloc is a smart alloc
TLDR
Lazy allocation is a model for allocating objects on the execution stack of a high-level language which does not create dangling references, and can reduce the amortized cost of allocation in such a heap by filtering out the short-lived objects that can be more efficiently managed in LIFO order.
Stop-and-Copy and One-Bit Reference Counting
TLDR
A stop-and-copy garbage collector updates one-bit reference counting with essentially no extra space and minimal memory cycles beyond the conventional collection algorithm, which extends to generation scavenging, it admits uncounted references from roots, and it corrects conservatively stuck counters.
Generational reference counting: a reduced-communication distributed storage reclamation scheme
TLDR
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
TLDR
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.
...
1
2
3
4
5
...