在玩了下面显示的最小化示例后，我得出的结论是，根本原因是特拉维斯·唐斯2017年问题的一个变体，题为英特尔Skylake上商店循环出乎意料的糟糕和奇怪的双峰性能，为此，他在2019年的博客文章《你的微码最近为你做了什么》中提供了进一步的规范。2020年发给RWT的帖子。我认为问题中显示的图表显示了这种影响是如何在多插座系统上加剧的，在多插座系统中，对RFO的响应需要更长的时间，使得RFO序列化更加明显。

在我的测试程序中，使用PRNG代替带有置换索引的额外数组，效果仍然可见。PRNG有4个周期的延迟，您可以看到，当工作集适合L1缓存时，每次迭代需要的时间比4*多一点（1

#include <stddef.h>
#include <stdio.h>
#include <stdint.h>

#include <sys/mman.h>

static uint64_t prng(int bits)
{
    static uint64_t state = 0;
    uint64_t ret = state >> (64 - bits);
    state = state * 6364136223846793005 + 1;
    return ret;
}

typedef uint64_t T;

typedef void fn(volatile T *, int, int);

static void no_prefetch(volatile T *buf, int log_n, int chunk)
{
    size_t n = (size_t)1 << log_n;
    for (size_t i, k = 0; k < n; k = i) {
        for (i = k; i < k + chunk; i++) {
            buf[i] = 0;
        }
        for (i = k; i < k + chunk; i++) {
            size_t j = prng(log_n);
            buf[j] = 0;
        }
    }
}

static void do_prefetch(volatile T *buf, int log_n, int chunk)
{
    size_t n = (size_t)1 << log_n;
    for (size_t i, k = 0; k < n; k = i) {
        for (i = k; i < k + chunk; i++) {
            buf[i] = 0;
        }
        for (i = k; i < k + chunk; i++) {
            size_t j = prng(log_n);
            __builtin_prefetch((T*)buf+j, 1);
            buf[j] = 0;
        }
    }
}

static fn *const fns[] = { no_prefetch, do_prefetch };

int main(int argc, char **argv)
{
    unsigned with_prefetch, chunk, log_sz, reps;
    if (argc < 2 || sscanf(argv[1], "%u", &with_prefetch) != 1)
        with_prefetch = 0;
    if (argc < 3 || sscanf(argv[2], "%u", &chunk) != 1)
        chunk = 1;
    if (argc < 4 || sscanf(argv[3], "%u", &log_sz) != 1)
        log_sz = 13;
    if (argc < 5 || sscanf(argv[4], "%u", &reps) != 1)
        reps = 10000;
    size_t sz = sizeof(T) << log_sz;
    void *m;

    if ((m = mmap(0, sz, PROT_READ | PROT_WRITE,
              MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)) == MAP_FAILED)
        return 1;

    for (; reps; reps--)
        fns[with_prefetch](m, log_sz, chunk);
}