Phillip Borge's questions

我没有将任何东西编译为本机，换句话说，我没有使用native-imageGraalVM。我只是使用 GraalVM 运行相同的 Java 类（相同的 Java 字节码），然后使用常规 Oracle JVM 运行相同的 Java 类（相同的 Java 字节码）。

我使用哪个版本的 Java 或平台并不重要（我在 Linux 和 Mac 上进行了测试）。GraalVM 总是比任何其他常规 JVM 快得多（30 倍）。

看起来常规 JVM 未使用其 JIT 正确优化该方法。请注意，该方法非常简单且很小。

有谁知道为什么会出现这种情况，以及我如何在常规 JVM 中修复这个问题？目前唯一的解决方法是迁移到 GraalVM。编译并运行下面的代码来重现该问题非常容易。只需先使用 Oracle JVM 编译然后运行，然后使用任何 Graal JVM 即可看到差异。

谢谢！

public class OracleJvm23MathBug {

    // simple and small amount of math
    // =====> should be optimized/compiled/inlined for sure!
    private static final long doSomething(int load, int i) {
        long x = 0;
        for (int j = 0; j < load; j++) {
            long pow = (i % 8) * (i % 16);
            if (i % 2 == 0) {
                x += pow;
            } else {
                x -= pow;
            }
        }
        return x;
    }

    /*
     * Execute this with OpenJDK/Zulu/Oracle JVM 23 => average 215 nanoseconds
     * Now execute this with Graal23 JVM 23 => average 7 nanoseconds
     * 
     * This bug can be observed in any platform (I tested on Linux and Mac)
     * 
     * $ java -version 
     * java version "23.0.1" 2024-10-15 
     * Java(TM) SE Runtime Environment (build 23.0.1+11-39)
     * Java HotSpot(TM) 64-Bit Server VM (build 23.0.1+11-39, mixed mode, sharing)
     * 
     * $ java -cp . OracleJvm23MathBug
     * Value computed: -550000000000
     * Measurements: 10000000| Avg Time: 215 nanos | Min Time: 83 nanos | Max Time: 199750 nanos
     * 
     * $ java -version
     * java version "23.0.1" 2024-10-15
     * Java(TM) SE Runtime Environment Oracle GraalVM 23.0.1+11.1 (build 23.0.1+11-jvmci-b01)
     * Java HotSpot(TM) 64-Bit Server VM Oracle GraalVM 23.0.1+11.1 (build 23.0.1+11-jvmci-b01, mixed mode, sharing)
     * 
     * $ java -cp . OracleJvm23MathBug
     * Value computed: -550000000000
     * Measurements: 10000000| Avg Time: 7 nanos | Min Time: 0 nanos | Max Time: 178625 nanos
     */
    public static final void main(String[] args) {
        final int iterations = 10_000_000;
        final int load = 10_000;
        NanoBench bench = new NanoBench();
        long computed = 0;
        for (int i = 0; i < iterations; i++) {
            bench.mark();
            computed += doSomething(load, i);
            bench.measure();
        }
        System.out.println("Value computed: " + computed);
        bench.printResults();
    }

    private static class NanoBench {

        private int measurements;
        private long totalTime, minTime, maxTime, time;
        private final StringBuilder sb = new StringBuilder(128);

        NanoBench() {
            reset();
        }

        public final void reset() {
            totalTime = time = measurements = 0;
            maxTime = Long.MIN_VALUE;
            minTime = Long.MAX_VALUE;
        }

        public final void mark() {
            time = System.nanoTime();
        }

        public final void measure() {
            long lastNanoTime = System.nanoTime() - time;
            totalTime += lastNanoTime;
            minTime = lastNanoTime < minTime ? lastNanoTime : minTime;
            maxTime = lastNanoTime > maxTime ? lastNanoTime : maxTime;
            measurements++;
        }

        public final void printResults() {
            sb.setLength(0);
            sb.append("Measurements: ").append(measurements);
            sb.append("| Avg Time: ").append((long) (totalTime / (double) measurements)).append(" nanos");
            sb.append(" | Min Time: ").append(minTime).append(" nanos");
            sb.append(" | Max Time: ").append(maxTime).append(" nanos\n\n");
            for (int i = 0; i < sb.length(); i++) System.out.print(sb.charAt(i));
        }
    }
}