A real-time garbage collection framework for embedded systems

@inproceedings{Fu2005ARG,
  title={A real-time garbage collection framework for embedded systems},
  author={Wei Fu and Carl H. Hauser},
  booktitle={SCOPES '05},
  year={2005}
}
Garbage collection is increasingly prevalent as part of the programming landscape, but its use in real-time embedded systems remains problematic. One approach is to separate the specification of the timing requirements of real-time tasks, the memory use behavior of the code that implements them, and the configuration of the memory management system to ensure that the tasks' real-time requirements are met. The Real Time Garbage Collector (RTGC) framework provides common language for describing a… 

Tables from this paper

A systematic approach to garbage collection for real-time systems
TLDR
A system model that outlines the systematic RTGC approach is presented, a GC cost model that guarantees garbage collection activities' worst-case execution time (WCET), and GC-integrated scheduling and schedulability analysis mechanisms that compute feasible GC execution parameters satisfying real-time timing requirements are presented.
Modeling Real-time Garbage Collection Cost
  • Wei Fu, C. Hauser
  • Computer Science
    13th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA 2007)
  • 2007
TLDR
A detailed GC cost model for incremental mark-and-sweep GC exemplified by a modified Boehm-Demers-Weiser (BDW) collector is described, which incorporates the cost of write barriers that are needed to support incremental GC.
Scheduling garbage collection in real-time systems
  • M. Kero, Simon Aittamaa
  • Computer Science
    2010 IEEE/ACM/IFIP International Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS)
  • 2010
TLDR
This paper shows how the reactive object model of the programming language Timber enables us to decouple the cost of a concurrently running copying garbage collector from the schedulability of the real-time tasks, and presents the garbage collection demand analysis, which determines if the garbage collector can be feasibly scheduled in the system.
Garbage collection for reactive real-time systems
Predictable use of resources, such as processor time and memory, is a desirable property for virtually any computer system. In real-time computing, static predictability is of particular concern. A
Parametric heap usage analysis for functional programs
TLDR
This paper presents an analysis that derives a formula describing the worst-case live heap space usage of programs in a functional language with automated memory management (garbage collection) to derive upper bounds on heap usage, without considering behaviors of the program that cannot lead to maximal space usage.
A novel algorithm to protect and manage memory locations
TLDR
A new approach is developed in this paper that supports comprehensive randomization, whereby the absolute locations of all (code and data) objects, as well as their relative distances are randomized.
Functional Modelling of Operating Systems
TLDR
Another embedded domain-specific functional language is created to provide a way for the programmer to express heuristics on how dataflow graphs are scheduled, which lead to the concept of “declarative scheduling”.
Fault tolerance for stream programs on parallel platforms
TLDR
This thesis is focused on creating two fault tolerance mechanisms for distributed systems with centralised control that uses stream processing for communication, which are leader election and log-based rollback-recovery, implemented using LPEL.

References

SHOWING 1-10 OF 29 REFERENCES
Flexible automatic memory management for real-time and embedded systems
TLDR
This thesis presents new approaches to flexible and robust memory management from an engineering perspective and is a step towards write once --- run anywhere with hard real-time performance.
Scheduling Garbage Collection in Embedded Systems
TLDR
A scheduling strategy is presented that employs the properties of control systems to ensure that no garbage collection work is performed during the execution of critical processes, and the hard real-time part of the system is thus never disturbed by garbage collector work.
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
Region-based memory management for real-time Java
TLDR
A thorough analysis of the parameters influencing the performance of memory management together with ways of improvement are presented and the implementation of a memory management solution, which is compliant with the RTSJ and integrating the proposed improvements is sketched.
The treadmill: real-time garbage collection without motion sickness
A simple real-time garbage collection algorithm is presented which does not copy, thereby avoiding some of the problems caused by the asynchronous motion of objects. This in-place "treadmill" garbage
Minimizing memory requirement of real-time systems with concurrent garbage collector
TLDR
The parameter configuration scheme is addressed using two different approaches, that is, the utilization based analysis and exact analysis of the selection of parameters, and the worst-case response time of a garbage collector is minimized, and so is the best-case system memory requirement.
Scheduling garbage collector for embedded real-time systems
TLDR
Simulation results demonstrate that the proposed algorithm can produce the feasible memory requirement comparable to the complex on-line scheduling algorithm such as slack stealing.
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.
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.
Garbage collector interface
TLDR
The purpose of the presented garbage collector interface is to provide a universal interface for many different implementations of garbage collectors, but also to support incremental, non-conservative, and thread safe implementations.
...
...