Keeping Your Java Hot by Solving the JVM Startup and Warmup Problem

Java bytecodes and class files deliver on the original vision of “write once, run anywhere”. Using a Just-in-Time (JIT) compiler allows JVM-based applications to compile frequently used code and optimise it precisely for its intended use. Using techniques like speculative optimisation can often deliver better performance than static, Ahead-of-Time (AOT) compiled code.

However, this flexibility and performance comes at a cost. Each time the JVM starts an application, it must perform the same analysis to find hot spots of code and compile them. This is referred to as the application warmup time.

In this session, we’ll look at several approaches to how this problem can be solved. Specifically:

• Static compilation of Java code ahead-of-time. Specifically, the Graal native image approach

• Generating a JIT compiler profile of a running, warmed-up application that can be reused when the same application is restarted, eliminating the need for much of the JIT compilation. This will include details of the work of the OpenJDK Project Leyden.

• Decoupling the JIT compiler from the JVM in the cloud. Providing a centralised JIT-as-a-Service allows caching of compiled code and offloading the compilation work when new code must be compiled.

• Creating a checkpoint of a running application. This includes all application state (heap, stack, etc.) in addition to the JIT-compiled code. Project CRaC will be used as an example.

At the end of the session, you’ll be all set to keep your Java hot!