6

当我在 Java 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);
    }
}
4

2 回答 2

7

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

无论如何,没有基准热身,并且有On Stack Replacement

解释可能是服务器热点优化得更好但更慢。它假设它有足够的时间并更长时间地收集必要的统计数据。因此,当客户端热点优化您的程序时,服务器热点正在准备自己生成更好的代码。

附加测试恶化的原因是最初的单态调用位点变成双态,然后变成超态。

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

或者您可能想要测量多态案例,但是您需要先对所有案例的代码进行预热。这样,即使在单个 JVM 中,您也可以找出哪种方法更快(尽管每个方法都会因超态调用开销而变慢。

更新

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

问题

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

于 2013-11-08T06:59:52.143 回答
0

简而言之,JIT 可以优化单个方法调用和两个方法调用,但它无法处理更多的多态调用。可能在任何给定行上调用的可能方法的数量是最重要的,JIT 会随着时间的推移建立起这张图片。当一个方法被内联时,进一步的优化是可能的,但在你的情况下,有问题的行增加了test1在整个运行生命周期中可能的方法调用的数量,因此它变得更慢。

我解决此问题的方法是复制简短的测试代码,以便对每个类进行平等测试(假设这是现实的)看到它可以改变结果。

当您从一个新循环运行该方法时,您会看到仅从该代码行调用一个方法的好处。

以下是您可能会看到的不同成本的表格,具体取决于任何单独的线路可以调用的可能方法的数量。http://vanillajava.blogspot.co.uk/2012/12/performance-of-inlined-virtual-method.html

多态性并不是为了提高性能而设计的,对我来说,随着多态性复杂性的增加,它应该变慢是完全合理的。

顺便说一句,制作方法final不再提高性能。如果您已逐行调用子类(如讨论的),则 JIT 会起作用


编辑正如您所见,clientJVM 并没有像设计的那样优化代码,因为它的设计时间相对较轻,只有 8 次启动时间。这意味着客户端 JVM 更加一致,但始终较慢。如果您想要获得最佳性能,则需要考虑多种优化策略,这些策略会导致多种可能的结果,具体取决于是否应用了优化。

于 2013-11-08T09:54:13.620 回答