寻求不适配现代CPU预取器、缓存等微架构的基准测试代码片段

针对分支预测器的低效代码 #

现代CPU的分支预测器依赖分支结果的可预测性（比如循环的固定方向、重复的条件模式），以下代码完全破坏了这种可预测性：

#include <stdlib.h>
#include <time.h>

int main() {
    srand(time(NULL));
    int sum = 0;
    for (int i = 0; i < 10000000; i++) {
        if (rand() % 2 == 0) {
            sum += i;
        } else {
            sum -= i;
        }
    }
    return sum;
}

这段代码的分支结果完全随机，分支预测器的准确率接近50%（相当于瞎猜），每次预测错误都会导致CPU流水线清空，性能暴跌。

针对指令预取器的低效代码 #

顺序指令预取器会按内存地址顺序预取后续指令，但无规律的间接跳转完全打乱了预取逻辑：

#include <stdlib.h>
#include <time.h>

void func1() {}
void func2() {}
void func3() {}
void func4() {}
void func5() {}

typedef void (*FuncPtr)();
FuncPtr funcs[] = {func1, func2, func3, func4, func5};

int main() {
    srand(time(NULL));
    for (int i = 0; i < 10000000; i++) {
        int idx = rand() % 5;
        funcs[idx]();
    }
    return 0;
}

每次间接跳转的目标都是随机的函数，预取器无法提前获取目标指令，导致流水线频繁停滞，完全无法利用预取带来的带宽优势。

针对数据缓存的低效代码 #

CPU的L1/L2数据缓存依赖空间局部性（连续访问相邻内存地址），以下代码完全破坏了这一特性：

#include <stdlib.h>
#include <time.h>

#define ARR_SIZE 1000000

int main() {
    srand(time(NULL));
    int* arr = malloc(ARR_SIZE * sizeof(int));
    int sum = 0;
    for (int i = 0; i < 10000000; i++) {
        int idx = rand() % ARR_SIZE;
        sum += arr[idx];
    }
    free(arr);
    return sum;
}

随机访问大数组的任意位置，会导致缓存命中率极低，CPU不得不频繁从主内存读取数据，而主内存的访问延迟是L1缓存的几十倍，性能被严重拖累。

针对乱序执行单元的低效代码 #

乱序执行单元需要无依赖的指令来并行处理，以下代码形成了超长的依赖链，让乱序执行完全无用武之地：

int main() {
    long long a = 1, b = 2, c = 3, d = 4;
    for (int i = 0; i < 100000000; i++) {
        a = a + b;
        b = a + c;
        c = b + d;
        d = c + a;
    }
    return (int)(a + b + c + d);
}

每一步计算都严格依赖前一步的结果，CPU只能串行执行这些指令，完全无法利用乱序执行带来的并行计算能力。

内容的提问来源于stack exchange，提问作者Setu