分支预测：编写代码以理解它； 获得奇怪的结果

Question

我试图通过测量运行具有可预测分支的循环与运行具有随机分支的循环的时间来更好地理解分支预测。

因此，我编写了一个程序，该程序采用以不同顺序排列的大型0和1数组（即全0，重复0-1，所有rand），并根据当前索引是0还是1，遍历数组分支进行时间浪费工作。

我预计很难猜测的数组将花费更长的时间运行，因为分支预测器会更频繁地猜测错误，并且两组数组在两次运行之间的时间增量将保持不变，而与时间量无关。浪费工作。

但是，随着浪费时间的工作量增加，阵列之间的运行时间差也增加了很多。

（X轴是浪费时间的工作量，Y轴是运行时间）

有谁了解这种行为？ 您可以在以下代码中看到我正在运行的代码：

#include <stdlib.h>
#include <time.h>
#include <chrono>
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
static const int s_iArrayLen = 999999;
static const int s_iMaxPipelineLen = 60;
static const int s_iNumTrials = 10;

int doWorkAndReturnMicrosecondsElapsed(int* vals, int pipelineLen){
        int* zeroNums = new int[pipelineLen];
        int* oneNums = new int[pipelineLen];
        for(int i = 0; i < pipelineLen; ++i)
                zeroNums[i] = oneNums[i] = 0;

        chrono::time_point<chrono::system_clock> start, end;
        start = chrono::system_clock::now();
        for(int i = 0; i < s_iArrayLen; ++i){
                if(vals[i] == 0){
                        for(int i = 0; i < pipelineLen; ++i)
                                ++zeroNums[i];
                }
                else{
                        for(int i = 0; i < pipelineLen; ++i)
                                ++oneNums[i];
                }
        }
        end = chrono::system_clock::now();
        int elapsedMicroseconds = (int)chrono::duration_cast<chrono::microseconds>(end-start).count();

        //This should never fire, it just exists to guarantee the compiler doesn't compile out our zeroNums/oneNums
        for(int i = 0; i < pipelineLen - 1; ++i)
                if(zeroNums[i] != zeroNums[i+1] || oneNums[i] != oneNums[i+1])
                        return -1;
        delete[] zeroNums;
        delete[] oneNums;
        return elapsedMicroseconds;
}

struct TestMethod{
        string name;
        void (*func)(int, int&);
        int* results;

        TestMethod(string _name, void (*_func)(int, int&)) { name = _name; func = _func; results = new int[s_iMaxPipelineLen]; }
};

int main(){
        srand( (unsigned int)time(nullptr) );

        vector<TestMethod> testMethods;
        testMethods.push_back(TestMethod("all-zero", [](int index, int& out) { out = 0; } ));
        testMethods.push_back(TestMethod("repeat-0-1", [](int index, int& out) { out = index % 2; } ));
        testMethods.push_back(TestMethod("repeat-0-0-0-1", [](int index, int& out) { out = (index % 4 == 0) ? 0 : 1; } ));
        testMethods.push_back(TestMethod("rand", [](int index, int& out) { out = rand() % 2; } ));

        int* vals = new int[s_iArrayLen];

        for(int currentPipelineLen = 0; currentPipelineLen < s_iMaxPipelineLen; ++currentPipelineLen){
                for(int currentMethod = 0; currentMethod < (int)testMethods.size(); ++currentMethod){
                        int resultsSum = 0;
                        for(int trialNum = 0; trialNum < s_iNumTrials; ++trialNum){
                                //Generate a new array...
                                for(int i = 0; i < s_iArrayLen; ++i)  
                                        testMethods[currentMethod].func(i, vals[i]);

                                //And record how long it takes
                                resultsSum += doWorkAndReturnMicrosecondsElapsed(vals, currentPipelineLen);
                        }

                        testMethods[currentMethod].results[currentPipelineLen] = (resultsSum / s_iNumTrials);
                }
        }

        cout << "\t";
        for(int i = 0; i < s_iMaxPipelineLen; ++i){
                cout << i << "\t";
        }
        cout << "\n";
        for (int i = 0; i < (int)testMethods.size(); ++i){
                cout << testMethods[i].name.c_str() << "\t";
                for(int j = 0; j < s_iMaxPipelineLen; ++j){
                        cout << testMethods[i].results[j] << "\t";
                }
                cout << "\n";
        }
        int end;
        cin >> end;
        delete[] vals;
}

Pastebin链接： http ： //pastebin.com/F0JAu3uw

Answer 1

我认为您可能正在衡量缓存/内存性能，而不是分支预测。 您内部的“工作”循环正在访问越来越多的内存。 这可以解释线性增长，周期性行为等。

我可能是错的，因为我没有尝试复制您的结果，但是如果您是我，我会在计时其他事项之前考虑内存访问。 也许将一个volatile变量加到另一个变量中，而不是在数组中工作。

还要注意的是，根据CPU的不同，分支预测可能比仅记录上次执行分支要聪明得多-例如，重复模式不如随机数据那么糟糕。

好吧，我在下午茶休息时间进行了一次快速而肮脏的测试，试图反映您自己的测试方法，但又不影响缓存，如下所示：

这是您期望的吗？

如果以后我有空的话，我还想尝试一下其他方法，因为我还没有真正研究过编译器在做什么……

编辑：

而且，这是我的最终测试-我在汇编器中对其进行了编码，以删除循环分支，并确保每个路径中的指令数量准确，依此类推。

我还添加了一种额外的情况，即5位重复模式。 似乎很难使我老化的Xeon上的分支预测器失效。

Answer 2

除了JasonD指出的内容外，我还想指出for循环内部还有一些条件，这些条件可能会影响分支预测：

if(vals[i] == 0)
{
    for(int i = 0; i < pipelineLen; ++i)
        ++zeroNums[i];
}

我<pipelineLen; 是像if那样的条件。 当然，编译器可能会展开此循环，但是pipelineLen是传递给函数的参数，因此可能不是。

我不确定这是否可以解释您的结果呈波浪形，但是：

由于BTB在奔腾4处理器中只有16个条目，因此对于超过16个迭代的循环，预测最终将失败。 通过展开循环直到只有16个迭代长，可以避免此限制。 完成此操作后，循环条件将始终适合BTB，并且在循环退出时不会发生分支错误预测。 以下是循环展开的示例：

阅读全文： http : //software.intel.com/zh-cn/articles/branch-and-loop-reorganization-to-prevent-mispredicts

因此，循环不仅在测量内存吞吐量，而且还在影响BTB。

如果您已在列表中传递了0-1模式，但随后执行了pipelineLen = 2的for循环，则您的BTB将被填充为0-1-1-0 - 1-1-1-0 - 0-1-1-0 - 1-1-1-0 ，然后它会开始重叠，因此这确实可以解释您的结果呈波浪形（某些重叠比其他重叠更有害）。

以此为例说明可能发生的情况，而不是字面意义。 您的CPU可能具有更为复杂的分支预测架构。