The Metronome: A Simpler Approach to Garbage Collection in Real-Time Systems

@inproceedings{Bacon2003TheMA,
  title={The Metronome: A Simpler Approach to Garbage Collection in Real-Time Systems},
  author={David F. Bacon and Perry Cheng and V. T. Rajan},
  booktitle={OTM Workshops},
  year={2003}
}
With the wide-spread adoption of Java, there is significant interest in using the language for programming real-time systems. The community has generally viewed a truly real-time garbage collector as being impossible to build, and has instead focused its efforts on adding manual memory management mechanisms to Java. Unfortunately, these mechanisms are an awkward fit for the language: they introduce significant run-time overhead, introduce run-time memory access exceptions, and greatly… 
Exploration of dynamic memory management systems
TLDR
A taxonomy for comparing garbage collection technologies is presented to bring a sense of uniformity to the language used to reason about garbage collections technologies, and to understand the costs associated with using scopes and NHRTs to manage memory.
Exploration of Dynamic Memory
TLDR
A dissertation presented to the Graduate School of Arts and Sciences of Washington University in partial fulfillment of the requirements for the degree of Doctor of Philosophy, exploring the costs associated with using dynamic memory management systems.
Cost Analysis for Real-time Java Scoped-memory Areas ∗
TLDR
An asymptotic analysis for RTSJ scoped-memory areas and NHRTs is presented, which shows that there is no system-independent analysis of their costs.
Asymptotic Analysis for Real-time Java Scoped-memory Areas ∗
TLDR
An asymptotic analysis for RTSJ scoped-memory areas and NHRTs is presented, which shows that there is no system-independent analysis of their costs.
Coarse grain memory management in real-time systems
TLDR
This thesis argues that a dynamic, coarse grain approach to memory management can help deliver tight time and space overheads at an acceptable development cost and motivates a number of changes and extension that address the shortcomings of the memory model as currently presented in the RTSJ.
A Comparison of Priority-based and Incremental Real-Time Garbage Collectors in the Implementation of the Shadow Design Pattern
TLDR
This report presents an investigation of the Shadow Design Pattern from the perspective of non-assignable priorities, and shows that the modified code for the Shadow design pattern runs well under Metronome.
Team up: Cooperative memory management in embedded systems
TLDR
A novel memory-management strategy is implemented in the KESO JVM that is a latency-aware garbage-collection algorithm called LAGC and the static analyses that can assist it are introduced.
On the Development of Dynamic Real-Time Applications in the RTSJ - A Model for Expressing Dynamic Memory Requirements
TLDR
This paper develops algorithms that give the best ordering for scoped memory based on this lifetime information and evaluates the overheads of this approach, and proposes a minimal extension to the RTSJ that reduces these overheads.
On the connection between functional programming languages and real-time Java scoped memory
TLDR
It is shown that programs written in a pure functional programming language can be executed in a provably safe manner using scoped memory in RTSJ, and a new connection allows extant implementations of important abstract data types to migrate safely to R TSJ.
Scheduling of hard real-time garbage collection
TLDR
It is shown that the restricted execution model of the Safety Critical Java standard simplifies root scanning and reduces copying of static data and an upper bound for the collector period is provided so that the application threads will never run out of memory.
...
...

References

SHOWING 1-10 OF 13 REFERENCES
Controlling fragmentation and space consumption in the metronome, a real-time garbage collector for Java
TLDR
This paper presents a more detailed analysis of fragmentation than in previous work, and shows how the collector is able to bound fragmentation to acceptable limits, and bound both the time for collection and consequently the space overhead required much more tightly.
A real-time garbage collector with low overhead and consistent utilization
Now that the use of garbage collection in languages like Java is becoming widely accepted due to the safety and software engineering benefits it provides, there is significant interest in applying
Trading data space for reduced time and code space in real-time garbage collection on stock hardware
TLDR
This paper shows that copying compacting real-time garbage collection algorithms do not always need to protect user programs from seeing uncopied data, so long as a slightly more complicated collection termination condition is used, and opens the way to adding an indirection pointer to all LISP heap objects making it unnecessary to check the garbage collection status of pointers.
Real-time garbage collection on general-purpose machines
  • T. Yuasa
  • Computer Science
    J. Syst. Softw.
  • 1990
Generational stack collection and profile-driven pretenuring
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
List Processing in Real Time on a Serial Computer
TLDR
A real-time list processing system is presented which continuously reclaims garbage, including directed cycles, while linearizing and compacting the accessible cells into contiguous locations to avoid fragmenting the free storage pool.
The Real-Time Specification for Java
TLDR
RTSJ's features and the thinking behind the specification's design are explained, which aims to provide a platform-a Java execution environment and application program interface (API) that lets programmers correctly reason about the temporal behavior of executing software.
Analyzing the performance of memory management in RTSJ
  • M. T. Higuera-Toledano, V. Issarny
  • Computer Science
    Proceedings Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISIRC 2002
  • 2002
TLDR
This paper provides an in-depth analytical investigation of the overhead of write barriers in RTSJ VMs, and describes and analyzes solutions for reducing them.
Controlling fragmentation and space consumption in the Metronome, a real-time garbage collector fo r Java. InProceedings of the Conference on Languages, Compilers, and Tools for Embedded Systems(San
  • 2003
Generational stack collection and profile - driven pre - tenuring . In Proc . of the Conference on Programming Language Design and Implementation ( June 1998 )
  • Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming
...
...