JVM’s JIT Optimization Techniques Promise to optimize the Code Performance Efficiently

An Overview of Java Platform

“Write Once, Run Anywhere”, is the concept of applications which are written in Java programming language. Before concentrating more about the JIT techniques, let us know few facts about Java. Java code can be run on a computing machine only through JVM, which, stands for Java Virtual Machine. Before being fed into these JVMs, the Java applications will be compiled into byte codes through javac. Note: Byte code is an instruction set of JVM. A question may arise that why the Java code is being compiled into some intermediate code? Also, why is it not possible to directly proceed through machine code?

Nature of Java Code Execution

One of the main agenda of Java is portability, so in order to attain that, an intermediate form is used. In byte code all the operational codes come under a single byte. Even though the machine code has same instructions as that of Java byte code, the former cannot run on virtual machines that are written to support the host system.

In the earlier JVM environment, the code execution used to be very slow. Each opcode were directly interpreted for execution, which was literally time-consuming. To counter this, Hotspot was introduced, which, through just-in-time compilation enabled the execution of code directly instead of interpreting them. One can achieve high-speed code execution through JIT. Code optimization in every phase is necessary to avoid application overhead. Following are few JIT optimization techniques that allows for code optimization.

• Null Check Elimination– Before speaking about its elimination; let us know why null is used? Whenever there is a need for object creation, an object reference is to be formed on prior. These object references cannot exist without any value, hence null value is assigned to it. Nulls and Null-pointer exception can cause a disruption in the whole code structure, hence should be avoided. Through a mechanism which is known as “uncommon trap”, the JIT effectively eliminates the null checks, thus optimizing the performance.
• Branch Prediction– This technique is all about reducing the number of Assembly jumps. If two operands are being compared under multiple conditions, then JIT will look through the conditions and compare their significance. If there are two different conditions, say A and B, and if condition A holds greater importance, then the condition B can be reordered. This approach instantly reduces the number of assembly jumps.
• Loop Unrolling– A compiler optimization technique, loop unrolling again deals with reducing the number of assemble jumps. Through reducing the number of instructions, the code size can be drastically reduced, this in turn minimizes the overhead time.
• Inlining Methods– Every approach here is being directed in eliminating the assembly jumps. This technique somewhat deals with a refactoring approach. Here two of the JVM arguments are used to achieve this,-XX:MaxInlineSize– Here the default value of bytecode for a method is ~35 bytes, Note: this is applicable even if the frequency of execution is very less.-XX:FreqInlineSize– Here if the execution is frequent, then the maximum size of the bytecode is decided based on the platform used.
• Thread Fields and Thread Local Storage– The main objective of this action is to enable faster access to data through using registers.

The main point to be noted is all the above JIT techniques are aimed at optimizing the performance through faster code execution.