Real-Time Memory Management: Life and Times

A dynamic memory management system has to take care of the allocation and deallocation of memory blocks in a software system. Real-time embedded systems add some more constraints to the design and the implementation of dynamic memory management systems if compared with the PC world. An increasing number of features are added to embedded mobile devices, however, resources like dynamic memory are limited. In addition, in real-time systems, real-time deadlines must be respected and allocations and deallocations must be done in due time. In this paper we present a case study on evaluating dynamic memory management in embedded real-time systems. We have used a scenario-based approach and used a simulation environment to evaluate the performance of different dynamic memory management systems. Our contribution is to present a practical approach, the tools and the rationales to evaluate dynamic memory management in embedded real-time systems.

Different memory allocation algorithms have been devised to organize memory efficiently in different timestamps according to the needs and scenario of usage yet there are issues and challenges of these allocators to provide full support for real time needs. Real time systems require memory on priority otherwise program may crash or may be unresponsive if demanded memory is not allocated with quick response. Besides the timing constraints, memory allocator algorithms must minimize the memory loss which comes in the form of fragmentation, the unusable memory in response to the memory allocation needs because memory is allocated in the form of blocks. Our focus would be to analyse traditional dynamic memory management algorithms with respect to their functionality, response time and efficiency to find out the issues and challenges with these allocators to sum up the knowledge to know the limitations of these algorithm which might reduce the performance of real time systems. This research paper will give a comparative analysis of some well known memory management techniques to highlight issues for real time systems and innovative techniques suitable for these applications will be argued.

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.

2005

One of the problems with Java for real-time and embedded real-time systems is the unpredictable behavior of garbage collection (GC). GC introduces unexpected load and causes undesirable delays for real-time applications. In this paper, we propose a technique that reduces and ...

Fourth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISORC 2001

The Real-Time Specification for Java [3] provides a framework for building real-time systems. We implemented the memory management portion of this specification and wrote sample applications to test it. We discuss the structure of our implementation and problems encountered during implementation and application development. This research was supported in part by DARPA/AFRL Contract F33615-00-C-1692 as part of the Program Composition for Embedded Systems program. I would like to acknowledge Scott Ananian for a large part of the development of the MIT Flex compiler infrastructure and the Precise-C backend. Karen Zee implemented stop and copy and mark and sweep garbage collectors, which facilitated the development of noheap real-time threads. Hans Boehm, Alan Demers, and Mark Weiser implemented the conservative garbage collector which was used for all of the listed benchmarks. Alex Salcianu tailored his escape analysis to verify the correctness of our Real-Time Java benchmarks with respect to scoped memory assignment violations. Brian Demsky implemented a user-threads package for the Flex compiler which improved the performance of some benchmarks. Victor Kuncak, the research paper fairy, bestowed interesting, relevant, and useful related work on my desk in the middle of the night. Peter Beebee, my brother, gave me the idea for a multiple-stack recycling heap based on reference counts, which eventually became the reference count memory allocator. Finally, I would like to acknowledge the support of Martin Rinard, my advisor, during the entire year it took to produce this work, from initially finding a problem to tackle, through the multiple failed implementations and final success, to the insightful and plentiful comments on drafts of this thesis. Thanks for always being there.

1998

This dissertation proposes a new garbage-collected memory module architecture for hard real-time systems. The memory module is designed for compatibility with standard workstation architectures, and cooperates with standard cache consistency protocols. Processes read and write garbage-collected memory in the same manner as standard memory, with identical performance under most conditions. Occasional contention between user processes and the garbage collector results in delays to the user process of at most six memory cycles. Thus the proposed architecture guarantees real-time performance at fine granularity. This dissertation investigates the viability of the proposed architecture in two senses. First, it demonstrates that a fundamental component of the architecture, the object space manager, can be produced at a reasonable cost. Second, this dissertation reports the results of experiments that measure the performance of the proposed architecture under real workloads. Results of these experiments show that the architecture currently performs more slowly than traditional schemes; but this appears to be correctable by employing a more efficient function call mechanism that caches heap-allocated activation frames. Finally, this dissertation reports on some simple extensions to the C++ programming language to support slice objects. Slice objects, which are supported by the garbage collection architecture, are useful for implementing fragmentable arrays, i.e., arrays in which subarrays may be retained while unused elements become garbage and are collected. Experimental evidence demonstrates that slice objects can be used to implement strings more efficiently than at least some popular ii TABLE OF CONTENTS 1.

Proc. IEEE-'Real-Time Systems Symposium

Traditional dynamic memory management techniques for imperative programming lan-guages are unsuitable for reliable real-time applications because their worst-case time and space requirements are insufficiently bounded. This is demonstrated by detailed measurements of sev-eral ...

2012

ABSTRACT For real-time and embedded systems limiting the consumption of time and memory resources is often an important part of the requirements. Being able to predict bounds on the consumption of these resources during the development process of the code can be of great value. Recent research results have advanced the state of the art of resource consumption analysis.

Science of Computer Programming, 2012

Developing a real-time system in Java requires awareness of memory behaviour in addition to software functional requirements. The Real-Time Specification for Java (RTSJ) introduces a scoped memory model to avoid garbage collection delays in critical real-time applications which need to meet hard real-time constraints. Scoped memory management has certain advantages over garbage collection in terms of predictability. However, developing a realtime application using scoped memory areas (regions) may suffer from both design and runtime errors. Moreover, from a memory footprint perspective, the inability to determine precisely how many scoped memory areas should be used and which objects or threads should be allocated into these scoped memory areas makes using RTSJ problematic for developing real-time systems. In this paper, a survey of the current approaches to improve scoped memory management and new emerging challenges in RTSJ scoped memory management model are presented. Categorizing those problems and challenges provides a picture of the issues researchers have yet to investigate and to support solutions for an optimal scoped memory model. Current approaches and a set of benchmarks used to evaluate current solutions are presented and new research questions in developing realtime Java systems using a scoped memory model are proposed.

Microprocessors and Microsystems, 2018

SystemJ is a programming language based on the Globally Asynchronous Locally Synchronous (GALS) Model of Computation (MoC) used to design safety critical hard real-time systems. SystemJ uses the Java programming language as the "host" language, for carrying out data computations, because Java provides clearly defined operational semantics, type and memory safety in the form of the Garbage Collector (GC), which help with formal functional verification. The same GC, which helps in functional verification, makes Worst Case Reaction Time (WCRT) 1 analysis challenging. Any WCRT analysis framework for GALS programs needs to consider the operations performed by the host language. It has been shown that the worst case time estimates for garbage collection cycles are in seconds, whereas the program's WCRT itself is in micro-seconds. These pessimistic estimates render the WCRT analysis framework ineffective. In order to overcome this problem, we develop a compiler assisted memory management technique for applications written in SystemJ. The SystemJ MoC plays the central role in the proposed technique. The SystemJ MoC allows clearly demarcating the state boundaries of the program, which in turn allows us to partition the heap, at compile time, into two distinct areas: (1) the memory area called the permanent heap , which holds objects that are alive throughout the life time of the application, and (2) the memory area used to hold all other objects, called the transient heap. The size of these memory areas are bounded statically. Furthermore, the memory allocation and reclaim procedures are simple load and pointer reset operations, respectively, which are guaranteed to complete within a bounded number of clock-cycles, thereby alleviating the need for large pessimistic WCRT bounds obtained due to the GC. Experimental results also show that the proposed approach is approximately three times faster, in terms of memory allocation times as compared to standard real-time GC approaches.

Second Workshop on …, 2005

The region-based memory model of The Real-time Specification for Java (RTSJ) is quite rigid, and it complicates the development of reusable predictable software for large-scale systems. In this paper, we propose an extension to the region model of the RTSJ called AGCMemory (Acyclic Garbage Collected Memory). This extension enables the destruction of floating garbage created during the execution of Java methods. The integration in the memory model of the RTSJ and the new required runtime barriers are addressed.

Automatyka, 2013

Abstract – Real Time Operating System (RTOS) is an operating system which supports real-time application by giving correct result within given dead line. There are so many features supported by RTOS like synchronization, clock and timer support, interrupt handling, memory management, task preemption etc. Among these all memory management is a crucial component. Memory management is nothing but memory allocation/ deallocation technique for the process. This paper presents different memory management algorithms for RTOS and comparison between them. Keywords – Memory management, Memory Allocation, Real time operating system

Eighth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC'05), 2000

One of the problems with Java for real-time systems is the unpredictable behavior of garbage collection (GC). GC introduces unexpected load and causes undesirable delays for real-time applications. In this paper, we propose a technique that reduces and bounds the memory requirements for real-time Java programs. This technique can eliminate or reduce the need for GC and allows for a more predictable execution behavior and efficient utilization of the available memory. A theoretical model is presented and a number of benchmark tests are used to evaluate this technique in PERC, NewMonics' realtime JVM, and Sun's JVM. The results show that in some cases GC can be eliminated and an application's execution time decreases and becomes more predictable.