The 12th International Workshop on Java Technologies for Real-time and Embedded Systems - JTRES 2014

Welcome Reception at the Niagara Falls Convention Center

Registration

Welcome

Keynote: Convergence in Concurrency (Chair: Wolfgang Puffitsch)

Approaches to concurrent programming and its support across real-time versus non-real-time contexts continue to converge in the multicore era. This talk will survey some of the territory and invite discussion on how to make further progress on issues including latency, predictability, resource and memory management, optimism, locality, isolation, composition, reactive designs, memory models, and virtualization.

Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is an author of books, articles, reports, and standardization efforts on object oriented software development including those on specification, design and implementation techniques, distributed, concurrent, and parallel object systems, and software reusability; and has served as chair, organizer, or program committee member for many conferences and workshops in these areas. He is the primary author of several widely used software packages and components.

Coffee/Tea

Session 1: Safety-Critical Java (Chair: James Hunt)

• A Safety-Critical Java Technology Compatibility Kit

  Hans Søndergaard, Stephan E. Korsholm, Anders P. Ravn

  In order to claim conformance with a given Java Specification Request (JSR), a Java implementation has to pass all tests in an associated Technology Compatibility Kit (TCK). This paper presents development of test cases and tools for the draft Safety-Critical Java (SCJ) specification. In previous work we have shown how the Java Modeling Language (JML) is applied to specify conformance constraints for SCJ, and how JML-related tools may assist in generating and executing tests. Here we extend this work with a layout for concrete test cases including checking of results in a simplified version of JUnit. The simplifications makes the test suite executable on resource constrained platforms. Also, the design of the suite is made more portable to other VMs with a SCJ implementation.

• Certifiable Java for Embedded Systems

  Martin Schoeberl, Andreas Engelbredt Dalsgaard, René Rydhof Hansen, Stephan E. Korsholm, Anders P. Ravn, Juan Ricardo Rios Rivas, Tórur Biskopstø Strøm, Hans Søndergaard

  The Certifiable Java for Embedded Systems (CJ4ES) project aimed to develop a prototype development environment and platform for safety-critical software for embedded applications. There are three core constituents: A profile of the Java programming language that is tailored for safety-critical applications, a predictable Java processor built with FPGA technology, and an Eclipse based application development environment that binds the profile and the platform together and provides analyses that help to provide evidence that can be used as part of a safety case. This paper summarizes key contributions within these areas during the three-year project period. In the conclusion the overall result of the project is assessed.

Lunch

Session 2: Evaluations (Chair: Steve Ko)

• On the Locality of Java 8 Streams in Real-Time Big Data Applications

  Yu Chan, Andy Wellings, Ian Gray, Neil Audsley

  Typical Big Data frameworks do not consider the architecture of the servers that make up the cluster. However, these computers are increasingly heterogeneous and are based on a ccNUMA architecture. In such architectures, main memory access times differ depending on the core on which access is requested. Hence, as well as locality of data access throughout a cluster of servers, locality of memory access within individual servers can have an impact on performance.
  Java is a commonly-used language for Big Data applications (through the popularity of Hadoop) and the newly-released Java 8 introduces streams to simplify data-parallel programming. However, this paper argues that there are no built-in parallel stream sources that can efficiently operate on very large datasets and take data locality into account. This paper details recent work from the JUNIPER project, an EU Framework 7 Project, which is investigating how the Java 8 platform (augmented by the Real-Time Specification for Java) can be used for real-time Big Data applications. JUNIPER introduces architecture-aware stream sources which are suitable for Big Data systems and which preserve locality of data. Our results show that when reading data from disk, thread affinity can seriously degrade the performance of standard Java streams, but JUNIPER's architecture-aware streams maintain their performance.

• Real-Time control of Humanoid Robots using OpenJDK

  Jesper Smith, Douglas Stephen, Alex Lesman, Jerry Pratt

  At IHMC we create state of the art walking algorithms for humanoid robots in Java. We successfully used our Java algorithms to control the Atlas humanoid, a 150kg robot with 28 actuated degrees of freedom, in the Darpa Robotics Challenge, placing second in an international competition. To execute our control loops within the deadlines imposed by the robot (1ms), we have brought POSIX real-time threads to the OpenJDK using a JNI library. Lockless synchronization primitives are used to communicate between the different threads, while Garbage Collection is avoided altogether. We have released the IHMCRealtime library created for this project under the Apache license.

Coffee/Tea

Session 3: Language Comparisons (Chair: Igor Kalkov)

• The Cardiac Pacemaker – SystemJ versus Safety Critical Java

  Heejong Park, Avinash Malik, Muhammad Nadeem, Zoran Salcic

  A cardiac pacemaker example is used to compare and contrast the Synchronous Reactive (SR) programming model of SystemJ with the SCJ programming model. Our pacemaker is implemented in the synchronous subset of the Globally Asynchronous Locally Synchronous (GALS) SystemJ, which extends the Java language with reactivity, concurrency and real-time constructs based on a formal mathematical framework. The use of different programming models results in different design choices and implementations. The SR programming model is driven by a logical clock, which clearly demarcates the state boundaries and is ideal for formal verification of functional and real-time properties. Unlike the preemptive scheduling model prescribed by the SCJ specification, the SystemJ program execution model is atomic and non-preemptive between two logical ticks, and as such it is statically schedulable without the need for a runtime scheduler. To check the effectiveness of the SystemJ approach, we implemented the cardiac pacemaker on three different execution platforms that demonstrate feasibility of guaranteed real-time of the pacemaker execution with a fraction of the used processor's resources.

• Using JetBench to Evaluate the Efficiency of Multiprocessor Support for Parallel Processing

  Haitao Mei, Andy Wellings

  JetBench is an Open Source OpenMP-based multicore benchmark application that was created to be used to analyse the real time performance of a multicore platform. The application is designed to be platform independent by avoiding target specific libraries and hardware counters and timers. JetBench uses jet engine parameters and thermodynamic equations presented in the NASA's EngineSim program, and emulates the calculation of a jet engine's performance. As a benchmark, it is, therefore, an application benchmark rather than a synthetic benchmark. This paper reports on the use of JetBench to compare the efficiency of several concurrency models when implemented on a shared memory multicore platform. We compare Ada, C (used in conjunction with Open Multi-Processing (OMP)), Java 8 using the Thread class, Java 8 using Thread Pools, Java using OpenMP, the Jamaica implementation of the Real-Time Specification for Java (RTSJ) with Real-time Threads (compiled), and C#. Our results show that Ada and C with OMP general perform slightly better than compiled RTSJ, and that all three outperform the Java-based languages and C#.

Panel: On to Greener Pastures? (Moderator: Andy Wellings)

How much more research does Real-Time Java need? Should we investigate Real-Time Scala, combining our real-time JVMs with a language paradigm that is different from established real-time languages? Could we use the knowledge we gained while working on Real-Time Java to create languages like Real-Time Haskell or Real-Time Ruby?

Social Event

Keynote: Challenges to Building Trustworthy and Resilient Real-Time Embedded Systems (Chair: Lukasz Ziarek)

This presentation will discuss some of the challenges the Trusted Systems branch faces in developing Trusted and Resilient Embedded Systems. DoD Research and Development priorities and the Air Force Research Laboratory Information Directorate mission will provide a framework for what is hoped to be continued discussion on how innovative Real-time Java based technologies might, or conversely why they might not, be able to meet these research challenges.

Mr. Steven Drager is a principal electronics engineer with over 25 years of experience at the Air Force Research Laboratory, Information Directorate, Computing and Communications Division, Trusted Systems Branch. He began with research and development in reliability physics, particularly in wafer-level testing and prognostics; led the development and standardization of the analog and mixed-signal extension to the VHSIC Hardware Description Language (VHDL-AMS); chaired the Deputy Under Secretary of Defense (DUSD) Information Science & Technology (IS&T) sub-panel for Computing and Software Technology; and was the Information Directorate’s Advanced Computing Architectures Core Technical Competency lead. He is currently leading research, in association with partners at the Office of the Assistant Secretary of Defense for Research & Engineering, Defense Advanced Research Projects Agency and Department of Homeland Security, in high assurance systems, trusted computing, and software assurance.

Coffee/Tea

Session 4: Android (Chair: Martin Schoeberl)

• Predictable Broadcasting of Parallel Intents in Real-Time Android

  Igor Kalkov, Alexandru Gurghian, Stefan Kowalewski

  Several approaches to extend the original Android implementation with real-time capabilities were presented in the last few years. Most of the research was limited to fundamental issues like real-time scheduling and non-blocking memory management. This paper demonstrates the weak predictability of Android’s intra- and inter-process communication and presents a concept to improve its soft real-time capability. The proposed approach introduces a priority-based broadcast handling, instead of the original first in – first out processing. Additionally, we reduce the size of responsible critical sections in order to improve the preemptibility and assure predictable delays for applications with real-time requirements. Our empirical evaluation highlights the improvements in comparison to the original Android implementation without loss of the performance for both global and local broadcast systems. Furthermore, the compatibility to already existing components and applications is preserved.

• Real-Time Sensing on Android

  Yin Yan, Shaun Cosgrove, Ethan Blanton, Steve Ko, Lukasz Ziarek

  Modern smartphones contain many hardware and software sensors, with numerous additional sensing capabilities scheduled to be added in future iterations of the hardware and Android framework layer. This comes at no surprise as sensing is a crucial aspect of most Android applications. Unfortunately, the Android framework provides few guarantees on the delivery of sensor data to applications that require it. Similarly, the Android specification does not provide much in terms of configuration, making its programming model difficult to utilize in more traditional real-time contexts.
  In this paper, we examine the Android’s sensor architecture in detail and show why it is not suitable for use in a real-time context. We then introduce the re-design of the sensor architecture within RTDroid, illustrating how the RTDroid approach can provide real-time guarantees on sensing applications. We then introduce real-time extensions to the Android manifest that enable real-time sensing application writers to express static configuration requirements, using jPapaBench as our motivating example. Finally, we experimentally show that our re-designed sensing architecture can provide predictable performance for jPapaBench with memory- and computation-intensive background workloads.

• Android 292: implementing invokedynamic in Android

  Jerome Pilliet, Remi Forax, Gilles Roussel

  Android OS uses for its applicative part a Java-based virtual machine called Dalvik. Java 7 introduces a new instructions set as well as a new API specified by the JSR 292 in order to improve and simplify the implementation of non-Java languages on top of the Java Virtual Machine. As far as we know, neither the JVMs that are compatible with Java ME 8 nor Android, while compatible at syntactical level with Java 7, implement this JSR. We believe this is due to the fact that current implementations for desktop and server rely on code generation at runtime which requires too much computing power and energy.
  This paper describes our implementation of the JSR 292 in Dalvik. First, we adapt the class format specification of the JSR 292 which is stack based and implicitly relies on the fact that the bytecode can be rewritten at runtime, to the opcode specification of Dalvik which is register based and read only. Then we explain, how we represent the different kinds of method handles in Java, and how method handles are interpreted, using either the C interpreter for the low level method handle or a Java flexible but slow interpreter for the "combiner" method handles.
  At the end, we present a comparison of the execution time of the different kinds of calls. This comparison shows that the implementation of the new instructions is faster than the reflection although the Java interpreter of combiners is slowed down by frequent object creations.

Lunch

Invited Talk: The next generation of the Realtime Specification for Java (Chair: Doug Locke)

Coffee/Tea

Session 5: Embedded JVMs (Chair: Ethan Blanton)

• RT-LAGC: Fragmentation-Tolerant Real-Time Memory Management Revisited

  Isabella Stilkerich, Michael Strotz, Christoph Erhardt, Michael Stilkerich

  The use of managed, type-safe languages such as Java in real-time and embedded systems is advantageous, as it offers productivity and especially safety and dependability benefits over dominating unsafe languages. A Java Virtual Machine (JVM) has to provide an implicit memory management system such as a garbage collector (GC), for example, as explicit memory management through allocation and release operations by the application developer is prone to programming errors and may result in a violation of the type system properties. Real-time systems have specific requirements regarding space and time bounds and a GC has to ensure that these defined upper limits will not be exceeded. A proper solution to address this issue is, for example, employing fragmentation-tolerant garbage collection as proposed by Pizlo et al. Their approach is called SCHISM/CMR. Based on their work, we developed an alternative fragmentation-tolerant GC variant called RT-LAGC, which is supported by our compiler jino and is part of the KESO JVM. RT-LAGC is a cooperative GC, that is, the real-time system developer and the compiler assist the GC through system configuration (e.g. enough slack time for the GC to run) and program analyses, respectively. This is achieved by integrating the GCs in the design process of the whole system just as any other user application. In RT-LAGC, we designed a new bidirectional fragmented object layout. Furthermore, we implemented latency-aware management of fragmented memory as well as an alternative collection technique for array meta-information. Moreover, the execution properties of an exemplary application were improved by jino’s extended escape analysis. RT-LAGC is evaluated against KESO’s purely incremental non-fragmentation-tolerant GC called IRRGC and a throughput-optimized stop-the-world collector named CBGC. A classification of typical memory patterns for Java objects supports the predictability of the examined embedded system.

• HVM-TP: A Time Predictable, Portable Java Virtual Machine for Hard Real-Time Embedded Systems

  Kasper Luckow, Stephan Korsholm, Bent Thomsen

  We present HVM-TP , a time predictable and portable Java Virtual Machine (JVM) implementation with applications in resource-constrained, hard real-time embedded systems, which implements the Safety Critical Java (SCJ) Level 1 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 HVM TP 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 TetaSARTS JVM . 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.

• The final Frontier: Coping With Immutable Data in a JVM for Embedded Real-Time Systems

  Christoph Erhardt, Simon Kuhnle, Isabella Stilkerich, Wolfgang Schröder-Preikschat

  Managed, type-safe languages such as Java are becoming an increasingly competitive alternative for programming real-time and embedded applications, a field which has traditionally been dominated by C. However, one peculiar issue in the use of Java is the insufficient way immutable data is handled. There are some important cases, such as primitive arrays, where the final keyword is not expressive enough to declare data as truly constant. This leads to an unnecessary increase in both code size and runtime memory footprint. Moreover, it prevents the compiler from applying its optimisations as aggressively as would be possible. In this paper, we propose a set of compiler techniques to improve the handling of immutable data in embedded Java applications. Our approach includes (a) detecting constant program data that could not be declared as such by the programmer, (b) eliminating the overhead associated with it, and (c) providing an automated way to allocate that data in flash memory in order to save RAM.

Closing, Next Workshop