Question

我试图衡量分支预测成本，我创建了一个小程序。

它将在堆栈上创建一个小缓冲区，以随机0/1填充。我可以使用N设置缓冲区的大小。该代码会反复导致分支产生相同的1<<N随机数。

现在，我已经预料到，如果1<<N足够大（例如> 100），则分支预测变量将无效（因为它必须预测> 100个随机数）。但是，这些是结果（在5820k机器上），随着N的增长，程序变得越来越慢：

N   time
=========
8   2.2
9   2.2
10  2.2
11  2.2
12  2.3
13  4.6
14  9.5
15  11.6
16  12.7
20  12.9

作为参考，如果将缓冲区初始化为零（使用注释的init），则时间或多或少是恒定的，对于N 8..16，时间在1.5-1.7之间变化。 / p>

我的问题是：分支预测变量可以有效预测如此大量的随机数吗？如果没有，那么这是怎么回事？

（更多解释：无论N，代码执行2 ^ 32个分支。所以我希望，无论N，代码都以相同的速度运行，因为分支无法完全可以预测。但是，如果缓冲区大小小于4096（N <= 12），似乎可以使代码快速运行。分支预测对4096个随机数有效吗？）

代码如下：

#include <cstdint>
#include <iostream>

volatile uint64_t init[2] = { 314159165, 27182818 };
// volatile uint64_t init[2] = { 0, 0 };
volatile uint64_t one = 1;

uint64_t next(uint64_t s[2]) {
    uint64_t s1 = s[0];
    uint64_t s0 = s[1];
    uint64_t result = s0 + s1;
    s[0] = s0;
    s1 ^= s1 << 23;
    s[1] = s1 ^ s0 ^ (s1 >> 18) ^ (s0 >> 5);
    return result;
}

int main() {
    uint64_t s[2];
    s[0] = init[0];
    s[1] = init[1];

    uint64_t sum = 0;

#if 1
    const int N = 16;

    unsigned char buffer[1<<N];
    for (int i=0; i<1<<N; i++) buffer[i] = next(s)&1;

    for (uint64_t i=0; i<uint64_t(1)<<(32-N); i++) {
        for (int j=0; j<1<<N; j++) {
            if (buffer[j]) {
                sum += one;
            }
        }
    }
#else
    for (uint64_t i=0; i<uint64_t(1)<<32; i++) {
        if (next(s)&1) {
            sum += one;
        }
    }

#endif
    std::cout<<sum<<"\n";
}

（该代码也包含非缓冲版本，请使用#if 0。它的运行速度与使用N=16的缓冲版本相同）

这是内部循环反汇编（与clang一起编译。它为8..16之间的所有N生成相同的代码，只是循环数不同。Clang展开了两次循环）：

  401270:       80 3c 0c 00             cmp    BYTE PTR [rsp+rcx*1],0x0
  401274:       74 07                   je     40127d <main+0xad>
  401276:       48 03 35 e3 2d 00 00    add    rsi,QWORD PTR [rip+0x2de3]        # 404060 <one>
  40127d:       80 7c 0c 01 00          cmp    BYTE PTR [rsp+rcx*1+0x1],0x0
  401282:       74 07                   je     40128b <main+0xbb>
  401284:       48 03 35 d5 2d 00 00    add    rsi,QWORD PTR [rip+0x2dd5]        # 404060 <one>
  40128b:       48 83 c1 02             add    rcx,0x2
  40128f:       48 81 f9 00 00 01 00    cmp    rcx,0x10000
  401296:       75 d8                   jne    401270 <main+0xa0>

Answer 1

分支预测可以如此有效。正如彼得·科德斯（Peter Cordes）所建议的那样，我已经用perf stat检查了分支丢失。结果如下：

N   time          cycles  branch-misses (%)      approx-time
===============================================================
8    2.2   9,084,889,375         34,806 ( 0.00)    2.2
9    2.2   9,212,112,830         39,725 ( 0.00)    2.2
10   2.2   9,264,903,090      2,394,253 ( 0.06)    2.2
11   2.2   9,415,103,000      8,102,360 ( 0.19)    2.2
12   2.3   9,876,827,586     27,169,271 ( 0.63)    2.3
13   4.6  19,572,398,825    486,814,972 (11.33)    4.6
14   9.5  39,813,380,461  1,473,662,853 (34.31)    9.5
15  11.6  49,079,798,916  1,915,930,302 (44.61)   11.7
16  12.7  53,216,900,532  2,113,177,105 (49.20)   12.7
20  12.9  54,317,444,104  2,149,928,923 (50.06)   12.9

Note: branch-misses (%) is calculated for 2^32 branches

如您所见，当N<=12时，分支预测器可以预测大多数分支（这令人惊讶：分支预测器可以存储4096个连续随机分支的结果！）。当N>12时，分支丢失开始增加。在N>=16，它只能正确预测约50％，这与随机掷硬币一样有效。

可以通过查看时间和分支丢失（％）列来估算所花费的时间：我添加了最后一列approx-time。我是这样计算的：2.2+(12.9-2.2)*branch-misses %/100。如您所见，approx-time等于time（不考虑舍入误差）。因此，这种效果可以通过分支预测来完美解释。

最初的目的是计算分支未命中所花费的周期数（在这种情况下-对于其他情况，此数字可能会有所不同）：

(54,317,444,104-9,084,889,375)/(2,149,928,923-34,806) = 21.039 = ~21 cycles.

了解分支预测效率

1 个答案: