inside the jvm - follow the white rabbit!
Post on 21-Jan-2018
928 Views
Preview:
TRANSCRIPT
Inside the JVMFollow the white rabbit!
Sylvain Wallez - @bluxteToulouse JUG - 2017-04-26
Who’s this guy?
Software engineer at Elastic (cloud team)
Previously:
● IoT tech lead at OVH● CEO at Actoboard● Backend architect at Sigfox● CTO at Goojet/Scoop it● Lead architect at Joost● Member of the Apache Software Foundation● Cofounder & CTO at Anyware Technologies (now part of Sierra Wireless)
Agenda● How it started: let’s optimize 6 lines of (hot) code!● Profiling memory usage● What’s in a class file?● Micro-benchmarking with JMH● Exploration of the OpenJDK source code
How it startedLet’s optimize 6 lines of (hot) code
On the CouchBase blog...“JVM Profiling - Lessons from the trenches”: optimize the conversion of a protocol error code into a readable message.
...
private final short code;
private final String description;
KeyValueStatus(short code, String description) {
this.code = code;
this.description = description;
}
public static KeyValueStatus valueOf(final short code) {
for (KeyValueStatus value: values()) {
if (value.code() == code) return value;
}
return UNKNOWN;
}
public enum KeyValueStatus {
UNKNOWN((short) -1, "Unknown code"),
SUCCESS((short) 0x00,
"The operation completed successfully"),
ERR_NOT_FOUND((short) 0x01,
"The key does not exists"),
ERR_EXISTS((short) 0x02,
"The key exists in the cluster"),
ERR_TOO_BIG((short) 0x03,
"The document exceeds the maximum size"),
ERR_INVALID((short) 0x04,
"Invalid request"),
ERR_NOT_STORED((short) 0x05,
"The document was not stored"),
...
On the CouchBase blog...Finding: values() is allocating memory
public static KeyValueStatus valueOf(final short code) {
for (KeyValueStatus value: values()) {
if (value.code() == code) return value;
}
return UNKNOWN;
}
public static KeyValueStatus valueOf(final short code) {
if (code == SUCCESS.code) {
return SUCCESS;
} else if (code == ERR_NOT_FOUND.code) {
return ERR_NOT_FOUND;
} else if (code == ERR_EXISTS.code) {
return ERR_EXISTS;
} else if (code == ERR_NOT_MY_VBUCKET.code) {
return ERR_NOT_MY_VBUCKET;
}
for (KeyValueStatus value : values()) {
if (value.code() == code) {
return value;
}
}
return UNKNOWN;
}
Optimization: fast path on common values
If something goes wrong, it’ll make it worse!
Oh well,nobody cares...
blog post
Profiling memory usage
Various kinds of memory optimization● Memory usage / memory leaks
○ My application needs tons of heap○ How many objects are held active?
→ Memory profiler / jmap
● Garbage collection pressure○ My application spends a lot of time in the GC○ How often are objects allocated?
→ Java Mission Control / jmap
jmap histogramsjmap -histo num #instances #bytes class name
----------------------------------------------
1: 4217124 674740720 [Lnet.bluxte.experiments.couchbase_keyvalue.KeyValueStatus;
2: 486 14947912 [I
3: 5855 493864 [C
4: 1461 166752 java.lang.Class
5: 5848 140352 java.lang.String
6: 503 136440 [B
7: 968 62480 [Ljava.lang.Object;
8: 1255 40160 java.util.HashMap$Node
9: 991 39640 java.util.LinkedHashMap$Entry
10: 258 30720 [Ljava.util.HashMap$Node;
11: 259 22792 java.lang.reflect.Method
12: 441 20952 [Ljava.lang.String;
13: 229 16488 java.lang.reflect.Field
14: 171 9576 java.util.LinkedHashMap
15: 291 9312 java.util.concurrent.ConcurrentHashMap$Node
16: 160 7680 java.util.HashMap
17: 178 7120 java.lang.ref.SoftReference
18: 89 7120 java.net.URI
19: 102 6528 java.net.URL
20: 256 6144 java.lang.Long
21: 76 6080 java.lang.reflect.Constructor
22: 258 5896 [Ljava.lang.Class;
23: 265 5680 [S
24: 166 5312 java.util.Hashtable$Entry
25: 94 5264 java.lang.Class$ReflectionData
code available on GitHub
jmap histogramsjmap -histo:live – perform a full GC first num #instances #bytes class name
----------------------------------------------
1: 5855 493864 [C
2: 1461 166752 java.lang.Class
3: 5848 140352 java.lang.String
4: 503 136440 [B
5: 967 62456 [Ljava.lang.Object;
6: 1255 40160 java.util.HashMap$Node
7: 991 39640 java.util.LinkedHashMap$Entry
8: 258 30720 [Ljava.util.HashMap$Node;
9: 259 22792 java.lang.reflect.Method
10: 441 20952 [Ljava.lang.String;
11: 283 19272 [I
12: 229 16488 java.lang.reflect.Field
....................
51: 35 1400 javax.management.MBeanOperationInfo
52: 3 1360 [Lnet.bluxte.experiments.couchbase_keyvalue.KeyValueStatus;
53: 55 1320 java.io.ExpiringCache$Entry
54: 29 1304 [Ljava.lang.reflect.Field;
55: 36 1152 net.bluxte.experiments.couchbase_keyvalue.KeyValueStatus
56: 27 1080 java.security.ProtectionDomain
Java Mission Control / Java Flight RecorderLightweight monitoring agent
● Integrated into the (Oracle) JVM● Very low overhead
Continuously samples diagnostics data
● Thread activity● GC activity● Memory allocations
Java Mission Control / Java Flight RecorderAvailable only with Oracle JDK
● Free for development● Commercial for use in production
How to enable it?
● at launch time: java -XX:+UnlockCommercialFeatures● after launch: jcmd <pid> VM.unlock_commercial_features
Original codeSimple loop on the enum values
public static KeyValueStatus valueOf(final short code) { for (KeyValueStatus value: values()) { if (value.code() == code) return value; } return UNKNOWN;}
Original code - Memory stats
Looks good! No leak!
Hmm… growing fast!
Original code - Allocations
Original code - GC activity
Iteration on constant arrayStill trivial, but reuse the values array
private static final KeyValueStatus[] VALUES = values();
public static KeyValueStatus valueOf(final short code) { for (KeyValueStatus value: VALUES) { if (value.code() == code) return value; } return UNKNOWN;}
Constant array - Allocations
Constant array - GC activity
GC pressure collateral damages
Full GC clears weak references→ clears some caches→ additional load to repopulate them!
Enum.values() ?Exploring the bytecode
Enum.values() – a generated method
The compiler automatically adds some special methods when it creates an enum. For example, they have a static values method that returns an array containing all of the values of the enum in the order they are declared.
– The Java Tutorial
/** * Returns an array containing the constants of this enum * type, in the order they're declared. This method may be * used to iterate over the constants as follows: * * for(E c : E.values()) * System.out.println(c); * * @return an array containing the constants of this enum * type, in the order they're declared */public static E[] values();
– The Java Language Specification
Show me the (byte)code!public class SimpleMain { public static void main(String[] args) { System.out.println("Hello world!"); }}
public class net.bluxte.experiments.talk.SimpleMain { public net.bluxte.experiments.talk.SimpleMain(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return
public static void main(java.lang.String[]); Code: 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3 // String Hello world! 5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return}
Default constructor
javap -c SimpleMain.class
or IntelliJ’s bytecode plugin
Show me the (byte)code!
public class SimpleMain { static String hello = "Hello"; static String world = "world";
public static void main( String[] args ) { System.out.println( hello + " " + world ); }}
public class net.bluxte.experiments.talk.SimpleMain { static java.lang.String hello;
static java.lang.String world;
public net.bluxte.experiments.talk.SimpleMain(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return
public static void main(java.lang.String[]); Code: 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: new #3 // class java/lang/StringBuilder 6: dup 7: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V 10: getstatic #5 // Field hello:Ljava/lang/String; 13: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 16: ldc #7 // String “ “ 18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 21: getstatic #8 // Field world:Ljava/lang/String; 24: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 27: invokevirtual #9 // Method java/lang/StringBuilder.toString:()Ljava/lang/String; 30: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 33: return
static {}; Code: 0: ldc #11 // String Hello 2: putstatic #5 // Field hello:Ljava/lang/String; 5: ldc #12 // String world 7: putstatic #8 // Field world:Ljava/lang/String; 10: return}
String concat with StringBuilder
Static initializer
Show me the (byte)code!public enum SimpleEnum { FIRST_ENUM, SECOND_ENUM}
... public static net.bluxte.experiments.talk.SimpleEnum[] values(); Code: 0: getstatic #1 // Field $VALUES:[Lnet/bluxte/experiments/talk/SimpleEnum; 3: invokevirtual #2 // Method "[Lnet/bluxte/experiments/talk/SimpleEnum;".clone:()Ljava/lang/Object; 6: checkcast #3 // class "[Lnet/bluxte/experiments/talk/SimpleEnum;" 9: areturn
public static net.bluxte.experiments.talk.SimpleEnum valueOf(java.lang.String); Code: 0: ldc #4 // class net/bluxte/experiments/talk/SimpleEnum 2: aload_0 3: invokestatic #5 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; 6: checkcast #4 // class net/bluxte/experiments/talk/SimpleEnum 9: areturn...
Aha! We found the culprit!
But why the clone?Java arrays are mutable
The caller can mess with it, which would break other users→ Perform a defensive copy every time
How to could it be prevented?
Return an immutable List, but probably too high level here
More on the bytecodeA class file is composed of:
● constant pool: strings, fields/methods name+type, class names, etc.● fields and methods definitions and code
○ Access flags and attributes○ Code○ Line number table○ Local variable table (type and name)○ Exception table
But wait…...why would I want to know about this?
● Better understand low level diagnostics● Check generated code
○ Java: enum values (!), for loops, etc○ Scala, Kotlin: implementation of higher level constructs○ Hibernate & co: how do they mangle your code?
● Grasping low level stuff allows writing better high-level code
#1 = Methodref #6.#20 // java/lang/Object."<init>":()V #2 = Fieldref #21.#22 // java/lang/System.out:Ljava/io/PrintStream; #3 = String #23 // Hello world #4 = Methodref #24.#25 // java/io/PrintStream.println:(Ljava/lang/String;)V #5 = Class #26 // net/bluxte/experiments/talk/SimpleMain #6 = Class #27 // java/lang/Object #7 = Utf8 <init> #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 LocalVariableTable #12 = Utf8 this #13 = Utf8 Lnet/bluxte/experiments/talk/SimpleMain; #14 = Utf8 main #15 = Utf8 ([Ljava/lang/String;)V #16 = Utf8 args #17 = Utf8 [Ljava/lang/String; #18 = Utf8 SourceFile #19 = Utf8 SimpleMain.java #20 = NameAndType #7:#8 // "<init>":()V #21 = Class #28 // java/lang/System #22 = NameAndType #29:#30 // out:Ljava/io/PrintStream; #23 = Utf8 Hello world #24 = Class #31 // java/io/PrintStream #25 = NameAndType #32:#33 // println:(Ljava/lang/String;)V #26 = Utf8 net/bluxte/experiments/talk/SimpleMain #27 = Utf8 java/lang/Object #28 = Utf8 java/lang/System #29 = Utf8 out #30 = Utf8 Ljava/io/PrintStream; #31 = Utf8 java/io/PrintStream #32 = Utf8 println #33 = Utf8 (Ljava/lang/String;)V
Constant pool for SimpleMain
public class net.bluxte.experiments.talk.SimpleMain { public net.bluxte.experiments.talk.SimpleMain(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return
public static void main(java.lang.String[]); Code: 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3 // String Hello world! 5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return}
Type encodingWhat is (Ljava/lang/String;)V ???
L<class path>; → class nameI, J, S, B, C → integer, long, short, byte, charF, D → float, doubleZ → boolean
public String foo(int a, char[] b, List<Integer> c, boolean d)
(I[CLjava/util/List;Z)Ljava/lang/String;
The bytecode “language”Stack-based machine
● Easier to target a large variety of CPUs(Android/Dalvik is register based)
Object-oriented assembler
● Method calls (static / virtual / interface / special)
Controlled memory access
● Local variables● Object fields
The bytecode “language”Very simple 200 instructions set
Instruction groups:
● Load and store● Arithmetic and logic● Type conversion● Object creation and manipulation● Operand stack management ● Control transfer● Method invocation and return
Only addition since 1996: invokedynamic in Java7
The bytecode “language”
public static void main(String[] args) {
long start = System.nanoTime();
while(System.nanoTime() - start < MAX_NANOS) { for (int i = 0; i < 1_000_000; i++) { resolved = resolve((short)rnd.nextInt(0x100)); } Thread.sleep(100); }}
0: invokestatic #2 // Method java/lang/System.nanoTime:()J 3: lstore_1 4: invokestatic #2 // Method java/lang/System.nanoTime:()J 7: lload_1 8: lsub 9: getstatic #3 // Field MAX_NANOS:J12: lcmp13: ifge 5516: iconst_017: istore_318: iload_319: ldc #4 // int 100000021: if_icmpge 4624: getstatic #5 // Field rnd:Ljava/util/Random;27: sipush 25630: invokevirtual #6 // Method java/util/Random.nextInt:(I)I33: i2s34: invokestatic #7 // Method resolve:(S)Lnet/bluxte/experiments/ couchbase_keyvalue/KeyValueStatus;37: putstatic #8 // Field resolved:Lnet/bluxte/experiments/ couchbase_keyvalue/KeyValueStatus;40: iinc 3, 143: goto 1846: ldc2_w #9 // long 100l49: invokestatic #11 // Method java/lang/Thread.sleep:(J)V52: goto 455: return
LocalVariableTable:Start Length Slot Name Signature 18 28 3 i I 0 56 0 args [Ljava/lang/String; 4 52 1 start J
Benchmarking with JMH(Back to good old Java)
Improving our solutionWe fixed the memory issue but it’s clearly non optimal
Let’s benchmark it!
private static final KeyValueStatus[] VALUES = values();
public static KeyValueStatus valueOf(final short code) { for (KeyValueStatus value: VALUES) { if (value.code() == code) return vue; }al return UNKNOWN;}
O(n) on constant data!
JMH: an OpenJDK project
● Provides drivers and guidance for writing tests● Takes care of pre-warming the JVM, collecting results and computing stats● Provides a Maven artifact type for benchmarking projects
“JMH is a Java harness for building, running, and analysing nano/micro/milli/macro benchmarks written in Java and other
languages targetting the JVM.”
Benchmark code@State(Scope.Benchmark)public class ValueOfBenchmark {
@Param({ "0", // 0x00, Success "1", // 0x01, Not Found "134", // 0x86 Temporary Failure "255", // undefined "1024" // undefined, out of bounds }) public short code;
@Benchmark public KeyValueStatus loopNoFastPath() { return KeyValueStatus.valueOfLoop(code); }
@Benchmark public KeyValueStatus loopFastPath() { return KeyValueStatus.valueOf(code); } ...}
mvn clean installjava -jar target/benchmarks.jar
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_121.jdk/Contents/Home/jre/bin/java# VM options: <none># Warmup: 20 iterations, 1 s each# Measurement: 20 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations# Benchmark mode: Throughput, ops/time# Benchmark: net.bluxte.experiments.couchbase_keyvalue.ValueOfBenchmark.loopNoFastPath# Parameters: (code = 0)
# Run progress: 0,00% complete, ETA 04:53:20# Fork: 1 of 10# Warmup Iteration 1: 152063982,769 ops/s# Warmup Iteration 2: 149808416,787 ops/s# Warmup Iteration 3: 210436722,740 ops/s# Warmup Iteration 4: 202906403,960 ops/s# Warmup Iteration 5: 204518647,481 ops/s# Warmup Iteration 6: 209602101,373 ops/s# Warmup Iteration 7: 204717066,594 ops/s# Warmup Iteration 8: 209156212,425 ops/s# Warmup Iteration 9: 215544157,049 ops/s# Warmup Iteration 10: 213919676,979 ops/s# Warmup Iteration 11: 211316588,650 ops/s# Warmup Iteration 12: 212046920,091 ops/s# Warmup Iteration 13: 212198820,202 ops/s# Warmup Iteration 14: 207165911,202 ops/s# Warmup Iteration 15: 209400520,248 ops/s# Warmup Iteration 16: 210509892,206 ops/s# Warmup Iteration 17: 207094517,640 ops/s# Warmup Iteration 18: 208435049,739 ops/s# Warmup Iteration 19: 208275287,735 ops/s# Warmup Iteration 20: 209727353,731 ops/sIteration 1: 210860563,039 ops/sIteration 2: 213258677,632 ops/sIteration 3: 210171275,812 ops/sIteration 4: 212516810,343 ops/s
Benchmark-driven optimizationpublic static KeyValueStatus valueOfLoop(final short code) { for (KeyValueStatus value: values()) { if (value.code() == code) return value; } return UNKNOWN;}
Benchmark (code) Mode Samples Score Score error Units
loopNoFastPath 0 avgt 10 19.383 0.331 ns/oploopNoFastPath 1 avgt 10 19.243 0.376 ns/oploopNoFastPath 134 avgt 10 24.855 0.651 ns/oploopNoFastPath 255 avgt 10 30.587 0.833 ns/oploopNoFastPath 1024 avgt 10 30.619 1.209 ns/op
Time grows linearly with value,even with out of bound values
Initial implementation
Benchmark-driven optimization
private static final KeyValueStatus[] VALUES = values();
public static KeyValueStatus valueOf(short code) { for (KeyValueStatus value: VALUES) { if (value.code() == code) return value; } return UNKNOWN;}
Benchmark (code) Mode Samples Score Score error Units
loopOnConstantArray 0 avgt 10 2.975 0.086 ns/oploopOnConstantArray 1 avgt 10 3.035 0.080 ns/oploopOnConstantArray 134 avgt 10 10.215 0.269 ns/oploopOnConstantArray 255 avgt 10 16.856 0.679 ns/oploopOnConstantArray 1024 avgt 10 17.015 0.577 ns/op
Still linear, removed ~15 ns allocation overhead
Reuse the constant array
Benchmark-driven optimizationprivate static final Map<Short, KeyValueStatus> code2statusMap = new HashMap<>();
static { for (KeyValueStatus value: values()) { code2statusMap.put(value.code(), value); }}
public static KeyValueStatus valueOf(final short code) { return code2statusMap.getOrDefault(code, UNKNOWN);}
Benchmark (code) Mode Samples Score Score error Units
lookupMap 0 avgt 10 4.954 0.134 ns/oplookupMap 1 avgt 10 4.036 0.125 ns/oplookupMap 134 avgt 10 5.597 0.157 ns/oplookupMap 255 avgt 10 4.006 0.144 ns/oplookupMap 1024 avgt 10 6.752 0.228 ns/op
More or less constantWorse on small valuesWay better on larger values
Prepare a hashmap,then simple lookup
Oh wait… autoboxing!
public static net.bluxte.experiments.couchbase_keyvalue.KeyValueStatus valueOfLookupMap(short);Code: 0: getstatic #17 // Field code2statusMap:Ljava/util/HashMap; 3: iload_0 4: invokestatic #18 // Method java/lang/Short.valueOf:(S)Ljava/lang/Short; 7: getstatic #15 // Field UNKNOWN:Lnet/bluxte/experiments/couchbase_keyvalue/KeyValueStatus; 10: invokevirtual #19 // Method java/util/HashMap.getOrDefault: (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; 13: checkcast #4 // class net/bluxte/experiments/couchbase_keyvalue/KeyValueStatus 16: areturn
public static KeyValueStatus valueOf(final short code) { return code2statusMap.getOrDefault(code, UNKNOWN);}
Oh wait… autoboxing!
Using Carrot HPPC (high performance primitive collections) avoids this
Benchmarking variationsprivate static final KeyValueStatus[] code2status = new KeyValueStatus[0x100];
static { Arrays.fill(code2status, UNKNOWN); for (KeyValueStatus keyValueStatus : values()) { if (keyValueStatus != UNKNOWN) { code2status[keyValueStatus.code()] = keyValueStatus; } }}
public static KeyValueStatus valueOfLookupArray(short code) { if (code >= 0 && code < code2status.length) { return code2status[code]; } else { return UNKNOWN; }}
Benchmark (code) Mode Samples Score Score error Units
lookupArray 0 avgt 10 3.061 0.126 ns/oplookupArray 1 avgt 10 3.048 0.127 ns/oplookupArray 134 avgt 10 3.070 0.084 ns/oplookupArray 255 avgt 10 3.035 0.113 ns/oplookupArray 1024 avgt 10 3.034 0.113 ns/op
Constant fast timeNo GC overheadw00t!
Prepare a lookup array,then simple lookup
Dangers of JMHBenchmark-driven iterations
● Can drive you to partial incremental improvements● Take a step back, think outside of the box
Optimizing for the sake of optimizing
● Time consuming● No real effect if not on “hot” code
Diving into OpenJDK(This gets scary!)
The VM does a lot of things
C1 “client”compiler
C2 “server”compilerInterpreter
Garbage collector
Finding your way in OpenJDKMain website http://openjdk.java.net/
Get the code:
hg clone http://hg.openjdk.java.net/jdk8/jdk8/hotspot/
hg clone http://hg.openjdk.java.net/jdk8/jdk8/jdk/
Mercurial still alive!
garbage collectors
bytecode interpreter
server compiler (c2 / opto)
client compiler (c1)
LLVM-based JIT
OS and/or CPU specific code
root of shared code
CPU-independent target (works with shark JIT)
Additional support in JDK9:● ARM 32 & 64 bits● PowerPC● S390● AIX
Intrinsic methodsWhat you see is not what you get
● The JVM “intercepts” some methods calls○ String / StringBuffer methods, Math, Unsafe, array manipulation, etc.
● Replaced inline with native (assembly) code○ Extremely fast and optimized○ Not even JNI overhead
● Find them in hotspot/src/share/vm/classfile/vmSymbols.hpp
Intrinsic methods
// IndexOf for constant substrings with size >= 8 chars// which don't need to be loaded through stack.void MacroAssembler::string_indexofC8(Register str1, Register str2, Register cnt1, Register cnt2, int int_cnt2, Register result, XMMRegister vec, Register tmp) { ShortBranchVerifier sbv(this); assert(UseSSE42Intrinsics, "SSE4.2 is required");
// This method uses pcmpestri inxtruction with bound registers // inputs: // xmm - substring // rax - substring length (elements count) // mem - scanned string // rdx - string length (elements count) // 0xd - mode: 1100 (substring search) + 01 (unsigned shorts) // outputs: // rcx - matched index in string assert(cnt1 == rdx && cnt2 == rax && tmp == rcx, "pcmpestri");
Label RELOAD_SUBSTR, SCAN_TO_SUBSTR, SCAN_SUBSTR, RET_FOUND, RET_NOT_FOUND, EXIT, FOUND_SUBSTR, MATCH_SUBSTR_HEAD, RELOAD_STR, FOUND_CANDIDATE;
// Note, inline_string_indexOf() generates checks: // if (substr.count > string.count) return -1; // if (substr.count == 0) return 0; assert(int_cnt2 >= 8, "this code isused only for cnt2 >= 8 chars");
// Load substring. movdqu(vec, Address(str2, 0)); movl(cnt2, int_cnt2); movptr(result, str1); // string addr
Example: String.indexOf on x86
In JDK9 beta, String.indexOf(String) is faster than String.indexOf(char)!
This is because one is intrinsic, and not yet the other
Intrinsic methods
Benchmark Mode Cnt Score Error Units
# JDK 8u121IndexOfBenchmark.StringIndexOfChar thrpt 5 141857.332 ± 5530.472 ops/sIndexOfBenchmark.StringIndexOfString thrpt 5 113091.517 ± 2241.533 ops/s
# JDK 9b152IndexOfBenchmark.StringIndexOfChar thrpt 5 154525.343 ± 3796.818 ops/sIndexOfBenchmark.StringIndexOfString thrpt 5 185917.059 ± 3391.230 ops/s
(from the jdk9-dev mailing-list)
Intrinsic methods● “I can do it better than JDK source” – think twice!
→ Have a look at vmSymbols.hpp first!
● Can sometimes be indirect (esp with strings and arrays)
● When in doubt, benchmark (with the same JVM)
Conclusion
Conclusion● Know your tools
● Be curious, and follow the white rabbit from time to time, you’ll learn a lot
● However… don’t go overboard and waste (too much) time!
Thanks!Questions?
Sylvain Wallez - @bluxteToulouse JUG - 2017-04-26
Bonus links to dive deeper
Java MissionControl & FlightRecorder docs
What the JIT!? Anatomy of the OpenJDK HotSpot VM
Intrinsic Methods in HotSpot VM
Zero and Shark (LLVM JIT)
top related