Excelsior JET is a toolkit and complete runtime environment for optimizing, deploying and running applications written in the Java(tm)programming language. The product package includes Excelsior JET Optimizer, Excelsior JET Runtime and Excelsior JET Installation Toolkit.
The JET Optimizer enables you to convert your application’s classes and jars into optimized x86 (IA-32) code on the developer’s system. As a result, you get high performance native executables for Microsoft Windows or Linux. The produced native code is highly resistant to reverse engineering and tampering.
The JET Runtime includes the Java SE API licensed from Sun Microsystems and provides all low-level Java routines which the optimized executables need to run such as garbage collection.
Excelsior JET Optimizer and Runtime are certified for compliance with the specification of the Java platform, Standard Edition (Java SE), versions 6 and 5.0.
If you want to distribute your application to a number of clients, you use the Installation Toolkit to prepare an installation package including your optimized Java application and the JET Runtime engine. Your clients simply install the package and start using your application. Additional software installation, such as the Java Runtime Environment (JRE), is not required on target systems.
The JET Optimizer transforms Java bytecode (.class/.jar files) into high performance native code on the developer’s system before program execution. The resulting optimized executables run directly on the hardware.
The Optimizer employs various optimization techniques commonly used in traditional C/C++ or FORTRAN compilers. To resolve Java performance challenges, the JET Optimizer is powered by state-of-the-art optimizations such as inlining virtual calls, safe removal of ubiquitous synchronization and allocating objects on the stack.
The Optimizer comes with the JET Control Panel, a graphical wizard that lets you quickly set up a project file and convert your application’s classes into the highly optimized executable (see Chapter JET Control Panel.)
The JET Runtime is a complete Java Virtual Machine (JVM). In particular, it includes a just-in-time (JIT) compiler to load and run Java class files. The key difference from other JVMs is that the JET Runtime can work with both Java classes and native executables produced by the JET Optimizer. For example, a JET-compiled application will be able to load Java plug-ins supplied in the form of jar files.
If your program uses plug-ins, loading them with the JIT compiler may take some time. To reduce the overhead, you may enable JIT caching in the JET Runtime. As a result, the native code produced by the JIT compiler will be retained in the JIT cache and reused on subsequent launches of the application. See Chapter Mixed Compilation Model for details.
To facilitate rapid creation of installation packages, Excelsior JET includes JetPackII, yet another graphical wizard. Using it, you prepare an installation package including your optimized Java application and the JET Runtime.
The deployment procedure is as simple as possible. You specify the JET-compiled application(s) and other files to be deployed, edit few settings, and the JetPackII generates a self-extracting installation executable, automatically including the JET runtime.
The installation executable is powered by the bundled Excelsior Installer that features both unattended and interactive installations.
In the interactive mode, the installer guides the users through the installation process allowing them to specify installation settings as usual. You can customize the installer to show end-user license agreement and to display installation interface in the English, German, French, Spanish, Polish, Russian or Japanese languages, depending on your choice or the system locale settings.
JetPackII can also prepare the resulting package in the form of self-contained directory that can be just copied to target systems. It contains the clickable application’s executable that requires neither extra environment settings, such as PATH, nor additional software installation, such as JRE. You can easily integrate such package into any setup generator or run the application off a USB flash drive without installation.
Please refer to Chapter Deployment automation for more details on the JetPackII and Excelsior Installer tools.
This release reinforces the IP protection capabilities of Excelsior JET: you may now enable encryption of executable data including reflection information and resource files.
The newly implemented Startup Optimizer helps you substantially reducing the cold start up time of your application.
The Installation Toolkit now supports creation of update packages that contain executables compiled for a different version of the JET Runtime thus removing the annoying limitation of the previous releases.
Other major improvements are usability enhancements of the Excelsior JET toolchain, faster JIT compilation, and better performance of the optimized Java applications.
In addition to code protection found in the previous versions of Excelsior JET, this new version supports encryption of data including:
Decryption is performed on demand at application run time so the implemented technique does not compromise the correctness of execution if the application heavily uses Java Reflection API and/or JNI.
This is a unique feature that cannot be found in Java bytecode obfuscators because Excelsior JET provides data protection at the JVM level.
In our tests, the impact on performance was minimal. For more details, see Chapter Intellectual property protection.
You have to do nothing special to enable the Startup Optimizer. Just run your application once on the page Test Run of the JET Control Panel and then build the executable as usual.
The underlying optimization relies on the reordering of code and data within the compiled executable. Compared to the Executable Image Optimizer available in the previous versions of Excelsior JET, the new Startup Optimizer has the following advantages:
With this optimization enabled, the cold start up time of your application can be reduced by a factor of 1.5 to 2. For more details, refer to Chapter Startup time optimization.
Now you may create an update package for existing installations after recompiling your application for a different version of the JET Runtime, which occurs if you:
In the previous releases, you had to create a new installation package in such circumstances.
Now, when you start creating an update or add an executable compiled for a different Runtime version to the update package, JetPackII displays a Runtime update dialog. With it, you can select an appropriate version of the Runtime to be included in the update package. For more details, see JET Runtime Updates.
The JET Optimizer now tracks changes in the project to avoid recompilation of the entire application if only auxiliary application files and/or project settings were modified. For more details, see Building the executable.
In future versions, we will enhance this basic implementation with support for partial recompilation of the project even if some application classes are changed.
Build time is reduced by about 15% without compromising the quality of optimizations.
Delivered by more efficient memory management, better register allocation and enhanced loop optimizations.
The average JIT compilation time for various scenarios is reduced by 15-20%.
Java SE 6 Update 7 (default) and J2SE 5.0 Update 15 are supported.
Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product.