JIT in Java

When we write a program in any programming language it requires converting that code in the machine-understandable form because the machine only understands the binary language. According to the programming languages, compiler differs. The compiler is a program that converts the high-level language to machine level code. The Java programming language uses the compiler named javac. It converts the high-level language code into machine code (bytecode). JIT is a part of the JVM that optimizes the performance of the application. JIT stands for Java-In-Time Compiler. The JIT compilation is also known as dynamic compilation. In this section, we will learn what is JIT in Java, its working, and the phases of the JIT compiler.

What is JIT in Java?

JIT in Java is an integral part of the JVM. It accelerates execution performance many times over the previous level. In other words, it is a long-running, computer-intensive program that provides the best performance environment. It optimizes the performance of the Java application at compile or run time.

The JIT compilation includes two approaches AOT (Ahead-of-Time compilation) and interpretation to translate code into machine code. AOT compiler compiles the code into a native machine language (the same as the normal compiler). It transforms the bytecode of a VM into the machine code. The following optimizations are done by the JIT compilers:

• Method In-lining
• Local Optimizations
• Control Flow Optimizations
• Constant Folding
• Dead Code Elimination
• Global Optimizations
• Heuristics for optimizing call sites

Advantages of JIT Compiler

• It requires less memory usages.
• The code optimization is done at run time.
• It uses different levels of optimization.
• It reduces the page faults.

Disadvantages of JIT Compiler

• It increases the complexity of the program.
• The program with less line of code does not take the benefit of the JIT compilation.
• It uses lots of cache memory.

Working of JIT Compiler

If the JIT compiler environment variable is properly set, the JVM reads the .class file (bytecode) for interpretation after that it passes to the JIT compiler for further process. After getting the bytecode, the JIT compiler transforms it into the native code (machine-readable code).

• Java Development Kit (JDK) provides the Java compiler (javac) to compile the Java source code into the bytecode (.class file). After that, JVM loads the .class file at runtime and transform the bytecode into the binary code (machine code). Further, the machine code is used by the interpreter.
• We know that the interpretation of Java bytecode reduces the performance of the native application. It is the reason to implement the JIT compiler. The JIT compiler accelerates the performance of the application by compiling the bytecode into native machine code.
• It is enabled by default when a method is invoked. The JVM directly invokes the compiled code of the method without interpreting it. It does not require much memory usage.

Therefore, the JIT compiler boosts the performance of the native application. We can understand the working of the JIT compiler with the help of the following flow chart.

The following figure shows the functional relationship of the JIT compiler with JRE and JVM.

Optimization Levels

It is also known as the optimization level. Each level provides a certain level of performance. JIT compiler provides the following level of optimization:

• Cold: It used during the startup of the large Java application. The goal is to achieve the best-compiled code speed.
• Warm: After the starting of the Java application, most of the methods compiled when they reach the invocation threshold.
• Hot: The methods that consume more than 1% are scheduled for hot compilation.
• Very Hot: The method scheduled for a very hot if they are not scorching but hot.
• Scorching: The methods that consume more than 5% are scheduled for scorching compilation.

The default and initial optimization levels are warm. We get better performance if the optimization level is hotter but it increases the cost in terms of memory and CPU.

At the higher optimization level, the virtual machine uses a thread called sampling. It identifies the methods that take a long time to execute. The higher optimization level includes the following techniques:

• Escape Analysis
• Partial Redundancy Elimination

The above techniques use more memory and CPU to improve the performance of the Java application. It increases the cost of compilation but compensates for performance.