This document summarizes a talk on what happens when Java code is executed, from compilation to bytecode to machine code. It discusses how the Java compiler converts code to bytecode and how the JIT compiler further converts it to machine code. It also demonstrates how optimizations like inlining can improve performance and how data structures like linked lists perform poorly due to cache misses. The document emphasizes that modern computing involves many layers of abstraction and technology below the surface.

1. Oracle Code One, October 2018
Dmitry Vyazelenko @DVyazelenko
Maurice Naftalin @mauricenaftalin
What Lies Beneath

2. Maurice Naftalin
Java 5 Java 8
2013 2014 20152017

3. Dmitry Vyazelenko
• Disorganiser-in-chief of the unconferences
JCrete and JAlba
• Actually understands today’s topic

4. What Lies Beneath
• What, another ”Hello World” talk?
• Yes! It’s about what happens when we type
• It’s amazingly complicated
— and interesting!
java Hello.java

5. Everybody Knows…
javac
jit
Bytecode
Java
Machine code

6. Java to Bytecode
private int add(int value) {
return value + 254;
}
public int compute(int value) {
return add(value / 0xdeadbeef);
}
public static void main(String[] args) {
System.out.println(new Computer().compute(0xcafebabe));
}
Result: 0xff

7. private int add(int value) {
return value + 254;
}
public int compute(int value) {
return add(value / 0xdeadbeef);
}
public static void main(String[] args) {
System.out.println(new Computer().compute(0xcafebabe));
}
Java to Bytecode
public int compute(int);
Code:
0: aload_0
1: iload_1
2: ldc #2 // int 0xdeadbeef
4: idiv
5: invokespecial #3 // Method add:(I)I
8: ireturn
javac

8. interpreter1.
2.
Everybody Knows…
javac
jit
Bytecode
Java
Machine code

9. Java to Bytecode
private int add250(int value) {
return value + 250; // FF: 250 + 5
}
public int caffeinate(int value) {
return 0xCAFEBABE * add3(value);
}
public static void main(String[] args) {
WhatLiesBeneath wlb = new WhatLiesBeneath();
System.out.println(new Adder().doubleAdd3(5));
}
public int compute(int);
Code:
0: aload_0
1: iload_1
2: ldc #2 // int 0xdeadbeef
4: idiv
5: invokespecial #3 // Method add:(I)I
8: ireturn
javac

10. public int compute(int);
Code:
0: aload_0
1: iload_1
2: ldc #2 // int 0xdeadbeef
4: idiv
5: invokespecial #3 // Method add:(I)I
8: ireturn
Bytecode to (Templated) Assembler
idiv 108 idiv [0x00007f8f8f72ecc0, 0x00007f8f8f72ed00] 64 bytes
0x00007f8f8f72ecc0: mov (%rsp),%eax
0x00007f8f8f72ecc3: add $0x8,%rsp
0x00007f8f8f72ecc7: mov %eax,%ecx
0x00007f8f8f72ecc9: mov (%rsp),%eax
0x00007f8f8f72eccc: add $0x8,%rsp
0x00007f8f8f72ecd0: cmp $0x80000000,%eax
0x00007f8f8f72ecd6: jne 0x00007f8f8f72ece7
0x00007f8f8f72ecdc: xor %edx,%edx
0x00007f8f8f72ecde: cmp $0xffffffff,%ecx
0x00007f8f8f72ece1: je 0x00007f8f8f72ecea
0x00007f8f8f72ece7: cltd
0x00007f8f8f72ece8: idiv %ecx
0x00007f8f8f72ecea: movzbl 0x1(%r13),%ebx
0x00007f8f8f72ecef: inc %r13
0x00007f8f8f72ecf2: movabs $0x7f8fadbe4d80,%r10
0x00007f8f8f72ecfc: jmpq *(%r10,%rbx,8)

11. Let’s Benchmark!
@Fork(3)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
public class ComputerBenchmark {
private Computer computer = new Computer();
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
@Benchmark
public int compute() {
return computer.compute(0xcafebabe);
}
}

12. JMH tells us...
REMEMBER: The numbers below are just data. To gain reusable insights, you need to
follow up on why the numbers are the way they are...
Do not assume the numbers tell you what you want them to tell.
Benchmark Mode Cnt Score Error Units
ComputerBenchmark.compute avgt 15 423.276 ± 22.782 ns/op

13. Improving Our Program…
private int add(int value) {
return value + 254;
}
public int compute(int value) {
return add(value / 0xdeadbeef);
}
public static void main(String[] args) {
System.out.println(new Computer().compute(0xcafebabe));
}

14. private int add(int value) {
return value + 254;
}
public int compute(int value) {
return (value / 0xdeadbeef) + 254;
}
public static void main(String[] args) {
System.out.println(new Computer().compute(0xcafebabe));
}
Improving Our Program…

15. 2.
interpreter1.
Everybody Knows…
javac
jit
Bytecode
Java
Machine code

16. Without Inlining (-XX:-Inline)
ComputerBenchmark::compute
...
mov $0xcafebabe,%edx
callq 0x00007f0568fb3c60 ;*invokevirtual Computer.compute
...
Computer::compute
...
imul $0x7aeca299,%r10,%r10
sar $0x3c,%r10
mov %r10d,%r10d
sub %r10d,%edx ;*idiv
callq 0x00007f0568fb40e0 ;*invokevirtual Computer.add
...
Computer::add
...
add $0xfe,%edx
...

17. With Inlining
ComputerBenchmark::compute
...
mov $0xff,%eax
...

18. Now JMH tells us…
REMEMBER: The numbers below are just data. To gain reusable insights, you need to
follow up on why the numbers are the way they are...
Do not assume the numbers tell you what you want them to tell.
Benchmark Mode Cnt Score Error Units
ComputerBenchmark.compute (interpreted) avgt 15 423.276 ± 22.782 ns/op
ComputerBenchmark.compute (no inlining) avgt 15 11.831 ± 0.002 ns/op
ComputerBenchmark.compute (w/ inlining) avgt 15 6.307 ± 0.006 ns/op

19. Hotspot Optimisations

20. Everybody Knows…
javac
jit
Bytecode
Java
Machine code
os/hardware

21. Computers Are Simple!

22. A Pile of Cache…
Intel Core i7-3770K Ivy Bridge Processor

23. The Memory Hierarchy

24. Measuring Cache-Friendliness
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(1024)
public void linkedList() {
if (iterator == null || !iterator.hasNext()) {
iterator = linkedList.iterator();
}
for (int i = 0; i < 1024 && iterator.hasNext(); i++) {
sink(iterator.next());
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(1024)
public void primitiveArray() {
if (index == intArray.length) {
index = 0;
}
for (int i = 0; i < 1024 && index < intArray.length; i++) {
sink(intArray[index++]);
}
}

25. list length (K) 1 7 63 511
performance (ns/op) 7.25 9.03 20.87 29.07
CPI (clockticks/instrn) 0.32 0.41 0.93 1.33
events/operation
cycles 17.97 22.77 51.32 72.66
instructions 56.08 55.88 54.96 54.49
L1-dcache-load-misses 1.18 1.83 1.87 2.65
L1-dcache-loads 18.94 19.39 18.88 18.22
L1-dcache-stores 12.00 12.18 11.99 11.15
LLC-load-misses 0 0 0.41 1.31
LLC-loads 0 0.72 1.33 1.56
LinkedList

26. Primitive Array
list length (K) 1 7 63 511
performance (ns/op) 3.62 3.65 3.65 3.66
CPI 0.30 0.30 0.30 0.31
events/operation
cycles 9.09 9.16 9.10 9.13
instructions 30.24 30.13 29.94 29.85
L1-dcache-load-misses 0.00 0.01 0.06 0.06
L1-dcache-loads 12.00 12.00 11.97 12.14
L1-dcache-stores 6.00 6.02 6.02 6.04
LLC-load-misses 0.00 0.00 0.00 0.00
LLC-loads 0.00 0.00 0.00 0.00

27. Poor Unloved LinkedList…

28. Conclusions
From javac soup to hardware nuts, there’s a lot of advanced
technology here.
And as everyone knows, to the ignorant –
“Any sufficiently advanced
technology is indistinguishable
from magic.”
Don’t believe in magic!

29. Digging Deeper…
• https://groups.google.com/forum/#!forum/mechanical-sympathy
• http://openjdk.java.net/projects/code-tools/jmh/
• https://github.com/AdoptOpenJDK/jitwatch
• https://github.com/AdoptOpenJDK/jitwatch/wiki/Building-hsdis