Specification For Java Research Articles

Java in Robotics: Bridging Software Development and Hardware Control

This research examines how Java bridges robotics software development with hardware control. The main goals are to assess Java's performance in robotic system integration, identify its drawbacks, and suggest ways to improve it. JRobotics, LeJOS, and ROSJava, are reviewed using secondary data to determine their effects on hardware interface, real-time performance, and data processing. According to major studies, Java's platform freedom and modularity enable software and hardware integration. Real-time performance, hardware interface, and memory management remain issues. The Real-Time Specification for Java (RTSJ) and specialized libraries provide partial solutions but need additional development. Policy implications include investing in Java library improvements and improving Java developer-robotics researcher cooperation. Research and optimization will improve Java's position in robotics, making robots more efficient and versatile.

Design and Implementation of an Escape Analysis in the Context of Safety-Critical Embedded Systems

The use of a managed, type-safe language such as Standard ML, Ada Ravenscar, or Java in hard real-time and embedded systems offers productivity, safety, and dependability benefits at a reasonable cost. Static software systems, that is systems in which all relevant resource entities such as threads and their priorities, for instance, and the entire source code are known ahead of time, are particularly interesting for the deployment in safety-critical embedded systems: Code verification is rather maintainable in contrast to dynamic systems. Additionally, static analyses can incorporate information from all software and system layers to assist compilers in emitting code that is well suited to an application on a particular hardware device. It was shown in the past that a program composed in type-safe Java in combination with a static system setup can be as efficient as one that is written in C [30], which is still the most widely used language in the embedded domain. Escape analysis (EA) is one of several static-analysis techniques. It supports, for instance, runtime efficiency by enabling automated stack allocation of objects. In addition, Stilkerich et al. [27, 28] have argued that EA enables further applications in safety-critical embedded systems such as the computation of memory classes stated in the Real-Time Specification for Java (RTSJ) [6]. EA can be applied to any programming language but the quality of its results greatly benefits from the properties of a type-safe language. Notably, embedded multicore devices can positively be affected by the use of EA. Thus, we explore an ahead-of-time (AOT) escape analysis in the context of the KESO JVM featuring a Java AOT compiler targeting (deeply) embedded (hard) real-time systems.

Comparison of JMS Products

Before the introduction of Java Messaging Service API (JMS),developers had to absorb the complex branded APIs of each specific messaging server from different supplier and this made creating messaging applications hard and gave rise to minor transportability. Additionally, messaging servers from different suppliers were not interoperable and ended in supplier limitations. JMS API is not a product but it is a Java specification for messaging middleware from Sun and its partners. JMS defines an enterprise messaging Java API that enables creating business applications effortlessly that can interchange business data and events not occurring at the same time and reliably in a supplier doubting manner. The messaging server suppliers offer the service provider interface that assists the standard JMS API. There are quite a lot of suppliers producing messaging products which promote JMS API and choosing a certain messaging product needs to evaluate the merits and demerits of the product.

Research and Application of the IOT Gateway Based on the Real-Time Specification for Java

The Internet Of Things (IOT) gateway plays an important role in connecting the traditional information network and network aware, in view of the present people use outdated development ways to realize Internet gateway software proposed a scheme of using real-time Java technology. This paper uses ARM cortex-A57 architecture of AMD Opteron 1100 processor as the core to build IOT gateway system hardware platform, through the gateway to realize remote monitoring of underlying device. The IOT gateway adopts "Internet + Sensor Network / FieldBus Technology" network schemes to realize wired / wireless data exchange, and use the fully compatible Real-Time Specification for Java (RTSJ) of the WebSphere Real Time development platform to achieve the Internet gateway protocol conversion and the design of the two layers network communication software to ensure the IOT gateway security real-time communication. Finally, this paper gives the implementation technique and application of the gateway.

Eliminating object reference checks by escape analysis on real-time Java virtual machine

The real-time specification for Java (RTSJ) makes Java to be a real-time programming language. However, the RTSJ’s memory management system is more complicated than J2SE’s. The assignment rules of RTSJ, which prevent the creation of dangling references, must be checked by real-time Java virtual machines (JVMs) at run-time. These frequent run-time object reference checks introduce significant time overheads and unpredictable execution time, which has great impact on real-time systems. This paper presents an equivalence class based, context sensitive and flow insensitive escape analysis algorithm that effectively eliminates unnecessary run-time reference checkpoints of RTSJ programs. The optimization framework has been implemented in an open-source real-time JVM namely jRate and evaluated by CD$$_x$$, a relative authority real-time Java benchmark suite. The results show that this optimization algorithm eliminates more than 90% static reference checkpoints, removes about 50% run-time reference checkpoints on average , and improves the run-time performance of average 3.13%, max 8.93%.

DecompositionJ: Parallel and Deterministic Simulation of Concurrent Java Executions in Cyber-Physical Systems

Simulation and performance evaluation of concurrent Java program execution have been difficult due to the lack of proper model and tools. Previous modeling and simulation approaches cannot simultaneously achieve three tasks: (1) support the direct simulation of unmodified multi-thread Java programs; (2) guarantee deterministic simulation results; and (3) offer low-overhead and scalable simulation. This paper first presents a novel simulation model based on the Java memory model. The model axiomatically defines action ordering, relationships, and constraints to ensure the well-formedness and determinism of a simulated execution. Then, based on the model, we implement the DecompositionJ simulation framework (deterministic, concurrent multi-processsing simulation for Java programs) which enables the direct-execution simulation of target program by using compiler-based source-to-source transformation and a purposely designed runtime library. The framework is compatible with any JVM that complies with the Java specifications, and does not require manual modifications on the target program code. The performance of the framework has been evaluated with the Grande Java concurrency benchmark suite, results have shown a geometric mean of 98.9% overhead over all cases, which significantly outperforms full-system simulation techniques.

Special issue on 12th international workshop on Java technologies for real‐time and embedded systems (JTRES2014)

This editorial describes a special issue of papers from the 2014 workshop on Java Technologies for Real-Time and Embedded Systems.1 There are four papers in this special issue. The first paper 2 presents HVMTP, a time predictable and portable Java virtual machine (JVM) implementation with applications in resource-constrained, hard real-time embedded systems, which implements all levels of the safety-critical Java (SCJ) specification. Time predictability is achieved by a combination of time-predictable algorithms, exploiting the programming model of the SCJ profile and harnessing the static knowledge of the hosted SCJ system. This paper presents HVMTP in terms of its design and capabilities and demonstrates how a complete timing model of the JVM represented as a network of timed automata can be obtained using the tool TETASARTSJVM. The timing model readily integrates with the rest of the TETASARTS toolset for temporal verification of SCJ systems. A complete timing scheme in terms of safe worst-case execution times and best-case execution times of the Java bytecodes is derived from the model. The paper takes a first look at how to support the new Java 8 language feature of Lambda expressions in an SCJ context – looking in particular at how the bytecode, used for invoking Java 8 closures, can be implemented in a time-predictable way and integrated into HVMTP. The second paper 3 presents the motivation for and outcomes of an engineering research project on certifiable Java for embedded systems. The project supports the upcoming SCJ standard for safety-critical Java, which defines a subset of Java and libraries aiming for the development of high criticality systems. The outcome of this project includes prototype safety-critical Java implementations, a time-predictable Java processor, analysis tools for memory safety, and example applications to explore the usability of safety-critical Java for this application area. The text summarizes developments and key contributions and concludes with the lessons learned. The third paper 4 presents a model-based development of a Technology Compatibility Kit test suite and a test execution tool for the draft safety-critical Java profile specification. Passing all tests in an associated Technology Compatibility Kit is needed in order for a Java implementation to claim conformance with a Java Specification Request. The Java Modeling Language is used to model conformance constraints for the profile. Java Modeling Language annotations define contracts for classes and interfaces. The annotations are translated by a tool into runtime assertion checks. Hereby, the design and elaboration of the concrete test cases are simplified, because the expected results are derived from contracts and thus do not need to be provided explicitly. Bottom-up testing is applied for testing methods of the safety-critical Java classes, whereas top-down testing is applied for testing global properties, such as protocols, memory management, and real-time properties, including scheduling. The tests are executed using a simplified version of JUnit, which makes the test suite executable on resource-constrained platforms. The last paper 5 shows the weak predictability of Android's internal intra-process and inter-process communication based on Intent messaging and presents a concept to improve its soft real-time capability. The proposed approach introduces a priority-based broadcast handling using explicit priority values, instead of the original first in – first out processing. Furthermore, the size of responsible critical sections is reduced in order to improve the preemptibility and to assure predictable processing times for applications with real-time requirements. Their evaluation highlights the improvements in comparison with the original Android implementation without any loss of the system performance. Additionally, the compatibility with already existing components and applications is preserved. We thank Wolfgang Puffitsch for his work on this special issue.

Conformance test development with the Java modeling language

SummaryIn order to claim conformance with a Java Specification Request, a Java implementation has to pass all tests in an associated Technology Compatibility Kit. This paper presents a model‐based development of a Technology Compatibility Kit test suite and a test execution tool for the draft safety‐critical Java profile specification. The Java Modeling Language is used to model conformance constraints for the profile. Java Modeling Language annotations define contracts for classes and interfaces. The annotations are translated by a tool into runtime assertion checks. Hereby, the design and elaboration of the concrete test cases are simplified, because the expected results are derived from contracts and thus do not need to be provided explicitly. Bottom‐up testing is applied for testing methods of the safety‐critical Java classes, whereas top‐down testing is applied for testing global properties, such as protocols, memory management, and real‐time properties, including scheduling. The tests are executed using a simplified version of JUnit, which makes the test suite executable on resource‐constrained platforms. Copyright © 2017 John Wiley & Sons, Ltd.

Safety‐Critical Java: level 2 in practice

SummarySafety‐Critical Java (SCJ) is a profile of the Real‐Time Specification for Java that brings to the safety‐critical industry the possibility of using Java. SCJ defines three compliance levels: Level 0, Level 1 and Level 2. The SCJ specification is clear on what constitutes a Level 2 application in terms of its use of the defined API but not the occasions on which it should be used. This paper broadly classifies the features that are only available at Level 2 into three groups: nested mission sequencers, managed threads and global scheduling across multiple processors. We explore the first two groups to elicit programming requirements that they support. We identify several areas where the SCJ specification needs modifications to support these requirements fully; these include the following: support for terminating managed threads, the ability to set a deadline on the transition between missions and augmentation of the mission sequencer concept to support composibility of timing constraints. We also propose simplifications to the termination protocol of missions and their mission sequencers. To illustrate the benefit of our changes, we present excerpts from a formal model of SCJ Level 2 written in Circus, a state‐rich process algebra for refinement. Copyright © 2016 John Wiley & Sons, Ltd.

HVMTP: A time predictable and portable java virtual machine for hard real‐time embedded systems

SummaryWe present HVMTP, a time predictable and portable Java virtual machine (JVM) implementation with applications in resource‐constrained, hard real‐time embedded systems, which implements all levels of the safety critical Java (SCJ) specification. Time predictability is achieved by a combination of time‐predictable algorithms, exploiting the programming model of the SCJ profile and harnessing static knowledge of the hosted SCJ system. This paper presents HVMTP in terms of its design and capabilities and demonstrates how a complete timing model of the JVM represented as a network of timed automata can be obtained using the tool TETASARTSJVM. The timing model readily integrates with the rest of the TETASARTS tool set for temporal verification of SCJ systems. We will also show how a complete timing scheme in terms of safe worst‐case execution times and best‐case execution times of the Java bytecodes can be derived from the model. Furthermore, we take a first look at how to support the new Java 8 language feature of Lambda expressions in a SCJ context – we look in particular at how the invokedynamic bytecode can be implemented in a time‐predictable way and integrated in HVMTP. Copyright © 2016 John Wiley & Sons, Ltd.

Monolithic and modular termination analyses for higher-order attribute grammars

In this paper we describe a sound, but not complete, analysis to prove the termination of higher-order attribute grammar evaluation caused by the creation of an unbounded number of (finite) trees as local tree-valued attributes, which are then themselves decorated with attributes. The analysis extracts a set of term-rewriting rules from the grammar that model creation of new syntax trees during the evaluation of higher-order attributes. If this term rewriting system terminates, then only a finite number of trees will be created during attribute grammar evaluation. The analysis places an ordering on nonterminals to handle the cases in which higher-order inherited attributes are used to ensure that a finite number of trees are created using such attributes. When paired with the traditional completeness and circularity analyses for attribute grammars and the assumption that each attribute equation defines a terminating computation, this analysis can be used to show that attribute grammar evaluation will terminate normally. This analysis can be applied to a wide range of common attribute grammar idioms and has been used to show that evaluation of our specification of Java 1.4 terminates. We also describe a modular version of the analysis that is performed on independently developed language extension grammars and the host language being extended. If the extensions individually pass the modular analysis then their composition is also guaranteed to terminate.

Resource management policies for real-time Java remote invocations

A way to deal with the increasing cost of next generation real-time applications is to extend middleware and high-level general-purpose programming languages, e.g. Java, with real-time support that reduces development, deployment, and maintenance costs. In the particular path towards a distributed real-time Java technology, some important steps have been given into centralized systems to produce real-time Java virtual machines. However, the integration with traditional remote invocation communication paradigms is far from producing an operative solution that may be used to develop final products. In this context, the paper studies how The Real-Time Specification for Java (RTSJ), the leading effort in real-time Java, may be integrated with Java’s Remote Method Invocation (RMI) in order to support real-time remote invocations. The article details a specific approach towards the problem of producing a predictable mechanism for the remote invocation–the core communication mechanism of RMI–via having control on the policies used in the remote invocation. Results obtained in a software prototype help understand how the key entities defined to control the performance of the remote invocation influence in the end-to-end response time of a distributed real-time Java application.

Circus Models for Safety-Critical Java Programs

Safety-Critical Java (SCJ) is a restriction of the Real-Time Specification for Java to support the development and certification of safety-critical applications. The SCJ technology specification is the result of an international effort from industry and academia. In this paper, we present a formalisation of the SCJ Level 1 execution model, formalise a translation strategy from SCJ into a refinement notation, and describe a tool that largely automates the generation of the formal models. Our modelling language is part of the Circus family; at the core, we have Z, CSP, and Morgan’s calculus, but we also use object-oriented and timed constructs from the OhCircus and Circus Time variants. Our work is an essential ingredient for the development of refinement-based reasoning techniques for SCJ.

Diseño de un Software de Intermediación de Comunicación para Sistemas Distribuidos de Tiempo Real Críticos en Java

Distributed real-time embedded systems are becoming increasingly important to society. More demands will be made on them and greater reliance will be placed on the delivery of their services. A relevant subset of them is high-integrity or hard real-time systems, where failure can cause loss of life, environmental harm, or significant financial loss.Additionally, the evolution of communication networks and paradigms as well as the necessity of demanding processing power and fault tolerance, motivated the interconnection between electronic devices; many of the communications have the possibility of transferring data at a high speed. The concept of distributed systems emerged as systems where different parts are executed on several nodes that interact with each other via a communication network.Java's popularity, facilities and platform independence have made it an interesting language for the real-time and embedded community. This was the motivation for the development of RTSJ (Real-Time Specification for Java), which is a language extension intended to allow the development of real-time systems. The use of Java in the development of high-integrity systems requires strict development and testing techniques.However, neither RTSJ nor its profiles provide facilities to develop distributed real-time applications. This is an important issue, as most of the current and future systems will be distributed. The Distributed RTSJ (DRTSJ) Expert Group was created under the Java community process (JSR-50) in order to define appropriate abstractions to overcome this problem. Currently there is no formal specification.The aim of this work is to describe the design and develop a communication middleware that is suitable for the development of distributed hard real-time systems in Java, based on the integration between the RMI (Remote Method Invocation) model and the HRTJ profile. It has been designed and implemented keeping in mind the main requirements such as the predictability and reliability in the timing behavior and the resource usage.The design starts with the definition of a computational model which identifies among other things: the communication model, most appropriate underlying network protocols, the analysis model, and a subset of Java for hard real-time systems. In the design, the remote references are the basic means for building distributed applications which are associated with all nonfunctional parameters and resources needed to implement synchronous or asynchronous remote invocations with real-time attributes.The proposed middleware separates the resource allocation from the execution itself by defining two phases and a specific threading mechanism that guarantees a suitable timing behavior. It also includes mechanisms to monitor the functional and the timing behavior. It provides independence from network protocol defining a network interface and modules. The JRMP protocol was modified to include two phases, non-functional parameters, and message size optimizations. Although serialization is one of the fundamental operations to ensure proper data transmission, current implementations are not suitable for hard real-time systems and there are no alternatives. This work proposes a predictable serialization that introduces a new compiler to generate optimized code according to the computational model. The proposed solution has the advantage of allowing us to schedule the communications and to adjust the memory usage at compilation time.In order to validate the design and the implementation a demanding validation process was carried out with emphasis in the functional behavior, the memory usage, the processor usage (the end-to-end response time and the response time in each functional block) and the network usage (real consumption according to the calculated consumption).

Tutorial overview

In spite of the high-level abstraction benefits of automatic tracing garbage collection, current prevailing sentiment within the safety certification community is that a simpler memory model is required for the most rigorous levels of software safety certification. Thus, the draft JSR-302 specification for safety critical Java relies on scope-based memory allocation rather than tracing garbage collection. The scoped memory model for JSR-302 is a simplification of the RTSJ model. JSR-302 enforces a strict hierarchy of scopes and distinguishes private scopes, which can be seen only by one thread, from mission scopes, which can be accessed by all the threads that comprise a mission, including threads running within inner-nested sub-missions. The hierarchical memory structure allows implementations to guarantee the absence of memory fragmentation for scope management, unlike the Real-Time Specification for Java from which the JSR-302 specification was derived. In the absence of block structure, it is more difficult in Java to safely manage references to stack-allocated objects than in Ada. While the simplified hierarchical management of scoped memory that is part of JSR-302 addresses memory fragmentation concerns, it does not guarantee the absence of dangling pointers. As with the Real-Time Specification for Java, JSR-302 requires a run-time check to enforce that no reference assignment creates a relationship whereby an outer-nested object is allowed to point to an inner-nested object. This rule assures the absence of dangling pointers, but it introduces a different problem: every assignment to a reference field must be accompanied by a run-time check to validate the appropriate scope nesting relationship. This run-time check will throw a run-time exception if the assignment is deemed inappropriate. The safety certification evidence for a given safety-critical Java program must therefore include an argument for every reference assignment that it will not cause the program to abort with a run-time exception. Furthermore, the certification evidence must prove that sufficient memory is available to reliably execute each safety-critical task in the system. This tutorial provides an overview of dynamic memory management in Safety Critical Java and describes two annotation systems that have been designed to support static (compile-time) enforcement of memory safety properties. The first annotation system is described in an appendix to the draft JSR-302 standard. This relatively simple annotation system, which is not considered normative, serves to demonstrate that memory safety can be statically proven without requiring extensive annotations throughout existing library code. The second annotation system is the system implemented in Perc Pico. This annotation system, which is much richer than the draft JSR-302 annotation, has been in experimental use for over five years. During that time, tens of thousands of lines of experimental application code have been developed, with the experience motivating a variety of refinements to the original design.

Supporting lock‐based multiprocessor resource sharing protocols in real‐time programming languages

SUMMARYLock‐based resource sharing protocols for single processor systems are well understood and supported in programming languages such as Ada and the Real‐Time Specification for Java, and in Real‐Time Operating Systems, such as those that conform to the Real‐Time POSIX standard. In contrast, multiprocessor resource sharing protocols are still in their infancy with no agreed best practices, and yet current real‐time programming languages and operating systems claim to be suitable for multiprocessor applications. This paper reviews the currently available multiprocessor resource allocation policies and analyzes their applicability to the main industry standard real‐time programming languages. It then proposes a framework that allows programmers to define and implement their own locking policy. A prototype implementation of the framework for Ada is presented and evaluated. Copyright © 2012 John Wiley & Sons, Ltd.

Simulation of safety-critical, real-time Java: A case study of dynamic analysis of scoped memory consumption

For critical, real-time applications, scoped memory management in Real-Time Specification for Java (RTSJ) achieves a level of predictability not found in applications that use garbage collection techniques. However, a scoped memory model creates new challenges for developers. First, the reference rules between scopes constrain the design of the application’s memory model. Second, there is no abstract model for scoped memory that can be applied to different applications. Third, deciding on the appropriate number of scopes and which objects or threads should be allocated into those scopes are not straightforward tasks and require tools to assist. This paper presents a simulation of a railway control system executed on the Sun RTS2.2 virtual machine; it illustrates how simulation of critical safety real-time applications in Java can be used to investigate the implementation of possible scoped memory design models and their memory consumption in multi-threaded environments. The simulation demonstrates that a developer is able to compare and choose the most appropriate scoped memory design model that achieves the least memory footprint. Results showed that the memory design model with a higher number of scopes achieved the least memory footprint. However, the number of scopes per se does not always indicate a satisfactory memory footprint; choosing the right objects/threads to be allocated into scopes is an important factor to be considered.

Enhancing OSGi with real‐time Java support

SUMMARYOSGi was designed with embedded systems in mind, its current support is insufficient for coping with one main characteristic of many embedded systems: real‐time performance. This article analyzes different key issues in providing OSGi with real‐time Java performance covering motivational issues, and different integration ways and challenges stemming from the integration. It also contributes a general framework for introducing real‐time performance in OSGi, which is called the real‐time for OSGi framework. The framework uses real‐time Java virtual machines and the real‐time specification for Java. The adoption of this framework allows cyber‐physical systems to experience real‐time Java performance in their applications. The framework introduces several integration levels for OSGi and real‐time specification for Java, and specific real‐time OSGi services. An empirical implementation was carried out using standard software, which was extended with the new defined services. Copyright © 2012 John Wiley & Sons, Ltd.

Region-Based RTSJ Memory Management: State of the art

Developing a real-time system in Java requires awareness of memory behaviour in addition to software functional requirements. The Real-Time Specification for Java (RTSJ) introduces a scoped memory model to avoid garbage collection delays in critical real-time applications which need to meet hard real-time constraints. Scoped memory management has certain advantages over garbage collection in terms of predictability. However, developing a real-time application using scoped memory areas (regions) may suffer from both design and runtime errors. Moreover, from a memory footprint perspective, the inability to determine precisely how many scoped memory areas should be used and which objects or threads should be allocated into these scoped memory areas makes using RTSJ problematic for developing real-time systems. In this paper, a survey of the current approaches to improve scoped memory management and new emerging challenges in RTSJ scoped memory management model are presented. Categorizing those problems and challenges provides a picture of the issues researchers have yet to investigate and to support solutions for an optimal scoped memory model. Current approaches and a set of benchmarks used to evaluate current solutions are presented and new research questions in developing real-time Java systems using a scoped memory model are proposed.

A Hardware Abstraction Layer in Java

Embedded systems use specialized hardware devices to interact with their environment, and since they have to be dependable, it is attractive to use a modern, type-safe programming language like Java to develop programs for them. Standard Java, as a platform-independent language, delegates access to devices, direct memory access, and interrupt handling to some underlying operating system or kernel, but in the embedded systems domain resources are scarce and a Java Virtual Machine (JVM) without an underlying middleware is an attractive architecture. The contribution of this article is a proposal for Java packages with hardware objects and interrupt handlers that interface to such a JVM. We provide implementations of the proposal directly in hardware, as extensions of standard interpreters, and finally with an operating system middleware. The latter solution is mainly seen as a migration path allowing Java programs to coexist with legacy system components. An important aspect of the proposal is that it is compatible with the Real-Time Specification for Java (RTSJ).