Introduction to JVM JIT Optimizations

Diego Parra | @dpsoft | Core Team @ Kamon

Agenda

What is JIT?
Tiered Compilation
Optimizations
Conclusion

JIT

Just-In-Time compilation

Compilation work happens during application execution

JIT'ing requires Profiling for more efficient optimization
- Because you don't want JIT everything
- Aggressively optimize based on profile information
- Tiered compilation
- Runtime Overhead?

JIT Lifecycle

JIT Compilers

C1 Client

C2 Server

Fast compiler
Invocation count > 1500
Produces Compilations quickly
Generated code runs Slow

Profile is about counters: https://github.com/dmlloyd/openjdk/blob/jdk8u/jdk8u/hotspot/src/share/vm/oops/methodCounters.hpp

Smart compiler
Invocation count > 10000
Produces Compilations slowly
Generated code runs Fast

Profiled Guided

Speculative

10x faster than Interpreter

2x faster than C1

Tiered Compilation

Available in Java 7
Default in Java 8
Client Startup
Server Performance

Best of Both Worlds - C1 + C2

Tiered : https://github.com/dmlloyd/openjdk/blob/jdk8u/jdk8u/hotspot/src/share/vm/runtime/advancedThresholdPolicy.hpp#L35-L158

Common Transitions

Common Transitions Patterns : https://www.slideshare.net/maddocig/tiered

Notes: https://github.com/dmlloyd/openjdk/blob/jdk8u/jdk8u/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp

JIT Optimizations

Compiler tactics

delayed compilation
tiered compilation
on-stack replacement
delayed reoptimization
program dependence graph representation
static single assignment representation

Speculative (profile-based)

optimistic nullness assertions
optimistic type assertions
optimistic type strengthening
optimistic array length strengthening
untaken branch pruning
optimistic N-morphic inlining
branch frequency prediction
call frequency prediction

Proof-based techniques

exact type inference
memory value inference
memory value tracking
constant folding
reassociation
operator strength reduction
null check elimination
type test strength reduction
type test elimination
algebraic simplification
common subexpression elimination
integer range typing

Flow-sensitive rewrites

conditional constant propagation
dominating test detection
flow-carried type narrowing
dead code elimination

Text

and much more..

Null check Elimination

In equivalent machine code

Null check Elimination

Into the rabbit hole

-XX:+PrintCompilation

Compilation Level

Deoptimizations

Null check Elimination

Into the rabbit hole

-XX:+UnlockDiagnosticVMOptions
-XX:+PrintAssembly
-XX:CompileCommand=print,NullCheck::isPowerOfTwo

Someone said Assembly?

Null check Elimination

Into the rabbit hole

implicit exception: dispatches to 0x00007fdff5318274

Null check Elimination

JVM uses SIGSEGV as control flow

Into the rabbit hole

Handle Signals: https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/signals001.html#CIHBBDED

Speculative Optimization

Faster IF not null are encountered (Uncommon Trap)

Implicit Null Check?

Field and Array access is null checked

Method Inlining

-XX:+PrintInlining

Method Inlining

Inlining is the most important optimization
Combine caller and callee into one unit
Expands the scope for other optimizations
Bytecode size < 35 bytes
Bytecode size < 325 bytes for inlining hot methods

What about virtual call inlining?

Black Magic: https://shipilev.net/blog/2015/black-magic-method-dispatch/

Monomorphic

Bimorphic

Megamorphic

Class Hierarchy Analysis
Devirtualization

On-Stack Replacement

-XX:+PrintCompilation

-XX:+PrintInlining

Compilation is OSR

Dead Code Elimination

Dead-Code: http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_08_DeadCode.java

Result is not used and the entire method is optimized away!

Escape Analysis

No synchronization lock when calling getNoEscapeSum method
No allocate a Sum object at all, just keep track of the individual fields of the object