Smarter garbage collection with simplifiers

O'Neill, Melissa E.; Burton, F. Warren

doi:10.1145/1178597.1178601

Cited by 8 publications

(5 citation statements)

References 39 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Numerous techniques for garbage collection (e.g., [25,14,9,17,36]) have been proposed and studied (e.g., [13,38] for surveys). Traversing collectors have been extended to offer domain-specific customization, such as simplifiers [28]. Simplifiers can help reduce total live memory by running programmer-supplied code during memory traversal.…”

Section: Related Workmentioning

confidence: 99%

Memory management for self-adjusting computation

Hammer

Acar

2008

Proceedings of the 7th International Symposium on Memory Management

View full text Add to dashboard Cite

The cost of reclaiming space with traversal-based garbage collection is inversely proportional to the amount of free memory, i.e., O(1/(1 − f )), where f is the fraction of memory that is live. Consequently, the cost of garbage collection can be very high when the size of the live data remains large relative to the available free space. Intuitively, this is because allocating a small amount of memory space will require the garbage collector to traverse a significant fraction of the memory only to discover little garbage. This is unfortunate because in some application domains the size of the memory-resident data can be generally high. This can cause high GC overheads, especially when generational assumptions do not hold. One such application domain is self-adjusting computation, where computations use memory-resident execution traces in order to respond to changes to their state (e.g., inputs) efficiently.This paper proposes memory-management techniques for selfadjusting computation that remain efficient even when the size of the live data is large. More precisely, the proposed techniques guarantee O(1) amortized cost for each reclaimed memory object. We propose a set of primitives for self-adjusting computation that support the proposed memory management techniques. The primitives provide an operation for allocating memory; we reclaim unused memory automatically.We implement a library for supporting the primitives in the C language and perform an experimental evaluation. Our experiments show that the approach can be implemented with reasonably small constant-factor overheads and that the programs written using the library behave optimally. Compared to previous implementations, we measure up to an order of magnitude improvement in performance and up to a 75% reduction in space usage.

show abstract

Section: Related Workmentioning

confidence: 99%

Memory management for self-adjusting computation

Hammer

Acar

2008

Proceedings of the 7th International Symposium on Memory Management

View full text Add to dashboard Cite

show abstract

“…O'Neill and Burton presented simplifiers as a way to improve the performance of a program [16]. Objects can add a simplify() method that the garbage collector invokes when the collector traces over it.…”

Section: Using Gc To Assist Running Programsmentioning

confidence: 99%

Prioritized garbage collection: explicit GC support for software caches

2016

View full text Add to dashboard Cite

Programmers routinely trade space for time to increase performance, often in the form of caching or memoization. In managed languages like Java or JavaScript, however, this space-time tradeoff is complex. Using more space translates into higher garbage collection costs, especially at the limit of available memory. Existing runtime systems provide limited support for space-sensitive algorithms, forcing programmers into difficult and often brittle choices about provisioning. This paper presents prioritized garbage collection, a cooperative programming language and runtime solution to this problem. Prioritized GC provides an interface similar to soft references, called priority references, which identify objects that the collector can reclaim eagerly if necessary. The key difference is an API for defining the policy that governs when priority references are cleared and in what order. Application code specifies a priority value for each reference and a target memory bound. The collector reclaims references, lowest priority first, until the total memory footprint of the cache fits within the bound. We use this API to implement a space-aware least-recently-used (LRU) cache, called a Sache, that is a drop-in replacement for existing caches, such as Google's Guava library. The garbage collector automatically grows and shrinks the Sache in response to available memory and workload with minimal provisioning information from the programmer. Using a Sache, it is almost impossible for an application to experience a memory leak, memory pressure, or an out-of-memory crash caused by software caching.

show abstract

“…Simplifiers [24] are abstractly described as lightweight daemons that attach themselves to program data and, when activated, improve the efficiency of the program. Our liveness-based GC can be seen as an instance of a simplifier which is tightly coupled with garbage collectors.…”

Section: Related Workmentioning

confidence: 99%

Liveness-based garbage collection for lazy languages

Sanyal

2016

SIGPLAN Not.

View full text Add to dashboard Cite

We consider the problem of reducing the memory required to run lazy first-order functional programs. Our approach is to analyze programs for liveness of heap-allocated data. The result of the analysis is used to preserve only live data-a subset of reachable data-during garbage collection. The result is an increase in the garbage reclaimed and a reduction in the peak memory requirement of programs. While this technique has already been shown to yield benefits for eager first-order languages, the lack of a statically determinable execution order and the presence of closures pose new challenges for lazy languages. These require changes both in the liveness analysis itself and in the design of the garbage collector.To show the effectiveness of our method, we implemented a copying collector that uses the results of the liveness analysis to preserve live objects, both evaluated and closures. Our experiments confirm that for programs running with a liveness-based garbage collector, there is a significant decrease in peak memory requirements. In addition, a sizable reduction in the number of collections ensures that in spite of using a more complex garbage collector, the execution times of programs running with liveness and reachability-based collectors remain comparable.

show abstract

Smarter garbage collection with simplifiers

Cited by 8 publications

References 39 publications

Memory management for self-adjusting computation

Memory management for self-adjusting computation

Prioritized garbage collection: explicit GC support for software caches

Liveness-based garbage collection for lazy languages

Contact Info

Product

Resources

About