Generational stack collection and profile-driven pretenuring

@article{Cheng1998GenerationalSC,
  title={Generational stack collection and profile-driven pretenuring},
  author={Perry Cheng and Robert Harper and Peter Lee},
  journal={Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation},
  year={1998}
}
  • P. Cheng, R. Harper, Peter Lee
  • Published 1998
  • Computer Science
  • Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
This paper presents two techniques for improving garbage collection performance: generational stack collection and profile-driven pretenuring. The first is applicable to stack-based implementations of functional languages while the second is useful for any generational collector. We have implemented both techniques in a generational collector used by the TIL compiler (Tarditi, Morrisett, Cheng, Stone, Harper, and Lee 1996), and have observed decreases in garbage collection times of as much as… Expand
Profile-Driven Pretenuring for Java
TLDR
A collector-neutral approach to obtaining object lifetime profile information is developed and a collection of Java programs exhibits a very high degree of homogeneity of object lifetimes at each allocation site, considerably simplifying the implementation of pretenuring and makes it more efficient. Expand
Profile-driven pretenuring for Java (poster session)
TLDR
A collector-neutral approach to obtaining object lifetime profile information is developed and a collection of Java programs exhibits a very high degree of homogeneity of object lifetimes at each allocation site, considerably simplifying the implementation of pretenuring and makes it more efficient. Expand
Dynamic pretenuring schemes for generational garbage collection
  • Wei Huang, W. Srisa-an, J. Chang
  • Computer Science
  • IEEE International Symposium on - ISPASS Performance Analysis of Systems and Software, 2004
  • 2004
TLDR
A novel approach that dynamically predicts object lifespan to assist with pretenuring selection based on a feedback mechanism that records lifespan of objects from each class during garbage collection invocations is proposed. Expand
Beltway: getting around garbage collection gridlock
TLDR
The generality of Beltway enables the design and implementation of new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which the author is aware. Expand
Age-based garbage collection
TLDR
A new, efficient write barrier implementation is described that works for age-based and traditional generational collectors, and reopens for consideration the question where in the heap and with which policies copying collectors will achieve their best performance. Expand
The case for profile-directed selection of garbage collectors
TLDR
In a study of 20 benchmarks and several collectors, compiled with the Marmot optimizing Java-to-native compiler, for every collector there was at least one benchmark that would be at least 15% faster with a more appropriate collector. Expand
Profile-based pretenuring
TLDR
This work produces pretenuring advice that is neutral with respect to the garbage collector algorithm and configuration, and improves the performance of generational, Older First, and Beltway collectors, illustrating that it is collector neutral. Expand
Nonblocking real-time garbage collection
TLDR
An interruptible copy unit is presented that implements nonblocking object copy and can be interrupted after a single word move, and is evaluated as a real-time garbage collector that uses the proposed techniques on a Java processor. Expand
A lock-free, concurrent, and incremental stack scanning for garbage collectors
TLDR
This work proposes the first concurrent, incremental, and lock-free stack scanning for garbage collectors, allowing high responsiveness and support for programs that employ fine-synchronization to avoid locks. Expand
A lock-free, concurrent, and incremental stack scanning mechanism for garbage collectors
TLDR
This work proposes the first concurrent, incremental, and lock-free stack scanning mechanism for garbage collectors, that allows high responsiveness and support for programs that employ fine-grain synchronization to avoid locks. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 65 REFERENCES
Garbage collection using a dynamic threatening boundary
TLDR
This paper describes a mechanism that extends existing generational collection algorithms by allowing them to reclaim tenured garbage more effectively, and describes an implementation of the dynamic threatening boundary mechanism and quantifies its associated costs. Expand
Comparative performance evaluation of garbage collection algorithms
TLDR
It is shown that object-level, trace-driven simulation can facilitate evaluation of language runtime systems and reaches new conclusions about the relative performance of important garbage collection algorithms, including mark-and-sweep garbage collection, which shows comparable CPU performance and much better reference locality than the more widely used copying algorithms. Expand
Simple generational garbage collection and fast allocation
  • A. Appel
  • Computer Science
  • Softw. Pract. Exp.
  • 1989
TLDR
A scheme for quick record allocation attacks this bottleneck because many garbage‐collected environments do not know when to ask the operating system for more memory, and a robust heuristic solves this problem. Expand
Uniprocessor Garbage Collection Techniques
We survey basic garbage collection algorithms, and variations such as incremental and generational collection. The basic algorithms include reference counting, mark-sweep, mark-compact, copying, andExpand
Better static memory management: improving region-based analysis of higher-order languages
TLDR
This work improves upon the Tofte/Talpin region-based scheme for compile-time memory management and reduces memory requirements significantly, in some cases asymptotically. Expand
Better Static Memory Management: Improving Region-Based
TLDR
This work improves upon the Tofte/Talpin region-based scheme for compile time memory management and reduces memory requirements significantly, in some cases asymptotically. Expand
A theory of stack allocation in polymorphically typed languages
TLDR
The main result of this report is that region inference is safe, a result which entails that regions really can be deallocated, when region inference says they can. Expand
Lag, drag, void and use—heap profiling and space-efficient compilation revisited
TLDR
A profiler that can identify heap consumption by 'useless' cells is described, unlike heap profilers based on traversals of the live heap, this profiler works by examining cells postmortem. Expand
Control-flow analysis of higher-order languages of taming lambda
TLDR
This dissertation presents a technique for recovering the control-flow graph of a Scheme program at compile time, and gives examples of how this information can be used to perform several data-flow analysis optimisations, including copy propagation, induction- variable elimination, useless-variable elimination, and type recovery. Expand
Compiling Prolog to Standard ML: Some Optimizations
TLDR
This paper focuses on the optimizations implemented which increase the performance of the Prolog system, which approaches that of a low-level implementation for certain types of programs. Expand
...
1
2
3
4
5
...