Non-blocking object copy for real-time garbage collection

Compacting garbage collectors must update all references to objects they move. Updating is a lengthy operation but the updates must be transparent to the mutator. The consequence is that no space can be reclaimed until all references have been updated which, in a real-time collector, must be done incrementally. One solution is to replace direct references to objects with handles. Handles offer several advantages to a real-time collector. They eliminate the updating problem. They allow immediate reuse of the space used by evacuated objects. They incur no copy reserve overhead. However, the execution time overhead of handles has led to them being abandoned by most modern systems. We re-examine this decision in the context of real-time garbage collection, for which several systems with handles have appeared recently. We provide the first thorough study of the overheads of handles, based on an optimised implementation of different handle designs within Ovm's Minuteman real-time collector. We find that with a good set of optimisations handles are not very expensive. We obtained zero overhead over the widely used Brooks-style compacting collector (1.6 and 3.1 on two other platforms) and 9 increase in memory usage. Our optimisations are particularly applicable to mark-compact collectors, but may also be useful to other collectors.

Real-Time Systems, 2000

This paper addresses the issue of improving the performance of memory management for real-time Java applications, building upon the real-time speci®cation for Java (RTSJ) from the Real-Time Java Expert Group. In a ®rst step, a collecting dynamic memory solution including both a real-time garbage collector and region-based memory management, is proposed. A thorough analysis of the parameters in¯uencing the performance of write barriers in memory management, together with ways of improvement are then presented. Finally, the implementation of a memory management solution compliant with the RTSJ and integrating the proposed improvements is sketched.

2007

Memory management is a critical issue for correctness and perfor-mance in real-time embedded systems. Recent work on real-time garbage collectors has shown that it is possible to provide guar-antees on worst-case pause times and minimum mutator utiliza-tion time. This paper presents a new hierarchical real-time garbage collection algorithm for mixed-priority and mixed-criticality envi-ronments. With hierarchical garbage collection, real-time program-mers can partition the heap into a number of heaplets and for each partition choose to run a separate collector with a schedule that matches the allocation behavior and footprint of the real-time task using it. This approach lowers worst-case response times of real-time applications by 26%, while almost doubling mutator utiliza-tion – all with only minimal changes to the application code.

Companion of the 18th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications - OOPSLA '03, 2003

The Real-Time Specification for Java (RTSJ) provides facilities for deterministic, real-time execution in a language that is otherwise subject to variable latencies in memory allocation and garbage collection. A major consequence of these facilities is that the normal Java practice of passing around references to objects in heap memory cannot be used in hard real-time activities. Instead, designers must think carefully about what type of non-heap memory to use and how to transfer data between components without violating RTSJ's memory-area assignment rules. This report explores the issues of programming with non-heap memory from a practitioner's view in designing and programming realtime control loops using a commercially available implementation of the RTSJ.

2007

Memory management is a critical issue for correctness and performance in real-time embedded systems. Recent work on real-time garbage collectors has shown that it is possible to provide guarantees on worst-case pause times and minimum mutator utilization time. This paper presents a new hierarchical real-time garbage collection algorithm for mixed-priority and mixed-criticality environments. With hierarchical garbage collection, real-time programmers can partition the heap into a number of heaplets and for each partition choose to run a separate collector with a schedule that matches the allocation behavior and footprint of the real-time task using it. This approach lowers worst-case response times of realtime applications by 26%, while almost doubling mutator utilization -all with only minimal changes to the application code.

Proceedings of the 6th international workshop on Java technologies for real-time and embedded systems - JTRES '08, 2008

Root scanning is a well known source of blocking times due to garbage collection. In this paper, we show that root scanning only needs to be atomic with respect to the thread whose stack is scanned. We propose two solutions to utilize this fact: (a) block only the thread whose stack is scanned, or (b) shift the responsibility for root scanning from the garbage collector to the application threads. The latter solution eliminates blocking due to root scanning completely. Furthermore, we show that a snapshot-atbeginning write barrier is sufficient to ensure the consistency of the root set even if local root sets are scanned independently of each other. The impact of solution (b) on the execution time of a garbage collector is shown for two different variants of the root scanning algorithm. Finally, we evaluate the resulting real-time garbage collector in a real system to confirm our theoretical findings.

1992

Hardware-assisted garbage collection combines the potential of high average-case allocation rates and memory bandwidth with fast worst-case allocation, fetch, and store times. This paper describes an architecture that allows memory fetch and store operations to execute, on the av erage, nearly as fast as traditional memory. Support for caching garbage-collected memory cells and a protocol designed to minimize communication between the CPU’s cache and memory allow the system to deliver very high performance. The architecture is real-time in that the worst-case time required for a memory fetch or store is approximately six traditional memory cycles, and the time required to allocate an object is bounded by a small constant times the size of the object. A prototype of the proposed architecture has been successfully simulated. Continuing research focuses on measuring the system’s performance under real workloads.

We have developed a portable user-level thread library RT-PTL on UNIX, which is intended to be used for soft realtime processings, such as multimedia systems. A user-level thread is known to be more efficient than a kernel-level one because of its small context switch overhead. However, user-level thread has a restriction that if one thread issues a system call that forces the calling process to be entirely blocked (such as disk I/O operation), no other thread is runnable until the system call has completed. This characteristic is undesirable for real-time processing.

Lecture Notes in Computer Science, 2005

Today more and more functionality is packed into all kinds of embedded systems, making high-level languages, such as Java, increasingly attractive as implementation languages. However, certain aspects, essential to high-level languages are much harder to address in a low performance, small embedded system than on a desktop computer. One of these aspects is memory management with garbage collection. This paper describes the design process behind a concurrent, garbage collector unit (GCU), a coprocessor to the Java Optimised Processor. The GCU, targeting small embedded real-time applications, implements a markcompact algorithm, extended with concurrency support, and tuned for improved performance.

2004

Priority inversion is an important concern in providing robust synchronization in real-time systems. When a highpriority task attempts to acquire a lock held by a low priority task, it is often necessary to momentarily resume the execution of the low priority task so as to allow it to leave the critical region safely, ensuring that shared resources are not in an inconsistent state. Once these resources are properly released, the high priority task can proceed. In pathological cases, the priority of several threads may have to be increased, and the high priority tasks can experience unbounded delays.