Fridtjof Siebert's Publications:

Java Virtual Machine Research & Technology Symposium '01 (JVM01), Monterey, CA, April 2001

Abstract

For the application of Java in realtime and safety critical domains, an analysis of the worst-case execution times of primitive Java operations is necessary. All primitive operations must either execute in constant time or have a reasonable upper bound for their execution time. The difficulties that arise for a Java virtual machine and a Java compiler in this context will be presented here. This includes the implementation of Javas class and interface model, class initialization, monitors and automatic memory management. A new Java virtual machine and compiler that solves these difficulties has been implemented and its performance has been analysed.

Download: PDF (392kB)

10th International Conference on Compiler Construction (CC2001), Genova, April 2001

Abstract

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 real-time 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. AJava 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.

Download: PDF (370kB)

Compilers, Architectures and Synthesis for Embedded Systems (CASES2000 ), San Jose, November 2000

Abstract

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.

Download: PDF (386kB)

Talk for the J-Consortium  Member's Meeting, Grenoble, France, 14-16  March 2000

Abstract

The configuration of different Garbage Collection implementations and algoritihms is presented from the user's view. The resulting system's real-time capabilities are then compared.

Download Slides: PDF (320kB)

Invited talk for the Java User Group Switzerland, WIP Session, Zürich, 7. February 2000

Abstract

Java's automatic memory management is the main reason that prevents Javafrom being used in hard real-time environments. In his talk, Fridtjof
will present the problems arising for the memory management in Javaimplementations and the garbage collection mechanism that is used by the
Jamaica Virtual Machine. 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 possiblewith hard real-time guarantees. This allows application of modern
object-oriented methods even for the development of software with hardreal-time requirements.

Download Slides: PDF (384kB)

The Sixth International Conference on Real-Time Computing Systems and Applications (RTCSA'99), Hong Kong

Abstract

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.

Download: PDF (258kB), PS (1267kB)

20th IEEE Real-Time Systems Symposium (RTSS'99), Phoenix, Arizona

Abstract

We show the difficulties that arise for the implementation of a real-time garbage collector in a multi-threaded system. A mechanism for synchronization between threads and the garbage collector activities is proposed for a single processor system. It is shown how this mechanism can be used to maintain exact information on roots, to implement efficient write-barriers, to do incremental or even constant-time root-scanning and to guarantee short pre-emption time of garbage collector activity.  Special aspects of an implementation for Java that are affected by this mechanism will also be addressed. Finally, experimental data is presented to show that the proposed mechanisms can efficiently be used in real programs.

Download:

short: PDF (17kB) , PS (70kB), HTML (13kB)
long: PDF (257kB), PS (1035kB)

ACM SIGPLAN Notices Vol 34 number 3, March 1999, International Symposium on Memory Management 1998 (ISMM'98)

Abstract

For Garbage Collection (GC) to be a generally accepted means of memory management it is required to prove its efficiency. This paper presents a scheme that guarantees that an incremental Garbage Collector will have completed its collection cycle before the system runs out of memory. Furthermore, it is shown that the work that has to be done by the collector in one incremental step is limited by a small constant depending on the percentage of total memory used by the application program. This result then allows a suitable trade-off between memory demand and GC overhead to be found.

Download: corrected version (PDF, 172kB) (original version contains serious error: (PDF, 132kB))

Michael Weiss, Fridtjof Siebert (Aicas GmbH), et. al.:
TurboJ, a Java Bytecode-to-Native Compiler

ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Embedded Systems 1998 (LCTES'98)

Abstract

TurboJ is an off-line Java compiler, translating Java byte-codes to native code. TurboJ operates in conjunction with a Java Virtual Machine (JVM); among the supported JVMs are those on HPUX, Linux, and Wind River's Tornado for Java (running under VxWorks). Interfacing with a standard JVM entails benefits not enjoyed by the alternate "standalone" approach; particularly important for embedded systems is the opportunity to reduce the memory footprint via mixed-mode execution. In this paper, we discuss the characteristics of TurboJ as currently implemented, focusing on two aspects of TurboJ: its interactions with the JVM, and the optimizations it makes. We then briefly summarize TurboJ's current status, compare it with some other Java off-line compilers, and outline future plans.

Download: Postscript part 1 (125kB), Postscript part 2 (22kB)

Universität Stuttgart, Fakultät Informatik, Abteilung Programmiersprachen, Diplomarbeit Nr. 1484 (1997)
107 Seiten, deutsch

CR-Klassifikation:

D.3.4 (Programming Languages Processors),
D.3.3 (Language Constructs and Features),
D.4.2 (Storage Management),
D.1.5 (Object-oriented Programming)

Zusammenfassung

Ziel der Arbeit war es, einen Compiler für die Programmiersprache Eiffel zu entwickeln. Als Zielcode wird direkt SPARC-Maschinencode erzeugt, so dass eine bei bisherigen Eiffel-Implementierungen nötige C-Compilation wegfällt. So
wird auch die Erzeugung effizienten Maschinencodes für Besonderheiten der Sprache Eiffel moeglich, wie dynamisch gebundene Aufrufe und die effiziente Implementierung eines Garbage-Collectors.

Der Compiler selbst sollte bei konsequenter Verwendung von objektorientierten Techniken entwickelt werden. Die Beschreibung des objektorientierten Aufbaus des Compilers nimmt daher auch einen großen Teil der Ausarbeitung ein.

Eiffel besitzt eine Reihe an leistungsstarken Konstrukten, wie die flexible Mehrfachvererbung und Generizität, deren effiziente Implementierung eine gute Wahl der im Zielcode benutzten Strukturen verlangt. Diesen Strukturen wurde daher ein wichtiger Teil dieser Arbeit gewidmet.

Schließlich ist die Speicherverwaltung durch einen Garbage-Collector in Eiffel unerlässlich. Auch wenn er im Rahmen dieser Arbeit nicht implementiert werden konnte, so befasst sich doch ein eigenes Kapitel ausführlich mit der detaillierten Beschreibung einer effizienten Implementierung der Speicherverwaltung.

Download: PDF Text (494kB), Compiler Source and Executable (DEAD LINK...)