High-level real-time programming in Java

Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming. While Metronome garbage collection has made it practical to use Java to implement real-time systems, many challenges remain for the construction of complex real-time systems, some specic to the use of Java and others simply due to the change in scale of such systems. The goal of our research is the creation of a comprehensive Java-based programming environment and methodology for the creation of complex real-time systems. Our goals include construction of a provably correct real-time garbage collec-tor capable of providing worst case latencies of 100 s, capa-ble of scaling from sensor nodes up to large multiprocessors; specialized programming constructs that retain the safety and simplicity of Java, and yet provide sub-microsecond la-tencies; the extension of Java's \write once, run anywhere" principle from functional correctness to timing behavior; on-line analysis and visualization that aids in the understanding of complex behaviors; and a principled probabilistic analy-sis methodology for bounding the behavior of the resulting systems. While much remains to be done, this paper describes the progress we have made towards these goals

Real-Time Video Processing Using Native Programming on Android Platform

As the smartphone industry grows rapidly, smartphone applications need to be faster and real-time. For this purpose, most of the smartphone platforms run the program on the native language or compiler that can produce native code for hardware. However for the Android platform that based on the JAVA language, most of the software algorithm is running on JAVA that consumes more time to be compiled. In this paper the performance of native programming and high level programming using JAVA are compared with respect to video processing speed. Eight image processing methods are applied to each frame of the video captured from a smartphone that is running on an Android platform. The efficiencies of the two applications with difference programming language are compared by observing their frame processing rate. The experimental results show that out of the eight images processing methods, six methods that are executed using the native programming are faster than that of the JAVA programming with a total average ratio of 0.41. An application of the native programming for real-time object detection is also presented in this paper. The result shows that with native programming on Android platform, even a complicated object detection algorithm can be done in real-time

Refining SCJ Mission Specifications into Parallel Handler Designs

Safety-Critical Java (SCJ) is a recent technology that restricts the execution and memory model of Java in such a way that applications can be statically analysed and certified for their real-time properties and safe use of memory. Our interest is in the development of comprehensive and sound techniques for the formal specification, refinement, design, and implementation of SCJ programs, using a correct-by-construction approach. As part of this work, we present here an account of laws and patterns that are of general use for the refinement of SCJ mission specifications into designs of parallel handlers used in the SCJ programming paradigm. Our notation is a combination of languages from the Circus family, supporting state-rich reactive models with the addition of class objects and real-time properties. Our work is a first step to elicit laws of programming for SCJ and fits into a refinement strategy that we have developed previously to derive SCJ programs.Comment: In Proceedings Refine 2013, arXiv:1305.563

Portable Robot Control

Abstract The topic of this master thesis is Portable Robot Control and it has been performed jointly with the thesis Portable Robot Programming. The robots mentioned in the title of the Master thesis are industrial robots. Industrial robots are embedded real-time systems. In the embedded real-time systems the computer is part of the system. As all other real-time systems they have to fulfill real-time requirements. Hence, they must be deterministic and predictable.Then, the control and programming tasks of these industrial robots must be performed with tools providing the mechanisms to fulfill the time requirements above-seen. The first task of the thesis is the communication of a robot system using a real-time network protocol. The real-time protocol chosen is ThrottleSim, the Java-based simulation of ThrottleNet. To perform this communications a real-time communications environment is designed. This environment is focused on the intermediate layer that is the link between the chosen network protocol and the application layer. Once the communications in robot systems are implemented, they must be integrated in that system. A robot system consists of many different elements. These parts are the mechanical manipulator (robot) and the robot control system which can consist of the robot server, the computers where the control parameters are generated, the simulator or the network which is used for the communication between all the different parts.The implementation of a Java-based infrastructure to integrate all the parts of the robot system in some experiments is the second main-task of the thesis. Finally, the tasks described above are implemented in the Java programming language, because of its wide range of advantages (platform independence, simplicity, security and robustness). Despite of the fact that Java has a lack of efficiency that makes it not suitable for real-time systems, it is possible to use it as a real-time language through the Java-to-C compilation. This solution provides the advantages of Java as a programming language and solves its main disadvantage

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. (C) 2015 Elsevier B.V. All rights reserved.This work has been partially funded by Distributed Java Infrastructure for Real-Time Big-Data (CAS14/00118) and by eMadrid: Investigación y Desarrollo de tecnologías educativas en la Comunidad de Madrid (S2013/ICE-2715). This research was supported by the national project REM4VSS (TIN-2011-28339) and by European Union’s 7th Framework Programme Under Grant Agreement FP7-IC6-318763

From Java to real-time Java : A model-driven methodology with automated toolchain

Real-time systems are receiving increasing attention with the emerging application scenarios that are safety-critical, complex in functionality, high on timing-related performance requirements, and cost-sensitive, such as autonomous vehicles. Development of real-time systems is error-prone and highly dependent on the sophisticated domain expertise, making it a costly process. There is a trend of the existing software without the real-time notion being re-developed to realise real-time features, e.g., in the big data technology. This paper utilises the principles of model-driven engineering (MDE) and proposes the first methodology that automatically converts standard time-sharing Java applications to real-time Java applications. It 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

Exploration of Dynamic Memory

Since the advent of the Java programming language and the development of real-time garbage collection, Java has become an option for implementing real-time applications. The memory management choices provided by real-time garbage collection allow for real-time eJava developers to spend more of their time implementing real-time solutions. Unfortunately, the real-time community is not convinced that real-time garbage collection works in managing memory for Java applications deployed in a real-time context. Consequently, the Real-Time for Java Expert Group formulated the Real-Time Specification for Java (RTSJ) standards to make Java a real-time programming language. In lieu of garbage collection, the RTSJ proposed a new memory model called scopes, and a new type of thread called NoHeapRealTimeThread (NHRT), which takes advantage of scopes. While scopes and NHRTs promise predictable allocation and deallocation behaviors, no asymptotic studies have been conducted to investigate the costs associated with these technologies. To understand the costs associated with using these technologies to manage memory, computations and analyses of time and space overheads associated with scopes and NHRTs are presented. These results provide a framework for comparing the RTSJ’s memory management model with real-time garbage collection. Another facet of this research concerns the optimization of novel approaches to garbage collection on multiprocessor systems. Such approaches yield features that are suitable for real-time systems. Although multiprocessor, concurrent garbage collection is not the same as real-time garbage collection, advancements in multiprocessor concurrent garbage collection have demonstrated the feasibility of building low latency multiprocessor real-time garbage collectors. In the nineteen-sixties, only three garbage collection schemes were available, namely reference counting garbage collection, mark-sweep garbage collection, and copying garbage collection. These classical approaches gave new insight into the discipline of memory management and inspired researchers to develop new, more elaborate memory-management techniques. Those insights resulted in a plethora of automatic memory management algorithms and techniques, and a lack of uniformity in the language used to reason about garbage collection. To bring a sense of uniformity to the language used to reason about garbage collection technologies, a taxonomy for comparing garbage collection technologies is presented

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

Unification of Safety-Critical Java

International audienceIn response to increasing interest in the use of objectoriented technology for development of safety-critical systems, the new DO-178C guidelines will include supplements to address object-oriented technology, model-driven development, formal methods, and development tool qualification [1]. These supplements correlate well with the emerging safety-critical Java standard. As a portable object-oriented programming language enabling high levels of abstraction, safety-critical Java is an ideal candidate for automatic code generation for programming models. The use of formal methods toprove the absence of certain memory management errors at run time is a critical distinction between safety-critical Java and the Real-Time Specification for Java (RTSJ) [2]. And the specialized development tools that facilitate the use of these formal methods will, in the ideal, be qualified so that the results of their analysis can be relied upon as trustworthy safety certification evidence