Real Java for real time - gain and pain

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 ...

2006

The object-oriented paradigm has become popular over the last years due to its characteristics that help managing the complexity in computer systems design. This feature also attracted the embedded systems community, as today's embedded systems need to cope with several complex functionalities as well as timing, power, and area restrictions. Such scenario has promoted the use of the Java language and its real-time extension (RTSJ) for embedded real-time systems design. Nevertheless, the RTSJ was not primarily designed to be used within the embedded domain. This paper presents an approach to optimize the use of the RTSJ for the development of embedded real-time systems. Firstly, it describes how to design real-time embedded applications using an API based on RTSJ. Secondly, it shows how the generated code is optimized to cope with the tight resources available, without interfering in the mandatory timing predictability of the generated system. Finally it discusses an approach to synthesize the applications on top of affordable FPGAs. The approach used to synthesize the embedded real-time system ensures a bounded timing behavior of the object-oriented aspects of the application, like the polymorphism mechanism and read/write access to object's data fields.

11th IEEE Symposium on …, 2008

2002

The Java language has several attractive features but cannot at present be used in on-board systems primarily because it lacks support for hard real-time operation. This shortcoming is in being addressed: some suppliers are already providing implementations of Java that are RTcompliant; Sun Microsystem has approved a formal specification for a real-time extension of the language; and an independent consortium is working on an alternative specification for real-time Java. It is therefore expected that, within a year or so, standardized commercial implementations of real-time Java will be on the market. Availability of real-time implementations now opens the way to its use on-board. Within this context, this paper has two objectives. Firstly, it discusses the suitability of Java for on-board applications. Secondly, it reports the results of an ESA study to port a software framework for on-board control systems to a commercial real-time version of Java.

2005

The embedded real-time development community is investigating different approaches in order to provide modularity and reuse features for system design in this area, as well as a more appropriate mapping technique between requirements and implementation. The Java technology is very promising for this community, mainly after the research efforts on its real-time extension RTSJ-real-time specification for Java. However, there are still some critic factors related to the adoption of Java for real-time applications, and some of them deserve special attention. This paper reports a study of some of these decisive factors, such as the choice of the underlying operating system, the use of a middleware (virtual machine) or a native code, and the use of the Java real-time API (RTSJ)

Real-Time Systems, 2007

Real-time systems are notoriously difficult to design and implement, and, as many real-time problems are safety-critical, their solutions must be reliable as well as efficient and correct. While higher-level programming models (such as the Real-Time Specification for Java) permit real-time programmers to use language features that most programmers take for granted (objects, type checking, dynamic dispatch, and memory safety) the compromises required for real-time execution, especially concerning memory allocation, can create as many problems as they solve. This paper presents Scoped Types and Aspects for Real-Time Systems (STARS) a novel programming model for real-time systems. Scoped Types give programmers a clear model of their programs' memory use, and, being statically checkable, prevent the run-time memory errors that bedevil the RTSJ. Adopting the integrated Scoped Types and Aspects approach can significantly improve both the quality and performance of a real-time Java systems, resulting in simpler systems that are reliable, efficient, and correct.

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.

Proceedings of the 7th International Workshop on Java Technologies for Real-Time and Embedded Systems - JTRES '09, 2009

Real-time Java is quickly emerging as a platform for building safety-critical embedded systems. The real-time variants of Java, including , are attractive alternatives to Ada and C since they provide a cleaner, simpler, and safer programming model. Unfortunately, current real-time Java implementations have trouble scaling down to very hard real-time embedded settings, where memory is scarce and processing power is limited. In this paper, we describe the architecture of the Fiji VM, which enables vanilla Java applications to run in very hard environments, including booting on bare hardware with only very rudimentary operating system support. We also show that our minimalistic approach delivers comparable performance to that of server-class production Java Virtual Machine implementations.

Proceedings of the 5th ACM international conference on Embedded software - EMSOFT '05, 2005

Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming.

2008 4th International Conference on Intelligent Computer Communication and Processing, 2008

This paper presents some of the issues related to the use of multi-core architectures for real-time systems, in particular for real-time Java. Currently, the Real-Time Specification for Java (RTSJ) does not account for aspects of parallel computing, but the widespread use of multi-core architectures advocates for the need of a change in this regard. Some of these aspects relate closely to architectural features that need to be properly exported to the application level. We discuss the impact of multi-core processors, both symmetric and asymmetric, on process/thread scheduling. We also analyze the changes needed for some of the important features of RTSJ, such as the priority inversion avoidance, in the new context of multi-core processing. Also, locking and fairness issues are discussed with respect to the use of multi-core processors for real-time Java.

Proceedings of the 5th European conference on Computer systems - EuroSys '10, 2010

While managed languages such as C# and Java have become quite popular in enterprise computing, they are still considered unsuitable for hard real-time systems. In particular, the presence of garbage collection has been a sore point for their acceptance for low-level system programming tasks. Realtime extensions to these languages have the dubious distinction of, at the same time, eschewing the benefits of highlevel programming and failing to offer competitive performance. The goal of our research is to explore the limitations of high-level managed languages for real-time systems programming. To this end we target a real-world embedded platform, the LEON3 architecture running the RTEMS real-time operating system, and demonstrate the feasibility of writing garbage collected code in critical parts of embedded systems. We show that Java with a concurrent, real-time garbage collector, can have throughput close to that of C programs and comes within 10% in the worst observed case on realistic benchmark. We provide a detailed breakdown of the costs of Java features and their execution times and compare to real-time and throughput-optimized commercial Java virtual machines.

2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC), 2008

The partitioning of applications into hardware and software is an important issue in embedded systems, opening room for high level specifications as well as the exploration of different implementation strategies. This paper presents a software architecture to specify threads in hardware in the context of the Real Time Specification for Java (RTSJ) standard. There is a Java class that encapsulates hardware components, providing an abstraction layer to the application developer. Below this Java class, a wrapper hardware component provides a standard interface between RTSJ-based software components and the hardware that implements the thread behavior. This approach provides a high flexibility in choosing either a hardware or software implementation, allowing to postpone hardware/software partitioning to the very end of system development. The paper includes some quantitative data from an example containing hardware and software threads. While both implementations are compatible with the rest of the application from an interface pointof-view, they lead to very different timing and area results.

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.

2012

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.