New languages, programming disciplines, operating systems, and software engineering techniques sometimes hold considerable potential for real-time software developers. A promising area of interest-but one fairly new to the real-time community-is object-oriented programming. Java, for example, draws heavily from object orientation and is highly suitable for extension to real-time and embedded systems. Recognizing this fit between Java and real-time software development, the Real-Time for Java Experts Group (RTJEG) began developing the real-time specification for Java (RTSJ) in March 1999 under the Java Community Process. This article explains RTSJ's features and the thinking behind the specification's design. The goal of the RTJEG, of which the authors are both members, was 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.

https://database.sarang.net/study/java/rtj/rtj.pdf

The Real-Time Specification for Java

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 garbage collection to hard real-time systems. Past approaches have generally suffered from one of two major flaws: either they were not provably real-time, or they imposed large space overheads to meet the real-time bounds. We present a mostly non-moving, dynamically defragmenting collector that overcomes both of these limitations: by avoiding copying in most cases, space requirements are kept low; and by fully incrementalizing the collector we are able to meet real-time bounds. We implemented our algorithm in the Jikes RVM and show that at real-time resolution we are able to obtain mutator utilization rates of 45% with only 1.6--2.5 times the actual space required by the application, a factor of 4 improvement in utilization over the best previously published results. Defragmentation causes no more than 4% of the traced data to be copied.

/pdf/a-real-time-garbage-collector-with-low-overhead-and-2wvfltzccw.pdf

A real-time garbage collector with low overhead and consistent utilization

A disclosed gaming machine provides a gaming machine with a non-volatile memory storage device and gaming software that allows the dynamic allocation and de-allocation of memory locations in a non-volatile memory. The non-volatile memory storage devices interface to an industry standard peripheral component interface (PCI) bus commonly used in the computer industry allowing communication between a master gaming controller the non-volatile memory. The master gaming controller executes software for a non-volatile memory allocation system that enables the dynamic allocation and de-allocation of non-volatile memory locations. In addition, the non-volatile memory allocation system enables a non-volatile memory file system. With the non-volatile memory file system, critical data stored in the non-volatile memory may be accessed and modified using operating system utilities such as word processors, graphic utilities and compression utilities.

High performance battery backed ram interface

Static analysis of software with deductive methods is a highly dynamic field of research on the verge of becoming a mainstream technology in software engineering. It consists of a large portfolio of - mostly fully automated - analyses: formal verification, test generation, security analysis, visualization, and debugging. All of them are realized in the state-of-art deductive verification framework KeY. This book is the definitive guide to KeY that lets you explore the full potential of deductive software verification in practice. It contains the complete theory behind KeY for active researchers who want to understand it in depth or use it in their own work. But the book also features fully self-contained chapters on the Java Modeling Language and on Using KeY that require nothing else than familiarity with Java. All other chapters are accessible for graduate students (M.Sc. level and beyond). The KeY framework is free and open software, downloadable from the book companion website which contains also all code examples mentioned in this book.

Deductive Software Verification - The KeY Book

Published in 1996, Richard Joness Garbage Collection was a milestone in the area of automatic memory management. The field has grown considerably since then, sparking a need for an updated look at the latest state-of-the-art developments. The Garbage Collection Handbook: The Art of Automatic Memory Management brings together a wealth of knowledge gathered by automatic memory management researchers and developers over the past fifty years. The authors compare the most important approaches and state-of-the-art techniques in a single, accessible framework. The book addresses new challenges to garbage collection made by recent advances in hardware and software. It explores the consequences of these changes for designers and implementers of high performance garbage collectors. Along with simple and traditional algorithms, the book covers parallel, incremental, concurrent, and real-time garbage collection. Algorithms and concepts are often described with pseudocode and illustrations. The nearly universal adoption of garbage collection by modern programming languages makes a thorough understanding of this topic essential for any programmer. This authoritative handbook gives expert insight on how different collectors work as well as the various issues currently facing garbage collectors. Armed with this knowledge, programmers can confidently select and configure the many choices of garbage collectors. Web ResourceThe books online bibliographic database at www.gchandbook.org includes over 2,500 garbage collection-related publications. Continually updated, it contains abstracts for some entries and URLs or DOIs for most of the electronically available ones. The database can be searched online or downloaded as BibTeX, PostScript, or PDF.

The Garbage Collection Handbook: The Art of Automatic Memory Management

Fragmentation can cause serious loss of memory in systems that are using dynamic memory management. Any useful memory management system must therefore provide means to limit fragmentation. Today's garbage collector implementations often do this by moving objects in a way that free memory is non-fragmented. This paper presents a new object model that is based on fixed size blocks. The model eliminates external fragmentation without the need to move objects. A Java virtual machine and a static Java bytecode compiler that use this object model have been implemented and analysed using the SPECjvm98 benchmark suite. This Java implementation allows for deterministic memory management as needed in real-time systems that is difficult to achieve with moving collectors and unparalleled by current implementations.

Eliminating external fragmentation in a non-moving garbage collector for Java

Java's automatic memory management is the main reason that prevents Java from being used in hard real-time environments. We present the garbage collection mechanism that is used by the Jamaica Virtual Machine, an implementation of the Java Virtual Machine Specification. This mechanism differs significantly from existing implementations in the way threads are implemented, root references are found and in the object layout that is used. The implementation provides hard real-time guarantees while it allows unrestricted use of the Java language. Even dynamic allocation of normal garbage collected Java objects is possible with hard real-time guarantees.

/pdf/hard-real-time-garbage-collection-in-the-jamaica-virtual-3yiw93nqj7.pdf

Hard real-time garbage collection in the Jamaica virtual machine

This paper provides an overview of the realtime garbage collector used by the RTSJ Java Virtual Machine JamaicaVM. A particular emphasis will be made on the improvements made in with release 3.0 JamaicaVM.The JamaicaVM garbage collector is incremental to an extreme extent: single incremental steps of the garbage collector correspond to scanning only 32 bytes of memory and have a worst-case execution time in the order of one μsec. The JamaicaVM garbage collector uses automatic pacing, making the system easier to configure than a garbage collector using explicit pacing that requires information on the application's allocation rate.The recent improvements of the garbage collector that will be present in this paper include support for automatic heap expansion; reduction of the memory overhead for garbage collector internal structures; and significant performance optimisation such as a faster write-barrier and a sweep phase that does not need to touch the objects and therefore reduces the number of cache misses caused during sweep.

http://www.aicas.com/papers/jtres07_siebert.pdf

Realtime garbage collection in the JamaicaVM 3.0

More and more, parallel multicore systems will be used even in low-end devices such as embedded controllers that require realtime guarantees. When garbage collection is used in these systems, parallel or concurrent garbage collection brings important performance advantages. In the context of realtime systems, it has to be shown that a parallel garbage collector implementation not only performs well in most cases, but guarantees on its performance in the worst case are required.This paper analyses the difficulties a parallel mark-and-sweep garbage collector faces during a parallel mark phase. The performance of such a garbage collector degrades when only some of the available processors can perform scanning work in the mark phase. Whenever the grey set contains fewer elements than the number of available processors, some processors may be stalled waiting for new objects to be added to the grey set. This paper gives an upper bound for the number of stalls that may occur as a function of simple properties of the memory graph.This upper bound is then determined for the Java applications that are part of the SPECjvm98 benchmark suite and the theoretical worst-case scalability of a parallel mark phase is analysed. The presented approach is then applied to a Java virtual machine that has uniform mark steps, which at first results in poor worst-case scalability. A small change in the implementation is then proposed and analysed to achieve good scalability even in the worst case.

http://www.aicas.com/papers/ISMM132-siebert.pdf

Limits of parallel marking garbage collection

Root scanning is the task of identifying references to heap objects that are stored outside of the heap itself, in global and local variables and on the execution stack. Root scanning is particularly difficult within an incremental garbage collector that needs to be deterministic or give hard realtime guarantees. Here, a method that allows exact root scanning is presented. The basic idea is to ensure that copies of all root references exist on the heap whenever the garbage collector might become active. This approach reduces the root scanning phase of the garbage collection cycle to an efficient constant-time operation. A Java virtual machine and a static Java byte-- code compiler that use this technique have been implemented and analysed using the SPECjvm98 benchmark suite. This Java implementation allows for deterministic memory management as needed in real-time systems that is difficult to achieve with traditional methods to perform root scanning.

/pdf/constant-time-root-scanning-for-deterministic-garbage-30qn2ykxax.pdf

Fridtjof Siebert

Papers

Eliminating external fragmentation in a non-moving garbage collector for Java

Hard real-time garbage collection in the Jamaica virtual machine

Realtime garbage collection in the JamaicaVM 3.0

Limits of parallel marking garbage collection

Constant-Time Root Scanning for Deterministic Garbage Collection