The JIT compiler works by compiling Java bytecode to native machine code at runtime to improve performance. It monitors methods for call counts and compiles frequently called methods. We can help the JIT compiler by writing simple, well-structured methods without unnecessary complexity, inlining short methods, optimizing branch prediction, and keeping code clean. While the JIT provides optimizations, overly optimizing code can remove runtime data useful for debugging.

1. How JIT compiler
works
and how we can help it when writing our Java code

2. Let’s start...

3. The objective

4. Vilfredo Pareto
Engineer, sociologist, economist,
political scientist and
philosopher
80% of the land in Italy is owned
by about 20% of the population

5. Joseph M. Juran
Engineer and management consultant
Evangelist of quality
and quality management
Applied to quality issues:
80% of the problems
come from 20% of the source code

6. 80% of execution time
is spent in 20% of the source code

7. How it works

8. .java
.class
Compiler (JDK)
Interpreter (JVM/JRE)

9. .java
.class
Compiler (JDK)
Interpreter (JVM/JRE) JIT Compiler (JVM/JRE)
Native machine code
When?

10. 80% of execution time
is spent in 20% of the source code

12. For each method
JVM
Call count
+1
> JIT
compilation
threshold?
yes
Native
machine
code
Call count
+1
> JIT
recompilation
threshold?
Optimized
native
machine
code
yes

13. JVM
Code cache
Process space
Method Native machine code
Method Native machine code
Method Native machine code
Method Native machine code

14. How can we help it in that task?

15. Writing methods as simple as possible

16. Method
(bytecode) merge
Method
(bytecode)
Method
(bytecode)
Native
machine
code

17. private int makeComplexCalculation(...) {
...
for (...) {
...
counter += makeComplexCalculation(x, y);
...
}
}
private int makeVeryComplexCalculation(int x, int y) {
return x + y;
}
private int makeComplexCalculation(...) {
...
for (...) {
...
counter += (x + y);
...
}
}
Optimization: Inlining methods

18. Branches order

19. private int makeComplexCalculation(int x, int y) {
...
if (x >= y) {
...
} else {
...
}
...
}
private int makeComplexCalculation(int x, int y) {
...
if (x < y) {
...
} else {
...
}
...
}
Optimization: Branch prediction to reduce jumps

20. More optimizations:
• Local data flow analyses and optimizations
• Register usage optimization
• Simplifications of Java idioms™
• Code reordering, splitting, and removal
• Loop reduction and inversion
• Loop striding and loop-invariant code motion
• Loop unrolling and peeling
• Loop versioning and specialization
• Exception-directed optimization
• Switch analysis
• Global data flow analyses and optimizations
• Partial redundancy elimination
• Escape analysis
• GC and memory allocation optimizations
• Synchronization optimizations

21. Clean code!

22. Final thought

23. Is it always the magic solution?

24. … we can loose valuable run time data