Understanding Java Compilers and JVM Optimization Techniques

As the second part of a JVM performance‑optimization series, this article introduces Java compilers, explains how the Just‑In‑Time (JIT) compiler works, and discusses typical optimization techniques used by the JVM.

What is a compiler? A compiler translates source code into another executable form. In Java, javac compiles source files into bytecode stored in .class files, which the JVM later translates into native machine instructions.

The JVM contains a component that turns bytecode into platform‑specific code, often through multiple intermediate representations. This final translation is platform‑dependent and may be performed by static or dynamic compilers.

Bytecode and the JVM For more details see “Bytecode basics” by Bill Venners (JavaWorld).

Static vs. Dynamic Compilers The static compiler javac produces bytecode that does not change until the source is recompiled. Dynamic compilers (JIT) compile bytecode to native code at runtime, using profiling data to apply optimizations.

Example of a simple method compiled by javac: static int add7(int x) { return x + 7; } Resulting bytecode (simplified):

iload_0

bipush 7

iadd

ireturn

When the method becomes hot, the JIT may replace it with optimized native code such as:

lea rax, [rdx+7]

ret

Client, Server, and Tiered Compilers The client compiler (C1) is lightweight, starts quickly, and performs modest optimizations. The server compiler (C2) runs longer, gathers more profiling data, and applies aggressive optimizations, at the cost of higher resource usage. Tiered compilation combines both: C1 runs early to improve startup time, while C2 later refines hot code.

Tip: Warm‑up the server compiler Give the server compiler time to collect profiling data before expecting major optimizations.

Common Optimization Techniques

Dead‑code elimination : Removes code that is never executed, reducing instruction count and CPU cycles.

Inlining : Replaces small, frequently called methods with their bodies to avoid costly jumps. Example listings show a caller, callee, and the inlined result.

Loop optimizations : Includes loop merging, loop reversal, loop blocking, and loop unrolling to reduce branch overhead and improve cache usage.

These optimizations are applied at the bytecode or native‑code level, often guided by performance counters that track hot spots.

Summary

Interpretation is the simplest form of execution, directly mapping bytecode to native instructions.

JIT compilers use profiling data to apply optimizations, consuming additional resources such as code cache and compilation threads.

Client compilation can improve performance by 5‑10× compared with pure interpretation.

Server compilation adds another 30‑50% performance boost at higher resource cost.

Tiered compilation offers fast startup (client) and high‑throughput optimizations (server) in one runtime.

Understanding these concepts helps developers make informed decisions about JVM tuning and code design.