Bounding space usage of conservative garbage collectors

@inproceedings{Boehm2002BoundingSU,
  title={Bounding space usage of conservative garbage collectors},
  author={Hans-Juergen Boehm},
  booktitle={ACM-SIGACT Symposium on Principles of Programming Languages},
  year={2002}
}
  • H. Boehm
  • Published in
    ACM-SIGACT Symposium on…
    16 January 2002
  • Computer Science
Conservative garbage collectors can automatically reclaim unused memory in the absence of precise pointer location information. If a location can possibly contain a pointer, it is treated by the collector as though it contained a pointer. Although it is commonly assumed that this can lead to unbounded space use due to misidentified pointers, such extreme space use is rarely observed in practice, and then generally only if the number of misidentified pointers is itself unbounded.We show that if… 

Figures from this paper

Space efficient conservative garbage collection

It is shown that some very inexpensive, but previously unused techniques can have dramatic impact on the effectiveness of conservative garbage collectors in reclaiming memory, and that programming style has a significant impact onThe amount of spuriously retained storage, typically even if the collector is not terribly conservative.

Transparent Programmer-Directed Garbage Collection for C++

The approach taken here is similar to that taken by Bjarne Stroustrup's much earlier proposal (N0932=96-0114), but based on prior discussion on the core reflector, this version does insist that implementations make an attempt at garbage collection if so requested by the application.

Transparent Garbage Collection for C++

The approach taken here is similar to that taken by Bjarne Stroustrup's much earlier proposal (N0932=96-0114), but based on prior discussion on the core reflector, this version does insist that implementations make an attempt at garbage collection if so requested by the application.

Garbage collection in the next C++ standard

An ambitious effort to support optional "transparent" garbage collection in the next C++ standard, and provides narrow interfaces that make it easy to both correct code violating this new restriction, and to supply hints to a conservative garbage collector to improve its performance.

Reducing pause time of conservative collectors

An incremental conservative garbage collector that significantly reduces pause time of an existing collector by Boehm et al. like their collector, it is a true conservative collector that does not require compiler cooperation but uses virtual memory primitives of operating systems for write barriers.

MineSweeper: a “clean sweep” for drop-in use-after-free prevention

MineSweeper, attached to JeMalloc, improves security at an acceptable overhead in memory footprint and an execution-time cost of only 5.4% (geometric mean for SPEC CPU2006), and considerably improve on the state-of-the-art for non-probabilistic drop-in temporal-safety systems.

Smarter garbage collection with simplifiers

Simplifiers can aid efficient collection by simplifying objects before they are traced, thereby eliminating some data that would otherwise have been traced and saved by the collector.

Forkscan: Conservative Memory Reclamation for Modern Operating Systems

Empirical evaluation on a range of classical concurrent data structure microbenchmarks shows that Forkscan can preserve the scalability of the original code, while maintaining an order of magnitude lower latency than automatic garbage collection, and demonstrating competitive performance with finely crafted memory reclamation techniques.

Plug : Automatically Tolerating Memory Leaks in C and C + + Applications Gene

Plug is presented, a runtime system for C/C++ applications that allows applications to deliver high performance in the face of both reachable and unreachable memory leaks, and uses a novel heap layout that isolates leaked objects from non-leaked objects, allowing them to be completely paged out to disk.

Magpie: Precise Garbage Collection for C

This dissertation describes Magpie, a system that uses several analyses and conversion techniques to relieve much of the burden of this conversion, and describes the effects of the conversion on several sample programs.
...

References

SHOWING 1-10 OF 19 REFERENCES

Space Eecient Conservative Garbage Collection

It is shown that some very inexpensive but previously unused tech niques can have dramatic impact on the e ectiveness of conservative garbage collectors in reclaiming memory, and some fairly common C and C pro gramming styles signi cantly decrease the effectiveness of any garbage collector.

Compacting garbage collection with ambiguous roots

Many modern garbage collectors recover space by copying using an initial "root" set of pointers which are stored in known locations, all accessible objects are copied into a "new space" using pointers from known locations.

Mostly Accurate Stack Scanning

This work shows how to apply systematic testing techniques and test coverage tools to an accurate stack scanner and introduces a new compression technique for type maps that uses a program-friendly format for the maps.

On the type accuracy of garbage collection

A novel approach to obtaining type-accurate information for garbage collection in a hardware and language independent way that uses a run-time analysis to propagate pointer/non-pointer information from significant type events.

Proper Tail Recursion and Space Eeciency

A formal and implementation-independent deenition of proper tail recursion for Scheme isomersed, which shows how an entire family of reference implementations can be used to characterize related safe-for-space properties, and proves the asymptotic inequalities that hold between them.

Understanding memory allocation of scheme programs

To help understand memory allocation behavior of Scheme programs, two complementary tools are designed that report on frequency of allocation, heap configurations and on memory reclamation, and their integration into a real programming environment for Scheme is detailed.

Proper tail recursion and space efficiency

This paper offers a formal and implementation-independent definition of proper tail recursion for Scheme, and shows how an entire family of reference implementations can be used to characterize related safe-for-space properties, and proves the asymptotic inequalities that hold between them.

Incremental Collection of Mature Objects

A garbage collection algorithm that extends generational scavenging to collect large older generations (mature objects) non-disruptively and naturally supports compaction and reclustering is presented.

Generational Garbage Collection without Temporary Space Leaks for Lazy Functional Languages

A simple implementation where all nodes that survive one garbage collection are tenured, i.e., moved to an old generation, works well in strict languages but in lazy languages such an implementation can create severe temporary space leaks.

Pitfalls of conservative garbage collection

Researchers have recently proposed conservative garbage collection as a technique which allows smooth integration of automatic memory management into existing high‐level languages. Conservative