Real-time Embedded Java HelloWorld with FijiVM

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


  1. This is pretty cool, but, is FijiVM available somewhere? I'm also working with RTSJ and embedded systems (or trying to), and it sounds like a perfect piece of software to me...

  2. The example demonstrated above does function nicely and prints the required output, but when I try to execute the following program

    import java.util.*;
    import java.io.*;

    public class SampleFijiTest{
    public static void main(String[] args){
    FileWriter fw = new FileWriter(new File("/home/ankitsablok89/Desktop/sample.txt"));
    BufferedWriter bwr = new BufferedWriter(fw);
    }catch(IOException e){

    it throws the following exception - java.lang.NoClassDefFoundError: When resolving reference to java/io/FileWriter: Class java/io/FileWriter was not supplied to the compiler