Newshot

逆向分析 Skylake-X 的下一页预取器

Translation(model translation, not the source's own text)

引言

Intel 对其 P-core 中下一页预取器的公开资料极少。早在 Ivy Bridge 时代,人们就知道 IVB 包含一个下一页预取器,依据是旧版《Intel 架构优化参考手册》中的一段古老摘录:

硬件预取增强:在 Intel 微架构代号 Ivy Bridge 中新增了下一页预取器(NPP)。当对接近页边界的缓存行进行向上或向下的顺序访问时,NPP 会被触发。

最近一期优化手册指出,Redwood Cove 包含一个末级缓存(LLC)页预取器,它类似 NPP,但预取算法稍微更精细:

LLC 页预取器扩展了下一页预取器算法,该算法检测一系列即将到达页末尾的访问(要么向上朝内存中的下一页,要么向下朝内存中的上一页),并触发向预测的下一页起始位置的线性预取。NPP 意图预取下一页的地址转换,并启动对预测页中前几个缓存行的预取。LLC 页预取在两个方面显著增强了下一页预取器:它在线性地址空间中提前两页发出预取。该预取尝试利用机会性 IDI 请求槽、在不使用 DCU 或 MLC 缓冲区的情况下将整个 4Kb 页带入末级缓存。

LLC 页预取器扩展了下一页预取器算法,该算法检测一系列即将到达页末尾的访问(要么向上朝内存中的下一页,要么向下朝内存中的上一页),并触发向预测的下一页起始位置的线性预取。NPP 意图预取下一页的地址转换,并启动对预测页中前几个缓存行的预取。LLC 页预取在两个方面显著增强了下一页预取器:

  • 它在线性地址空间中提前两页发出预取。
  • 该预取尝试利用机会性 IDI 请求槽、在不使用 DCU 或 MLC 缓冲区的情况下将整个 4Kb 页带入末级缓存。

Redwood Cove 是相对较新的微架构,自 2023 年底起随 Meteor Lake P-core 出货。另一方面,Ivy Bridge 非常古老;它于 2012 年推出,并在 2015 年、即 Skylake 推出前夕停产。这就引出了一个问题:这中间发生了什么?IVB 之后的每个微架构都包含下一页预取器吗?

这些细节不太可能从一个微架构到下一个微架构保持不变,但事实证明,我最近获得了一台 Skylake-X 机器的无限访问权限,而且一分钱都没花。既然有了这样的条件,我自然就被吸引去逆向下一页预取器了……而这正是本文的主题。希望你喜欢!

那么什么是预取器

预取器是一种硬件组件,用于预加载程序可能很快需要的数据。其目标是消除 CPU 实际请求某块数据时的内存停顿,而这块数据本可以由预取器提前加载。现代 CPU 中存在各种类型的预取器。下一行预取器在第 N 个缓存行被访问时预取紧邻的下一个缓存行。步幅预取器(通常基于 IP)跟踪源自同一指令的连续内存访问的步幅,如果访问模式足够规律,就急切地从其预测的地址发起加载。下一页预取器在软件以可预测方式遍历内存页时,将页表项预加载到转译后备缓冲区(TLB)中。这些绝不是仅有的三种类型;高性能 CPU 可能实现许多其他类型的预取器,其中一些记录在这份 Intel 白皮书中。

文章标题:逆向分析 Skylake-X 的下一页预取器

正文: 需要快速执行的预取器在逻辑上很简单,并且往往不会跨越页边界,因为那可能会把事情复杂化,例如缺页异常以及 TLB 未命中时的页表遍历。例如,next-line 预取器本应在访问连续时获取下一条缓存行,但如果下一条缓存行位于不同的页中,它可能决定完全不预取。next-page 预取器在这方面略有不同;它们将下一个页表项(PTE)预取到 TLB 中。按设计它们必须跨页边界工作。

在这篇文章中,我将尝试回答以下问题:

  • Skylake-X 是否具有下一页预取器?
  • 如果是,是什么触发了下一页预取?
  • 会预取多少个“未来的”PTE?
  • NPP 在哪里加载未来的 PTE?
  • 预取的方向是什么?仅向前?仅向后(那会很奇怪!)?还是两者都有?

但在我们开始之前,先为我们的实验做好准备。

为实验配置 Linux

如果你不打算运行本文中描述的实验,可以跳过这一部分。

记录各种平台上性能监控的众多细节值得单独写一篇文章,而且篇幅会相当长。为简单起见,我只关注 Linux。Linux 允许通过 perf_event_open 系统调用来配置性能监控事件。这也是我在实验中将使用的方式,但一般来说,你不需要特殊的系统 API 来访问 PMU 计数器。至少在 Intel 上,你只需要某种方式来写入一组性能监控 MSR(通常只是 IA32_PERFEVTSELx MSR),并从一组相应的 IA32_PMCx MSR 中读取计数器。WRMSR 和 RDMSR 需要 Ring0 权限,所以如果你在 Windows 上,就必须编写内核模式驱动,并使用 __readmsr/__writemsr 内建函数来读/写相关的 MSR。话虽如此,为 Windows 制作自定义驱动的困难之处不在于编写驱动本身,而在于说服内核加载你的驱动。更多内容将在未来的博客文章中讨论。

允许读取 PMU 计数器的性能监控工具(例如 perf、VTune)也可能有效。我会坚持使用 perf_event_open,因为它能更好地控制我需要测量的确切代码段。manpage 中包含了一个如何使用 perf_event_open 的示例。对于我们的实验,我们需要按顺序做三件事:

  • 配置我们想要计数的事件。初始时所有计数器都将被禁用。
  • 启用计数器并运行工作负载。此时 IA32_PMCx 计数器开始计时。
  • 一旦工作负载执行完成,停止计数器并读取它们的值。

我们将为这些步骤分别编写一个辅助函数:configure_event_group 用于配置事件,start_counters 用于启用计数器,stop_counters 用于停止并读取计数器。除此之外,以下是 configure_event_group:


        // Configures a set of events (i.e. an "event group") for counting.
void configure_event_group(PerfContext& ctx) {
    if (ctx.nevents < 1 || ctx.nevents > 4) {
        printf("Number of events must be between 1..4!\n");
        exit(EXIT_FAILURE);
    }

int pid = 0;                // Count events for the calling process.
    int cpu = -1;               // Count events for the calling thread. Counters don't reset when thread migrates CPU.
    int group_fd = -1;          // The group leader, always created with fd = -1.
    int flags = 0;              // Use no special flags.

perf_event_attr attr;
    memset(&attr, 0, sizeof(attr));

attr.type = PERF_TYPE_RAW;              // 允许使用原始事件代码配置事件。
    attr.size = sizeof(attr);
    attr.config = ctx.events[0];            // 配置事件组中的第一个事件。
    attr.disabled = 1;                      // 初始时禁用计数器。
    attr.exclude_kernel = 1;                // 当控制转移到内核空间时停止计数。
    attr.exclude_hv = 1;                    // 当控制转移到 hypervisor 时停止计数。
    attr.read_format = PERF_FORMAT_GROUP;   // 通过一次 `read` 调用读取事件组中的所有计数器。

group_fd = syscall(SYS_perf_event_open, &attr, pid, cpu, group_fd, flags);
    if (group_fd == -1) {
        perror("perf_event_open");
        exit(EXIT_FAILURE);
    }
    ctx.open_fds[0] = group_fd;

// 添加事件组中剩余的事件。
    for (int i = 1; i < ctx.nevents; i++) {
        attr.config = ctx.events[i];
        int fd = syscall(SYS_perf_event_open, &attr, pid, cpu, group_fd, flags);
        if (fd == -1) {
            perror("perf_event_open");
            exit(EXIT_FAILURE);
        }
        ctx.open_fds[i] = fd;
    }
}
      

本文中每个实验、数据结构和辅助函数的完整源代码都可以在 github 上找到。group_fd 标识通过 perf_event_open 配置的事件组。你可以使用该 group_fd 对事件组执行某些操作,例如启用或禁用计数器。这就是我们接下来要做的:用 start_counters 启用计数器,其定义如下:


        // 启动事件组中事件的计数器。ctx.open_fds[0] 即 group_fd。
void start_counters(PerfContext& ctx) {
    int ret = ioctl(ctx.open_fds[0], PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
    if (ret == -1) {
        perror("ioctl");
        exit(EXIT_FAILURE);
    }
}
      

调用 start_counters 会启动由 group_fd 标识的事件组中每个已配置事件的计数器。此时我们将运行工作负载,然后调用 stop_counters 停止并读取计数器:


        // 停止并读取事件组中的计数器。ctx.open_fds[0] 即 group_fd。
void stop_counters(PerfContext& ctx) {
    // 停止计数器。
    int group_fd = ctx.open_fds[0];
    int ret = ioctl(group_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
    if (ret == -1) {
        perror("ioctl");
        exit(EXIT_FAILURE);
    }
    // 读取计数器。
    u64 counters_with_header[5];
    int len = (ctx.nevents + 1) * sizeof(u64);
    ret = read(group_fd, &counters_with_header, len);
    if (ret == -1) {
        perror("read");
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < ctx.nevents; i++) {
        ctx.counters[i] = counters_with_header[i + 1];
    }
    // 关闭事件组中的所有 fd。
    for (int i = 0; i < ctx.nevents; i++) {
        int ret = close(ctx.open_fds[i]);
        if (ret == -1) {
            perror("close");
            exit(EXIT_FAILURE);
        }
    }
}
      

在使用上述函数读取 PMU 计数器之前,我们需要调整 Linux 上的一些设置。取决于你的发行版,出于安全原因,默认可能会对硬件 PMU 访问施加某些限制。你可以通过将 perf_event_paranoid 设置为 0 或 -1 来克服这些限制:


        echo "-1" | sudo tee /proc/sys/kernel/perf_event_paranoid
      

如果你的机器上活动太多,你可能还需要禁用 THP 并将调用线程固定到某个核心上。

现在我们已具备开始监控硬件事件所需的所有部分。在本文中,我们将使用以下事件:

EventConfigDescription
MEM_INST_RETIRED.STLB_MISS_LOADS0x11D0在 STLB 中引发未命中的已退休加载指令。
MEM_INST_RETIRED.STLB_MISS_STORES0x12D0在 STLB 中引发未命中的已退休存储指令。
DTLB_LOAD_MISSES.STLB_HIT0x2008未命中数据 TLB 但命中统一 STLB 的加载操作。

文章标题:逆向分析 Skylake-X 中的下一页预取器

正文: 不难观察到,事件配置的形式为 0x<Umask><EventSel>,其中 Umask 和 EventSel 直接来自 perfmon 网站上对应事件“PROGRAMMING INFO”一列(‘H’后缀是 Intel 表示该数字以十六进制给出的方式)。并非所有事件配置都是这样推导出来的,但对于我们这里将要使用的简单事件来说已经足够了。

Skylake-X 中的 TLB 层次结构

SKX(Skylake-X 的代号)有两个 TLB 层级:L1 和 L2。每个 SKX 核心都有物理上独立的 L1 数据 TLB(dTLB)和 L1 指令 TLB(iTLB)。L2 TLB(也称为二级 TLB 或 STLB)是统一的,即指令和数据的 PTE 都进入同一个 STLB。

L1 和 L2 TLB 都按页大小进行分区。L1 dTLB 共有 100 个条目:64 个保留给 4k 页,32 个给 2M 或 4M 页,4 个给 1G 页。dTLB 是 4 路组相联的,因此每组可以容纳 4 个页表条目。iTLB 也是分区的:有 128 个条目用于 4k 页,16 个条目用于 2M 或 4M 页,1G 页没有条目。STLB 有 1536 个条目在 4k 和 2M 页之间共享,另有 16 个条目用于 1G 大页。STLB 不包含 L1 TLB。这意味着在任意时刻,一个页表条目可能存在于某个 L1 TLB 中、STLB 中,或两者中都有。

就本文而言,我们不需要进一步深究 SKX TLB 的几何结构。是时候做一些实验了!

它是否存在

我们应该问的第一个问题是:下一页预取器在 SKX 中到底存不存在。NPP 总体上似乎是个好主意;考虑到 Intel 在 Ivy Bridge 中有足够的硅片预算来加入一个,我们预期 SKX 中的答案也是“存在”。为了测试这一点,我们将设计一个工作负载,顺序遍历 1000 个 4K 页的映射范围,并测量我们得到多少次 TLB 未命中。如果 NPP 真的存在,我无法想象还有比这更有利的访问模式能让它生效。如果下面的工作负载没有触发预取器,我们就可以安全地得出结论:SKX 没有预取器。


        [[gnu::always_inline]]
inline void touch_all_bytes(int zero) {
    u8* map_base = (u8*)MAP_BASE;
    u8 dummy = 0;
    for (u64 i = 0; i < MAP_SIZE; i++) {
        dummy += map_base[i + zero];
        zero = zero & dummy;
    }
    asm volatile("" :: "r"(dummy));
}
      

这里没有太多复杂的东西。我们有一个函数,它触及从 MAP_BASE 开始的映射范围内的每一个字节。看似无用的 zero 有助于确保从映射范围加载的操作串行执行。仔细看看我们在循环中如何使用 zero。在第 i 次迭代中加载映射范围的下一个字节,依赖于第 i-1 次迭代计算出的 zero 值。而第 i-1 次迭代计算 zero 又依赖于第 i-1 次迭代计算出的 dummy。我们这里有一个循环携带的依赖链:map_base[i + zero] 中的加载为 dummy += .... 中的加法提供输入。该加法的结果又为 zero = zero & .... 中的与运算提供输入。与运算的结果又为第 i+1 次迭代的下一次加载提供输入。用通俗的话说,第 i 次迭代和第 i+1 次迭代的加载不能一起执行,也不能乱序执行。这是有意为之:允许两次加载乱序执行可能会显著干扰我们的结果。稍后我们就会明白为什么。

最后一行是一个常见技巧,用于避免编译器丢弃我们的计算;它虚假地宣称内联汇编使用了循环中计算出的 dummy 值,迫使编译器将 dummy 实体化到寄存器中。

用 g++ -O2 编译,该循环编译为:


        .loop:
    movsxd rdx, ebp                     ; tmp = zero
    add    rdx, rax                     ; tmp += i
    add    rax, 0x1                     ; i++
    add    bl, BYTE PTR [rcx+rdx]       ; dummy += map_base[tmp]
    and    ebp, ebx                     ; zero = zero & dummy
    cmp    rax, 4096000                 ; if (i < MAP_SIZE)
    jne    .loop                        ; goto .loop
      

文章标题:逆向分析 Skylake-X 中的下一页预取器

不错。虽然零散地出现了一些指令,但我们完全按照想要的方式编译出了这个循环。注意,我们刚才讨论的依赖链也完全对应到汇编上。运行该工作负载后,两个事件的计数如下:


        DTLB_LOAD_MISSES.STLB_HIT           = 70
MEM_INST_RETIRED.STLB_MISS_LOADS    = 1
      

在多次运行中,DTLB_LOAD_MISSES.STLB_HIT 在 50..75 区间波动,但从未超过 75。这已经很有意思了:我们在循环中遍历了 1000 个页面,但 DTLB_LOAD_MISSES.STLB_HIT 远不到 1000。DTLB_LOAD_MISSES.STLB_HIT = 70 意味着在 1000 次 PTE 请求中,只有 70 次在 dTLB 中未命中并命中了 STLB。接下来显而易见的问题是,剩下的 1000 - 70 = 930 次由循环发起的新鲜 PTE 请求发生了什么?有两种可能的答案:

  • 它们也在 STLB 中未命中。
  • 它们没有在 dTLB 中未命中。

我们可以很快排除 (1),因为 MEM_INST_RETIRED.STLB_MISS_LOADS = 1。于是只剩下 (2):约 930 次新的 PTE 请求在需求到达时命中了 dTLB。但这一定意味着 SKX 有一个预取器在用未来的 PTE 预填充 dTLB。没错!这就是下一页预取器在起作用。严格来说,这也有可能是一个允许跨页边界预取的非 NPP 预取器,但正如俗话所说,如果它叫起来像鸭子,那它就是下一页预取器!

一个容易被忽略的微妙之处:预取器是把条目加载进 dTLB。这并不能自动证明或否定它同时也在预填充 STLB。在 SKX 中,STLB 充当受害者缓存,即从 L1 TLB 中驱逐出的条目会存放在 STLB 中。沿着这个思路想,预取器同时预填充 STLB 并没有太大意义,但我会避免这类推测。也许一个精心设计的实验能揭开这个秘密,但那不是本文的重点。我们现在也不去担心 iTLB。

微架构探索通常需要谨慎运用统计学,才能从噪声中提取信号。幸运的是,在这个案例中信号如此之强,以至于我们可以马虎一点也无妨。

好了,我们已经确认 SKX 有一个预填充 dTLB 的下一页预取器。进入下一个问题!

什么触发了下一页预取器

touch_all_bytes 中的循环里一定有某个东西触发了下一页预取。最明显的猜测是从前一页发起的一次加载。问题是,是哪次加载?是来自某个特殊偏移的单独一次加载?还是一组加载?这里可以问的问题太多了……我们需要一个能缩小可能性空间的实验。我们可以设想一个只访问每个页面左半部分(字节范围 page[0..2047],含端点)的工作负载,并统计 TLB 未命中。如果我们仍然看到类似第一个实验中的 TLB 未命中数,那就意味着从页面左半部分的访问触发了预取。如果我们反而看到 TLB 未命中数累计达到 1000(或更多),我们就可以重复同样的实验,但这次访问页面的右半部分(字节范围 page[2048..4095],含端点)。一个接受 offset 和 slice_length 的通用工作负载可以处理这两种情况:


        [[gnu::always_inline]]
inline void touch_page_slice(u64 offset, u64 slice_length, int zero) {
    u8 dummy = 0;
    for (u64 p = 0; p < N_MAPPED_PAGES; p++) {
        u8* page_base = (u8*)(MAP_BASE + p * PAGE_SIZE);
        for (u64 i = offset; i < offset+slice_length; i++) {
            dummy += page_base[i + zero];
            zero &= dummy;
        }
    }
    asm volatile("" :: "r"(dummy));
}
      

当以 offset = 0、slice_length = 2048 调用 touch_page_slice 时,它会遍历 1000 个已映射页面中每个页面的左半部分。遍历右半部分同样简单,只需以 offset = 2048、slice_length = 2048 调用 touch_page_slice。遍历左半部分的结果:


        Left half:
DTLB_LOAD_MISSES.STLB_HIT               = 33
MEM_INST_RETIRED.STLB_MISS_LOADS        = 1001
      

遍历左半部分产生了 MEM_INST_RETIRED.STLB_MISS_LOADS = 1001。这个数字可疑地接近我们遍历的页面总数!最合理的解释是,遍历左半部分时 NPP 没有触发,因此每一次新的 PTE 请求都在 dTLB 中未命中。这些未命中随后进入 STLB,在那里也未能命中。

那么右半部分呢?以下是遍历右半部分的结果:


        Right half:
DTLB_LOAD_MISSES.STLB_HIT           = 32
MEM_INST_RETIRED.STLB_MISS_LOADS    = 2
      

相比之下,遍历右半部分的结果一点也不差。事实上,这一次预取器显然触发了。我们可以继续以二分查找的方式切分会触发预取的片段,进一步缩小访问范围。下表展示了结果:

左半部分右半部分片段长度触发预取的片段
[0..2047][2048..4095]2048右半部分
[2048..3071][3072..4095]1024右半部分
[3072..3583][3584..4095]512左半部分
[3072..3327][3328..3583]256右半部分
[3328..3455][3456..3583]128左半部分
[3328..3391][3392..3455]64两者皆非

嗯,最后一行的左、右片段都没有触发预取器。但我们确实知道遍历 page[3328..3455] 是有效的。所以新计划是:从偏移 3328 开始遍历,但不在 3391 处停止,而是一次一个字节地向右推进右边界,直到触发预取器为止。例如,我们会遍历 page[3328..3392],如果这没有触发 NPP,就遍历 page[3328..3393],依此类推。我们预期预取器会在到达 page[3328..3455] 之前触发。这里也可以复用 touch_page_slice;只需以 offset = 3328、slice_length = 65,66,... 来调用它即可。

找出触发预取的片段并不需要太久:就是那个隐蔽的 page[3328..3392]。以 offset = 3328、slice_length = 65 调用 touch_page_slice 会立即触发预取。如果你喜欢这类把戏,应该不难注意到 3392 是一个页面内第 53 条缓存行(从零开始计数)的第一个字节。好,这是否意味着访问第 53 条缓存行就会触发预取?但这不可能成立,因为我们访问了第 53 条缓存行中的每一个字节,并验证了没有预取(见表格最后一行的“右半部分”)。此外,偏移 3328 是一个页面内第 52 条缓存行(从零开始计数)的起点,所以我们同样知道访问第 52 条缓存行中的每一个字节也不会触发预取(见表格最后一行的“左半部分”)。会不会是,要触发预取器,后续的加载必须跨越第 52 条缓存行进入第 53 条缓存行?如果预取条件真的就是“两次后续加载,一次来自第 52 条缓存行,下一次来自第 53 条缓存行”这么简单,那么以下条件必须成立:

  • 访问一个页面中除第 52 条缓存行之外的每个字节,不会触发预取。
  • 访问一个页面中除第 53 条缓存行之外的每个字节,不会触发预取。
  • 两次背靠背的加载,第一次加载第 52 条缓存行中的任意字节,第二次加载第 53 条缓存行中的任意字节,就足以触发预取。

为了验证这些假设,我们需要一个会访问页面中除少数几个字节之外每个字节的工作负载。这应该可行:


        [[gnu::always_inline]]
inline void touch_page_with_hole(u64 hole_offset, u64 hole_length, int zero) {
    u8 dummy = 0;
    u64 repeat_idx = hole_offset == 0 ? 0 : hole_offset - 1;
    for (u64 p = 0; p < N_MAPPED_PAGES; p++) {
        u8* page_base = (u8*)(MAP_BASE + p * PAGE_SIZE);
        for (u64 i = 0; i < PAGE_SIZE; i++) {
            u64 outside_hole = (i - hole_offset) >= hole_length;
            u64 idx = (i & -outside_hole) | (repeat_idx & (outside_hole - 1));
            dummy += page_base[idx + zero];
            zero &= dummy;
        }
    }
    asm volatile("" :: "r"(dummy));
}
      

文章标题:逆向分析 Skylake-X 中的下一页预取器

正文: 在内层循环中用那个看起来奇怪的技巧计算 idx,有助于在探测路径中避免一个分支。是的,我们还寄希望于这一点:当我们在内层循环中走完一个页面并跳回外层循环时,分支预测器会表现得足够好。严格来说,分支预测失败不应该以影响我们结果的方式干扰 TLB,但一般来说,在这类实验中尽最大努力消除噪声源是个好主意。除此之外这里没什么特别之处。我们跳过范围 page[hole_offset, hole_offset+hole_length],并触碰页面中其他所有字节。当 i 落在被跳过的范围内时,我们只是把加载重定向到 hole_offset - 1。

好,那么如果我们跳过第 52 和第 53 条缓存行,即范围 page[3328, 3391] 和 page[3392, 3456],结果如何:


        Skipping 52nd cache line (touch_page_with_hole(3328, 64, zero)):
DTLB_LOAD_MISSES.STLB_HIT           = 63
MEM_INST_RETIRED.STLB_MISS_LOADS    = 1000

Skipping 53rd cache line (touch_page_with_hole(3392, 64, zero)):
DTLB_LOAD_MISSES.STLB_HIT           = 66
MEM_INST_RETIRED.STLB_MISS_LOADS    = 1000
      

两种情况下 MEM_INST_RETIRED.STLB_MISS_LOADS = 1000。这验证了我们假设列表中的 (1) 和 (2)。我们可以通过调用 touch_page_slice,令 offset = 3391、slice_length = 2 来测试 (3)。结果如下:


        Load from cache line 52 and 53:
DTLB_LOAD_MISSES.STLB_HIT           = 4
MEM_INST_RETIRED.STLB_MISS_LOADS    = 3
      

正如预期,仅仅触碰第 52 和第 53 条缓存行中各一个字节就会触发预取器。诚然,这个实验并没有证明“两条缓存行中任意字节”这一部分;我们只展示了先加载第 52 条缓存行的最后一个字节、再加载第 53 条缓存行的第一个字节会触发预取,但你可以通过调整 touch_page_with_hole 的参数轻松验证这一点。例如,hole_offset = 3329、hole_length = 126 会触碰第 52 条缓存行的第一个字节和第 53 条缓存行的最后一个字节,跳过中间所有内容。这仍然会触发预取。为了控制本文的篇幅,从现在起我会省略诸如此类的某些细节。如果你有问题,我很乐意在评论区补上这些空缺。

注意,要让预取器触发,来自第 52 条缓存行的加载必须先于来自第 53 条缓存行的加载执行(除非预取器是双向的,但我们稍后会讨论这一点)。这就是为什么引入依赖链来限制页面加载的乱序执行至关重要。

如果你想知道 Intel 为什么要把预取器的触发条件设计得如此苛刻,你并不孤单。我也有完全相同的疑问。我的意思是,当加载越来越接近下一页时触发预取是合理的。但为什么要把所有赌注都押在仅仅跨越第 52 条缓存行上呢?!如果超过某个阈值的任意两次访问都能触发预取,那会更合理。Peter Cordes(没错,就是那个 Peter Cordes)对为什么这样合理给出了一个精彩的回答。如果你感兴趣,去读一读吧。

那存储呢?

好问题。到目前为止我们的实验只使用了加载。一个理智的人会认为存储的行为不应该有任何不同。但令我惊讶的是,存储似乎不会触发预取。如果你在 GitHub 上浏览完整源码,你会注意到我们是用加载来对映射范围进行缺页处理的。这个选择是刻意的:我们有意将映射范围内的每个虚拟页都映射到物理零页。这减少了缓存占用,并可能再限制一个噪声源。

不过,对于下一个实验,我们不能再这样做了;我们不希望在探测路径中发生缺页。所以我们在开始实验之前改用存储来进行缺页处理。排除这一点后,下面是我们将用来验证存储不会触发预取的 kernel:

像 {{NAME_ab12cd34}} 这样写入的值是真实值的占位符。请完全按照所写的方式使用它们,无论是在回复中还是在工具调用中:它们会在任何内容运行之前被填入真实值。不要要求验证它们,也不要用示例替换它们。


        [[gnu::always_inline]]
inline void touch_with_stores(int zero) {
    u8* map_base = (u8*)MAP_BASE;
    for (u64 i = 0; i < MAP_SIZE; i++) {
        map_base[i + zero] = i;
        zero *= zero;
    }
}
      

运行这段代码会得到 MEM_INST_RETIRED.STLB_MISS_STORES = 1000。注意,这次我们测量的是存储操作上的 STLB 缺失。你可以通过同时计数 DTLB_STORE_MISSES.WALK_COMPLETED 与 MEM_INST_RETIRED.STLB_MISS_STORES 来验证这些缺失中的每一个都至少触发了一次页表遍历。这就排除了 dTLB 命中以及(STLB 之外的)末级 TLB 拦截了来自 STLB 的全部缺失的可能性。

预取了多少个 PTE

我们已经确认下一页预取器至少会预取一个未来的 PTE。我们不应该期望它预取超过一页,毕竟它叫下一页预取器是有原因的。不过,我们还是用这个简单的工作负载来验证一下,以消除疑虑:


        void how_many_pages_prefetched(int future_limit, int zero) {
    u8 dummy = 0;
    int poke_limit = 8;
    for (int p = 0; p < poke_limit; p++) {
        u8* page_base = (u8*)(MAP_BASE + p * PAGE_SIZE);
        dummy += page_base[3391 + zero];
        zero &= dummy;
        dummy += page_base[3392 + zero];
        zero &= dummy;
    }
    for (int i = 0; i < future_limit; i++) {
        u8* page_base = (u8*)(MAP_BASE + (i + poke_limit) * PAGE_SIZE);
        dummy += page_base[zero];
        zero &= dummy;
    }
    asm volatile("" :: "r"(dummy));
}
      

思路是通过在前 poke_limit 个页面中跨越第 52 条缓存行来“预热”预取器——第一个循环做的就是这件事——然后在第二个循环中加载 poke_limit 之后 future_limit 个页面的第一个字节。我们会反复调用这个函数,每次把 future_limit 加 1,并计数 TLB 缺失。我们可以先用 future_limit = 0 得到一个基线:


        Run 1:
DTLB_LOAD_MISSES.STLB_HIT           = 1
MEM_INST_RETIRED.STLB_MISS_LOADS    = 1

Run 2:
DTLB_LOAD_MISSES.STLB_HIT           = 2
MEM_INST_RETIRED.STLB_MISS_LOADS    = 1

Run 3:
DTLB_LOAD_MISSES.STLB_HIT           = 0
MEM_INST_RETIRED.STLB_MISS_LOADS    = 3

...
      

在多次运行中,STLB 缺失基线在 1 和 3 之间波动,但似乎从未超过 3。好,我们可以以此为参照。现在试试 future_limit = 1:


        Run 1:
DTLB_LOAD_MISSES.STLB_HIT           = 0
MEM_INST_RETIRED.STLB_MISS_LOADS    = 3

Run 2:
DTLB_LOAD_MISSES.STLB_HIT           = 1
MEM_INST_RETIRED.STLB_MISS_LOADS    = 2

Run 3:
DTLB_LOAD_MISSES.STLB_HIT           = 1
MEM_INST_RETIRED.STLB_MISS_LOADS    = 2

...
      

对,符合预期!“加热器”中的最后一次加载必定触发了对 poke_limit 处页面的预取,所以 future_limit = 1 不应该增加观察到的缺失数。那 future_limit = 2 呢?


        Run 1:
DTLB_LOAD_MISSES.STLB_HIT           = 0
MEM_INST_RETIRED.STLB_MISS_LOADS    = 4

Run 2:
DTLB_LOAD_MISSES.STLB_HIT           = 0
MEM_INST_RETIRED.STLB_MISS_LOADS    = 5

Run 3:
DTLB_LOAD_MISSES.STLB_HIT           = 1
MEM_INST_RETIRED.STLB_MISS_LOADS    = 4

...
      

看起来 NPP 只预取前面一页。不错,对此没有异议!

预取方向

预取器在反方向上也起作用吗?这是最后一块拼图,而且幸运的是很容易测试:只需反向遍历映射范围。如果你得到接近 1000 的缺失数,答案就是否;否则就是是。以下是工作负载:


        [[gnu::always_inline]]
inline void touch_bytes_backward(int zero) {
    u8* map_base = (u8*)MAP_BASE;
    u8 dummy = 0;
    for (u64 i = 1; i <= MAP_SIZE; i++) {
        dummy += map_base[MAP_SIZE - i + zero];
        zero &= dummy;
    }
    asm volatile("" :: "r"(dummy));
}
      

……以及结果:


        DTLB_LOAD_MISSES.STLB_HIT               = 69
MEM_INST_RETIRED.STLB_MISS_LOADS        = 1000
      

这有点令人震惊。如果你还记得“引言”部分,Intel 手册似乎暗示 next-page prefetcher 在向上(我称之为 forward)或向下(我称之为 backward)遍历时触发。这种行为在 Ivy Bridge 和 Redwood Cove 上都有文档记录……但我们在 SKX 上看到的并非如此。我没有任何理论能解释 SKX 与其他微架构之间的这种差异,如果你有想法,欢迎在评论区分享。

那么我能在哪里用到这些知识

如果你是一名软件开发者,正在寻找一种酷炫的新方法来优化程序性能,那大概哪里都用不上。针对单一 CPU 厂商的单一微架构来优化程序,对于任何生命周期超过下周五的东西来说,几乎总是一个坏主意。我在这里的目标是分享我如何尝试逆向未文档化的机器行为,并邀请同好们 kick-start 讨论,希望能帮助我或其他人学到新东西。

话虽如此,如果你是那种只关心一种机器(确切地说是 Skylake-X)的怪人,你可能会从实用角度觉得这些细节很有趣。不管怎样,我累了。对于第一篇帖子来说,这写得太多了。👋

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Lobsters
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗