4 Compilation Optimization

4.1 Compiler Considerations

Unlike Oracle JRockit, HotSpot features a Java byte code interpreter in addition to two different JIT compilers - client (aka C1) and server (aka C2)). HotSpot VM defaults to interpreting Java byte code, and will only JIT compile methods that runtime profiling determines to be "hot" - the methods that have been executed for a threshold number of times. Originally, users had to chose at startup which of the two JIT compilers, client or server, would be used. The client compiler compiles methods quickly, but emits machine code that is less optimized than the server compiler. By comparison, the server JIT compiler often takes more time (and memory) to compile the same methods, but generates better optimized machine code than the code produced by the client compiler. The result is that the client compiler allows most applications to start up faster (because of less compilation overhead), but the server compiler untimely provides better run-time performance once the application has reached stead-state (has warmed up). Used independently, each of these two compilers serve two different use-cases:

• client: quick startup and smaller memory footprint is more important than steady-state performance

• server: steady–state performance is more important than a quick startup

If having to chose a single JIT compiler, most Oracle JRockit users should chose the server compiler. As Oracle JRockit was designed as a server side JVM, most environments that use Oracle JRockit are server deployments like WLS or Coherence. The one notable exception would be cases where Oracle JRockit was used to run a smaller client application. For example, the client compiler would probably be a better fit for a command line administration tool like WLST.

Oracle JRockit JVM compiles a Java method and generates the machine code for it the very first time it is invoked. This compiled code of frequently invoked methods is then later optimized in the background by an Optimizer thread. This is completely different from the HotSpot JVM where methods are first interpreted and later compiled either by the Client (less optimizations) or the Server (more optimizations) compiler.

The client compiler can be invoked using -client JVM option and the server compile can be invoked using -server JVM option. The server compiler is selected by default on the server-class machines.

Tiered compilation, introduced in Java SE 7, brings client startup speeds to the server VM. A server VM uses the interpreter to collect profiling information about methods that is fed into the compiler. In the tiered scheme, in addition to the interpreter, the client compiler generates compiled versions of methods that collect profiling information about themselves. Since the compiled code is substantially faster than the interpreter, the program executes with greater performance during this profiling phase. In many cases, a startup that is even faster than with the client VM can be achieved because the final code produced by the server compiler may be already available during the early stages of application initialization. The tiered scheme can also achieve better peak performance than a regular server VM because the faster profiling phase allows a longer period of profiling, which may yield better optimization. Use the -XX:+TieredCompilation flag with the java command to enable tiered compilation.

In Java SE 8, Tiered compilation is the default mode for the server VM. Both 32 and 64 bit modes are supported. -XX:-TieredCompilation flag can be used to disable tiered compilation.