1) The document discusses several Java performance myths and uses microbenchmarks to analyze them. It finds that final variables and String concatenation are not necessarily faster than alternatives. 2) It recommends using the Caliper framework for robust microbenchmarking and provides several useful JVM flags for profiling and optimization. 3) The document outlines various Java optimization strategies used by the JVM compiler including inlining, intrinsics, escape analysis, and loop unrolling. It emphasizes the importance of clear and readable code over premature optimization.

1. Java Performance
MythBuster
@szarnekow
(c) itemis

2. Micro-Benchmarking
✦ Fictional Test of a Small Code-Snippet
✦ Compare Functionally Equivalent
Implementations
✦ Seek for Arguments in the “Java is Slow”
Battle

3. Disclaimer

4. Disclaimer

5. More Disclaimer
Don’t do this at home.
(even though it’s fun)

6. #1: Final Variables Are
Faster
int computeSmth(final int a) {
final int result = a * a * a;
return result;
}

7. In C++, everytime someone
writes ">> 3" instead of "/ 8",
I bet the compiler is like,
"OH DAMN! I would have
never thought of that!"
(@jonshiring)

8. #2: String + String
is Slow!
"a" + "b"
vs.
new StringBuilder("a")
.append("b")
.toString();

9. public class Sample {
static String s = "a" + "b";
}
$javap -c Sample

10. public class Sample {
static String s = "a" + "b";
}
$javap -c Sample
Compiled from "Sample.java"
public class Sample extends java.lang.Object{
static java.lang.String s;
static {};
Code:
0:! dc! #10; //String ab
l
2:! utstatic! #12; //Field s:Ljava/lang/String;
p
5:! eturn
r
...

11. static String b = "b";
static String s = "a" + b;

12. static String b = "b";
static String s = "a" + b;
5:!
! new! #14; //class StringBuilder
8:!
! dup
9:!
! ldc! #16; //String a
11:! invokespecial! #18; //StringBuilder."<init>"
14:! getstatic! #12; //Field b
17:! invokevirtual! #22; //StringBuilder.append
20:! invokevirtual! #26; //StringBuilder.toString

13. #3: {Objects,
Exceptions, Things} Are
Too Slow!

14. Caliper
Micro-Benchmarking done right.

15. Caliper
Micro-Benchmarking done right.
✦ Warm-Up, Trails, Params

16. Caliper
Micro-Benchmarking done right.
✦ Warm-Up, Trails, Params
✦ Forked JVM per Trial

17. Caliper
Micro-Benchmarking done right.
✦ Warm-Up, Trails, Params
✦ Forked JVM per Trial
✦ Pretty Results

18. Caliper
Micro-Benchmarking done right.
✦ Warm-Up, Trails, Params
✦ Forked JVM per Trial
✦ Pretty Results
✦ Avoid “Heisenbenchmark”

19. List as Queue

20. List as Queue

21. The Art of Adding Numbers
int sum() {
int result = 0;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
result = result + j;
}
}
return result;
}

22. The Art of Adding Numbers
✦ Plain Imperative: Nested Loops
✦ Extracted Methods (addAll, add)
✦ Parameter Objects (AddParam, AddResult)
✦ Strategies (addAll(strategy)
✦ Fields (this.result = this.a + this.b)
✦ Control Flow By Exception (throw result)

23. Show Me The Numbers
(a = 25000 / b = 25000)

24. Show Me The Numbers
(a = 25000 / b = 25000)

25. Show Me The Numbers
(a = 25000 / b = 25000)

26. Show Me The Numbers
(a = 25000 / b = 25000)

27. Diagnose
Some Useful VM Args
$java -server -Xmx...
-XX:+UnlockDiagnosticVMOptions
-XX:+PrintCompilation
-XX:+PrintInlining
ObjectOrientedAdder 25000 25000

28. More VM Args
-XX:CompileCommand
$java -server -Xmx...
-XX:+UnlockDiagnosticVMOptions
-XX:+PrintCompilation
-XX:+PrintInlining
'-XX:CompileCommand=print,*ObjectOrientedAdder.sum*'
ObjectOrientedAdder 25000 25000

30. -XX:+PrintInlining
ObjectOrientedAdder::sum (27 bytes)
@ 9 ObjectOrientedAdder::addAll (39 bytes) inline (hot)
@ 13 AddParam::<init> (15 bytes) inline (hot)
@ 1 java.lang.Object::<init> (1 bytes) inline (hot)
@ 19 ObjectOrientedAdder::add (17 bytes) inline (hot)
@ 5 AddParam::getA (5 bytes) inline (hot)
@ 9 AddParam::getB (5 bytes) inline (hot)
@ 13 AddResult::<init> (10 bytes) inline (hot)
@ 1 java.lang.Object::<init> (1 byte) inline(hot)
@ 22 AddResult::getResult (5 bytes) inline (hot)

31. Optimization Strategies
✦ Inlining

32. Optimization Strategies
✦ Inlining
✦ Intrinsics

33. Optimization Strategies
✦ Inlining
✦ Intrinsics
✦ Escape Analysis

34. Optimization Strategies
✦ Inlining
✦ Intrinsics
✦ Escape Analysis
✦ Loop Unrolling

35. Optimization Strategies
✦ Inlining
✦ Intrinsics
✦ Escape Analysis
✦ Loop Unrolling
✦ Lock Fusion and Lock Elision

36. Optimization Strategies
✦ Inlining
✦ Intrinsics
✦ Escape Analysis
✦ Loop Unrolling
✦ Lock Fusion and Lock Elision
✦ Many More ...

37. ... As of Oct 2009
compiler tactics flow-sensitive rewrites global code shaping
delayed compilation conditional constant propagation inlining (graph integration)
tiered compilation dominating test detection global code motion
on-stack replacement flow-carried type narrowing heat-based code layout
delayed reoptimization dead code elimination switch balancing
program dependence graph representation throw inlining
static single assignment representation language-specific techniques
class hierarchy analysis control flow graph transformation
speculative (profile-based) techniques devirtualization local code scheduling
optimistic nullness assertions symbolic constant propagation local code bundling
optimistic type assertions autobox elimination delay slot filling
optimistic type strengthening escape analysis graph-coloring register allocation
optimistic array length strengthening lock elision linear scan register allocation
untaken branch pruning lock fusion live range splitting
optimistic N-morphic inlining de-reflection copy coalescing
branch frequency prediction constant splitting
call frequency prediction memory and placement transformation copy removal
expression hoisting address mode matching
proof-based techniques expression sinking instruction peepholing
exact type inference redundant store elimination DFA-based code generator
memory value inference adjacent store fusion
memory value tracking card-mark elimination
constant folding merge-point splitting
reassociation
operator strength reduction loop transformations
null check elimination loop unrolling
type test strength reduction loop peeling
type test elimination safepoint elimination
algebraic simplification iteration range splitting
common subexpression elimination range check elimination
integer range typing loop vectorization

38. Should I ...
Always Use Objects, then?

39. Should I ...
Always Use Objects, then?

40. Other Things ...

41. Some Advice
✦ [..] Write Readable and Clear Code. [..]
(David Keenan)
✦ [..] slavishly follow a principle of simple, clear
coding that avoids clever optimizations [..]
(Caliper FAQ)
✦ Performance advice has a short shelf-life
(B. Goetz)

42. Credits: I’m thankful to Arno Haase, who allowed to
highjack the title of his great session at
JAX 2012 which inspired me for this talk.