java - JMH:看似均匀的设置中的不均匀测试

Question

我正在玩 Math.max 看看它是否受到分支预测的影响(不，至少在 x64 的 JDK 上不是，有一个 cmovl)，如果按位实现可以与默认实现竞争。所有测试如下所示:

@Threads(4)
@State(Scope.Thread)
@BenchmarkMode({Mode.AverageTime, Mode.SampleTime})
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class CoreMaximum {
    private int[][] corpus;

    @Setup
    public void setUp() {
        corpus = Corpus.create();
    }

    @Benchmark
    public void constant(Blackhole blackhole) {
        val arguments = corpus[0];
        for (val payload : corpus) {
            blackhole.consume(arguments[0]);
            blackhole.consume(arguments[1]);
            blackhole.consume(payload[0]);
            blackhole.consume(payload[1]);
            blackhole.consume(Math.max(arguments[0], arguments[1]));
        }
    }

    @Benchmark
    public void random(Blackhole blackhole) {
        val payload = corpus[0];
        for (val arguments : corpus) {
            blackhole.consume(arguments[0]);
            blackhole.consume(arguments[1]);
            blackhole.consume(payload[0]);
            blackhole.consume(payload[1]);
            blackhole.consume(Math.max(arguments[0], arguments[1]));
        }
    }
}

其中 Math.max 可以替换为对另一个实现的调用，并且 Corpus.create() 返回 int[1_000_000][2] 由 SecureRandom 填充。

问题是，即使我确信被调用的代码不受分支预测的影响，并且在constant和random基准测试中执行均匀数量的负载和消耗，我仍然得到所有实现的基准的类似差异:

CoreMaximum.constant                               avgt     25         13.080 ±        0.680  ms/op
CoreMaximum.constant:CPI                           avgt      5          0.528 ±        0.027   #/op
CoreMaximum.constant:L1-dcache-load-misses         avgt      5     478734.008 ±     2419.011   #/op
CoreMaximum.constant:L1-dcache-loads               avgt      5   49990187.380 ±   114908.845   #/op
CoreMaximum.constant:L1-dcache-stores              avgt      5   17998192.002 ±    42008.496   #/op
CoreMaximum.constant:L1-icache-load-misses         avgt      5       2142.398 ±      526.619   #/op
CoreMaximum.constant:LLC-load-misses               avgt      5      28553.636 ±     1338.175   #/op
CoreMaximum.constant:LLC-loads                     avgt      5      33148.939 ±      667.526   #/op
CoreMaximum.constant:LLC-store-misses              avgt      5        150.218 ±       26.488   #/op
CoreMaximum.constant:LLC-stores                    avgt      5        271.536 ±      113.444   #/op
CoreMaximum.constant:branch-misses                 avgt      5        187.060 ±      123.697   #/op
CoreMaximum.constant:branches                      avgt      5   17001028.964 ±    32923.938   #/op
CoreMaximum.constant:cycles                        avgt      5   57063715.464 ±  2900664.885   #/op
CoreMaximum.constant:dTLB-load-misses              avgt      5      13153.047 ±     1808.179   #/op
CoreMaximum.constant:dTLB-loads                    avgt      5   49999483.367 ±    94718.665   #/op
CoreMaximum.constant:dTLB-store-misses             avgt      5         36.217 ±        7.357   #/op
CoreMaximum.constant:dTLB-stores                   avgt      5   17999664.120 ±    23160.612   #/op
CoreMaximum.constant:iTLB-load-misses              avgt      5         32.138 ±        4.584   #/op
CoreMaximum.constant:iTLB-loads                    avgt      5         16.571 ±       20.613   #/op
CoreMaximum.constant:instructions                  avgt      5  107989860.816 ±   240202.175   #/op
CoreMaximum.random                                 avgt     25         14.082 ±        0.717  ms/op
CoreMaximum.random:CPI                             avgt      5          0.503 ±        0.037   #/op
CoreMaximum.random:L1-dcache-load-misses           avgt      5     479117.110 ±     2632.690   #/op
CoreMaximum.random:L1-dcache-loads                 avgt      5   56030755.475 ±   120501.598   #/op
CoreMaximum.random:L1-dcache-stores                avgt      5   24015559.169 ±    51480.836   #/op
CoreMaximum.random:L1-icache-load-misses           avgt      5       2473.731 ±      968.508   #/op
CoreMaximum.random:LLC-load-misses                 avgt      5      29106.351 ±     1251.508   #/op
CoreMaximum.random:LLC-loads                       avgt      5      34274.838 ±     1178.339   #/op
CoreMaximum.random:LLC-store-misses                avgt      5        156.975 ±       29.332   #/op
CoreMaximum.random:LLC-stores                      avgt      5        268.092 ±      128.106   #/op
CoreMaximum.random:branch-misses                   avgt      5        169.811 ±      102.783   #/op
CoreMaximum.random:branches                        avgt      5   18007736.925 ±    42002.060   #/op
CoreMaximum.random:cycles                          avgt      5   61431988.502 ±  4506086.004   #/op
CoreMaximum.random:dTLB-load-misses                avgt      5      13157.184 ±     1496.518   #/op
CoreMaximum.random:dTLB-loads                      avgt      5   56026614.485 ±   144375.149   #/op
CoreMaximum.random:dTLB-store-misses               avgt      5         37.321 ±        6.870   #/op
CoreMaximum.random:dTLB-stores                     avgt      5   24011292.571 ±    54348.034   #/op
CoreMaximum.random:iTLB-load-misses                avgt      5         38.059 ±       19.549   #/op
CoreMaximum.random:iTLB-loads                      avgt      5         18.290 ±       36.399   #/op
CoreMaximum.random:instructions                    avgt      5  122045528.539 ±   313318.615   #/op

(我没有足够的经验来得出结论，但显然随机基准测试比常量具有更多的计数器，最值得注意的是指令 和分支)

Random 总是需要更长的时间并且有更多的指令，这显然表明基准测试没有考虑到某些内容，但我不知道出了什么问题。除了线程数之外，我没有调整任何东西(不知道为什么，但它只使用一个而不是核心数)，预热应该完成它们的工作(我看到 C2 已经编译了代码第一次预热)，并且转储 ASM(在 CompileCommandFile 中使用 print)除了几个 nops 和特定指令的放置之外没有显示出显着差异。我错过了什么？

Answer 1

虽然对我来说根本原因是什么仍然是个谜(可能 ASM 列表包含答案，但我没有足够的时间来挖掘所有这些)，但我想我发现了问题。删除 for 循环就完成了这项工作:

@Threads(4)
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class CoreMaximum {
    @Param({"true", "false"})
    public boolean constant;

    private int[][] corpus;

    @Setup
    public void setUp() {
        corpus = constant ? Corpus.constant() : Corpus.random();
    }

    @Benchmark
    public void run(Blackhole blackhole) {
        blackhole.consume(Math.max(corpus[0][0], corpus[0][1]));
        blackhole.consume(Math.max(corpus[1][0], corpus[1][1]));
        blackhole.consume(Math.max(corpus[2][0], corpus[2][1]));
        blackhole.consume(Math.max(corpus[3][0], corpus[3][1]));
        blackhole.consume(Math.max(corpus[4][0], corpus[4][1]));
        blackhole.consume(Math.max(corpus[5][0], corpus[5][1]));
        blackhole.consume(Math.max(corpus[6][0], corpus[6][1]));
        blackhole.consume(Math.max(corpus[7][0], corpus[7][1]));
        blackhole.consume(Math.max(corpus[8][0], corpus[8][1]));
        blackhole.consume(Math.max(corpus[9][0], corpus[9][1]));
        blackhole.consume(Math.max(corpus[10][0], corpus[10][1]));
        blackhole.consume(Math.max(corpus[11][0], corpus[11][1]));
        blackhole.consume(Math.max(corpus[12][0], corpus[12][1]));
        blackhole.consume(Math.max(corpus[13][0], corpus[13][1]));
        blackhole.consume(Math.max(corpus[14][0], corpus[14][1]));
        blackhole.consume(Math.max(corpus[15][0], corpus[15][1]));
        blackhole.consume(Math.max(corpus[16][0], corpus[16][1]));
        blackhole.consume(Math.max(corpus[17][0], corpus[17][1]));
        blackhole.consume(Math.max(corpus[18][0], corpus[18][1]));
        blackhole.consume(Math.max(corpus[19][0], corpus[19][1]));
        blackhole.consume(Math.max(corpus[20][0], corpus[20][1]));
        blackhole.consume(Math.max(corpus[21][0], corpus[21][1]));
        blackhole.consume(Math.max(corpus[22][0], corpus[22][1]));
        blackhole.consume(Math.max(corpus[23][0], corpus[23][1]));
        blackhole.consume(Math.max(corpus[24][0], corpus[24][1]));
        blackhole.consume(Math.max(corpus[25][0], corpus[25][1]));
        blackhole.consume(Math.max(corpus[26][0], corpus[26][1]));
        blackhole.consume(Math.max(corpus[27][0], corpus[27][1]));
        blackhole.consume(Math.max(corpus[28][0], corpus[28][1]));
        blackhole.consume(Math.max(corpus[29][0], corpus[29][1]));
        blackhole.consume(Math.max(corpus[30][0], corpus[30][1]));
        blackhole.consume(Math.max(corpus[31][0], corpus[31][1]));
    }
}

Benchmark                              (constant)  Mode  Cnt     Score    Error  Units
CoreMaximum.run                              true  avgt   25    92.235 ±  7.998  ns/op
CoreMaximum.run:CPI                          true  avgt    5     0.392 ±  0.049   #/op
CoreMaximum.run:instructions                 true  avgt    5  1000.988 ±  5.330   #/op
CoreMaximum.run                             false  avgt   25    92.556 ±  9.010  ns/op
CoreMaximum.run:CPI                         false  avgt    5     0.390 ±  0.074   #/op
CoreMaximum.run:instructions                false  avgt    5   999.559 ±  5.132   #/op

我手动展开循环，因为单次基准测试没有理由分支，并且在基准测试中引入对 Random/SecureRandom 的直接调用可能会比实际执行调用太容易出错。而且，说实话，面对这样的问题，移除实际的测试对象并检查结果应该是第一件事。

对于那些通过谷歌最终到达这里的人来说:当你发现测试中有一些错误并且没有时间充分挖掘时，你可以作弊。如果您确定基准测试的某些部分在撒谎，您可以尝试找出它是哪个部分并重写您的基准测试以消除它。 但请记住，a)获得您想要看到的数字并不能证明任何事情，而是让您感到安慰，而不是实际证实一个假设；b)如果您想正确做事，您必须找出根本原因，否则你的基准测试只是一种逃避，(再次)可能隐藏了一个错误。 这次我作弊只是因为 a) 我没有做我工作的一部分等等b)我对结果很确定，因为我已经看到了所有实现的 ASM 列表，以及我所追求的实际实现 - 库之一 -只是少数指令，所有这些指令都排除了分支预测的可能性。 如果寻找准确答案是您工作的一部分，请不要作弊，否则您将无法解决您正在寻找的问题。