Real-Time Java

Running a C HelloWorld on ARM BeagleBoard

2011-07-27T12:52:00.000-07:00

In this simple tutorial I will show you howto prepare your linux distribution for compiling and running C code on a BeagleBoard (ARM architecture). In short, you will need to install the cross-compiler, connect the board with your computer, load the compiled binaries to the board and finally execute them. Here we go in more details:

0. Prerequisites

Linux OS distribution (Ubuntu or Fedora should do)
BeagleBoard-xm with ARM A7 processor (or higher)

1. Install the ARM compiler

You will need to install a compiler for ARMv7 / Linux. See for example ARM/GNU Linux.

Let's assume you have installed the compiler into the following location: /opt/CodeSourcery/Sourcery_G++_Lite.

Then add the location into your PATH:

$ export  PATH=$PATH:/opt/CodeSourcery/Sourcery_g++_Lite/bin

And test your compile by executing:

$ arm-none-linux-gnueabi-gcc  -o hello.arm hello.c

This should work, later on we will use the generated hello.arm to run it on the beagle-board.

2. Connecting the BeagleBoard

Here is a nice manual on setting up the BeagleBoard on a linux-server machine:
http://elinux.org/BeagleBoardBeginners

After going through the manul, your board should be sitting on your network at some IP address, it may be for example 192.168.0.2

To connect to the board:

$ shh root@192.168.90.2

Tip: If you reboot your linux desktop, you probably want to do the following to re-enable the connection with the board:

$ sudo ifconfig usb0 192.168.0.3

3. Running HelloWorld on BeagleBoard

First, we need to copy the executable to the BeagleBoard:

$ scp hello.arm root@192.168.0.3

And then just login to the board and run the executable:

$ shh root@192.168.90.2

$ ./hello.arm 
Hello World!

And that should be all.

[Note: This tutorial is based on my notes when working with the beagle-board, so it may omit some details. Hope it will help anyway.]

Real-time Embedded Java HelloWorld with FijiVM

2011-07-26T08:39:00.000-07:00

The previous post introduced FijiVM. In this follow up we show how to compile and run simple Java programs with FijiVM.

Consider a classical HelloWorld Java Program :

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello World.");
  }
}

1. Compile .java files

Running a Java compiler on this program will produce HelloWorld.class – a Java byte code representation of this program. In most Java implementations HelloWorld.class would then be provided as input to a Java VM. The program’s main method would be interpreted or JIT-compiled and run.

$ javac -d build/ HelloWorld.java

2. Java2C generation

Instead, to run this program in the Fiji JVM, HelloWorld.class would be provided as input to Fiji’s AOT compiler fivmc. The Fiji compiler then creates a native executable for the target platform as well as a build directory containing the generated code and the resources required to build this executable.

$ $(FIJI_HOME)/bin/fivmc  -o HelloWorld ./build/*.class

This command will then execute the Fiji Java2C compiler that translates the bytecode from the .build/ dir to a C source code and then generates a binary executable file "HelloWorld".

Notable compiler options and runtime variables are:

--more-opt - enable maximal possible performance optimizations
--max-threads 5 - max number of threads running in the application
--g-def-max-mem=1200k - set up the heap size
--g-def-trigger=850k - set up the trigger for the GC
export FIVMR_LOG_FILE=log.txt - log file to document fiji runtime
export FIVMR_LOG_LEVEL=3 - filter the log messages, the level 3 will give you the most information
export FIVMR_FAKE_RT_PRIORITIES=true - make FijiVM run on an OS that does not provide real-time guarantees
FIVMR_GC_COMPILE_INFO=true
FIVMR_GC_MAX_MEM=1m
FIVMR_TRIGGER_LOG_GC=true
FIVMR_SHOW_COMPILE_INFO=true
--no-inline - disable inlining of the C methods, useful when hacking the Java2C compiler or debugging the generated code.
--c-debug yes - enables C debug mode

3. Running HelloWorld

And, to run:

$ ./HelloWorld

Hello World!

4. FijiVM generated content

Inspection of the build directory after successful compilation gives us some insight into how Fiji works. The build directory contains five types of files:

XML files — one which contains the mapping from Java method to generated C function and two containing configuration for the Java component of the compiler;
- text files containing analysis of the Java program including string literals, referenced methods, types and classes;
- the generated, OS-independent C code representation of the program; • a copy of the Fiji runtime for the target platform;
- a generated Makefile used to build the executable, as well as build scripts to rebuild without regenerating content.

There are in effect two “main” functions, the C main function in the Fiji runtime and the generated C representation of the Java program’s main method. The runtime main invokes the generated Java main after it has completed its initial setup.

5. Cross-compiling with FijiVM

You an also use FijiVM running on your x86 machine to generate executables for other platforms. For example RTEMS running on LEON3 processor or ARM processor running on BeagleBoard. Setting up the FijiVM to cross-compile to a desired platform is very straightforward:

Example #1: adding a Mac OS X PowerPC target on OS X:

$ bin/add-target --name ppc --cc "gcc -arch ppc"

This will create a target called 'ppc' that will build a Fiji VM compiler and runtime that will generate a OS X PowerPC executables. You can run such executables on almost all Macs, since they have a built-in emulator. This is great for validating our PowerPC support. Note that the argument to '--name' can be anything you like. In many cases, the name is automatically inferred; but specifying one explicitly is often a good idea. You can then run fivmc as follows to create a binary for PowerPC:

$ bin/fivmc --target ppc

Example #2: adding an RTEMS target:

$ bin/add-target --rtems-build /path/to/rtems/bsp/build/dir

This will automatically infer everything it needs to know about the BSP, architecture, RTEMS version, etc. It will also automatically name the target something like RTEMS-sis-rtems4.9-sparc-32, with useful aliases such as sis, rtems4.9, sparc, and sparc-rtems4.9. So you can then run fivmc using any of the following --target options; whatever you like best:

$ bin/add-target --target sis

$ bin/add-target --target sparc-rtems4.9 
$ bin/add-target --target sparc 
$ bin/add-target --target RTEMS-sis-rtems4.9-sparc-32

And that's it. You should be now able to play with the FijiVM, target various platforms and use specific compile options to tailor the generated executables to your specific needs.

FijiVM - A Real-time Java VM Overview

2011-07-14T06:08:00.000-07:00

FijiVM is a real-time Java implementation which runs on RTEMS (a real-time OS for embedded devices) and a number of POSIX-compliant operating systems. It has the following components:

AOT Java2C Compiler: An ahead-of-time compiler written in Ruby and Java. This compiler takes in Java byte code and produces machine independent C. The Java component performs the code generation whilst the Ruby component acts as a harness for the Java component — providing configuration, marshalling input files, directing output to the appropriate location and finally invoking the C compiler on the generated code.
Fiji Runtime: A Java run-time written in C and Java. The runtime includes a real-time garbage collector as described in Section 2.5.2. The C code is invoked by the Java code by calling methods marked with Java’s native keyword.
FijiCore lib: A Java class library called FijiCore written in C and Java. Similarly to the run-time, C and Java code is bridged by the native keyword.
Real-time Garbage Collector - a set of GC algorithms offering both performance and real-time guarantees.
SCJ and RTSJ libraries (RTSJ is supported only partially) - SCJ and RTSJ libraries are distributed with FijiVM to offer alternatives to regular Java and Java+RTGC.

Let's look at some of these components in detail.

Garbage Collector

The key part of the FijiVM is a set of garbage collector algorithms that offer various performance characteristics and real-time guarantees. You can find more information about FijiVM's GC in Schism: Fragmentation-Tolerant Real-Time Garbage Collection. PLDI'10.

FijiVM Compilation Process

Since the FijiVM is based on an AOT compiler that translates the application from its Java byte-code to native C code, the compilation process is different from what we are used to in regular Java VMs. It is best illustrated on the following picture:

AOT Java2C Compiler

The Java2C compiler not only translates byte-code to C code but it performs number of tasks. There is several level of transformation, each introducing various code optimization techniques known from standard compilers. The byte-code is translated into Fiji's specific intermediate representation (IR) where the code is optimized further again. Until the final transformation generating the C-code, several phases of transformation+optimization is performed, each closer to the final product which is the generated C code. Again, illustrated on the following picture:

Fiji Libraries

FijiCore contains a subset of the standard Java class library, including generic collections and events from java.util, I/O and character set support from java.nio and java.io, arbitrary-sized arithmetic from java.math and all of java.lang, including annotations and reflections.

Instead of FijiCore, developers may also elect to use GNU Classpath (an open source implementation of the standard Java library). A second Fiji-specific class library called HardRTJ is currently in development. HardRTJ is intended to provide a library option with a smaller memory footprint than FijiCore, and a yet smaller feature set (note that to use any alternate library the library must be supported on the target platform).

SCJ and RTSJ support

Apart from the FijiVM libraries that replace a standard Java library known from a regular JavaVM distributions, FijiVM offers a support for extending libraries focused on real-time and safety-critical systems. The FijiVM comes with a distribution of oSCJ - an open-source Safety-critical Java implementation based on the JSR-302. Further, FijiVM offers a basic RTSJ (the JSR-1 implementation) support.

Resources

See my previous post : Is Java ready for Real-time?
James Hatherly's thesis: Native real-time Java on seL4
FijiVM research publications:

oSCJ Project:

In the next post, I plan to show you how to use FijiVM to compile basic Java programs and how to use the VM in practice.

Is Java ready for Real-Time?

2011-07-08T13:04:00.000-07:00

"Is Java ready for Real-Time?" is a title of an invited talk given by Prof. Jan Vitek at MVD'10 - Midwest Verification Day, [slides].

The talk reviews advances of Java technology for hard real-time and safety-critical systems as of September 2010. Its a nice summary of the state of the art of Real-time Java and that's why I am linking it here.

SCJ Checker : A new release, v2.0

2011-06-20T14:01:00.000-07:00

We have just released a new version of the Safety-Critical Java Annotations Checker. The checker introduces an improved checking of memory-safety annotations along with a lot of other improvements and bug-fixes.

Along with the Checker, we have produced a short tutorial [PDF], the document contains:

Checker installation and running instructions,
the essential concepts and ideas behind the annotation system,
various examples to illustrate the basic features of all the annotations,
the key restrictions and rules enforced by the annotation system.

The document is written with the motivation to give the reader the basic understanding of programming SCJ applications with the annotations.

Safety-Critical Java Case Studies

2011-05-27T08:36:00.000-07:00

We have recently put together a set of Safety-Critical Java applications. The implementation of these applications is open source, you can find them in our oSCJ repository, in directories oSCJ/examples and oSCJ/tools/checker/examples. The directories now contain more than 3O KLOC of Safety-Critical Java application code, here is a description of the most interesting case studies:

Quicksort is benchmark based on the quicksort algorithm. The application periodically sorts an array of objects that are allocated in an upper-scope, thus introducing a cross-scope manipulation of objects into the algorithm.

Thruster case-study simulates a spacecraft thruster engine. Control of the engine requires a 100-millisecond periodic activity to adjust the valve settings to avoid mechanical drift and, therefore, obtain an even fuel flow. Inspired by [Wellings-JTRES10].

Fast-MD5 implements a periodic execution of the Fast-MD5 encryption algorithm of a fixed string within its most inner memory area.

Webserver is an application handling http requests and was developed as a case study within the SquawkVM project to evaluate SCJ implementation running on SUN SPOTS embedded devices.

CDx-SCJ is an open-source family of benchmarks that can be used to measure performance of various hard and soft real-time platforms. The CDx benchmark consists of a periodic task that takes air traffic radar frames as input and predicts potential collisions.

Railsegment, developed by Kelvin Nilsen at Atego, is a complex simulator of a train control software that is responsible for collecting the data about speed and position of the train, analyzing them in real-time and adjusting the train speed according to the route plan.

Jpapabench is a SCJ benchmark based on the Paparazzi project which provides an open-source implementation of an autopilot for unmanned aerial vehicles (UAVs). The autopilot has been successfully tested on several real devices. The JPapabench is developed by Michal Malohlava at MFF UK, see the JPapabench webpage.

We believe that these applications are a representative set of SCJ case studies that demonstrate many SCJ concepts on real examples.

A family of real-time Java benchmarks

2011-05-02T14:06:00.000-07:00

Be sure not to miss a new publication on the Collision Detector (CDx) benchmark [PDF]. Tomas Kalibera and his team put together an updated journal publication on CDx.

The article also reports on our performance comparison of the oSCJ platform running on LEON3 boards. Although the paper reports 50% overhead of the oSCJ in comparison to the C version of the benchmark, we are happy to announce that in the last few months we have been able to further decrease the overhead to ~28%.

The figure shows are new measurement of the improved performance of oSCJ. Further, our most recent experiments suggest that we can do even better. Stay tuned.

JPapaBench : A new benchmark was born.

2011-04-19T08:45:00.000-07:00

A new real-time Java benchmark - JPapabench, was developed by a team lead by Michal Malohlava at Charles University in Prague.

The most exciting facts about this benchmark are:

jPapabench is based on the Paparazi project which provides an actual implementation of an unmanned aerial vehicles (UAV) autopilot. Therefore, the benchmark is trully reflecting an autopilot software that is used in real life UAVs.
JPapabench is available in several versions: regular Java, Real-time Java, and Safety-Critical Java.
the project is open-source and available at http://code.google.com/p/jpapabench/.

Enjoy.

Paparazi project screenshot.

Safety-Critical Java Specification : First Draft Released

2011-02-13T11:41:00.000-08:00

The moment we all have been waiting for is here.

The first public version of the Safety-Critical Java Specification (JSR-302) was released. The draft can be downloaded from JSR-302 webpage, go to the Download Section.

To make a good picture of what SCJ is about, read the first two chapters. And if you want to know what we have been contributing to, read the Chapter 9 : Java Metadata Annotations.

Real-Time Java HelloWorld

2010-11-08T13:47:00.000-08:00

Are you starting with Real-time Java and don't know where to look first? Here is a step-by-step tutorial showing you how to install and run simple RT Java programs.

1. Install Real-time Java VM
There is a bunch of RT VMs that you can donwload and use but perhaps the one that is the easiest to install and to play with is Oracle's Java RTS. The current version is Java RTS 2.2. After filling the download form, you should be able to download it to your desktop. The name of the donwloaded file will be something like : java_rts-2_2-fcs-bin-b19-linux-i586-eval_academic.zip

1.0 Requirements

RT Linux - if you want to really run with real-time priorities. However, for starting and learning how to work with RT VMs, a regular linux should do - try eg. Ubuntu or Fedora OS.

1.1 Install the RTJ VM
untar downloaded distributable into /opt/jrts2.2 directory. Let's call it RTJAVA_HOME.

$ export RTJAVA_HOME=/opt/jrts2.2/

For more details, see SUN Java RTS Technical Documentation. Java RTS is distributed under restricted academic license that expires after 365 days but don't worry, you can just dowload a new distribution and re-install it.

1.2. Verify the Installation
Type:

$ $RTJAVA_HOME/bin/java -version

You should see:

java version "1.5.0_20"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_20_Java-RTS-2.2_fcs-b19_RTSJ-1.0.2)
Java Real-Time System HotSpot(TM) 64-Bit Client VM (build 1.5.0_20-b19, mixed mode)

In case you are not running in a real-time environment or your linux does not have the rt-kernel extensions, you will also see the following warning:

Java Real-Time System HotSpot(TM) 64-Bit Client VM warning: Unable to lock pages into memory: insufficient privileges
Java Real-Time System HotSpot(TM) 64-Bit Client VM warning: Cannot use the real-time scheduling class.

You can safely ignore this one for testing RTSJ.

1.3. A missing libcap.so problem
However, a problem can occur when running the "./bin/java" on some systems:

$RTJAVA_HOME/bin/java -version

dl failure on line 824Error: failed /opt/sunrts-2.2/jre/lib/i386/server/libjvm.so,
because libcap.so.1: cannot open shared object file: No such file or directory

This happened to me both on Ubuntu and Fedora OS. There is a detailed description of this problem here (as it appears, I was the first person to identify this issue).

Solution to the missing libcap.so.1 lib is to locate a libcap.so.2 and rename it as libcap.so.1

$ locate libcap.so.2

$ sudo cp /lib/libcap.so.2 /lib/libcap.so.1

2. Runnig a Real-time HelloWorld program
Now we can finally run some real-time Java code. A classical real-time Java hello world example is below:

import javax.realtime.RealtimeThread;

public class HelloRealtimeWorld extends RealtimeThread {

    String message;

    public void run(){
      message = "Hello Realtime World";
    }
   
    public static void main(String args[]){
      HelloRealtimeWorld thread = new HelloRealtimeWorld();
      thread.start();
      try{
        thread.join();
      } catch(InterruptedException ie){
        System.err.println("got interrupted");
        return;
      }
      System.out.println(thread.message);
    }
}

To compile the Real-Time HelloWorld class:

$ $RTJAVA_HOME/bin/javac -classpath $RTJAVA_HOME/jre/lib/rt2.jar

-d build/  HelloRealtimeWorld.java

And, to run:

$ $RTJAVA_HOME/bin/java -cp build/ HelloRealtimeWorld

Hello Realtime World!

And we are done!

Further resources on RT Java:

Concurrent and Real-time Java Programming book,
try our CDx - Real-Time Java Benchmark,
Oracle's RTSJ Introduction
Embedded and Real-time Computing class taught by Prof. Vitek (check out the slides for selected topics)

Further blog-post on the same topic:

http://viswanathj.wordpress.com/2011/04/09/installing-java-rts-on-ubuntu-2/

October Reading List

2010-11-03T15:34:00.000-07:00

The list of papers, books, and other articles that caught my attention during the last month.

Papers:

ASTREE project: Proving the Absence of Runtime Errors [PDF]

Static Analysis and Verification of Aerospace Software by Abstract Interpretation [PDF]

NASA : Monitoring Distributed Real-Time Systems: A Survey and Future Directions
OOPSLA papers:

Books:

Revisiting some chapters in Compilers: Principles, Techniques, and Tools
Neal Stephenson : Snow Crash (finally!)

Others:

Hacker Monthly
High-Frequency Trading Interview : TradeWorkx
Matt Might's blog (as usually)

oSCJ News

2010-10-22T13:40:00.000-07:00

Recently, there has been a lot of activity around the oSCJ project, here is a short summary.

We currently develop several new features in parallel:

SCJ benchmarks - we have added a set of new SCJ programs to compare performance and memory usage of the SCJ memory management againts real-time garbage collection algorithms
SCJ Annotations - soon, our annotation checker will be extended to cover a full-scale of different allocation scenarios to guarantee memory safety of the applications running on oSCJ. Furthermore, this feature will allow us to disable the runtime scope checks in the underlying VM, achieving 5-10% speed-up!
SCJ library extensions - as JSR-302 is nearing to its completion, we extend the set of supported features.

Also, the installation and running of oSCJ is now super-easy! First, you can get an academic version of FijiVM - our major platform for running oSCJ. Just contact us so we can send you the Fiji VM distribution!

Installation procedure:

$ wget fivm.tar.gz
$ untar fivm.tar.gz

$ cd fivm

$ hg clone https://scj-jsr302.googlecode.com/hg/ scj

and then compile FijiVM, which will also compile the oSCJ as well:

$ autoreconf -i

$ ./configure

$ make

To update oSCJ:

$ cd fivm/scj

$ hg pull

$ hg update

For your better orientation in the distribution directory, here is a structure of the distribution directory

fivm/                 fivm/scj

...

  lib/                this is where "scj.jar" is

  scj/

    oSCJ/             oSCJ root dir

      doc/              Documenation

      examples/         oSCJ examples and benchmarks dir

        minicdx/          our CDx benchmark implemented in SCJ

        hello/            SCJ helloworld example

...

      scj/              oSCJ library implementation

        ri/               SCJ library source codes

...

      tools/            our SCJ tools

        checker/          Static Checker for SCJ

        tck/              TCK for SCJ

  scjruntime/

See our oSCJ Code base for the most recent updates.

Azul@Purdue Project

2010-10-18T07:53:00.000-07:00

Recently, our team acquired a revolutionary Azul appliance platform. I had a great opportunity to play with this exciting hardware a little when installing and running the first helloworld programs both in Java and C. This was the first time ever that this machine was used in an academic institution. Here is some more info:

Azul appliance is built around the Vega 3 chip and is a unique virtualization platform that features 54 cores pre processor giving users the power to run up to 800 Java threads in parallel. Futhermore, the appliance offers ~700GB of memory while running a concurrent GC that achieves garbage collection without any pauses in the host application.

Find more at our webpage: http://sss.cs.purdue.edu/projects/azul/

Garbage Collection and Real-time Garbage Collection Introduction

2010-09-26T17:48:00.000-07:00

Here are some documents and slides you may find useful when studying Garbage Collection and Real-time Garbage Collection:

First, look at SUN's
Memory Management in the Java HotSpotTM Virtual Machine. Its from 2006 but contains a very nice introduction to GC, even parallel and small-pause collection algorithms are mentioned.

An another introduction slides are:
GC Introduction Presentation

When looking at performance of GCs, look at a nice study
Myths & Realities The Performance Impact of Garbage Collection from Steve Blackburn, Perry Cheng and Kathryn McKinley.

For interesting implementation details, I recommend:

Barrier techniques for incremental tracing
And Schism GC paper presented at PLDI (2010), contains also a very nice performance statistics.
GC FAQ

Static Checker for SCJ: Paper and its Presentation

2010-09-16T10:27:00.000-07:00

Presentation of our Static SCJ Checker is now available online:

Static Checker for Safety-Critical Java Annotations

The paper itself can be downloaded from JTRES2010 webpage.

Developing Safety-Critical Java Applications with oSCJ : Presentation

2010-08-20T05:46:00.000-07:00

Our oSCJ slides presented at JTRES:

oSCJ : Safety Critical Java Virtual Machine Development

View more our presentations.

Developing Safety-Critical Java Applications with oSCJ

2010-08-15T09:08:00.000-07:00

Read our oSCJ paper:

Developing Safety-Critical Java Applications with oSCJ

Abstract:

We present oSCJ, an implementation of the draft of Safety Critical Java (SCJ) specification. SCJ is designed to make Java amenable to writing mission- and safety-critical software. It does this by defining a subset of the Real-time Specification for Java that trades expressiveness for verifiability.

This paper gives a high-level description of our implementation of the first compliance level of the SCJ speci- fication, a library called oSCJ, and reports on performance evaluation on the Ovm real-time Java virtual machine. We compare SCJ to C on both a real-time operating system on the RTEMS/LEON3 platform and Linux on a x86. Our results suggest that a high-degree of predictability and competitive performance can indeed be achieved.

The paper will be presented at JTRES'10 in Prague.

Download the paper in [PDF].

JTRES'10: Advance Program

2010-08-09T08:32:00.000-07:00

The advance program of the JTRES conference, held next week in Prague, is already availabe at JTRES Webpage. Here are some highlights.

The keynotes:

Greg Bollella (ORACLE) : Some Recent Developments Around The RTSJ and Oracle.
Marc Pantel (University of Toulouse) : Certification and qualification concerns in the development of safety critical systems.
Rainer Trummer (University of Salzburg) : The JAviator Project
Marek Prochazka (European Space Agency) : Java in Space?

Also, do not miss the presentations of our two papers, I will be presenting:

Developing Safety-Critical Java Applications with oSCJ/L0 by Ales Plsek, Lei Zhao, Veysel H. Sahin, Daniel Tang, Tomas Kalibera, and Jan Vitek

and

Static Checking of Safety-Critical Java Annotations by Daniel Tang, Ales Plsek, and Jan Vitek

See you at JTRES.

Certification challenges for Real-Time Java

2010-07-26T10:44:00.000-07:00

A very interesting article about recent development in the area of certification for Real-time Java:

DO-178B certification challenges for real-time Java applications

Its exciting to see that Safety-Critical Java (JSR-302) is in the middle of these efforts!

See our implementation of safety-critical Java here: oSCJ

RTEMS HelloWorld Tutorial

2010-06-23T13:12:00.000-07:00

Let's go embedded.

RTEMS is a real-time executive which provides a high performance environment for embedded applications on a range processors and embedded hardware. In this tutorial you will learn howto:

install RTEMS and build RTEMS tools
run RTESM applications on TSIM simulator

We leave the topic of compiling RTEMS applications for a separe howto article. Check the blog for updates.

Note: This tutorial is focused on the following platforms : SPARC LEON3 and ERC32/SIS.

1) Prerequisities
First, you will need a linux distribution supporting RTEMS. Try Fedora 11 or higher or SUSE 11 or higher.
This tutorial is using the RTEMS version 4.9. RTEMS 4.10 is not officially distributed, but the instructions here in general should be valid once this new distribution is released.

2) RTEMS OS installation
As part of the installation, we need to install the RTEMS prebuilt tools first.

Browse http://www.rtems.org/ftp/pub/rtems/linux/4.9/suse/11.2/i586/ (Suse)
Browse http://www.rtems.org/ftp/pub/rtems/linux/4.9/fedora/11/i586/ (for Fedora)
Download and istall the following packages (for Suse, Fedora packages will have similar names)

            rtems-4.9-autoconf-2.62-4.suse11.2.noarch.rpm
            rtems-4.9-automake-1.10.3-1.suse11.2.noarch.rpm
            rtems-4.9-binutils-common-2.19-3.suse11.2.i586.rpm
            rtems-4.9-gcc-common-4.3.2-24.suse11.2.i586.rpm
            rtems-4.9-gdb-common-6.8-11.suse11.2.noarch.rpm
            rtems-4.9-newlib-common-1.16.0-24.suse11.2.i586.rpm
            rtems-4.9-sparc-rtems4.9-binutils-2.19-3.suse11.2.i586.rpm
            rtems-4.9-sparc-rtems4.9-gcc-4.3.2-24.suse11.2.i586.rpm
            rtems-4.9-sparc-rtems4.9-gcc-c++-4.3.2-24.suse11.2.i586.rpm
            rtems-4.9-sparc-rtems4.9-gdb-6.8-11.suse11.2.i586.rpm
            rtems-4.9-sparc-rtems4.9-newlib-1.16.0-24.suse11.2.i586.rpm
Install (SUSE):

$ rpm -Uvh <package name>.rpm

Install (Fedora):

$ yum install "installation_package_name"

Notes:

All the packages will be installed in /opt/rtems-4.9/ by default.
During installation you can get some warnings about keys. Don't worry about them.
During installation you can get some dependency errors. Find the required packages from suse repositories and install them.

3. Build RTEMS
In this step we will build RTEMS for two different configurations - LEON3 and ERC32/SIS.

3.1 Build RTEMS with LEON3 support
1. Become root
2. Browse http://www.rtems.org/ftp/pub/rtems/4.9.3/
3. Download rtems-4.9.3.tar.bz2. Extract archive in the /opt/ directory. This will create /opt/rtems-4.9.3/
4. Execute the following:

$ cd /opt/rtems-4.9/
$ export PATH=/opt/rtems-4.9/bin:$PATH
$ ./bootstrap
$ mkdir leon3
$ cd leon3
$ ../../rtems-4.9.3/configure --target=sparc-rtems4.9 
         --enable-rtemsbsp=leon3 --enable-posix
$ make
$ make install

3.2 Build RTEMS with ERC32/SIS support (optional)
The same approach as above, only the configuration during the building is different:

$ cd /opt/rtems-4.9/
$ export PATH=/opt/rtems-4.9/bin:$PATH
$ ./bootstrap
$ mkdir bsis
$ cd bsis
$ ../../rtems-4.9.3/configure --target=sparc-rtems4.9

--enable-rtemsbsp=sis --enable-posix
$ make
$ make install

3.3 TSIM simulator
Go to TSIM distribution at Gaisler Inc.
- install the TSIM simulator, eg. in /opt/tsim
- the simulator will allow you to execute RTEMS binnaries on your x86

4. RTEMS Helloworld with TSIM:

First, you need to compile RTEMS C application. We will however not address this step here, we will dedicate a separate tutorial for this step. But, in order to verify that your installation is correct, RTEMS distribution contains many pre-compiled examples that you can use to run out of the box.
You can also download it here: RTEMS HelloWorld binnary (compiled for SPARC LEON3).

And then load the binnary file into the TSIM simulator and run it:

$ /opt/tsim/linux/tsim-eval
tsim> load hello
tsim> go
resuming at 0x40000000
Hello World!

Program exited normally.
tsim> quit

5. RTEMS installation - Building a toolchain and target C library (optional)

First, fetch gcc-core and gcc-c++ 4.3.2, binutils 2.19, newlib 1.16.0, and related patches from http://www.rtems.org/ftp/pub/rtems/SOURCES/4.9/. You need only the newest patch (the filenames include the date) for each component. Extract and patch each component from the same directory (we'll call it $TOP), so that you have $TOP/gcc-4.3.2/, $TOP/binutils-2.19/, and $TOP/newlib-1.16.0/.

Link $TOP/newlib-1.16.0/newlib to $TOP/gcc-4.3.2/newlib:

ln -s $TOP/newlib-1.16.0/newlib $TOP/gcc-4.3.2

Create a build directory for each of binutils and gcc, indicating the architecture; something like binutils-2.19-$ARCH, where $ARCH is i386, sparc, etc.

Pick an install directory; we will call it $PREFIX -- I use /opt/rtems-4.9.
Configure and build binutils:

cd $TOP/binutils-2.19-$ARCH
../binutils-2.19/configure --target=$ARCH-rtems4.9

--prefix=$PREFIX --disable-werror
make
make install

Configure and build gcc; this may require some platform-specific arguments:

cd $TOP/gcc-4

6. Other Tips (optional)

RTEMS on x86:
If you wish to boot RTEMS using grub (as for qemu), provide --enable-rtems-grub. This forces the binary to load up above the 1MB mark.

FPU support:
In case your RTEMS configuration is not FPU-friendly, when building your tools, provide --with-float=soft to the gcc configuration.

References:
1) Another RTEMS installation tutorial
2) RTEMS: http://www.rtems.com/

Acknowledgment: Thanks to Petr Maj and Ethan Blanton for help with this tutorial!

Static Checker for SCJ released!

2010-06-14T12:20:00.000-07:00

We have released a new version of our Static Checker for SCJ. The checker is based on the Checker framework that will be shipped with Java 7 and is able to statically verify various SCJ properties.

Here you can see an example SCJ code and possible errors that the checker will identify:

(click to enlarge)

We now support all the SCJ annotations:

@SCJAllowed
@SCJRestricted
@DefineScope
@Scope
@RunsIn

A typical example of a checker output can be seen here:

(click to enlarge)

You can find more information about the Checker at oSCJ Home Page.

The checker is open-source and can be downloaded from here.

Comparator: An AST Parser for SCJ

2010-06-01T14:05:00.000-07:00

Keeping specification and its corresponding implementation in sync is often a huge hasle.

In our case, the situation is even more complex since we have several different implementations of the same Specification. Moreover, the Spec. itself is being constantly updated.

Therefore, we introduce Comparator -- our new tool that is able to automatically determine all the differences between a specification class and its corresponding implementation.

Comparator creates AST trees both from the spec and from the implementation and compares them, simple yet powerful.

You can see a typical report log produced by the Comparator :

Comparator will be shipped with the updated version of SCJ TCK soon, stay tuned.

JTRES Workshop

2010-06-01T07:58:00.000-07:00

As every year, JTRES'10 : International Workshop on Java Technologies for Real-time and Embedded Systems is coming.

This year in Prague, Czech Republic, August 19-21.
Research Paper Deadline : June 7th (firm).

For more info, see:

CDx Benchmark : Update

2010-05-13T16:06:00.000-07:00

We have released a new version of the CDx benchmark: Version 1.2!

Version 1.2 unifies the CDx implementation across all the platforms and implementations languages.

We now provide the same CDx algorithm implemented in:

CDj-Java - CDx in regular Java,
CDj-RTSJ - CDx in RTSJ,
CDj-SCJ - CDx in SCJ,
CDj-Fiji - a specific-FijiVM-implementation,
CDc - language C implementation.

We specifically paid attention to implementation of each version so that all the provided CDx applications and computationally identical, the only difference is the programming language used for their implementation.

Download the CDx benchmark.

Open Safety-Critical Java Presentation

2010-04-24T13:20:00.001-07:00

Presenting our oSCJ Project:

Open Safety-Critical Java

View more presentations from Ales Plsek.

oSCJ on GoogleCode!

2010-04-13T17:42:00.000-07:00

We have set up a GoogleCode project for oSCJ.

See the project here: http://code.google.com/p/scj-jsr302/
This move allows you to closely follow updates on oSCJ. We now introduce new features almost every day!

You can now easily check-out oSCJ from our Mercurial repository:
hg clone https://scj-jsr302.googlecode.com/hg/ scj-jsr302

oSCJ Released!

2010-03-31T09:48:00.000-07:00

We are happy to announce

oSCJ : open Safety-Critical Java implementation

has been released.

The oSCJ distribution contains:

Library

SCJ Level 0 library implementation
an RTSJ-compatible implementation for evaluating SCJ on top of RTSJ VMs

SCJ-compliant VM

our VM is based on OVM
we provide support also for FijiVM

Tools

Checker - a static checker for proving memory safety of SCJ programs and other properties
TCK - Technology Compatibility Kit for SCJ

Benchmark Suite

HelloWorld example for experimenting with SCJ
miniCDj - SCJ implementation of our CDx benchmark

Download the distribution from oSCJ webpage.

Enjoy and we are looking forward to your feedback!

Collision Detector Benchmark : A New Version Released

2010-03-07T15:13:00.000-08:00

We have just released a new version of CDx : Open-source Realtime Collision Detector benchmark.
Download our CDx benchmark version 1.1 here.

This new version is largely simplified, specially the simulation of the input Frames is changed, now each frame is computed on-the-fly. The version 1.1 of the benchmark is used in two research papers recently published at EuroSys'10 and PLDI'10, see our list of publications.

The CDx benchmark is now distributed under the New BSD License.

ROOTs'10 Workshop Announcement

2010-02-03T08:08:00.000-08:00

ROOTs 2010 stands for 1st International Workshop on Real-time Object-Oriented Technologies. Workshop will be collocated with ECOOP 2010 in Slovenia in June.

Briefly, the workshop will be concentrated around object-oriented desing and development of real-time, embedded and safety-critical applications.
The Program Committee comprises 16 independent specialists both from academia and industry.
See more at our webpage:

Feel free to propose participation. We are looking for your papers, demos submissions, etc.

See you at ECOOP 2010!

oSCJ White Paper

2010-01-31T19:29:00.000-08:00

oSCJ : Open Safety-Critical Java white paper will be part of annual report of Computer Science department at Purdue University. See the paper here:

Safety-Critical Java Introduction

2009-12-19T20:31:00.000-08:00

Safety-Critical Java is a new JSR-302 specification for a Safety-Critical standard on the Java platform.

A good introductory paper to the Safety-Critical Java implementation is Java for Safety-Critical Applications.

Look also at TCK for SCJ paper.

oSCJ Webpage Launched

2009-12-11T11:56:00.000-08:00

Recently, we have launched our Open Safety-Critical Java (oSCJ) Project. This project is based on the JSR302 Safety-Critical Java Specification,

As the first result, an oSCJ Home Page was launched:

More news to come soon, the first release is coming January 2010. Stay tuned.

A New Real-time VM Was Born - Fiji VM

2009-11-16T16:46:00.001-08:00

The new virtual machine for real-time world is here. Fiji VM technology enables developers to:

Seamlessly integrate pure Java code into real-time, safety-critical, and mission-critical systems.
Deploy on a broad range of hardware and operating systems, ranging from ARM and ERC32 to PowerPC and x86/x86_64, from RTEMS to Linux or Darwin.
Boot Java from bare hardware - for small footprint (100KB) applications, Fiji VM provides the unique ability to boot Java from bare hardware.
Execute Java with deterministic garbage collection, as well as full support for safe GC-less allocation.
Achieve high performance execution. From the peformance perspective, Fiji VM seems very promising, having only 40% slow down comparing to C.

Fiji VM technology offers a variety of footprint and library options to the developer, if extremely small footprint (100KB) is desired, Fiji offers Fiji HardRTJ library.

To give you a better picture, here is how FijiVM fits into the whole stuck:

Fiji VM 1.0 release is coming in December 2009. More at Fiji Systems LLC home page.

A Component Framework for RTSJ

2009-09-22T14:02:00.001-07:00

The following slides are presenting SOLEIL - a component framework for RTSJ-based systems.

These slides were used also during my PhD defense:

Soleil: A Component Framework for RTSJ

View more presentations from aplsek.

A PhD thesis about RTSJ

2009-08-27T03:52:00.001-07:00

My PhD thesis focused on RTSJ is titled:

SOLEIL : An Integrated Approach for Designing and Developing Component-based Real-time Java Systems

The defense of this thesis will take plate at INRIA Lille, France on September 14, 1:30 pm. Visitors are welcomed.

The thesis can be downloaded from: SOLEIL thesis download.

A New Real-time Java Book

2009-08-24T03:54:00.000-07:00

Recently, a new book about RTSJ has been published:

Real-Time Java™ Programming with Java RTS

by Eric J. Bruno; Greg Bollella, Prentice Hall, 2009

Read it online here.

Real-time Java Programming - Introduction

2009-08-12T13:38:00.000-07:00

New to the world of real-time and real-time Java programming?

Look at my Real-time Java programming in 10 minutes presentation:

Real-time Programming in Java

View more presentations from aplsek.

When searching for more information about real-time programming in general, try the
Douglas E. Jensen Tutorial.

JTRES’09 Workshop

2009-08-06T01:10:00.001-07:00

“This is the place to be.”

Greg Bollella

JTRES is a workshop of Java Technologies for Real-Time and Embedded Systems. Annually, RTSJ professionals, researchers and fans are meeting to discuss, exchange…

We will be there too, presenting our CDx paper - an open-source RTSJ benchmark.

This year in Madrid, Spain. See more at JTRES Home Page.

CDx : A Family of Real-time Java Benchmarks

2009-07-07T03:26:00.000-07:00

Collision Detector (CDx) is our new open-source Real-time Java
benchmark. The key features of the CDx benchmark are:

the first open-source RTSJ benchmark,
highly configurable for different VMs,
provides various workflows,
a large case study suitable for learning and experimenting with RTSJ.

Find more at our new webpage presenting CDx:

CDx : A Family of Real-time Java Benchmarks

Real-time Java VMs

2009-06-30T02:03:00.000-07:00

Although real-time Java is becoming well known, the specific Virtual Machines implementing its functionalities are still known only to the community. There is no list of VMs supporting real-time features, furthermore, every VM is implementing a different subset of RTSJ.

Therefore, I am posting a list of RTSJ-compatible VMs that are available up to this date (sorted by first release date).

TimeSys RTSJ Reference Implementation Only licensed for non-commercial use. Runs on X86/Linux. Available at www.timesys.com.
Java RTS Sun - Java SE Real-time (Java RTS). Runs on Sparc/Solaris (Beta for SUSE Linux Enterprise Realtime 10, and Red Hat Enterprise MRG 1.0.). Available at http://java.sun.com/javase/technologies/realtime/rts/.
IBM WebSphere Real Time. IBM WebSphere Real Time V2 for Real Time Linux, running on main-line real-time Linux distributions (Red Hat MRG and Novell SLERT). However, there are limitations on the hardware supported. The main reason for the hardware limitation is that the supported models have modified firmware to allow better control over SMI event prioritization, in order to achieve determinism of the underlying hardware. Availale at www.ibm.com/software/webservers/realtime/.

Furthermore, other real-time, Java-like platforms have been developed, either commercial or academic projects. Usually, these VMs are not fully compliant with RTSJ.

OVM is an academia research project at Purdue University that implements RT VM. Available at http://www.ovmj.org
JamaicaVM implements RTSJ and a deterministic garbage collector. Runs on various platforms. Available at http://www.aicas.com/jamaica.html.
jRate (Java Real-Time Extension) is an extension of the GNU GCJ compiler front-end and runtime system which adds support for most of the features required by the RTSJ. Available at http://jrate.sourceforge.net/.
Aonix PERC is a commercial project targeting many hard real-time, safety critical and embedded systems. The PERC platform is introducing many trade-offs and therefore is not fully compliant with RTSJ, however, allows developers to target a broader scope of applications rather than having strict limitations as it is the case of RTSJ. Available at www.aonix.com/perc.
aJ100 is a hardware coded JVM. Available at www.ajile.com.
JRockit Real-Time JRockit Enterprise Java Runtime provided by ORACLE is a Java VM featuring real-time garbage collection suitable for soft real-time systems. Available at www.oracle.com/jrockit.
IBM/Apogee Aphelion is comprised of reliable and high performance JREs for deploying Java applications on devices based on embedded systems. Supports many OS platforms, further details at http://www.apogee.com/
[UPDATE: 07/2011] LJRT - Lund Java based Real-Time, http://www.robot.lth.se/java
[UPDATE: 07/2011] FijiVM - FijiVM, http://www.fiji-systems.com/, more also at this post.

Source: Real-time Java programming book, discussions in the Real-time Java Group.

Please, let me know if there is any VM missing in this list.

Why This Blog?

2009-06-29T13:38:00.000-07:00

The goal of this blog is to inform about the new technologies and trends in the domain of Real-time Java programming. Currently, there is no consistent source of information about RT Java, this blog will try to close this gap.

During the past few years, I have gathered some links, documents, experience and knowledge about Real-time Java. I would like to share them in this blog.

Anyone who would like to contribute and become a co-author is welcomed!