Joint scheduling of garbage collector and hard real-time tasks for embedded applications

Abstract

Programs with complex data structures often require dynamic memory management based on automatic memory reclamation (garbage collection). A major problem in adopting garbage collection for embedded real-time systems is that it often causes unpredictable pauses and that, as a result of such delays, hard real-time tasks may miss their deadlines. In this paper, we propose a new real-time garbage collection technique for embedded applications. In our approach, the system jointly schedules garbage collector and hard real-time tasks using one of the aperiodic server approaches. Our study focuses on reducing memory requirements while guaranteeing the deadlines of hard real-time tasks. To achieve this objective, we model garbage collection requests as aperiodic hard real-time tasks, and schedule them using the sporadic server (SS). We also present an effective live-memory analysis to bound the worst-case garbage collection time. Performance analysis shows that the proposed approach considerably reduces the worst-case memory reservation compared with a background policy. The analytic results are verified by simulation based on trace-driven data.

Introduction

As information technology permeates into every aspect of our society and industry, distributed real-time computing systems have been implemented in many forms, such as component-based software, software agents and Java virtual machines with applets. These techniques are characterized by objects, mobility, autonomy and dynamic behavior. Execution of programs with complex data structures often requires dynamic memory management of a heap to utilize memory efficiently by reclaiming unused space. We usually hold the system, not the programmer, responsible for the memory management so as to achieve improved productivity, robustness and program integrity. Central to this automatic memory reclamation is the garbage collection process. A garbage collector identifies the data items that will never be used again and then recycles their space for reuse at the system level. In spite of its advantages, garbage collection has not been widely used in embedded real-time applications. For example, few embedded real-time systems have been written in Java™ language, even though it has been popular for years. This is partly because garbage collection may cause the response time of an application to become unpredictable.

For predictable execution of a real-time application, the garbage collector itself must run in real-time mode. We summarize and extend the requirements for a real-time garbage collector that were presented by Wilson (1994):

• Concurrent or incremental execution. In order to avoid intolerable pauses incurred by stop-and-go reclamation, a real-time garbage collector often interleaves its execution with the execution of an application. Depending on the implementation, the garbage collector runs either concurrently with mutators¹ or incrementally in the context of mutator execution. The system needs to remain consistent or safe while the garbage collector identifies all the live objects and processes them. To preserve the consistency of a heap, a real-time collector must have mutators report on any changes that they have made to the liveness of heap objects.

• Bounded interference with mutator execution. Garbage collector must not interfere with the schedulability of hard real-time mutators. For this purpose, we need to keep the basic memory operations, such as memory allocation and pointer modification, short and bounded. We must also aim to minimize the synchronization overhead between garbage collector and mutators.

• Bounded execution time. In real-time systems, the worst-case behavior of the garbage collector should also be predictable. Real-time systems with garbage collection must meet the deadlines of hard real-time mutators while preventing the application from running out of memory. Unbounded garbage collection times may cause either the deadlines of hard real-time mutators to be missed or memory shortage.

Considering these properties, we develop a new approach for real-time garbage collection. Our approach integrates garbage collection with task scheduling. For hard real-time periodic tasks, the objective of our approach is to guarantee that deadlines are always met. Another objective is to reduce the memory requirement since heap memory is usually a scarce resource in embedded systems.

To achieve these objectives, our approach first models garbage collection requests as hard real-time aperiodic tasks. The sporadic server (SS) (Sprunt et al., 1989) schedules them with a preset capacity. Our approach determines the server capacity using the worst-case response time analysis for the SS (Ghazalie and Baker, 1995, Bernat and Burns, 1999). In this way, we can guarantee the schedulability of hard real-time mutators. We also provide a worst-case live-memory analysis to bound the worst-case garbage collection time. Live-memory analysis provides a safe and effective bound of live memory. The worst-case response time of the garbage collector and the worst-case live memory requirement are the dominant factors in determining the total memory requirement, which is minimized by our approach. We choose a semi-space copying collector (Baker, 1978, Brooks, 1984, Kim et al., 2000) for the discussion in this paper because it automatically compacts the live-object area, and thus simplifies the estimation of garbage collection time. From now on, the term garbage collector will indicate a real-time copying garbage collector unless specified otherwise.

The rest of this paper is organized as follows. In Section 2, we review related work on real-time garbage collection. Section 3 formulates the problem addressed in this paper. The scheduling algorithm for real-time garbage collection is introduced in Section 4; this section also presents the live-memory analysis based on the scheduling approach. We evaluate the effectiveness of the proposed approach in Section 5. Section 6 briefly discusses the design consideration for embedded real-time systems with garbage collection. Section 7 concludes this paper.