{"id":66345,"date":"2022-08-10T09:01:22","date_gmt":"2022-08-10T09:01:22","guid":{"rendered":"https:\/\/www.cryptocabaret.com\/?p=66345"},"modified":"2022-08-10T09:01:22","modified_gmt":"2022-08-10T09:01:22","slug":"a-guide-to-jvm-interpretation-and-compilation","status":"publish","type":"post","link":"https:\/\/www.cryptocabaret.com\/?p=66345","title":{"rendered":"A guide to JVM interpretation and compilation"},"content":{"rendered":"

A guide to JVM interpretation and compilation<\/span>
\nJayashree Hutt\u2026<\/a><\/span>
\nTue, 08\/09\/2022 – 10:36<\/span><\/p>\n

\n
Register<\/a> or Login<\/a> to like<\/div>\n
Register<\/a> or Login<\/a> to like<\/div>\n<\/div>\n
\n

Java is a platform-independent language. Programs are converted to bytecode<\/em> after compilation. This bytecode gets converted to machine code<\/em> at runtime. An interpreter emulates the execution of bytecode instructions for the abstract machine on a specific physical machine. Just-in-time (JIT) compilation happens at some point during execution, and ahead-of-time (AOT) compilation happens during build time.\u00a0<\/p>\n

This article explains when an interpreter comes into play and when JIT and AOT will occur. I also discuss the trade-offs between JIT and AOT.<\/p>\n

Source code, bytecode, machine code<\/h2>\n

Applications are generally written using a programming language like C, C++, or Java. The set of instructions written using high-level programming languages is called source code. Source code is human readable. To execute it on the target machine, source code needs to be converted to machine code, which is machine readable. Source code is typically converted into machine code by a compiler.\u00a0<\/p>\n

In Java, however, the source code is first converted into an intermediate form called bytecode<\/em>. This bytecode is platform independent, which is why Java is well known as a platform-independent programming language. The primary Java compiler javac<\/code> converts the Java source code into bytecode. Then, the bytecode is interpreted by the interpreter.<\/p>\n

Here is a small Hello.java<\/code> program:<\/p>\n

\n
\/\/Hello.java<\/span>
public<\/span> class<\/span> Hello {<\/span>

\n\u00a0 \u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>String<\/span><\/a>[<\/span>]<\/span> args)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"Inside Hello World!\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0}<\/span>
}<\/span><\/div><\/div><\/pre>\n
Compile it using javac<\/code> to generate a Hello.class<\/code> file containing the bytecode.\u00a0<\/p>\n
\n
$ javac Hello.java<\/span>
\n$ ls
\nHello.class<\/span> \u00a0Hello.java<\/span><\/div><\/div><\/pre>\n
Now, use javap<\/code> to disassemble the content of the Hello.class<\/code> file. The output of javap<\/code> depends on the options used. If you don’t choose any options, it prints basic information, including which source file this class file is compiled from, the package name, public and protected fields, and methods of the class.<\/p>\n
\n
$ javap Hello.class<\/span>
\nCompiled from \"Hello.java\"<\/span>
public<\/span> class<\/span> Hello {<\/span>
\n\u00a0 public<\/span> Hello(<\/span>)<\/span>;<\/span>
\n\u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>java.lang<\/span>.String<\/span><\/a>[<\/span>]<\/span>)<\/span>;<\/span>
}<\/span><\/div><\/div><\/pre>\n
To see the bytecode content in the .class<\/code> file, use the -c<\/code> option:<\/p>\n
\n
$ javap -c<\/span> Hello.class
\nCompiled from \"Hello.java\"<\/span>
\npublic class Hello {<\/span>
\n\u00a0 public Hello(<\/span>)<\/span>;
\n\u00a0 \u00a0 \u00a0 \u00a0 Code:
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a00<\/span>: aload_0
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a01<\/span>: invokespecial #1 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\/\/ Method java\/lang\/Object.\"\":()V<\/init><\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a04<\/span>: return<\/span>

\n\u00a0 public static void main(<\/span>java.lang.String[<\/span>]<\/span>)<\/span>;
\n\u00a0 \u00a0 \u00a0 \u00a0 Code:
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a00<\/span>: getstatic \u00a0 \u00a0 \u00a0 \u00a0 #2 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\/\/ Field java\/lang\/System.out:Ljava\/io\/PrintStream;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a03<\/span>: ldc \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 #3 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\/\/ String Inside Hello World!<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a05<\/span>: invokevirtual #4 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\/\/ Method \u00a0 \u00a0<\/span>
\njava\/<\/span>io\/<\/span>PrintStream.println:(<\/span>Ljava\/<\/span>lang\/<\/span>String;)<\/span>V
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a08<\/span>: return<\/span>
}<\/span><\/div><\/div><\/pre>\n
To get more detailed information, use the -v<\/code> option:<\/p>\n
\n$ javap -<\/span>v Hello.class<\/span><\/code><\/span><\/pre>\n
Interpreter, JIT, AOT<\/h2>\n
The interpreter is responsible for emulating the execution of bytecode instructions for the abstract machine on a specific physical machine. When compiling source code using javac\u00a0<\/code>and executing using the java<\/code> command, the interpreter operates during runtime and serves its purpose.<\/p>\n
\n
$ javac Hello.java<\/span>
\n$ java Hello
\nInside Hello World!<\/span><\/div><\/div><\/pre>\n
The JIT compiler also operates at runtime. When the interpreter interprets a Java program, another component, called a runtime profiler, is silently monitoring the program’s execution to observe which portion of the code is getting interpreted and how many times. These statistics help detect the hotspots<\/em> of the program, that is, those portions of code frequently being interpreted. Once they’re interpreted above a set threshold, they are eligible to be converted into machine code directly by the JIT compiler. The JIT compiler is also known as a profile-guided compiler. Conversion of bytecode to native code happens on the fly, hence the name just-in-time. JIT reduces overhead of the interpreter emulating the same set of instructions to machine code.<\/p>\n
The AOT compiler compiles code during build time. Generating frequently interpreted and JIT-compiled code at build time improves the warm-up time of the Java Virtual Machine (JVM). This compiler was introduced in Java 9 as an experimental feature. The jaotc<\/code> tool uses the Graal compiler, which is itself written in Java, for AOT compilation.\u00a0<\/p>\n
Here’s a sample use case for a Hello program:<\/p>\n
\n
\/\/Hello.java<\/span>
public<\/span> class<\/span> Hello {<\/span>


\n\u00a0 \u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>String<\/span><\/a>[<\/span>]<\/span> args)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"Inside Hello World!\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 }<\/span>
}<\/span>


\n$ javac Hello.java<\/span>
\n$ jaotc --<\/span>output libHello.so<\/span> Hello.class<\/span>
\n$ java -<\/span>XX:+<\/span>UnlockExperimentalVMOptions -<\/span>XX:<\/span>AOTLibrary=<\/span>.\/<\/span>libHello.so<\/span> Hello
\nInside Hello World!<\/span><\/div><\/div><\/pre>\n
When do interpreting and compiling come into play: an example<\/h2>\n
This example illustrates when Java uses an interpreter and when JIT and AOT pitch in. Consider a simple Java program, Demo.java<\/code>:<\/p>\n
\n
\/\/Demo.java<\/span>
public<\/span> class<\/span> Demo {<\/span>
\n\u00a0 public<\/span> int<\/span> square(<\/span>int<\/span> i)<\/span> throws<\/span> Exception<\/span><\/a> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 return<\/span>(<\/span>i*<\/span>i)<\/span>;<\/span>
\n\u00a0 }<\/span>


\n\u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>String<\/span><\/a>[<\/span>]<\/span> args)<\/span> throws<\/span> Exception<\/span><\/a> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i  10<\/span>;<\/span> i++<\/span>)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"call \"<\/span> +<\/span> Integer<\/span><\/a>.valueOf<\/span>(<\/span>i)<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 long<\/span> a =<\/span> System<\/span><\/a>.nanoTime<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Int r =<\/span> new<\/span> Demo(<\/span>)<\/span>.square<\/span>(<\/span>i)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"Square(i) = \"<\/span> +<\/span> r)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 long<\/span> b =<\/span> System<\/span><\/a>.nanoTime<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"elapsed= \"<\/span> +<\/span> (<\/span>b-<\/span>a)<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"--------------------------------\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 }<\/span>
\n\u00a0 }<\/span>
}<\/span><\/span><\/div><\/div><\/pre>\n
This simple program has a main<\/code> method that creates a Demo<\/code> object instance, and calls the method square<\/code>, which displays the square root of the for<\/code> loop iteration value. Now, compile and run the code:<\/p>\n
\n
$ javac Demo.java<\/span>
\n$ java Demo
1<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 1<\/span>
Time<\/span><\/a> taken=<\/span> 8432439<\/span>
--------------------------------<\/span>
2<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 4<\/span>
Time<\/span><\/a> taken=<\/span> 54631<\/span>
--------------------------------<\/span>
\n.
\n.
\n.
--------------------------------<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 66498<\/span>
--------------------------------<\/span><\/div><\/div><\/pre>\n<\/p>\n
\n
More on Java<\/div>\n
\n
What is enterprise Java programming?<\/a><\/div>\n
Red Hat build of OpenJDK<\/a><\/div>\n
Java cheat sheet<\/a><\/div>\n
Free online course: Developing cloud-native applications with microservices<\/a><\/div>\n
Fresh Java articles<\/a><\/div>\n<\/p><\/div>\n<\/p><\/div>\n
The question now is whether the output is a result of the interpreter, JIT, or AOT. In this case, it’s wholly interpreted. How did I conclude that? Well, to get JIT to contribute to the compilation, the hotspots of the code must be interpreted above a defined threshold. Then and only then are those pieces of code queued for JIT compilation. To find the threshold for JDK 11:<\/p>\n
\n
$ java -<\/span>XX:+<\/span>PrintFlagsFinal -<\/span>version |<\/span> grep CompileThreshold
\n\u00a0intx CompileThreshold \u00a0 \u00a0 =<\/span> 10000<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0{<\/span>pd product}<\/span> {<\/span>default<\/span>}<\/span>
[<\/span>...]<\/span>
\nopenjdk version \"11.0.13\"<\/span> 2021<\/span>-<\/span>10<\/span>-<\/span>19<\/span>
\nOpenJDK Runtime<\/span><\/a> Environment<\/span><\/a> 18.9<\/span> (<\/span>build 11.0.13+<\/span>8<\/span>)<\/span>
\nOpenJDK 64<\/span>-<\/span>Bit Server VM 18.9<\/span> (<\/span>build 11.0.13+<\/span>8<\/span>, mixed mode, sharing)<\/span><\/div><\/div><\/pre>\n
The above output demonstrates that a particular piece of code should be interpreted 10,000 times to be eligible for JIT compilation. Can this threshold be manually tuned, and is there some JVM flag that indicates whether a method is JIT compiled? Yes, there are multiple options to serve this purpose.\u00a0<\/p>\n
One option for learning whether a method is JIT compiled is -XX:+PrintCompilation<\/code>. Along with this option, the flag -Xbatch<\/code> provides the output in a more readable way. If both interpretation and JIT are happening in parallel, the -Xbatch<\/code> flag helps distinguish the output of both. Use these flags as follows:<\/p>\n
\n
$ java -<\/span>Xbatch \u00a0-<\/span>XX:+<\/span>PrintCompilation \u00a0Demo
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a034<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0b \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 java.util<\/span>.concurrent<\/span>.ConcurrentHashMap<\/span>::<\/span>tabAt (<\/span>22<\/span> bytes)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a035<\/span> \u00a0 \u00a0 \u00a0 \u00a02<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 jdk.internal<\/span>.misc<\/span>.Unsafe<\/span>::<\/span>getObjectVolatile (<\/span>native<\/span>)<\/span> \u00a0\u00a0
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a035<\/span> \u00a0 \u00a0 \u00a0 \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0b \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 java.lang<\/span>.Object<\/span><\/a>::init><\/span> (<\/span>1<\/span> bytes)<\/span>
[<\/span>...]<\/span>
210<\/span> \u00a0269<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 java.lang<\/span>.reflect<\/span>.Array<\/span><\/a>::<\/span>newArray (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 211<\/span> \u00a0270<\/span> \u00a0 \u00a0 \u00a0 \u00a0b \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 java.lang<\/span>.String<\/span><\/a>::<\/span>substring (<\/span>58<\/span> bytes)<\/span>
[<\/span>...]<\/span>
--------------------------------<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 50150<\/span>
--------------------------------<\/span>\u00a0<\/span><\/div><\/div><\/pre>\n
The output of the above command is too lengthy, so I’ve truncated the middle portion. Note that along with the Demo program code, the JDKs internal class functions are also getting compiled. This is why the output is so lengthy. Because my focus is Demo.java<\/code> code, I’ll use an option that can minimize the output by excluding the internal package functions. The command –XX:CompileCommandFile<\/code> disables JIT for internal classes:<\/p>\n
\n$ java -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler Demo<\/code><\/span><\/pre>\n
The file hotspot_compiler<\/code> referenced by -XX:CompileCommandFile<\/code> contains this code to exclude specific packages:<\/p>\n
\n
$ cat hotspot_compiler
\nquiet
\nexclude java\/* *
\nexclude jdk\/* *
\nexclude sun\/* *<\/span><\/div><\/div><\/pre>\n
In the first line, quiet<\/code> instructs the JVM not to write anything about excluded classes. To tune the JIT threshold, use -XX:CompileThreshold<\/code> with the value set to 5, meaning that after interpreting five times, it’s time for JIT:<\/p>\n
\n
$ java -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler 
-<\/span>XX:<\/span>CompileThreshold=<\/span>5<\/span> Demo
\n\u00a0 \u00a0 \u00a0 \u00a0 47<\/span>\u00a0 \u00a0 \u00a0 1<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>LLLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0(<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 47<\/span>\u00a0 \u00a0 \u00a0 2<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>LLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 47<\/span>\u00a0 \u00a0 \u00a0 3<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToSpecial(<\/span>LLLLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0(<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 48<\/span>\u00a0 \u00a0 \u00a0 4<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>L)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 48<\/span>\u00a0 \u00a0 \u00a0 5<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 48<\/span>\u00a0 \u00a0 \u00a0 6<\/span> \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToSpecial(<\/span>LL)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0(<\/span>static<\/span>)<\/span>
[<\/span>...]<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 1<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 69<\/span> \u00a0 40<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>ILIIL)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0(<\/span>static<\/span>)<\/span>
[<\/span>...]<\/span>
\nSquare(<\/span>i)<\/span> =<\/span> 1<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 78<\/span> \u00a0 48<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>ILIJL)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 
(<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 79<\/span> \u00a0 49<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>ILIJ)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 
[<\/span>...]<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 86<\/span> \u00a0 54<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>J)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 87<\/span> \u00a0 55<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n 0<\/span> \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToSpecial(<\/span>LJL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
(<\/span>static<\/span>)<\/span>
Time<\/span><\/a> taken=<\/span> 8962738<\/span>
--------------------------------<\/span>
2<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 4<\/span>
Time<\/span><\/a> taken=<\/span> 26759<\/span>
--------------------------------<\/span>

10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 26492<\/span>
--------------------------------<\/span><\/div><\/div><\/pre>\n
The output is still not different from interpreted output! This is because, as per Oracle’s documentation, the -XX:CompileThreshold<\/code> flag is effective only when TieredCompilation<\/code> is disabled:<\/p>\n
\n
$ java -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler 
-<\/span>XX:-<\/span>TieredCompilation -<\/span>XX:<\/span>CompileThreshold=<\/span>5<\/span> Demo
124<\/span> \u00a0 \u00a0 1<\/span> \u00a0 \u00a0 \u00a0 n \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>LLLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
127<\/span> \u00a0 \u00a0 2<\/span> \u00a0 \u00a0 \u00a0 n \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>LLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
[<\/span>...]<\/span>
1<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 187<\/span> \u00a0 40<\/span> \u00a0 \u00a0 \u00a0 \u00a0n \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>ILIIL)<\/span>I (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
[<\/span>...]<\/span>
(<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 212<\/span> \u00a0 54<\/span> \u00a0 \u00a0 \u00a0 \u00a0n \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>invokeBasic(<\/span>J)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 
\n\u00a0 \u00a0 \u00a0 \u00a0 212<\/span> \u00a0 55<\/span> \u00a0 \u00a0 \u00a0 \u00a0n \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToSpecial(<\/span>LJL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
Time<\/span><\/a> taken=<\/span> 12337415<\/span>
[<\/span>...]<\/span>
--------------------------------<\/span>
4<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 16<\/span>
Time<\/span><\/a> taken=<\/span> 37183<\/span>
--------------------------------<\/span>
5<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 214<\/span> \u00a0 56<\/span>\u00a0 \u00a0 \u00a0 \u00a0 b \u00a0 \u00a0 \u00a0 Demo::init><\/span> (<\/span>5<\/span> bytes)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 215<\/span> \u00a0 57<\/span>\u00a0 \u00a0 \u00a0 \u00a0 b \u00a0 \u00a0 \u00a0 Demo::<\/span>square (<\/span>16<\/span> bytes)<\/span>
\nSquare(<\/span>i)<\/span> =<\/span> 25<\/span>
Time<\/span><\/a> taken=<\/span> 983002<\/span>
--------------------------------<\/span>
6<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 36<\/span>
Time<\/span><\/a> taken=<\/span> 81589<\/span>
[<\/span>...]<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 52393<\/span><\/span><\/div><\/div><\/pre>\n
This section of code is now JIT compiled after the fifth interpretation:<\/p>\n
\n
--------------------------------<\/span>
5<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 214<\/span> \u00a0 56<\/span>\u00a0 \u00a0 \u00a0 \u00a0 b \u00a0 \u00a0 \u00a0 Demo::init><\/span> (<\/span>5<\/span> bytes)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 215<\/span> \u00a0 57<\/span>\u00a0 \u00a0 \u00a0 \u00a0 b \u00a0 \u00a0 \u00a0 Demo::<\/span>square (<\/span>16<\/span> bytes)<\/span>
\nSquare(<\/span>i)<\/span> =<\/span> 25<\/span>
Time<\/span><\/a> taken=<\/span> 983002<\/span>
--------------------------------<\/span><\/span><\/div><\/div><\/pre>\n
Along with the square()<\/code> method, the constructor is also getting JIT compiled because there is a Demo instance inside the for<\/code> loop before calling square()<\/code>. Hence, it will also reach the threshold and be JIT compiled. This example illustrates when JIT comes into play after interpretation.\u00a0<\/p>\n
To see the compiled version of the code, use the -XX:+PrintAssembly flag<\/code>, which works only if there is a disassembler in the library path. For OpenJDK, use the hsdis<\/code> disassembler. Download a suitable disassembler library\u2014 in this case,\u00a0hsdis-amd64.so<\/code>\u2014 and place it under Java_HOME\/lib\/server<\/code>. Make sure to use -XX:+UnlockDiagnosticVMOptions<\/code> before -XX:+PrintAssembly<\/code>. Otherwise, JVM will give you a warning.\u00a0<\/p>\n
The entire command is as follows:<\/p>\n
\n
$ java -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler  -<\/span>XX:-<\/span>TieredCompilation -<\/span>XX:<\/span>CompileThreshold=<\/span>5<\/span> -<\/span>XX:+<\/span>UnlockDiagnosticVMOptions  -<\/span>XX:+<\/span>PrintAssembly Demo
[<\/span>...]<\/span>
5<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 178<\/span> \u00a0 56<\/span>\u00a0 \u00a0 \u00a0 \u00a0 b \u00a0 \u00a0 \u00a0 Demo::init><\/span> (<\/span>5<\/span> bytes)<\/span>
\nCompiled method (<\/span>c2)<\/span> \u00a0 \u00a0178<\/span> \u00a0 56<\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Demo::init><\/span> (<\/span>5<\/span> bytes)<\/span>
\n\u00a0total in heap \u00a0[<\/span>0x00007fd4d08dad10,0x00007fd4d08dafe0]<\/span> =<\/span> 720<\/span>
\n\u00a0relocation \u00a0 \u00a0 [<\/span>0x00007fd4d08dae88,0x00007fd4d08daea0]<\/span> =<\/span> 24<\/span>
[<\/span>...]<\/span>
\n\u00a0handler table \u00a0[<\/span>0x00007fd4d08dafc8,0x00007fd4d08dafe0]<\/span> =<\/span> 24<\/span>
[<\/span>...]<\/span>
\n\u00a0dependencies \u00a0 [<\/span>0x00007fd4d08db3c0,0x00007fd4d08db3c8]<\/span> =<\/span> 8<\/span>
\n\u00a0handler table \u00a0[<\/span>0x00007fd4d08db3c8,0x00007fd4d08db3f8]<\/span> =<\/span> 48<\/span>
----------------------------------------------------------------------<\/span>
\nDemo.square<\/span>(<\/span>I)<\/span>I \u00a0[<\/span>0x00007fd4d08db1c0, 0x00007fd4d08db2b8]<\/span> \u00a0248<\/span> bytes
[<\/span>Entry Point<\/span><\/a>]<\/span>
[<\/span>Constants]<\/span>
\n\u00a0 # {<\/span>method}<\/span> {<\/span>0x00007fd4b841f4b0}<\/span> 'square'<\/span> '(I)I'<\/span> in 'Demo'<\/span>
\n\u00a0 # this<\/span>:<\/span> \u00a0 \u00a0 \u00a0 rsi:<\/span>rsi \u00a0 =<\/span> 'Demo'<\/span>
\n\u00a0 # parm0:<\/span>\u00a0 \u00a0 \u00a0 rdx \u00a0 \u00a0 =<\/span> int<\/span>
\n\u00a0 # \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 [<\/span>sp+<\/span>0x20]<\/span> \u00a0(<\/span>sp of caller)<\/span>
[<\/span>...]<\/span>
[<\/span>Stub<\/span><\/a> Code]<\/span>
\n\u00a0 0x00007fd4d08db280:<\/span> movabs $0x0,%<\/span>rbx \u00a0 \u00a0 \u00a0\u00a0 \u00a0 ;<\/span> \u00a0 {<\/span>no_reloc}<\/span>
\n\u00a0 0x00007fd4d08db28a:<\/span> jmpq \u00a0 0x00007fd4d08db28a \u00a0;<\/span> \u00a0 {<\/span>runtime_call}<\/span>
\n\u00a0 0x00007fd4d08db28f:<\/span> movabs $0x0,%<\/span>rbx \u00a0 \u00a0 \u00a0\u00a0 \u00a0 ;<\/span> \u00a0 {<\/span>static_stub}<\/span>
\n\u00a0 0x00007fd4d08db299:<\/span> jmpq \u00a0 0x00007fd4d08db299 \u00a0;<\/span> \u00a0 {<\/span>runtime_call}<\/span>
[<\/span>Exception<\/span><\/a> Handler]<\/span>
\n\u00a0 0x00007fd4d08db29e:<\/span> jmpq \u00a0 0x00007fd4d08bb880 \u00a0;<\/span> \u00a0 {<\/span>runtime_call ExceptionBlob}<\/span>
[<\/span>Deopt Handler Code]<\/span>
\n\u00a0 0x00007fd4d08db2a3:<\/span> callq \u00a00x00007fd4d08db2a8
\n\u00a0 0x00007fd4d08db2a8:<\/span> subq \u00a0 $0x5,(<\/span>%<\/span>rsp)<\/span>
\n\u00a0 0x00007fd4d08db2ad:<\/span> jmpq \u00a0 0x00007fd4d08a01a0 \u00a0;<\/span> \u00a0 {<\/span>runtime_call DeoptimizationBlob}<\/span>
\n\u00a0 0x00007fd4d08db2b2:<\/span> hlt \u00a0 \u00a0
\n\u00a0 0x00007fd4d08db2b3:<\/span> hlt \u00a0 \u00a0
\n\u00a0 0x00007fd4d08db2b4:<\/span> hlt \u00a0 \u00a0
\n\u00a0 0x00007fd4d08db2b5:<\/span> hlt \u00a0 \u00a0
\n\u00a0 0x00007fd4d08db2b6:<\/span> hlt \u00a0 \u00a0
\n\u00a0 0x00007fd4d08db2b7:<\/span> hlt \u00a0 \u00a0
\nImmutableOopMap{<\/span>rbp=<\/span>NarrowOop }<\/span>pc offsets:<\/span> 96<\/span>
\nImmutableOopMap{<\/span>}<\/span>pc offsets:<\/span> 112<\/span>
\nImmutableOopMap{<\/span>rbp=<\/span>Oop }<\/span>pc offsets:<\/span> 148<\/span> Square(<\/span>i)<\/span> =<\/span> 25<\/span>
Time<\/span><\/a> taken=<\/span> 2567698<\/span>
--------------------------------<\/span>
6<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 36<\/span>
Time<\/span><\/a> taken=<\/span> 76752<\/span>
[<\/span>...]<\/span>
--------------------------------<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 52888<\/span><\/span><\/span><\/div><\/div><\/pre>\n
The output is lengthy, so I’ve included only the output related to Demo.java<\/code>.<\/p>\n
Now it’s time for AOT compilation. This option was introduced in JDK9. AOT is a static compiler to generate the .so<\/code> library. With AOT, the interested classes can be compiled to create an .so<\/code> library that can be directly executed instead of interpreting or JIT compiling. If JVM doesn’t find any AOT-compiled code, the usual interpretation and JIT compilation takes place.\u00a0<\/p>\n
The command used for AOT compilation is as follows:<\/p>\n
\n$ jaotc --<\/span>output=<\/span>libDemo.so<\/span> Demo.class<\/span><\/code><\/span><\/pre>\n
To see the symbols in the shared library, use the following:<\/p>\n
\n$ nm libDemo.so<\/span><\/code><\/span><\/pre>\n
To use the generated .so<\/code> library, use -XX:AOTLibrary<\/code> along with -XX:+UnlockExperimentalVMOptions<\/code> as follows:<\/p>\n
\n
$ java -<\/span>XX:+<\/span>UnlockExperimentalVMOptions -<\/span>XX:<\/span>AOTLibrary=<\/span>.\/<\/span>libDemo.so<\/span> Demo
1<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 1<\/span>
Time<\/span><\/a> taken=<\/span> 7831139<\/span>
--------------------------------<\/span>
2<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 4<\/span>
Time<\/span><\/a> taken=<\/span> 36619<\/span>
[<\/span>...]<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 42085<\/span><\/div><\/div><\/pre>\n
This output looks as if it is an interpreted version itself. To make sure that the AOT compiled code is utilized, use -XX:+PrintAOT<\/code>:<\/p>\n
\n
$ java -<\/span>XX:+<\/span>UnlockExperimentalVMOptions -<\/span>XX:<\/span>AOTLibrary=<\/span>.\/<\/span>libDemo.so<\/span> -<\/span>XX:+<\/span>PrintAOT Demo
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a028<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 loaded \u00a0 \u00a0 \u00a0 \u00a0.\/<\/span>libDemo.so<\/span> \u00a0aot library
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a080<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.main<\/span>(<\/span>[<\/span>Ljava\/<\/span>lang\/<\/span>String<\/span><\/a>;<\/span>)<\/span>V
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a080<\/span> \u00a0 \u00a0 \u00a0 \u00a02<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.square<\/span>(<\/span>I)<\/span>I
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a080<\/span> \u00a0 \u00a0 \u00a0 \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.init><\/span>(<\/span>)<\/span>V
1<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 1<\/span>
Time<\/span><\/a> taken=<\/span> 7252921<\/span>
--------------------------------<\/span>
2<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 4<\/span>
Time<\/span><\/a> taken=<\/span> 57443<\/span>
[<\/span>...]<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 53586<\/span><\/span><\/div><\/div><\/pre>\n
Just to make sure that JIT compilation hasn’t happened, use the following:<\/p>\n
\n
$ java -<\/span>XX:+<\/span>UnlockExperimentalVMOptions -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation  -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler -<\/span>XX:-<\/span>TieredCompilation  -<\/span>XX:<\/span>CompileThreshold=<\/span>3<\/span> -<\/span>XX:<\/span>AOTLibrary=<\/span>.\/<\/span>libDemo.so<\/span> -<\/span>XX:+<\/span>PrintAOT Demo
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a019<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 loaded \u00a0 \u00a0 \u00a0 \u00a0.\/<\/span>libDemo.so<\/span> \u00a0aot library
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a077<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.square<\/span>(<\/span>I)<\/span>I
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a077<\/span> \u00a0 \u00a0 \u00a0 \u00a02<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.main<\/span>(<\/span>[<\/span>Ljava\/<\/span>lang\/<\/span>String<\/span><\/a>;<\/span>)<\/span>V
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a077<\/span> \u00a0 \u00a0 \u00a0 \u00a03<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.init><\/span>(<\/span>)<\/span>V
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a077<\/span> \u00a0 \u00a0 \u00a0 \u00a02<\/span> \u00a0 \u00a0 \u00a0 \u00a0 aot[<\/span> 1<\/span>]<\/span> \u00a0 Demo.main<\/span>(<\/span>[<\/span>Ljava\/<\/span>lang\/<\/span>String<\/span><\/a>;<\/span>)<\/span>V \u00a0 made not entrant
[<\/span>...]<\/span>
4<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 16<\/span>
Time<\/span><\/a> taken=<\/span> 43366<\/span>
[<\/span>...]<\/span>
10<\/span> iteration
\nSquare(<\/span>i)<\/span> =<\/span> 100<\/span>
Time<\/span><\/a> taken=<\/span> 59554<\/span><\/span><\/div><\/div><\/pre>\n
If any small change is made to the source code subjected to AOT, it’s important to ensure that the corresponding .so<\/code> is created again. Otherwise, the stale AOT-compiled .so<\/code> won’t have any effect. For example, make a small change to the square function such that now it’s calculating cube:<\/p>\n
\n
\/\/Demo.java<\/span>
public<\/span> class<\/span> Demo {<\/span>

\n\u00a0 public<\/span> int<\/span> square(<\/span>int<\/span> i)<\/span> throws<\/span> Exception<\/span><\/a> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 return<\/span>(<\/span>i*<\/span>i*<\/span>i)<\/span>;<\/span>
\n\u00a0 }<\/span>

\n\u00a0 public<\/span> static<\/span> void<\/span> main(<\/span>String<\/span><\/a>[<\/span>]<\/span> args)<\/span> throws<\/span> Exception<\/span><\/a> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i  10<\/span>;<\/span> i++<\/span>)<\/span> {<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"\"<\/span> +<\/span> Integer<\/span><\/a>.valueOf<\/span>(<\/span>i)<\/span>+<\/span>\" iteration\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 long<\/span> start =<\/span> System<\/span><\/a>.nanoTime<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 int<\/span> r=<\/span> new<\/span> Demo(<\/span>)<\/span>.square<\/span>(<\/span>i)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"Square(i) = \"<\/span> +<\/span> r)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 long<\/span> end =<\/span> System<\/span><\/a>.nanoTime<\/span>(<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"Time taken= \"<\/span> +<\/span> (<\/span>end-<\/span>start)<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 System<\/span><\/a>.out<\/span>.println<\/span>(<\/span>\"--------------------------------\"<\/span>)<\/span>;<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 }<\/span>
\n\u00a0 }<\/span>
}<\/span><\/span><\/div><\/div><\/pre>\n
Now, compile Demo.java<\/code> again:<\/p>\n
\n$ java Demo.java<\/span><\/code><\/span><\/pre>\n
But, don’t create libDemo.so<\/code> using jaotc<\/code>. Instead, use this command:<\/p>\n
\n
$ java -<\/span>XX:+<\/span>UnlockExperimentalVMOptions -<\/span>Xbatch -<\/span>XX:+<\/span>PrintCompilation -<\/span>XX:<\/span>CompileCommandFile=<\/span>hotspot_compiler -<\/span>XX:-<\/span>TieredCompilation -<\/span>XX:<\/span>CompileThreshold=<\/span>3<\/span> -<\/span>XX:<\/span>AOTLibrary=<\/span>.\/<\/span>libDemo.so<\/span> -<\/span>XX:+<\/span>PrintAOT Demo
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a020<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 loaded \u00a0 \u00a0 \u00a0 \u00a0.\/<\/span>libDemo.so<\/span> \u00a0aot library
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a074<\/span> \u00a0 \u00a0 \u00a0 \u00a01<\/span> \u00a0 \u00a0 \u00a0 \u00a0 n \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 java.lang<\/span>.invoke<\/span>.MethodHandle<\/span>::<\/span>linkToStatic(<\/span>LLLLLL)<\/span>L (<\/span>native<\/span>)<\/span> \u00a0 (<\/span>static<\/span>)<\/span>
2<\/span> iteration
\nsqrt(<\/span>i)<\/span> =<\/span> 8<\/span>
Time<\/span><\/a> taken=<\/span> 43838<\/span>
--------------------------------<\/span>
3<\/span> iteration
\n\u00a0 \u00a0 \u00a0 \u00a0 137<\/span> \u00a0 56<\/span> \u00a0 \u00a0 \u00a0 \u00a0b \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Demo::init><\/span> (<\/span>5<\/span> bytes)<\/span>
\n\u00a0 \u00a0 \u00a0 \u00a0 138<\/span> \u00a0 57<\/span> \u00a0 \u00a0 \u00a0 \u00a0b \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Demo::<\/span>square (<\/span>6<\/span> bytes)<\/span>
\nsqrt(<\/span>i)<\/span> =<\/span> 27<\/span>
Time<\/span><\/a> taken=<\/span> 534649<\/span>
--------------------------------<\/span>
4<\/span> iteration
\nsqrt(<\/span>i)<\/span> =<\/span> 64<\/span>
Time<\/span><\/a> taken=<\/span> 51916<\/span>
[<\/span>...]<\/span>
10<\/span> iteration
\nsqrt(<\/span>i)<\/span> =<\/span> 1000<\/span>
Time<\/span><\/a> taken=<\/span> 47132<\/span><\/span><\/div><\/div><\/pre>\n
Though the old version of libDemo.so<\/code> is loaded, JVM detected it as a stale one. Every time a .class<\/code> file is created, a fingerprint goes into the class file, and a class fingerprint is kept in the AOT library. Because the class fingerprint is different from the one in the AOT library, AOT-compiled native code is not used. Instead, the method is now JIT compiled, because the -XX:CompileThreshold<\/code> is set to 3.<\/p>\n
AOT or JIT?<\/h2>\n
If you are aiming to reduce the warm-up time of the JVM, use AOT, which reduces the burden during runtime. The catch is that AOT will not have enough data to decide which piece of code needs to be precompiled to native code. \u00a0By contrast, JIT pitches in during runtime and impacts the warm-up time. However, it will have enough profiling data to compile and decompile the code more efficiently.<\/p>\n<\/div>\n
\n
Use interpretation, just-in-time compilation, and ahead-of-time compilation efficiently by understanding the differences among them.<\/p>\n<\/div>\n
\n
\n
  \"Learning<\/div>\n
Image by: <\/span><\/p>\n
Image by\u00a0WOCinTech Chat<\/a>,\u00a0CC BY 2.0<\/a><\/p>\n<\/div>\n<\/article>\n<\/div>\n
\n
Java<\/a><\/div>\n<\/p><\/div>\n
What to read next<\/div>\n

\n        \"Creative<\/a>This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License.<\/div>\n
\n
\n
Register<\/a> or Login<\/a> to post a comment.<\/div>\n<\/p><\/div>\n<\/section>\n
Powered by WPeMatico<\/a><\/small><\/p>\n","protected":false},"excerpt":{"rendered":"
A guide to JVM interpretation and compilation Jayashree Hutt\u2026 Tue, 08\/09\/2022 – 10:36 Register or Login to like Register or Login to like Java is a platform-independent language. Programs are converted to bytecode after compilation. This bytecode gets converted to machine code at runtime. An interpreter emulates the execution of bytecode instructions for the abstract […]<\/p>\n","protected":false},"author":1,"featured_media":66346,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[307],"tags":[],"class_list":["post-66345","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-open-source"],"_links":{"self":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts\/66345","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=66345"}],"version-history":[{"count":0,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts\/66345\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/media\/66346"}],"wp:attachment":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=66345"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=66345"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=66345"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}