A JVM for Soft-Error-Prone Embedded Systems - Stilkerich, Isabella; Strotz, Michael; Erhardt, Christoph; Hoffmann, Martin; Lohmann, Daniel; Scheler, Fabian; Schröder-Preikschat, Wolfgang (Proceedings of the 14th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems, 2013)
The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption. Copyright © 2013 ACM.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.ajvmfo
Keywords: KESO; DanceOS; AORTA; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

A Practical Getaway: Applications of Escape Analysis in Embedded Real-Time Systems - Stilkerich, Isabella; Lang, Clemens; Erhardt, Christoph; Stilkerich, Michael (Proceedings of the 16th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems, 2015)
UnivIS-Import:2015-04-17:Pub.2015.tech.IMMD.IMMD4.apract
Keywords: KESO; AORTA; DanceOS; invasic; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

Automated Application of Fault Tolerance Mechanisms in a Component-Based System - Stilkerich, Isabella; Stilkerich, Michael; Kapitza, Rüdiger; Lohmann, Daniel; Schröder-Preikschat, Wolfgang (Proceedings of the 9th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2011)
Due to the reduction of structure sizes in modern embedded systems, tolerating soft errors presenting itself as bit flips becomes a mandatory task even for moderate critical applications. Accordingly, software-based fault tolerance mechanisms recently gained in popularity and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. As a consequence, an application- and environment-tailored selection of mechanisms is required to balance protection and costs. Accounting the diverse solution space, we propose to make software-based fault tolerance a matter of configuration that should be transparent to the applications. While this would be cumbersome when using an unsafe programming language, we show that in the context of KESO, a JVM for deeply embedded systems, this can be achieved by utilizing the Java type system and static code analysis. As an initial technique we decided to add redundant execution to KESO, which enables us to selectively and transparently replicate an application. This essentially builds a first step to a JVM, which offers reliable execution of components as demanded by the system configuration. © 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.automa
Keywords: Java; embedded systems; fault tolerance; TMR; KESO; DanceOS

Fehlertoleranz-Techniken automatisiert einbetten - Stilkerich, Isabella; Sechser, Bernhard (Elektronikpraxis - Profiline, 2012)
UnivIS-Import:2015-03-09:Pub.2012.tech.IMMD.IMMD4.fehler

KESO: An Open-Source Multi-JVM for Deeply Embedded Systems - Stilkerich, Isabella; Stilkerich, Michael; Wawersich, Christian; Schröder-Preikschat, Wolfgang (Proceedings of the 8th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2010)
Java still is a rather exotic language in the field of real-time and particularly embedded systems, though it could provide productivity and especially safety and dependability benefits over the dominating language C. The reasons for the lack of acceptance of Java in the embedded world are the high resource consumption caused by the Java runtime environment and lacking language features for low-level programming. KESO is a JVM under LGPL license that was specifically designed for the domain of statically-configured deeply embedded systems. KESO provides a sensible selection of Java features useful to the majority of embedded applications and safe and convenient constructs for low-level programming in Java. A key feature of KESO is its Multi-JVM architecture, which allows the isolated cohabitation of different applications on one hardware platform. The resource consumption of applications developed on the base of KESO is comparable to C applications, and its mechanisms for communicating among isolated components are efficient and encourage the actual utilization of spatial isolation. Copyright 2010 ACM.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD4.kesoan
Keywords: AUTOSAR; Java; KESO; OSEK/VDX; embedded systems; memory protection; spatial isolation

RT-LAGC: Fragmentation-Tolerant Real-Time Memory Management Revisited - Stilkerich, Isabella; Strotz, Michael; Erhardt, Christoph; Stilkerich, Michael (Proceedings of the 12th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.rtlagc
Keywords: KESO; AORTA; invasic; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

Tailor-made JVMs for statically configured embedded systems - Stilkerich, Michael; Stilkerich, Isabella; Wawersich, Christian; Schröder-Preikschat, Wolfgang (Concurrency and Computation-Practice & Experience, 2012)
Java still is a rather exotic language in the field of real-time and particularly embedded systems, eventhough it could provide productivity and especially safety and dependability benefits over the dominating language C. The reasons for the lack of acceptance of Java in the embedded world are the high resource consumption caused by the Java runtime environment and the lacking language features for low-level programming. KESO is a Java Virtual Machine (JVM) that was specifically designed for statically configured resource-constrained embedded systems. Rather than providing a fixed subset of the Java standard functionality, KESO uses the available ahead-of-time knowledge to generate a Java runtime that is specifically tailored towards the particular application. A key feature of KESO is its Multi-JVM architecture, which allows the isolated cohabitation of different applications on one hardware platform. Our evaluation uses two non-trivial real-time applications, a control application for a quadrotor helicopter and a collision detector, to compare the cost of an application using KESO to its C counterpart. Our results show that the resource consumption of applications developed on the base of KESO is comparable to C applications, and its mechanisms for communicating among isolated components are efficient and encourage the actual utilization of spatial isolation. Copyright © 2011 John Wiley & Sons, Ltd.
UnivIS-Import:2015-03-09:Pub.2012.tech.IMMD.IMMD4.tailor
Keywords: AUTOSAR; embedded systems; Java; memory protection; OSEK/VDX; spatial isolation

Team Up: Cooperative Memory Management in Embedded Systems - Stilkerich, Isabella; Taffner, Philip; Erhardt, Christoph; Dietrich, Christian; Wawersich, Christian; Stilkerich, Michael (Proceedings of the 2014 Conference on Compilers, Architectures and Synthesis for Embedded Systems - CASES'14, 2014)
The use of a managed, type-safe languages such as Java in realtime and embedded systems can offer productivity and, in particular, safety and dependability benefits over the dominating unsafe languages at reasonable costs. A JVM that has dynamic memory-management needs to provide an implicit memory-management strategy, that is, for example, a garbage collector (GC) or stack allocation provided by the escape analysis of the JVM's compiler: Explicit management of dynamically allocated memory (i.e., by use of functions such as C's malloc() and free()) is vulnerable to programming errors such as neglected or false memory release operations causing memory leaks or dangling pointers. Such operations have the potential to break the soundness of the type system and are therefore usually not available for strongly typed languages. Type-safe languages in combination with static analyses - which respect hardware as well as system-specific information - can efficiently be employed to provide a runtime system including memory management (MM) that is specifically suited to an embedded application on a particular hardware device. In the context of this paper, we present novel memory-management strategy we implemented in our KESO JVM. It is a latency-aware garbage-collection algorithm called LAGC. Also, we introduce the static analyses that can assist LAGC. The application developers have to ensure that there is enough time for the GCs to run. Hardware characteristics such as soft-error proneness of the hardware or the memory layout can also be taken into consideration as demanded by the system configuration. This is achieved by integrating the GCs in the design process of the whole system just as any other user application, which is the reason why this approach is called cooperative memory management. The suggested strategies require reasonably low overhead. Copyright 2014 ACM.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.teamup
Keywords: KESO; AORTA; invasic; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

The final Frontier: Coping With Immutable Data in a JVM for Embedded Real-Time Systems - Erhardt, Christoph; Kuhnle, Simon; Stilkerich, Isabella; Schröder-Preikschat, Wolfgang (Proceedings of the 12th International Workshop on Java Technologies for Real-Time and Embedded Systems, 2014)
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD4.thefin
Keywords: KESO; AORTA; Java; RTSJ; Embedded Systems; Real-Time Systems; Reliability

The Perfect Getaway: Using Escape Analysis in Embedded Real-Time Systems - Stilkerich, Isabella; Lang, Clemens; Erhardt, Christoph; Bay, Christian; Stilkerich, Michael (ACM Transactions on Embedded Computing Systems, 2017)
UnivIS-Import:2017-01-09:Pub.2017.tech.IMMD.IMMD4.theper
Keywords: Memory Management; Real-Time Systems; Type-safe Runtime Systems; Functional Safety; Dependable Software Architectures; KESO

The Use of Java in the Context of AUTOSAR 4.0 - Wawersich, Christian; Stilkerich, Isabella; Stilkerich, Michael (Embedded World Proceedings & Conference Materials, 2011)
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD4.theuse
Keywords: KESO; Java; AUTOSAR