More Related Content
What's hot
What's hot (20)
Similar to White and Black Magic on the JVM
Similar to White and Black Magic on the JVM (20)
Recently uploaded
Recently uploaded (20)
White and Black Magic on the JVM
- 1. White and Black Magic on the JVM Ivaylo Pashov Daniel Darakchiev 12 Nov 2018
- 3. White • Knowledge about Java language and JVM specifications • More efficient and optimized code • Spells for troubleshooting • Knowledge about the internal implementation of the JVM • Low level manipulation • Subvert the JVM mechanics • Great power Great responsibilities Black
- 5. Bytecode Compilation • Platform independent and language agnostic • Compile-time constants inlining • Tricks around type erasure, nested classes and lambdas conversion • Annotations processing • Offloads from the developer the need for code optimizations • Unpredictable and inconsistent • Limited set of configurations JIT Compilation
- 6. Lambdas Translation vs Inner Class Translation Definition Compilation public class LambdaSubmitter { public void submit(ExecutorService executor) { executor.submit(() -> System.out.println("Called from " + this)); } } public class InnerClassSubmitter { public void submit(ExecutorService executor) { executor.submit(new Runnable() { @Override public void run() { System.out.println("Called from " + this); } }); } }
- 7. Lambdas Translation vs Inner Class Translation Compilation Linkage Classloading ALOAD 0 //capturing this INVOKEDYNAMIC run(LOuter;) LRunnable; [ LambdaMetafactory.metafactory(..)LCallSite; ()V, //Runnable argument types Outer.lambda$submit$0()V, ()V // lambda$submit$0 argument types ] //synthetic method containing lambda body private synthetic lambda$submit$0()V ALOAD 0 //capturing this INVOKESPECIAL Outer$1.<init> (LOuter;)V //class Outer$1 class Outer$1 implements Runnable { final LOuter this$0; <init>(LOuter;);
- 8. Lambdas Translation vs Inner Class Translation Linkage Classloading Capture Instantiate Lambda Metafactory CallSite create Class Loader Outer$1 Class load
- 9. Lambdas Translation vs Inner Class Translation Capture Instantiate Invoke Runnable.run() CallSite Runnable invoke with instance of Outer Outer$1 Class Runnable invoke with instance of Outer
- 10. Lambdas and Method References Tips • Avoid inner classes when possible • No worse performance than inner classes in the worst case • 5-20x better than inner classes in a common case • Prefer non-capturing (stateless) lambdas/method references • Faster capturing (reusing the call site) • Easier to inline • Prefer method references over lambdas • Improved readability • Avoid method generation
- 11. Combine the speed of compiled code with the flexibility of interpretation JIT (Just in Time) Compiler Source (.java) Bytecode (.class) Native code Optimizer Run Interpreter
- 12. Interperter vs JIT • Simplest for of bytecode to machine code translation • Executes 1 bytecode instruction at a time • Repeated every time bytecode is executed • No opportunity to optimize over an instruction set • Easy to implement • Fairly slow • Look at entire or partial context • Optimization decisions based on code graphs analysis • Optimized native code stored in code cache • Runtime profiling – delayed compilation • Compiles hot methods only as compilation is costly
- 13. JIT Impact on Performance
- 14. JIT compared to AOT + Advanced optimizations at runtime + Based on profiling + Optimized for target CPU + Global code optimizations + Better cache utilization + Only compile what is really needed (hot) + Reduces long build times - Requires warmup period until reaching peak performance - Increased CPU and memory usage - Non-predictable execution overhead - Optimistic – deoptimizing if wrong
- 15. JIT and Dynamic Dispatch
- 17. Classloading Process • Classloaders hierarchy • Initialization order • Laziness • Classpath precedence • Load a class multiple times • Application servers • Multi-versioned dependencies • Insatiate a class via another class • Define dynamic class at runtime Custom Classloaders
- 18. Lazy Classloading A class or interface typeT will be initialized immediately before the first occurrence of any one of the following: • Instance creation • Static method invocation • Static field read/write (except compile-time constants) +Effective Metaspace (PermGen) management – Can result in degraded performance after startup
- 19. Classloader Hierarchies •Bootstrap CL loads the internal JVM classes from the java.lang package •The Extension CL (removed in Java 9) loads everything from the java extension directory •The System CL loads everything from the classpath •All user-defined CLs (usually) have the System CL as their parent Extension classloader Bootstrap classloader System classpath classloader …/lib/rt.jar …/lib/ext/*.jar $CLASSPATH
- 20. Memory Leaks Class Object Classloader Class Class Class Object Object Object Static fields All loaded classes A single object can leak its classloader
- 21. Memory Magic
- 22. Memory Access Patterns • Memory access is crucial for performance (locality) • Tradeoff between encapsulation and efficient memory layout (objects vs. primitives) • Method invocation cost • Low level memory manipulation (C-style memory access) • Subverting Java memory structures • Heap vs off-heap (unmanaged) Memory Manipulation
- 23. Stack vs Heap final class Point { final int x; final int y; } Stack Heap ref header x y Allocated on the Heap More GC
- 24. Objects Layout final class Point { final int x; final int y; } Point[] pts = header header x y header x y header x y Extra memory for headers Indirection
- 25. Objects Layout int[] x = header int[] y = header
- 26. Objects Layout
- 27. Objects Layout
- 28. Instance Memory Representation instance 0 mark 4 klass 8 field1 12 field2 … class 0 vtbl ptr 4 layout_helper 8 super_check_offset 12 name 16 secondary_super_cache 20 secondary_supers 24 primary_supers 0 28 primary_supers 1 32 primary_supers 2 36 primary_supers 3 …
- 29. Memory Types Heap vs Off-heap Memory Heap Off-heap Stack Managed by GC Not Managed By GC Objects Raw bytes
- 31. Agents Magic
- 32. Java Agent • Real Black Magic • Bytecode manipulation technique • Plugs into JVM and modifies classes loaded by the class loader • Extremely as powerful as dangerous • Used with JDK up to Java 8, from Java 9 it is available in the JRE
- 33. Launch Time Instrumentation Class Loader Class Loader Java Agent 1. premain() Transformer .class files 2. register 3. load 5. bytes4. transform JVM MainClass 6. run main() java –javaagent:/to/agent.jar MainClass
- 34. Other Process JVM 1 Java Agent agentmain() JVM 2 VirtualMachine vm = VirtualMachine.attach("2177"); vm.loadAgent(”/to/agent.jar", ”arg1=1"); pid=2177 Instrumentation
- 35. Same Process JVM 1 Java Agent agentmain() Instrumentation
Editor's Notes
- The JIT compiler is a part of the JVM, which is responsible for compilation done during the execution of a program – at run time – rather than prior to execution. If the compilation is done before the execution, then we speak about Ahead-Of-Time compilation (AOT). The JIT compiler could improve the performance significantly and the flexibility of interpretation remained. The main questions we look answers for: What to compile? (compilation is costly) When to compile? (the ASAP approach is not the best, because we have to gather statistics) How to compile? (different optimization levels, cost-benefit)
- Classpath -> order: CP Patching
- The delegation model requires that any request for a class loader to load a given class is first delegated to its parent class loader before the requested class loader tries to load the class itself. The parent class loader, in turn, goes through the same process of asking its parent. This chain of delegation continues through to the bootstrap class loader (also known as the primordial or system class loader). If a class loader's parent can load a given class, it returns that class. Otherwise, the class loader attempts to load the class itself.
- Classpath -> order: CP Patching