Region-based memory management
Information and Computation
Memory management with explicit regions
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Analysis and development of Java Grande benchmarks
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
Recursive functions of symbolic expressions and their computation by machine, Part I
Communications of the ACM
A method for overlapping and erasure of lists
Communications of the ACM
Modern Operating Systems
A real-time garbage collector with low overhead and consistent utilization
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
TLSF: A New Dynamic Memory Allocator for Real-Time Systems
ECRTS '04 Proceedings of the 16th Euromicro Conference on Real-Time Systems
IBM Systems Journal
A unified theory of garbage collection
OOPSLA '04 Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compile-time deallocation of individual objects
Proceedings of the 5th international symposium on Memory management
Free-Me: a static analysis for automatic individual object reclamation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Replay compilation: improving debuggability of a just-in-time compiler
Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Cork: dynamic memory leak detection for garbage-collected languages
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Detecting and eliminating memory leaks using cyclic memory allocation
Proceedings of the 6th international symposium on Memory management
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
A compacting real-time memory management system
ATC'08 USENIX 2008 Annual Technical Conference on Annual Technical Conference
Proceedings of the 14th international conference on Architectural support for programming languages and operating systems
Programming in Objective-C 2.0
Programming in Objective-C 2.0
Overview of the H.264/AVC video coding standard
IEEE Transactions on Circuits and Systems for Video Technology
Hi-index | 0.00 |
We propose a new memory model called short-term memory for managing objects on the heap. In contrast to the traditional persistent memory model for heap management, objects in short-term memory expire after a finite amount of time, which makes deallocation unnecessary. Instead, expiration of objects may be extended, if necessary, by refreshing. We have developed a concurrent, incremental, and non-moving implementation of short-term memory for explicit refreshing called self-collecting mutators that is based on programmer-controlled time and integrated into state-of-the-art runtimes of three programming languages: C, Java, and Go. All memory management operations run in constant time without acquiring any locks modulo the underlying allocators. Our implementation does not require any additional heap management threads, hence the name. Expired objects may be collected anywhere between one at a time for maximal incrementality and all at once for maximal throughput and minimal memory consumption. The integrated systems are heap management hybrids with persistent memory as default and short-term memory as option. Our approach is fully backwards compatible. Legacy code runs without any modifications with negligible runtime overhead and constant per-object space overhead. Legacy code can be modified to take advantage of short-term memory by having some but not all objects allocated in short-term memory and managed by explicit refreshing. We study single- and multi-threaded use cases in all three languages macro-benchmarking C and Java and micro-benchmarking Go. Our results show that using short-term memory (1) simplifies heap management in a state-of-the-art H.264 encoder written in C without additional time and minor space overhead, and (2) improves, at the expense of safety, memory management throughput, latency, and space consumption by reducing the number of garbage collection runs, often even to zero, for a number of Java and Go programs.