硬件预取Prefetch如何加速访存

可视化演示

预取器预测访问地址提前加载数据到缓存，隐藏访存延迟。

预取基本原理

图书管理员的本事不在跑得快，而在“猜得早”。她不需要每次等你报书名才动身，而是看你刚拿起第一本，就推测你马上需要第二本，于是先把第二本从仓库搬到了前台。这份“提前量”，就是她让图书馆显得快的全部秘密。CPU 世界里，这份秘密对应一个朴素事实：内存太慢，不能每次都等。

现代 CPU 一个时钟周期不到 1 纳秒，而访问内存（DRAM）通常要几十到上百纳秒。如果每次取数都等内存，处理器绝大多数时间都在空转。于是 CPU 引入了多级缓存：L1、L2、L3，就像前台、中厅、后院三个越来越远但越来越大的书架。绝大多数紧挨着会用到的数据，都能在前台命中（Cache Hit）；一旦没命中（Cache Miss），CPU 就得一直等到“后院仓库”把货送来。硬件预取器要做的，就是让“必中的下一击”提前到位，把 miss 变成 hit。

用公式描述这个代价。设命中率为 H，命中缓存延迟为 $T_{cache}$，未命中要额外花时间从内存搬运 $T_{mem}$，则平均访存时间：

预取器就像一个不断“补货”的管理员，把 H 这个命中率一点点抬高。H 从 90% 提升到 99%，平均访存时间几乎减半——管理员多跑几趟腿，读者少等很多次。这正是预取的全部意义：用提前搬运的“体力”，换回 CPU 最宝贵的“等待时间”。

顺序预取策略

图书馆最常见的规律是“顺书架读”。管理员观察到一个读者每次还书的位置总在上一本旁边，于是她会习惯性地把相邻的下一本先拿到前台。这种“紧挨着猜”的直觉，是预取器最朴素也最有效的一招，对应到 CPU 世界里，就是顺序预取（Sequential Prefetching）。

程序中最常见的访问模式同样是顺序访问——遍历数组、读文件、扫描数据表，地址像翻书一样一页页往后翻。顺序预取器的策略简单直接：当某个缓存行 $L_i$ 被 CPU 访问时，立刻把下一个缓存行 $L_{i+d}$ 也读入缓存。这里的 $d$ 称为预取距离（Prefetch Distance），$d=1$ 是最保守的选择，每次多搬一行；$d=4$ 则更激进，一次搬四行，适合内存延迟特别大的场景。

管理员“顺书架读”的直觉看似简单，却是真实世界覆盖面最广的预测：大多数科学计算、流式处理和日志分析都被顺序模式主导。想让她猜得准，你只需把数据摆成“一排书”——连续的内存布局——剩下的交给她。现代 CPU 的流式预取器（Stream Prefetcher）甚至会同时跟踪多个顺序流，一次维护好几排“正在读的书”。

步长预取策略

但并非所有读者都按顺序读。那位分析师总跳过两本取第三本；递归程序的指针也常以固定间隔跳跃。管理员观察两次便会心一笑：“又隔两本。”于是她开始按“隔两本”的节奏提前取书。这种对“等差数列”的直觉，对应硬件里的步长预取（Stride Prefetching）。

步长（Stride）是两次成功访问地址之间的差值。步长预取器的核心是一个小表格，记录最近几次访问的地址差，如果差值稳定出现，就认为找到了规律，并把下一次访问预测为“现有地址 + 步长”。经典的例子是按列访问二维数组：逻辑上你访问 a[i][j]，实际每跳一行物理地址就偏移一整个行长度，地址差始终是同一个常数。

管理员靠“间隔”预判取书，步长预取器靠“地址差”预判访存。走列的二维数组、矩阵转置、按某种跨度采样的信号处理，都是它的用武之地。对程序员来说，如果无法避免跳跃，让跳跃保持固定步长，管理员就能继续“神机妙算”，预取器也能维持接近完美的命中率。

预取性能指标

管理员也不是每次都能猜中。她热心肠地提前从仓库搬回 10 本书，结果你只借走了 7 本——剩下 3 本白跑一趟，还占用了前台空间。这就是预取的代价，也是预取器设计者最头疼的权衡。于是需要两个数字来评价管理员：她拿来的是不是你要的（准确率），她有没有把你要的都拿来（覆盖率）。

预取准确率（Prefetch Accuracy）衡量预取操作的有效性：在全部预取动作里，有多少数据最终被 CPU 真正用到。

预取覆盖率（Prefetch Coverage）则衡量预取消除了多少本应发生的未命中：在所有本来会 miss 的访问中，有多少被预取提前“救活”。

这两个指标常常互相拉扯。预取器变得保守，准确率高但覆盖率低，许多 miss 没被提前消除；预取器变得激进，覆盖率上去了，但大量无效预取挤占缓存和内存带宽，可能让整体速度反而下降。硬件通常用一个可调阈值在两者之间找平衡。管理员心里也有一杆秤：宁可少拿几本，也别让错书占着前台——真正的高手，是在准确率和覆盖率之间走钢丝。

软件预取指令

有些读者更主动，进门就递上借书单：“我接下来要这几本，请提前准备。”管理员照单取书，一拿一个准。程序员也可以做同样的事——与其等硬件预取器“猜”，不如直接用软件 prefetch 指令告诉 CPU：“这个地址马上要用，帮我先搬到缓存里。”这就是软件预取（Software Prefetching）。

GCC/Clang 提供了内置函数 __builtin_prefetch(ptr, rw, locality)，x86 平台则有 prefetcht0、prefetchnta 等指令。程序员可以在循环里手动插入这些指令，把“未来会用到”的地址提前暴露给硬件。关键在于提前量：太近，数据还在路上，CPU 照样等；太远，数据可能还没来得及用就被其他数据挤出缓存。经验上，提前轮数应接近“内存延迟 ÷ 单轮循环耗时”，并向上取整：

实践中，软件预取常用于内存延迟极长、且访问模式硬件猜不到的场合：链表遍历、稀疏矩阵、按索引跳跃的哈希扫描。配合编译器自动插桩（如 GCC 的 -fprefetch-loop-arrays），编译器能分析循环并自动插入指令。借书单写得越早越精准，prefetch 指令插得越靠前越贴合热点，命中率越高。软件预取让程序员从“被动等管理员猜”升级为“主动递纸条”，在关键循环里，这个动作往往能让性能翻上数倍。

实际应用效果

回到图书馆本身——读者形形色色：按顺序读的文学青年、隔三本借一本的数据分析师、在特定区域反复翻阅的论文党。管理员对不同读者采用不同策略：顺序读者顺势走，跳跃读者数间隔，反复读者则把常用书长期摆在最顺手的位置。整体下来，全馆平均等待时间大幅缩水。真实系统也是如此，预取最典型的舞台就是数据库扫描。

PostgreSQL、ClickHouse 做全表扫描时，数据页是一口气顺序读出的；如果每页都等内存，性能会被访存瓶颈死死卡住。数组遍历、矩阵乘法、卷积计算同样受益。把预取和循环展开等优化结合，命中率能从 70% 拉到 95% 以上，访存加速比可以直观写成：

要吃到这波红利，最实用的一条建议是让数据访问保持规整：用连续内存（数组而非散乱链表）、按行访问二维数组、把热点结构体对齐到缓存行。这些“缓存友好代码”不是玄学，而是让管理员更容易看穿你的阅读习惯，把预取器的优势最大化。管理员让读者几乎不用等书，预取器让 CPU 的访存等待被悄悄填满——你写代码时的每一个布局决定，都在告诉管理员“我接下来要看哪一排书”。对齐、连续、步长稳定，这三件事做到位，性能自然水到渠成。

AI 应用场景

Python 演示

"""模拟硬件顺序预取的效果:对比无预取与预取距离 d=1 时的命中率与总耗时。"""from collections import deque  def simulate(accesses, capacity=64, miss_latency=20, prefetch_distance=0):    cache = {}            # 缓存: 地址 -> 有效标记    queue = deque()       # FIFO 淘汰顺序    hits = 0    cycles = 0     for addr in accesses:        if addr in cache:            hits += 1            cycles += 1               # 命中延迟 1 周期        else:            cycles += miss_latency    # 未命中延迟 20 周期            cache[addr] = True            queue.append(addr)            if len(queue) > capacity:                old = queue.popleft()                cache.pop(old, None)         if prefetch_distance > 0:            pf = addr + prefetch_distance            if pf not in cache:                cache[pf] = True      # 提前把下一块搬进缓存                queue.append(pf)                if len(queue) > capacity:                    old = queue.popleft()                    cache.pop(old, None)     return cycles, hits / len(accesses)  def main():    accesses = list(range(200))  # 顺序访问 0..199     cycles_no, rate_no = simulate(accesses, prefetch_distance=0)    cycles_yes, rate_yes = simulate(accesses, prefetch_distance=1)     print(f"无预取:   命中率 {rate_no:6.1%}  总耗时 {cycles_no} 周期")    print(f"顺序预取:  命中率 {rate_yes:6.1%}  总耗时 {cycles_yes} 周期")    print(f"加速比: {cycles_no / cycles_yes:.2f}x")  if __name__ == "__main__":    main()

1. cache[addr] = True未命中时把数据装入缓存，标记为有效。
2. queue.append(addr)记录 FIFO 淘汰顺序，模拟缓存容量有限。
3. old = queue.popleft(); cache.pop(old, None)缓存满了就淘汰最旧的行，模拟真实缓存的替换策略。
4. pf = addr + prefetch_distance计算预取目标：当前地址加预取距离。
5. cache[pf] = True提前把下一块数据搬进缓存，这是顺序预取的核心动作。
6. cycles += miss_latency未命中时要等 20 个周期，命中只要 1 个周期。
7. simulate(accesses, prefetch_distance=0)用预取距离 0 模拟无预取的基线表现。
8. cycles_no / cycles_yes两个场景总耗时之比，就是预取带来的加速比。

常见误区

面试题