Real-time Java Research Articles

Compiler-assisted energy reduction of java real-time programs

Optimizations in energy consumption are critical for battery-powered hard real-time embedded systems. Energy management is often accomplished by dynamic frequency scaling which requires compilers to insert special instructions in the code at appropriate places, which are then used by the operating system and the processor to calculate and change the frequency at these places in the code. The addition of code snippets for frequency change may affect the worst-case execution time of the program, which is a major concern for hard real-time systems. In addition to the above problem, run time calculation of the optimal frequency prohibits a compile-time estimate of the battery life by the system designers. In this paper, we present compiler optimizations for hard real-time Java applications executing on a time predictable Java processor, which reduces the energy consumption of the program while retaining the original worst-case execution time for the program intact. We also generate a compile-time frequency change schedule for the program resulting in compile-time estimates for worst-case energy consumption. We found that on average, reduction in energy consumption is better in run-time frequency schedule based mechanism but the compile-time frequency schedule allows us to get bounds on energy consumption at the compile-time.

Development Automation of Real-Time Java

Many applications in emerging scenarios, such as autonomous vehicles, intelligent robots, and industrial automation, are safety-critical with strict timing requirements. However, the development of real-time systems is error prone and highly dependent on sophisticated domain expertise, making it a costly process. This article utilises the principles of model-driven engineering (MDE) and proposes two methodologies to automate the development of real-time Java applications. The first one automatically converts standard time-sharing Java applications to real-time Java applications, using a series of transformations. It is in line with the observed industrial trend, such as for the big data technology, of redeveloping existing software without the real-time notion to realise the real-time features. The second one allows users to automatically generate real-time Java application templates with a lightweight modelling language, which can be used to define the real-time properties—essentially a synthesis process. This article opens up a new research direction on development automation of real-time programming languages and inspires many research questions that can be jointly investigated by the embedded systems, programming languages as well as MDE communities.

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

High-performance software control platform designed for the autonomous navigation of quad-rotor helicopter

In recent years, unmanned aerial vehicles have gained increasing popularity. They are employed in many applications due to its features in terms of flexibility, low cost, and small size. Due to special structure of mechanical system for the quad-rotor helicopter (typical small-sized unmanned aerial vehicle), one of the main research fields for quad-rotor helicopter is to improve its stability flight control so as to well implement its autonomous navigation. However, for the quad-rotor helicopter whose power is supplied by battery, the embedded operating system directly affects its flight performance; thus, it is of very importance to implement this goal. This article aims to put forward a high-performance software platform consisted of embedded operating system and JAVA virtual machine in the quad-rotor helicopter. Then, this article also proposes an autonomous control algorithm written by real-time JAVA application, which uses image entropy to avoid obstacles and optical flow to discover the most appropriate area to fly in while avoiding obstacles; besides, image identification with image contour detection is used for the cases of junction turn and landing. The practical experimental results show that the implemented software control platform and proposed autonomous flight application are component for indoor autonomous flight of quad-rotor helicopter.

A switchable approach to large object allocation in real-time Java

Over the last 20 years object-oriented programming languages and managed run-times like Java have been very popular because of their software engineering benets. Despite their popularity in many application areas, they have not been considered suitable for real-time programming. Besides many other factors, one of the barriers that prevent their acceptance in the development of real-time systems is the long pause times that may arise during large object allocation. This paper examines different kinds of solutions that have been developed so far and introduces a switchable approach to large object allocation in real-time Java. A synthetic benchmark application that is developed to evaluate the effectiveness of the presented technique against other currently implemented techniques is also described.

A library for developing real-time and embedded applications in C

Next generation applications will demand more cost-effective programming abstractions to reduce increasing maintenance and development costs. In this context, the article explores the integration of an efficient programming language and high-level real-time programming abstractions. The resulting abstraction is called Embedded Cyber Physical C (ECP-C) and it is useful for designing real-time applications directly on C. The abstraction has its roots on the real-time Java: one of the most modern programming languages, which benefited from mature programming patterns previously developed for other languages. It also targets embedded processors running on limited hardware. ECP-C takes the programming abstractions described in real-time Java and reflects them into a C application system, providing extensions for multi-threading, resource sharing, memory management, external event, signaling, and memory access. It also reports on the performance results obtained in a set of infrastructures used to check ECP-C, providing clues on the overhead introduced by these mechanisms on limited infrastructures.

A simple distributed garbage collector for distributed real-time Java

The use of real-time distribution middleware programmed with high-level languages like Java is becoming of increasing interest in next generation applications. Technology like Java's Remote Method Invocation (RMI) paves the way towards these new distributed horizons. RMI offers many high-level abstractions useful for distributed application programmers to reduce their development times. One of these abstractions is a distributed garbage collector (DGC) that removes unreachable remote objects from the distributed ecosystem. However, in real-time Java, distributed garbage collection is underspecified and it introduces unbounded indeterminism on end-to-end real-time Java communications. This article analyzes this problem proposing a simple characterization for a predictable real-time distributed garbage collector (RT-DGC). The approach requires support from the middleware infrastructure that implements the abstraction but it also introduces bounded overhead. The article provides insight on the performance that RT-DGC offers to a distributed real-time Java application and the extra overheads due to the intrinsic cost of this abstraction.

Real-time Embedded Java Virtual Machine for Application Development in Wireless Sensor Network

The application development in wireless sensor network (WSN) is complicated due to the diverse software and hardware platforms. One way to solve this problem is to apply the embedded Java virtual machine (EJVM) on the WSN nodes. With the EJVM, the users can program the applications by the popular and high-level abstract Java language. However, several challenges exist for applying the EJVM on the WSN nodes, such as the memory resources on the WSN nodes are constrained, the multitasking programming and real-time response are required by many WSN applications. Currently, these challenges cannot be addressed well by most EJVMs. And in order to address these challenges, a real-time memory-efficient Java operating system HEROS is developed. By means of HEROS, the multitasking real-time Java applications can be developed even on the memory-constrained WSN nodes. Nevertheless, the execution efficiency of the Java bytecode is not high, making the EJVM not suitable to be used on the tight energy-constrained WSN nodes. To solve this problem, a new mid-layer software REMID, which is designed to have some similar functionalities as the EJVM, is also developed. Different from the EJVM, REMID is designed to be both memory efficient and energy efficient, thus it can substitute the EJVM to be used even on the severe energy-constrained WSN nodes. The final evaluation works prove that a user-friendly WSN application development environment can be provided to the users by means of the EJVM, HEROS and REMID.

Kipu: hilos ligeros para Java

This paper describes a cooperative thread scheduling mechanism, which can be used effectively on real-time java virtual machines. This scheduler is implemented using a heap-based priority queue which allows for O(log N) processing time. Since this scheduler is strictly cooperative, thread coordination is performed without the requirement of formal java thread synchronization. Though similar outcomes can be achieved through program design, this abstraction allows developers to focus on their application.

Comparative analysis of two different middleware approaches for reconfiguration of distributed real-time systems

Software-based reconfiguration of distributed real-time systems is a complex problem with many sides to it ranging from system-wide concerns down to the intrinsic non-robust nature of the specific middleware layer and the used programming techniques. In a completely open distributed system, mixing reconfiguration and real-time is not possible; the set of possible target states can be very large threatening the temporal predictability of the reconfiguration process. Over the last years, middle ware solutions have appeared mainly for general purpose systems where efficient state transitions are sought for, but real-time properties are not considered. One of the few contributions to run-time software reconfiguration in distributed real-time environments has been the iLAND middleware, where the germ of a solution with high potential has been conceived and delivered in practice. The key idea has been the fact that a set of bounds and limitations to the structure of systems and to their open nature needs to be imposed in order to come up with practical solutions. In this paper, the authors present the different sides of the problem of software reconfiguration from two complementary middleware perspectives comparing two strategies built inside distribution middleware. We highlight the lessons learned in the iLAND project aimed at service-based reconfiguration and compare it to our experience in the development of distributed real-time Java reconfiguration based on distributed tasks rescheduling. Authors also provide a language view of both solutions. Lastly, empirical results are shown that validate these solutions and compare them on the basis of different programming language realizations.

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.

Towards an Agent Computing Platform for Distributed Computing on Satellites

Today's mobile devices and countless other embedded devices now aim to use networking technologies utilizing the latest electronics and software to provide new functions. Distributed satellite systems, seen to be analogous to mobile ad hoc networks (MANET), perform new mission functions with high mobility and intermittent connectivity that make satellite network management and operations difficult. New drivers and requirements are outlined for node and network levels in any given topology requiring real-time client-server or peer-to-peer (P2P) networking applications. To meet these requirements a novel agent computing platform (ACP) is proposed utilizing technologies from the multi-processor and agent middleware fields for real-time Java networking and mobile ad hoc network-based distributed computing applications at a minimal overhead to existing systems. The Java optimised processor (JOP) is investigated and embedded into an existing LEON3-based system-on-a-chip (SoC) design to provide a new fault-tolerant, parallel processing, and network functionalities. Agent middleware is discussed and compared for porting to the new dual processor design with a new middleware instance manager thread to enable software resets at runtime on the Java processor without halting the processor. After verification these two technologies are combined and discussed in depth to highlight key technological problems of this real-time ACP implementation.

Overview of Real-Time Java Computing

This paper presents a complete survey of recent techniques that are applied in the field of real-time Java computing. It focuses on the issues that are especially important for hard real-time applications, which include time predictable garbage collection, worst-case execution time analysis of Java programs, real-time Java threads scheduling and compiler techniques designed for real-time purpose. It also evaluates experimental frameworks that can be used for researching real-time Java. This overview is expected to help researchers understand the state-of-the-art and advance the research in real-time Java computing.

Real-time Java in modernization of the aegis weapon system

The U.S. Navy's Aegis system, considered to be the "shield of the fleet", provides area air defense for a carrier battle group in addition to providing long-range ballistic missile defense. A typical Aegis deployment consists of about 100 computers, many of which have multiple cores. The application is distributed, with typical real-time threads spanning 4 or 5 different computers. End-to-end distributed thread timing constraints measured from stimulus to response are typically under 100 ms. The target jitter constraints on the individual contributions of processors to the end-to-end deadline constraint are well below 1 ms. The system is fully redundant to support fault tolerance. The software is considered to be safety critical because it aims and fires weapons. The Aegis Weapons System software was recently rewritten into real-time Java as part of the Aegis Modernization activity. This project involved replacement of about 200,000 lines of CMS-2 and Ada code with roughly 500,000 lines of Java. The effort began in 2003 and the new Java implementation of Aegis Weapons System is now being deployed on warships. This paper describes the motivation for the modernization effort and provides a summary of Lockheed Martin's experiences with this project.

Towards harnessing theories through tool support for hard real-time Java programming

We present a rationale for a selection of tools that assist developers of hard real-time applications to verify that programs conform to a Java real-time profile and that platform-specific resource constraints are satisfied. These tools are specialised instances of more generic static analysis and model checking frameworks. The concepts are illustrated by two case studies, and the strengths and the limitations of the tools are discussed.

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.

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 Dual Programming Model for Distributed Real-Time Java

More-and-more, the use of Java as a programming language for real-time applications is becoming of interest in industrial middleware. This is mainly because it offers advantages for the programmer as reduced deployment times, increased portability, and a number of APIs that may be integrated in large distributed applications. This paper contributes a dual communication model for distributed real-time Java applications. Current efforts in distributed real-time Java [e.g., The Distributed Real Time Specification for Java (DRTSJ)] are mainly focused on remote invocations (R.I.) and set aside other valuable approaches such as distributed events. The proposed model offers two choices for developing distributed real-time Java applications (one based on R.I., and another on distributed events), which may be used to develop applications. Both models include an additional support for asynchronism in communications, a feature that may speed up their communication performance. This paper includes a description for the two models, the changes that are required in the current API to accommodate them, and an empirical evaluation of their performance on a reference implementation.

Scheduling real-time garbage collection on uniprocessors

Managed languages such as Java and C# are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for analysis and implementation of real-time execution environments. This article comprehensively compares leading approaches to hard real-time garbage collection. There are many design decisions involved in selecting a real-time garbage collection algorithm. For time-based garbage collectors on uniprocessors one must choose whether to use periodic , slack-based or hybrid scheduling. A significant impediment to valid experimental comparison of such choices is that commercial implementations use completely different proprietary infrastructures. We present Minuteman, a framework for experimenting with real-time collection algorithms in the context of a high-performance execution environment for real-time Java. We provide the first comparison of the approaches, both experimentally using realistic workloads, and analytically in terms of schedulability.