java - Java Hotspot 服务器中多态性的高成本

Question

当我在 Java Hotspot 客户端中运行计时测试程序时，我得到了一致的行为。然而，当我在 Hotspot 服务器上运行它时，我得到了意想不到的结果。本质上，在我尝试过的某些情况下，多态性的成本高得令人无法接受复制下面。

这是 Hotspot 服务器的已知问题/错误，还是我做错了什么？

测试程序和时间如下:

Intel i7, Windows 8
Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode)
Mine2: 0.387028831 <--- polymorphic call with expected timing
Trivial: 1.545411765 <--- some more polymorphic calls
Mine: 0.727726371 <--- polymorphic call with unexpected timing. Should be about 0.38
Mine: 0.383132698 <--- direct call with expected timing

随着我添加额外的测试，情况变得更糟。列表末尾附近的测试时间完全关闭。

interface canDoIsSquare {
    boolean isSquare(long x);
}

final class Trivial implements canDoIsSquare {
    @Override final public boolean isSquare(long x) {
        if (x > 0) {
            long t = (long) Math.sqrt(x);
            return t * t == x;
        }
        return x == 0;
    }
    @Override public String toString() {return "Trivial";}
}

final class Mine implements canDoIsSquare {
    @Override final public boolean isSquare(long x) {
        if (x > 0) {
            while ((x & 3) == 0)
                x >>= 2;
            if ((x & 2) != 0 || (x & 7) == 5)
                return false;
            final long t = (long) Math.sqrt(x);
            return (t * t == x);
        }
        return x == 0;
    }

    @Override public String toString() {return "Mine";}
}

final class Mine2 implements canDoIsSquare {
    @Override final public boolean isSquare(long x) {
        // just duplicated code for this test
        if (x > 0) {
            while ((x & 3) == 0)
                x >>= 2;
            if ((x & 2) != 0 || (x & 7) == 5)
                return false;
            final long t = (long) Math.sqrt(x);
            return (t * t == x);
        }
        return x == 0;
    }
    @Override final public String toString() {return "Mine2";}
}

public class IsSquared {
    static final long init = (long) (Integer.MAX_VALUE / 8)
            * (Integer.MAX_VALUE / 2) + 1L;

    static long test1(final canDoIsSquare fun) {
        long r = init;
        long startTimeNano = System.nanoTime();
        while (!fun.isSquare(r))
            ++r;
        long taskTimeNano = System.nanoTime() - startTimeNano;
        System.out.println(fun + ": " + taskTimeNano / 1e9);
        return r;
    }

    static public void main(String[] args) {
        Mine mine = new Mine();
        Trivial trivial = new Trivial();
        Mine2 mine2 = new Mine2();

        test1(mine2);
        test1(trivial);
        test1(mine);

        long r = init;
        long startTimeNano = System.nanoTime();
        while (!mine.isSquare(r))
            ++r;
        long taskTimeNano = System.nanoTime() - startTimeNano;
        System.out.println(mine + ": " + taskTimeNano / 1e9);
        System.out.println(r);
    }
}

Answer 1

的确，成本很高，但您的基准并没有衡量任何真正相关的东西。 JIT 可以优化大部分开销，但您没有给它任何机会。参见例如here .

无论如何，没有基准预热并且有 On Stack Replacement .

解释可能是Server Hotspot优化的比较好但是比较慢。它假定它有足够的时间并且收集必要的统计数据的时间更长。因此，在客户端热点优化您的程序的同时，服务器热点也在准备自己生成更好的代码。

额外测试导致恶化的原因是最初是单态的 call site变成了双态，然后是巨态。

实际上，可能只会调用其中一种方法。如果要对此进行基准测试，则必须在其自己的 JVM 中运行每个测试。这是一个真正的痛苦，但现有的基准测试框架可以为您做到这一点。

或者您可能想要测量多态情况，但是您需要先用所有情况预热代码。通过这种方式，即使在单个 JVM 中，您也可以找出哪个方法更快(尽管每个方法都会因巨态调用开销而变慢。

更新

解释似乎是从单态到巨态的变化。当第一个测试运行时，JVM 知道所有类(因为实例已经创建)，但乐观地假设调用站点上只出现 Mine2。所以它做了一个快速检查(翻译为条件分支，它总是被正确预测，因此非常快)，并调用了正确的方法。因为它后来看到其他两个实例在那里使用，所以它必须为它们创建一个分支表(分支预测仍然有效，但开销更高)。

问题

不清楚的地方:JVM 可以将此测试移出循环，从而将其成本降低到几乎为零。我不知道为什么它没有发生。