Real-Time Specification For Java Research Articles

Using GenERTiCA to Generation Code from RT-UML: A Case Study

Tool support is essential to allow the use of Model-Driven Engineering (MDE) in the design of distributed embedded real-time systems. GenERTiCA is a flexible tool that supports a MDE approach, which uses concepts of Aspect-Oriented Development (AOD) to handle non-functional requirements from real-time and embedded systems domain. This paper presents a comprehensive case study that illustrates GenERTiCA usage to generate source code from UML models. GenERTiCA also performs aspects weaving using aspect's information specified in UML models. Results regarding source code generation for a Java platform based on the Real-Time Specification for Java (RTSJ) are presented. Additionally, this paper discusses the implementation of some aspects of a high-level aspects framework, named DERAF, using the mentioned platform.

Control programming using Java

Networking and distributed applications have an increasing relevance in industrial automation as the horizontal and vertical integration of control systems progresses. In this context, object-oriented programming concepts and languages like Java become more and more interesting for all levels of automation. Within this article the state of the art in real-time Java and its applicability in the automation domain are discussed and an example for an implementation of a run-time environment utilizing the real-time specification for Java (RTSJ) will be introduced.

Research and application of predictable CER-real time Java developing model

Based on the analysis of the limitations of existing Real Time Specification for Java(RTSJ) and developing models,we designed a CER-Java developing model,which can be used to develop embedded high-reliability real-time systems.The model adopted a three-layer developing architecture,including Creation Layer,Execution Layer and Recycle Layer.The Creation Layer created and started various groups of threads and objects.The Execution Layer executed threads that had been started.The Recycle Layer recovered the memory that was no longer in use.The practice shows that the mechanisms,such as the three-layer developing architecture,creating various groups of threads and the periodic garbage collection,etc,not only guarantee the predictability of a system,but also reduce memory usage and simplify the complexity of model.

Implicit ownership types for memory management

The Real-time Specification for Java (RTSJ) introduced a range of language features for explicit memory management. While the RTSJ gives programmers fine control over memory use and allows linear allocation and constant-time deallocation, the RTSJ relies upon dynamic runtime checks for safety, making it unsuitable for safety critical applications. We introduce ScopeJ, a statically-typed, multi-threaded, object calculus in which scopes are first class constructs. Scopes reify allocation contexts and provide a safe alternative to automatic memory management. Safety follows from the use of an ownership type system that enforces a topology on run-time patterns of references. ScopeJ’s type system is novel in that ownership annotations are implicit. This substantially reduces the burden for developers and increases the likelihood of adoption. The notion of implicit ownership is particularly appealing when combined with pluggable type systems, as one can apply different type constraints to different components of an application depending on the requirements without changing the source language. In related work we have demonstrated the usefulness of our approach in the context of highly-responsive systems and stream processing.

It's Time for a Change: The Sun Java Real-Time System for Automation Systems

The Sun Java Real-Time System (Java RTS) 2.0 was released as a produce in June of 2007. This release includes several innovative features new to Sun and Java; real-time garbage collection and initialization-time compilation. Additionally, this release offers customers remarkable precision in the control of the execution of logic in the temporal dimension.The Java Platform requires, for any usable implementation, internal processes which automatically collect and return to the free pool unused blocks of memory. Typically called garbage collection this internal process executes in, what is essentially, opposition to the application in its access to the memory referencing data word topology (reference topology from now on) and in its movement and access to application defined blocks of memory (objects from now on). Garbage collectors need, at some level, to synchronize with the application to avoid mutually destructive simultaneous access to the reference topology and objects. Two points we can now assert, garbage collectors require processor cycles, i.e., overhead, to complete their work and garbage collectors contend with the application for access to application data structures; hence garbage collectors introduce inconsistencies in the execution of logic when viewed in the temporal dimension. For general-purpose applications these inconsistencies, also known as pause times, are currently small enough to be unnoticeable in all but the most demanding applications. For applications which control and monitor physical machines or processes, e.g., robots, cars, trains, oil refineries, manufacturing systems, financial markets, etc., these pause times are too large by three orders of magnitude and in the past have completely eliminated the possibility of using the Java Platform to develop and execute such applications.Java Specification Request 01, finalized in 2001, known as The Real-Time Specification for Java (RTSJ), defines libraries and semantics which when implemented in a Java Virtual Machine (JVM) give developers and, consequently, applications precise control over temporal behavior. The semantics are a strict subset of the semantics of the general-purpose Java Platform which means that implementation of JSR-01 or the RTSJ are, in fact, also conforming implementations of the general-purpose Java Platform. The RTSJ offers developers a rich and deep set of abstractions in which logic can be executed but the one we are interested in is instances of RealtimeThread (RTT), (a class in the RTSJ which is a subclass of Thread). In all observable dimensions and function except the temporal domain logic executing in the context of an RTT is exactly equivalent to that logic executing in the context of a Thread.

Cost enforcement in the real-time specification for Java

The Real-Time Specification for Java (RTSJ) provides an integrated approach to scheduling periodic real-time threads and monitoring their CPU execution time. It defines a cost enforcement model whereby a periodic real-time thread is suspended when it consumes more CPU time (budget) than it requested in a single release. However, compliant implementations need not support this model, as the underlying operating systems mechanisms are not widely available. Consequently, experience with the model is limited (it is generally not provided in most implementations of the RTSJ). In previous work we showed, using model checking techniques, that the current version of the cost enforcement model can, under certain unlikely scenarios, allow a periodic thread more than its CPU budget in a single period. Such a behaviour can undermine any schedulability analysis that has been undertaken. In this paper, we present a revised formal model, which corrects this anomalous behaviour, and evaluate its properties. We also extend the formal model, so it allows support for real-time threads with sporadic and aperiodic releases, and show how our revised cost enforcement model is valid for all types of threads.

Scoped types and aspects for real-time Java memory management

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.

Java Processor Optimized for RTSJ

Due to the preeminent work of the real-time specification for Java (RTSJ), Java is increasingly expected to become the leading programming language in real-time systems. To provide a Java platform suitable for real-time applications, a Java processor which can execute Java bytecode is directly proposed in this paper. It provides efficient support in hardware for some mechanisms specified in the RTSJ and offers a simpler programming model through ameliorating the scoped memory of the RTSJ. The worst case execution time (WCET) of the bytecodes implemented in this processor is predictable by employing the optimization method proposed in our previous work, in which all the processing interfering predictability is handled before bytecode execution. Further advantage of this method is to make the implementation of the processor simpler and suited to a low-cost FPGA chip.

Hardware support for detecting illegal references in a multiapplication real-time Java environment

Our objective is to adapt the Java memory management to an embedded system, e.g., a wireless PDA executing concurrent multimedia applications within a single JVM. This paper provides software, and hardware-based solutions detecting both illegal references across the application memory spaces and dangling pointers within an application space. We give an approach to divide/share the memory among the applications executing concurrently in the system. We introduce and define application-specific memory, building upon the real-time specification for Java (RTSJ) from the real-time Java expert group. The memory model used in RTSJ imposes strict rules for assignment between memory areas, preventing the creation of dangling pointers, and thus maintaining the pointer safety of Java. Our implementation solution to ensure the checking of these rules before each assignment inserts write barriers that use a stack-based algorithm. This solution adversely affects both the performance and predictability of the RTSJ applications, which can be improved by using an existing hardware support.

Scoped, coarse-grain memory management and the RTSJ scoped memory model in the development of real-time applications

As real-time systems become increasingly large and complex, forcing a static memory model becomes untenable. The challenge is to provide a memory model that guarantees tightly bounded time and memory requirements without overburdening the developer with memory concerns. This paper revisits the memory management problem in real-time systems. We introduce a simple model that describes memory usage in a program composed of coarse-grain entities and evaluate a minimal scoped model in this context. We thereby conclude that a scoped, coarse-grain approach similar to that adopted by the Real-Time Specification for Java (RTSJ) is attractive when targeting systems with tight timing constraints.

AGCMemory

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 transparent destruction of floating garbage created during the execution of Java methods. The integration within the memory model of the RTSJ and its automatic memory management algorithm, based on run-time barriers, are described.

Improving the memory management performance of RTSJ

AbstractFrom a real‐time perspective, the garbage collector (GC) introduces unpredictable pauses that are not tolerated by real‐time tasks. Real‐time collectors eliminate this problem but introduce a high overhead. Another approach is to use memory regions (MRs) within which allocation and deallocation is customized. This facility is supported by the memory model of the Real‐Time Specification for Java (RTSJ). RTSJ imposes strict access and assignment rules to avoid both the dangling inter‐region references and the delays of critical tasks of the GC. A dynamic check solution can incur high overhead, which can be reduced by taking advantage of hardware features. This paper provides an in‐depth analytical investigation of the overhead introduced by dynamic assignments checks in RTSJ, describing and analysing several solutions to reduce the introduced overhead. Copyright © 2005 John Wiley & Sons, Ltd.

AN APPROACH FOR DESIGNING REAL-TIME EMBEDDED SYSTEMS FROM RT-UML SPECIFICATIONS

The current work presents an API based on the Real-Time Specification for Java (RTSJ) that optimizes real-time embedded systems development. Using this API it is possible to state non-functional specifications, like time constraints, and guarantee its implementation in the selected platform. Moreover, it discusses how real-time requirements derived from the RT-UML standard can be mapped to the elements from the proposed API. An integrated toolset is used to support the intermediate steps of this mapping process. The paper illustrates the mapping mechanism by means of a case study that implements the control system of an automated wheelchair.

Region inference for an object-oriented language

Region-based memory management offers several important potential advantages over garbage collection, including real-time performance, better data locality, and more efficient use of limited memory. Researchers have advocated the use of regions for functional, imperative, and object-oriented languages. Lexically scoped regions are now a core feature of the Real-Time Specification for Java (RTSJ)[5].Recent research in region-based programming for Java has focused on region checking, which requires manual effort to augment the program with region annotations. In this paper, we propose an automatic region inference system for a core subset of Java. To provide an inference method that is both precise and practical, we support classes and methods that are region-polymorphic, with region-polymorphic recursion for methods. One challenging aspect is to ensure region safety in the presence of features such as class subtyping, method overriding, and downcast operations. Our region inference rules can handle these object-oriented features safely without creating dangling references.

Memory Management for Real-Time Java: An Efficient Solution using Hardware Support*

This paper addresses the issue of improving the performance of memory management for real-time Java applications, building upon the real-time specification for Java (RTSJ) from the Real-Time Java Expert Group. In a first step, a collecting dynamic memory solution including both a real-time garbage collector and region-based memory management, is proposed. A thorough analysis of the parameters influencing the performance of write barriers in memory management, together with ways of improvement are then presented. Finally, the implementation of a memory management solution compliant with the RTSJ and integrating the proposed improvements is sketched.

Session summary

The purpose of this session was to review the Real-Time Specification for Java (RTSJ) and look at the scheduling that Java offers. The discussion focused on the assertion that Java offers a higher-level of abstraction for scheduling than Ada.

Java technology comes to real-time applications

The Java language provides many benefits to application developers, including memory access safety, platform portability, and very high levels of productivity. However, some of the very Java language features that bring these benefits, such as the garbage collector, have also made it difficult or impossible to create applications with bounded response time characteristics. Implementations of the real-time specification for Java (RTSJ) are now available that have proven to be capable of supporting all aspects of real-time systems. This paper discusses the principal concepts underlying the RTSJ, use of the RTSJ's features in real-time applications, the most critical considerations that must be addressed by RTSJ-compliant Java virtual machine implementers, and two example RTSJ-compliant application designs that can fully utilize the RTSJ to portably support their performance requirements.

Real-time programming safety in Java and Ada

Both Java and the Real-time Specification for Java contain concurrency-related constructs that are easily abused or simply misunderstood by a programmer without sufficient knowledge of multi-threading. This article lists a number of those constructs and shows how they are avoided in Ada. Many of the mistakes arise when a programmer confuses exclusion synchronization and condition synchronization. The article opens with an explanation of those concepts.

Ownership types for safe region-based memory management in real-time Java

The Real Time Specification for Java (RTSJ) allows a program to create real-time threads with hard real-time constraints. Real-time threads use region-based memory management to avoid unbounded pauses caused by interference from the garbage collector. The RTSJ uses runtime checks to ensure that deleting a region does not create dangling references and that real-time threads do not access references to objects allocated in the garbage-collected heap. This paper presents a static type system that guarantees that these runtime checks will never fail for well-typed programs. Our type system therefore 1) provides an important safety guarantee for real-time programs and 2) makes it possible to eliminate the runtime checks and their associated overhead.Our system also makes several contributions over previous work on region types. For object-oriented programs, it combines the benefits of region types and ownership types in a unified type system framework. For multithreaded programs, it allows long-lived threads to share objects without using the heap and without memory leaks. For real-time programs, it ensures that real-time threads do not interfere with the garbage collector. Our experience indicates that our type system is sufficiently expressive and requires little programming overhead, and that eliminating the RTSJ runtime checks using a static type system can significantly decrease the execution time of real-time programs.

Evaluating the Expressive Power of the Real-Time Specification for Java*

The goal of this paper is to evaluate the real-time specification for Java proposal by performing several case studies. These case studies include: an extensible general resource controller; atomic action support infrastructure; unbounded and imprecise computations. They have been used previously by the Ada community to evaluate the efficacy of the Ada concurrency and real-time models. Our results indicate that the Real-Time Specification for Java is expressive enough to cope with the demands of real-time concurrent programming. If it can be implemented efficiently, it will provide an alternative to Ada 95 for programming real-time systems.