Real-time Programming Language Research Articles

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.

C++ hard-real-time active library

General-purpose programming languages C and C++ address only the functional aspect of programs. In contrast, real-time programming languages address not only the functional aspect but also the nonfunctional real-time aspect to automatically ensure the consistency of both aspects in the resulting code. Despite many real-time programming languages proposed in the literature, embedded and real-time programs for economical reasons have continued to be written in C/C++ with their real-time aspect being dealt separately using modeling tools (e.g., MATLAB/Simulink) and the consistency of both aspects being checked manually. As embedded and real-time systems permeate through people's lives, it becomes increasingly imperative that both aspects be kept consistent automatically to improve the reliability of the systems. To that end, we propose a real-time programming language called Tice with three novel features: (1) Tice programs are written as modern standard C++ programs. (2) Tice programs can be compiled using any modern off-the-shelf standard C++ compiler. (3) Tice programs compose with other C/C++ programs as C++ libraries. These novel features make Tice significantly more economical than other real-time programming languages proposed in the literature.

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

Static stages for heterogeneous programming

Heterogeneous hardware is central to modern advances in performance and efficiency. Mainstream programming models for heterogeneous architectures, however, sacrifice safety and expressiveness in favor of low-level control over performance details. The interfaces between hardware units consist of verbose, unsafe APIs; hardware-specific languages make it difficult to move code between units; and brittle preprocessor macros complicate the task of specializing general code for efficient accelerated execution. We propose a unified low-level programming model for heterogeneous systems that offers control over performance, safe communication constructs, cross-device code portability, and hygienic metaprogramming for specialization. The language extends constructs from multi-stage programming to separate code for different hardware units, to communicate between them, and to express compile-time code optimization. We introduce static staging, a different take on multi-stage programming that lets the compiler generate all code and communication constructs ahead of time. To demonstrate our approach, we use static staging to implement BraidGL, a real-time graphics programming language for CPU-GPU systems. Current real-time graphics software in OpenGL uses stringly-typed APIs for communication and unsafe preprocessing to generate specialized GPU code variants. In BraidGL, programmers instead write hybrid CPU-GPU software in a unified language. The compiler statically generates target-specific code and guarantees safe communication between the CPU and the graphics pipeline stages. Example scenes demonstrate the language's productivity advantages: BraidGL eliminates the safety and expressiveness pitfalls of OpenGL and makes common specialization techniques easy to apply. The case study demonstrates how static staging can express core placement and specialization in general heterogeneous programming.

Distributed Intelligent MEMS

In recent years, distributed intelligent microelectromechanical systems (DiMEMSs) have appeared as a new form of distributed embedded systems. DiMEMSs contain thousands or millions of removable autonomous devices, which will collaborate with each other to achieve the final target of the whole system. Programming such systems is becoming an extremely difficult problem. The difficulty is due not only to their inherent nature of distributed collaboration, mobility, large scale, and limited resources of their devices (e.g., in terms of energy, memory, communication, and computation) but also to the requirements of real-time control and tolerance for uncertainties such as inaccurate actuation and unreliable communications. As a result, existing programming languages for traditional distributed and embedded systems are not suitable for DiMEMSs. In this article, we first introduce the origin and characteristics of DiMEMSs and then survey typical implementations of DiMEMSs and related research hotspots. Finally, we propose a real-time programming framework that can be used to design new real-time programming languages for DiMEMSs. The framework is composed of three layers: a real-time programming model layer, a compilation layer, and a runtime system layer. The design challenges and requirements of these layers are investigated. The framework is then discussed in further detail and suggestions for future research are given.

Programming Language Constructs Supporting Fault Tolerance

In order to render software viable for highly safety-critical applications, we describe how to incorporate fault tolerance mechanisms into the real-time programming language PEARL. Therefore, we present, classify, evaluate and illustrate known fault tolerance methods for software. We link them together with the requirements of the international standard IEC 61508-3 for functional safety. We contribute PEARL-2020 programming language constructs for fault tolerance methods that need to be implemented by operating systems, and code-snippets as well as libraries for those independent from runtime systems.

Teaching real-time programming using mobile robots

Teaching theoretical concepts of real-time systems may be a challenging task without real hardware support. This paper discusses the use of the LEGO MINDSTORMS NXT mobile robots for teaching real-time programming to bachelor’s students. The stable real-time control of a segway-like robot with a PID controller is used as case study to demonstrate the teaching methodology. Ada was used as real-time programming language. In general, very positive reviews were collected from the students after the course.

PEARL-Coded Function Block Diagrams — From Language Design to Verification

Highly safety-critical applications require designated development processes that foster verifiability by design. A constructive method to prevent introducing systematic errors into software is to use simple but expressive language elements. Therefore, this paper defines a fusion of function block diagrams and the real-time programming language PEARL in order to support the development and verification process of highly safety-critical programs.

Integration of Physical Units into the Real-time Programming Language PEARL

Physical quantities are only insufficiently mapped into software. Software components, that interpret the same variable with different physical units, bear a risk for human beings, the environment and assets, that depend on the correct functioning of safety-related devices in embedded systems. Programmers can only define atomic types and restrict their range, but physical units like metres or seconds are not attached. This prevents more profound static analyses by compilers, which could detect software errors like physical formulae with false operands or procedure invocations with different units in callers and callees. This paper addresses physical unit checking within the real-time programming language PEARL. Therefore, our contribution is two-fold: On one hand, we define additional PEARL syntax for physical units and implement a static analyser for the procedural variant of PEARL. On the other hand, we define classes for the object-oriented variant of PEARL in order to check the units statically without the need for adapting compilers.

Ada in Real-time Embedded System

Ada has an important role in the real-time/embedded/safety-critical areas. It is the only ISO-standard, object-oriented, concurrent, real-time programming language. Ada is used as a usual language for application areas such as defense embedded systems that reliability and efficiency are very essential. One of the main Ada's characteristics in compare with other programming languages is that, Ada was developed from the ground up with capabilities that provide real-time requirements. In this study it will be shown why Ada is used as the new standard for real-time programming languages and basic characteristics of real-time programming system in general and how they are addressed in Ada will be explained.

Embedded, hard, real-time systems with Ada

Development of real-time systems is expensive and difficult, in part because of low-level languages that force developers to use facilities that are ad hoc, incomplete, and not portable. The Real-Time Systems Annex of Ada 2005 (along with the language core) represents the state-of-the-art in realtime programming languages and offers an extensive set of standardized packages and facilities for this domain. In addition, the language-defined Ravenscar profile describes a tasking subset that is analyzable for both high-integrity and hard real-time applications, and is small enough for very tightly resource-constrained applications as well. This tutorial examines the packages and pragmas defined by the annex for direct application use, examines the Ravenscar profile, and provides detailed examples of how they both are meant to be applied.

Certification of software for real-time safety-critical systems: state of the art

This paper presents an overview and discusses the role of certification in safety-critical computer systems focusing on software, and partially hardware, used in the civil aviation domain. It discusses certification activities according to RTCA DO-178B “Software Considerations in Airborne Systems and Equipment Certification” and touches on tool qualification according to RTCA DO-254 “Design Assurance Guidance for Airborne Electronic Hardware.” Specifically, certification issues as related to real-time operating systems and programming languages are reviewed, as well as software development tools and complex electronic hardware tool qualification processes are discussed. Results of an independent industry survey done by the authors are also presented.

Completeness of a combination of neighbourhood logic and temporal logic

Abstract. This paper presents a completeness result, with respect to a possible world semantics, for a combination of a first-order temporal logic and neighbourhood logic. This logic was considered by Qiu and Zhou (1998, Proceedings of the PROCOMET ‘98 , pp 444–461) to define semantics of a real-time OCCAM-like programming language.

Advanced Features of Duration Calculus and Their Applications in Sequential Hybrid Programs

Duration Calculus was introduced as a logic to specify real-time requirements of computing systems. It has been used successfully in a number of case studies. Moreover, many variants were proposed to deal with various features of real time systems, including sequential communicating processes, sequential hybrid systems and imperative programming languages. This paper aims to integrate several variants of Duration Calculus, and to provide a semantic framework for real-time programming languages and sequential hybrid programs.

Design of a Mobile Robot Controller using Esterel Tools

Robot controllers are often programmed using either standard sequential programming languages or a robot-specific language, which are then compiled to assembly language specific to the robot. Modern real-time programming languages, on the other hand, are more appropriate to program robots, as they better fit the real-time reactive model of robots. This paper reports on a project to program a non-trivial robot, the Rug Warrior, in the Artificial Intelligence Laboratory of UNSW, using Esterel, which is a real-time programming language. The approach is illustrated by simulation of a colony of Siberian ants using a group of Rug Warriors.

A sequential real-time refinement calculus

We present a comprehensive refinement calculus for the development of sequential, real-time programs from real-time specifications. A specification may include not only execution time limits, but also requirements on the behaviour of outputs over the duration of the execution of the program. The approach allows refinement steps that separate timing constraints and functional requirements. New rules are provided for handling timing constraints, but the refinement of components implementing functional requirements is essentially the same as in the standard refinement calculus. The product of the refinement process is a program in the target programming language extended with timing deadline directives. The extended language is a machine-independent, real-time programming language. To provide valid machine code for a particular model of machine, the machine code produced by a compiler must be analysed to guarantee that it meets the specified timing deadlines.

Achieving Hard Real-Time Java

Real-time systems engineers have, for some time, identified Java as an attractive programming language, but have been unable to exploit its benefits as it cannot provide the fundamental temporal predictability required. However, this is all changing, as academic and industrial experts propose extensions to the Java environment. On the basis of this study, significant agreement has been found in how some of the critical areas of Java may be addressed for real-time, such as memory management and portability. However, areas such as scheduling and interprocess communication, have been contentious, even among expert opinion. This paper considers the current status of this exciting and emerging, soon to become, real-time programming language, with a focus on process control application. In addition, it will overview a preliminary performance assessment of the alleged real-time java virtual machine (JVM) from NewMonics Inc and compared upfront with the Sun JVM.

State of the Art and Open Research Topics in Embedded Hard Real-Time Systems Design

The most important and necessary properties of embedded real-time systems, and the ways to achieve them, are explored. The basic and most prominent domains of real-time systems design are discussed, starting with processor and system hardware architectures, ranging over operating systems, tasking and scheduling, high level real-time programming languages, worst case execution time and schedulability analysis, to application design engineering and safety related applications. Common misconceptions, which are still strongly present in control systems design, are identified. Guidelines for consistent implementation are proposed, and sample solutions in certain areas presented. Finally, directions for future research are indicated.

Real-time programming: extending PEARL with interfaces and active objects

An object-oriented extension to the real-time programming language PEARL is presented in this paper. The new language preserves PEARL’s expressiveness for timeliness and industrial processes and, at the same time, improves the language’s readability and manageability through the adoption of a better encapsulation paradigm, derived from the object concept. Some extensions are also proposed, to enhance the language’s testability and safety. The proposed language is fully backward compatible with PEARL, while allowing powerful abstraction concepts.

Real-Time Programming: Extending PEARL with Interfaces and Active Objects

Abstract An object-oriented extension to the real-time programming language PEARL is presented in this paper. The new language preserves PEARL’s expressiveness for timeliness and industrial processes and, at the same time, improves the language’s readability and manageability through the adoption of a better encapsulation paradigm, derived from the object concept. Some extensions are also proposed, to enhance the language’s testability and safety. The proposed language is fully backward compatible with PEARL, while allowing powerful abstraction concepts.