Performance optimization: JIT just-in-time compilation and AOT ahead-of-time compilation

JIT Just-in-time compilation refers to the process of converting bytecode into machine code that can be run directly on the hardware during the running process of the program and deploying it to the hosting environment. AOT compilation refers to the process of converting bytecode into machine code before the program is run.

.java -> .class -> (using jaotc compilation tool) -> .so (program function library, that is, compiled code and data that can be used by other programs)

2. JIT

In the HotSpot virtual machine, there are two types of JIT built in, namely the C1 compiler and the C2 compiler. The compilation process of these two compilers is different.

【1】C1 compiler: C1 compiler is a simple and fast compiler. The main focus is on local optimization. It is suitable for For programs that have short execution times or require startup performance, it is also called Client Compiler.
【2】C2 compiler: C2 compiler is a compiler that performs performance tuning for long-running server-side applications and is suitable for Programs that take a long time to execute or require peak performance are also called Server Compiler. For example, long-running Java applications on the server have certain requirements for stable operation. . JDK 6 begins to define server-level machines as having at least two CPU and 2GB of physical memory before enabling C2;
【3】Layered compilation: In Java8, layered compilation is enabled by default. Before 1.8, layered compilation was turned off by default. Before Java7, you needed to select the corresponding JIT based on the characteristics of the program. By default, the virtual machine used an interpreter to work with one of the compilers.

Layered compilation divides the execution status of JVM into 5 levels:
[1] Layer 0: Program interpretation and execution, the performance monitoring function Profiling is enabled by default. If it is not enabled, the second layer of compilation can be triggered;
【2】Level 1: It can be called C1 compilation, which compiles bytecode into local code for simple and reliable optimization without turning on Profiling;
【3】Level 2: Also known as C1 compilation, turn on Profiling, and only perform the number of method calls and the number of loopback executions profiling Compiled with C1;
【4】Level 3: Also called C1 compilation, performs all C1 compilation with Profiling;
[5] Layer 4: It can be called C2 compilation, which also compiles bytecode into local code, but will enable some optimizations that take a long time to compile, and even perform some optimizations based on performance monitoring information. Unreliable aggressive optimization.

mixed mode represents the default mixed compilation mode. In addition to this mode, we can also use the -Xint parameter to force the virtual machine to run in the interpreter-only compilation mode. At this time, JIT does not intervene at all; you can also use the parameter -Xcomp to force the virtual machine to run in the compilation mode of only JIT. as follows:

If you only want to enable C2, you can turn off tiered compilation -XX:-TieredCompilation. If you only want to use C1, you can turn on tiered compilation. At the same time, use the parameters: -XX:TieredStopAtLevel=1

C1, C2 and C1 + C2 correspond to client, server and layered compilation respectively. C1 has a fast compilation speed and a conservative optimization method; C2 has a slow compilation speed and a more aggressive optimization method. C1 + C2 is compiled with C1 at the beginning, and is recompiled with G2 when the code reaches a certain temperature.

The parameter -XX:ReservedCodeCacheSize = N (where N is the default value provided for a specific compiler) mainly sets the size of the hot code cache codecache. If the cache is not enough, JIT will not be able to continue compilation and will be optimized. For example, compilation execution will be changed to interpretation execution. As a result, performance will be reduced. At the same time, you can check the usage of codecache through java -XX: + PrintCodeCache:

C:/Users/Administrator> java -XX: + PrintCodeCache
CodeCache: size=245760Kb used=1165Kb max_used=1165Kb free=244594Kb
 bounds [0x000000010be1b000, 0x000000010c08b000, 0x00000011ae1b000]
 total_blobs=293 nmethods=48 adapters=159
 compilation: enable

Related parameters:

How to determine hot code

[1] Sampling-based hotspot detection: Mainly the virtual machine periodically checks the top of the stack of each thread. If a certain method or methods often appear on the top of the stack, then this method is a “hotspot method” “. The advantage is that it is simple to implement. The disadvantage is that it is difficult to accurately determine the popularity of a method, and it is easily affected by thread blocking or external factors.
[2] Counter-based hotspot detection (Typical application-Hotspot): Mainly, the virtual machine establishes a counter for each method or even code block to count the number of execution times of the method. If it exceeds a certain threshold, Mark this method as a hotspot method. Counter-based hotspot detection method used by Hotspot. Then two types of counters are used: method call counters and edge counters. When the sum of the method counter and the edge counter exceeds the method counter threshold, the JIT compiler is triggered.
[3] Method call counter: The method call counter is used to count the number of times a method is called. The default threshold is 1500 times in C1 mode. In C2 mode, it is 10000 times, which can be set by -XX: CompileThreshold; in the case of layered compilation The threshold specified by -XX: CompileThreshold will become invalid and will be dynamically adjusted based on the current number of methods to be compiled and the number of compilation threads.
[4] Edge-back counter: The edge-back counter is used to count the number of times the loop body code is executed in a method. Instructions that jump back when the control flow is encountered in the bytecode are called “edge-back” Back Edge, this value is used to calculate the threshold for triggering C1 compilation. When layered compilation is not enabled, C1 defaults to 13995, C2 defaults to 10700, which can be set by -XX: OnStackReplacePercentage=N; while in layered compilation In the case of -XX: OnStackReplacePercentage, the threshold specified will also be invalid. At this time, it will be dynamically adjusted according to the current number of methods to be compiled and the number of compilation threads.

Edge counter threshold calculation rules:
1. In C1 mode: CompileThreshold*OnStackReplacePercentage/100; that is: method call counter threshold *OSR ratio/100;
2. In C2 mode: (CompileThreshold)*(OnStackReplacePercentage-InterpreterProfilePercentage)/100; that is: method call counter threshold * (OSR ratio – Interpreter monitoring ratio)/100;

JIT optimization

JIT compilation uses some classic compilation optimization techniques to achieve code optimization: there are two main types: Method inlining and escape analysis.

 private int add1(int s1, int s2, int s3, int s4) {<!-- -->
        return add2(s1 + s2) + add2(s3 + s4);
    }

    private int add2(int s1, int s2) {<!-- -->
        return s1 + s2;
    }

    //Code after method inline
    private int add(int s1, int s2, int s3, int s4) {<!-- -->
        return s1 + s2 + s3 + s4;
    }

 //-XX:-EliminateLocks First close the lock to eliminate it, then open it. Execute this code 1 million times to view the difference.
    public static String getString(String s1, String s2) {<!-- -->
        StringBuffer sb = new StringBuffer();
        sb.append(s1);
        sb.append(s2);
        return sb.toString();
    }

public void foo() {<!-- -->
    Person info = new Person ();
    info.name = "queen";
    info.age= 18;
}

//After escape analysis, the code will be optimized (scalar replacement) as:
public void foo() {<!-- -->
    String name= "queen";
    int age= 18;
}

Variable name: JAVA_HOME
Variable value: D:\graalvm-ce-java17-22.3.0

C:/Users/Administrator>java -version
openjdk version "17.0.5" 2023-10-32
OpenJDK Runtime Environment GraalVM CE 22.3.0 (build 17.0.5 + 8-jvmci-22.3-b08)
OpenJDK 64-Bit Server VM GraalVM CE 22.3.0 (build 17.0.5 + 8-jvmci-22.3-b08, mixed mode, sharing)

C:/Users/Administrator>gu install native-image
...
C:/Users/Administrator>gu list
...
native-image 22.3.0 Native Image Early adopter