Features

The TurboJ technology was designed as a native Java compiler with full optimization capabilities that:

• transforms Java byte codes executed by the Java interpreter to native executable code;
• retains that executable code for subsequent usage;
• has no application start-up penalty;
• provides a performance superior to JIT compilers;
• allows multiple users to share the results from the compiler;
• allows the mix and match of both interpreted code and compiled code;
• performs sophisticated optimizations at the application level.

The TurboJ compiler can also be viewed as an 'install' compiler for Java applications. Many applications in the future will be distributed as Java bytecode by software vendors. However, users probably do not want to download several megabytes of code and wait for JIT compilation each time they want to run a spreadsheet. By using TurboJ, they can compile such an application when installing it, which generates native code that can be run each time is is needed (therefore using the byte code only as a platform independent distribution format).

In addition, the TurboJ compiler is an optimizing compiler that performs a number of optimizations that JIT compilers do not have time to do (since the user is waiting for immediate execution, the compiler must execute as fast as possible) whereas a few minutes of optimizations are worthwhile at installation time.

Architecture

The TurboJ implementation captures the Java byte codes for each class as it is requested by the Java run-time system. However, instead of loading them into memory for interpretation, the methods are translated into machine binary code, using C as an intermediate representation.

Where possible, the TurboJ generated code does its work in-line, but all of the facilities of the Java run-time system are required to run Turbo compiled programs. In other words, TurboJ comes as an adjunct to the existing native Java run-time system. TurboJ does not include its own memory allocation, nor a garbage collector or a thread package. It uses instead the native JDK (the Java runtime distributed by the platform vendor). The TurboJ technology currently operates as an adjunct to Sun's Java run-time as it uses internally the JNI interface defined by Javasoft. However, it is designed to operate in conjunction with other Java run-times.

One other advantage is that TurboJ supports mix and match of interpreted code and compiled code. Users can run in the same environment interpreted programs, compiled programs, or programs that include both compiled classes and interpreted classes.

Any Java application which can be run in the interpreter mode on a given system can also run in TurboJ mode. The TurboJ generated code still retains all of the run-time checks required to conform to the Java semantics (e.g. array bounds checking), in order to ensure that the safety model for Java is not violated. However, it looks for opportunities to remove redundant checks.

In order to be totally portable, the TurboJ compiler is written in Java (which also provides a stress test as our first test is to compile the compiler itself) and it generates ANSI-C source code. In addition to being a completely portable solution, the choice of generating C code instead of machine code allows us to take advantage directly of existing optimizers for multiple architectures. In particular, hardware platform vendors all provide C compilers that are specifically tuned to generate high performance code on their architecture (i.e. Arm, HP-PA, Intel, PowerPC, SPARC, etc.). As TurboJ produces C code that lends itself to C compiler optimization, we can leverage the architecture specific optimizations that would be difficult to reproduce for a large set of hardware architectures.

Upcoming

The new features that are planned for the next releases are:

• Provide an additional performance boost. In particular, with the Hot Set technology, take advantage of profiling results to optimize compilation of applications.
• Take advantage of recent results in compiler theory. In the last couple of years, there have been significant advances in compiler techniques developed in various Universities and Research Centers that we want to integrate into our compiler.
• Provide more options for generating smaller code size for embedded systems.

Press Releases

• TurboJ obtains an award at Java One 2000 as Best Embedded Java Product, June 2000
• Hewlett Packard introduces TurboChai for ChaiVM, March 2, 1999
"... An Ahead-of-Time Compiler That Boosts Java Application Performance Up to 20 Times Faster ..."
• WindRiver announces TurboJ for Personal JWorks, February 8, 1999
"... Improves performance of Java applications by more than 10 times ..."

Further Information

 For further information please contact Christian Fabre