LSQ 访存消歧:load 能不能越过前面的 store,谁来裁决
承 cpu-out-of-order 的乱序执行框架与 lsu 的访存执行单元总览。寄存器侧的假依赖靠寄存器重命名打掉了,但内存侧的依赖没法在译码时静态判定——
load rax, [rsi]和前面那条store [rdi], rbx到底冲不冲突,要等rsi、rdi都算出来才知道。LSQ 访存消歧(Memory Disambiguation)就是乱序核心里专门回答这个问题的裁决机构:load 什么时候可以越过前面的 store 先跑,什么时候必须等,赌错了怎么抓回来。命中后怎么把数据直接递过去是 store-to-load-forwarding 的话题,本篇只讲队列与消歧机制本身。
本文要回答的问题
- 为什么寄存器依赖能在译码时解决,内存依赖却必须拖到执行时动态裁决?
- load queue 和 store queue 各记什么字段,各自服务什么目的?
- 前面 store 的地址还没算出来时,load 是等还是赌?保守与投机两条路各付出什么代价?
- 一条 load 做消歧检查要跟前多少个 store 比地址,这个"集合并发检查"在硬件上怎么实现?
- 投机赌错了(内存依赖违例)怎么检测、怎么恢复,代价有多大?
一、为什么内存依赖不能静态解决
寄存器依赖是"名字依赖":add rax, rbx 读了 rbx,译码器一看名字就知道它依赖谁。内存依赖是"值依赖"——两条访存指令是否别名(alias,指访问同一地址),取决于指针寄存器里跑出来的值:
store [rdi], rbx ; 地址 = rdi 的值,执行时才知道
...几十条无关指令...
load rax, [rsi] ; 地址 = rsi 的值
; rdi == rsi 吗?编译器不知道,译码器也不知道如果 CPU 保守地规定"任何 load 都必须等前面所有 store 退休",乱序执行在访存密集代码里就废了一半——真实程序里相邻 load/store 地址冲突的概率很低(多数指向不同变量),绝大多数等待都是白等。但如果完全放任 load 随便超前,一旦真撞上别名,load 读到的就是旧数据,程序语义直接错了。
LSQ 消歧要做的就是在这两个极端之间找最优解:尽量让 load 提前跑,同时保证一旦撞车能抓到并恢复。这个"猜 + 验证 + 回滚"的模式和分支预测在哲学上完全一致,只是裁决对象从控制流换成了数据流。
二、LSQ 的结构:两个队列各管一半
LSQ(Load/Store Queue)通常拆成 load queue 与 store queue 两个按程序序排列的 FIFO,条目在译码/分配阶段按序占据,退休时才释放。
两个队列的分工值得说透:
- store queue 是"尚未提交到内存的写"的暂存区。store 即使算出了地址和数据,也不能立刻写 cache——它还处在投机状态,分支可能翻悔、前面可能有异常。所以 store 的执行结果先落在 store queue 里,等指令经 rob 退休确认安全后才真正写进 L1D。这也意味着 load 读内存时,最新的数据可能根本不在 cache 里,而在前面某条 store 的队列条目里——这正是 store-to-load forwarding 存在的原因。
- load queue 是"已发射但还没被证明清白"的读的账本。每条 load 执行完后不能拍拍屁股走人,它要留在 load queue 里等到退休,期间随时可能被证明"读早了"(后面会讲违例检测)。
队列容量是个硬约束:典型桌面核 load queue 72~128 项、store queue 48~72 项(Golden Cove 级别约 128/72)。队列满了,前端直接停发——这就是 uop-pipeline-lsu-buffers 里讨论的访存缓冲瓶颈之一。
store queue 里每条 store 还有一条独立的生命周期值得展开:地址就绪和数据就绪是两个事件,常常相差很多拍。store [rdi], rbx 的地址 rdi 可能一拍就算出来了,但要写入的值 rbx 还依赖一条正在执行的除法——这条 store 会以"地址已知、数据悬空"的状态躺在队列里。消歧检查时,load 撞上这种条目的结果不是直接转发,而是建立等待关系:load 被标记为"等 SQ#k 的数据",store 数据一落地就触发转发。反过来也存在"数据早有了、地址还没算"的 store,这种条目对消歧来说就是上一节讲的"地址未知"场景,只能靠投机或等待处理。把两个就绪事件拆开追踪,是 LSQ 比表面看起来复杂得多的第一层原因。
第二层复杂性来自年龄排序。load 和 store queue 是两套独立的编号体系,"这条 store 比那条 load 老吗"不能直接比编号。硬件用 ROB 序号或专门的 age matrix 维护全局程序序:每个 LSQ 条目记下自己在 ROB 里的位置,比较时先算出"比我老的所有 store"的掩码,再在这个掩码内做地址匹配。乱序窗口越大,这套年龄逻辑的比较面越宽,它也是限制 LSQ 规模的隐性成本之一。
三、消歧检查:一次 load 要对前多少个 store 比地址
LSQ 访存消歧的核心动作只有一句话:load 地址算出来后,和 store queue 里所有"比它老"的条目并发比较地址。
| 比较结果 | 含义 | load 的动作 |
|---|---|---|
| 无匹配 | 前面没有写同地址的 store | 正常读 cache,清白执行 |
| 精确匹配且 store 数据已就绪 | 别名命中,数据就在队列里 | 走 store-to-load forwarding,不碰 cache |
| 精确匹配但 store 数据未就绪 | 别名命中,但要写的值还没算出来 | 等:挂起,等 store 数据就绪后转发 |
| 匹配到地址未知的 store | 没法判定 | 按预测策略处理(见第四节) |
比较不是简单判等,还要处理部分重叠:store 写了 8 字节 [0x1000..0x1007],load 读 4 字节 [0x1004..0x1007]——地址区间相交但不重合。精确重叠可以完整转发;跨越多个 store 条目、或 load 比 store 范围更大时,多数硬件直接判"无法转发",load 走慢路径:等所有相关 store 提交到 cache 后重读。这类 partial overlap 是 forwarding 失败、性能毛刺的常见来源。
硬件实现上,store queue 的地址字段做成 CAM(内容可寻址存储器):load 地址一拍之内同时驱动所有条目的比较器,输出一个匹配位向量,再用"年龄逻辑"从中选出程序序上最近的那个匹配(多个历史 store 写同一地址时,只有最新一条是 load 该读的值)。128 项的全 CAM 比较是一拍完成的,代价是面积和功耗——这是 LSQ 规模不能随便翻倍的根本原因。
四、地址未知时:等,还是赌
真正难的不是比较,而是比较对象还没准备好。load 的地址算出来了,可前面某条 store 的地址操作数还没就绪(比如它依赖一条还在路上的 cache miss),这条 store 是敌是友无从判断。两条路线:
保守消歧:只要前面有地址未知的 store,load 一律挂起等待。安全但慢——store 的地址可能还要几十拍才能算出来,期间这个 load 连同它后面依赖它的一串计算全部停摆。
投机消歧(主流做法):赌它无关,load 先跑。现代高性能核心几乎都走这条路,配套两种实现:
- 盲投机:默认所有 load 都可以越过地址未知的 store,赌错了靠违例检测抓回来。
- 预测器辅助:历史上某些 load 反复赌错(比如生产者-消费者共享缓冲区),于是引入内存依赖预测器记住"这条 load 以前撞过车",下次遇到它直接让它等。这套预测机制在 memory-dependence-prediction 里有专门展开,本篇不重复。
投机策略的收益是实打实的:在地址无关占绝对多数的真实代码里,load 平均可以提前几十拍发射,把 cache 访问延迟藏进乱序窗口里。Intel 的公开性能文档把 memory disambiguation 列为乱序引擎的关键特性,原因就在于此。反过来说,这也是"为什么 store 密集代码的 IPC 常常比 load 密集代码低一截"的深层原因之一:store 越多,每条 load 要等待裁决的不确定源越多,队列占用也越重,乱序窗口的有效容量被两头挤压。
五、违例检测:赌错了怎么抓回来
投机必须有裁判。内存依赖违例(memory order violation)的检测逻辑是双向的——load 发出时做一次检查不够,因为发出之后还可能有新的信息出现:
上面这张图把完整的裁决流程画出来了,关键是第③步的反向检查:load 发射时前面的 store 地址未知,load 投机通过了;等那条 store 的地址终于算出来时,硬件拿它去比 load queue 里所有比它年轻且已发射的 load——如果发现某个年轻 load 已经读过同一地址,就坐实了违例:这个 load 拿到的是 store 写入之前的旧数据,它以及它下游用这份数据算出的所有结果都是错的。
恢复方式两档:
- load 重放(replay):只把违例的 load 及其依赖链重新发射,流水线前端不动。代价相对小,几代 Intel 核在部分场景用这种方式。
- 流水线清空(machine clear / nuke):从违例 load 之后的第一条指令起全部作废,前端从该 load 重新取指——和分支误预测同级别的惩罚,典型代价 15~20 拍以上,外加被清掉指令的已耗工时。之后这条 load 还会被记进依赖预测器,下次直接让它等,避免反复翻车。
违例率高的典型场景:多线程误共享(false sharing 不算违例,但真共享的同地址读写算)、栈上溢出槽与局部变量别名、以及手写汇编里刻意的指针交叠。perf 侧可以用 machine_clears.memory_ordering(Intel)事件直接观测这类清空次数:
perf stat -e machine_clears.memory_ordering,machine_clears.count ./app如果这个事件在每百万指令里出现频率显著非零,值得用 -e mem-loads,mem-stores 配合采样定位是哪对 load/store 在打架。
可以拿一个具体场景把整条链路串一遍。假设一个拷贝循环里编译器生成了 store [rdi], rbx; load rax, [rsi] 这样的指令对,rdi 依赖一条刚发射的 load(还没回来),rsi 是现成的:
- load 地址先就绪,检查 store queue:前面那条 store 地址未知 → 按预测器历史,这对指令从没撞过车 → 投机放行,load 从 L1D 读到数据,下游加法立刻发射。
- 十几拍后
rdi算出来了,store 地址落地,反向扫 load queue:发现年轻 load 已发射,比地址——rdi != rsi,虚惊一场,load 摘账,继续往退休走。 - 下一次迭代,
rdi == rsi(比如调用方传了交叠的缓冲区),反向检查命中 → 违例坐实:从 load 起全部清空,前端重新取指,预测器把这条 load 记为"危险分子"。 - 再下一次迭代,load 刚算完地址就被预测器拦下,乖乖等 store 数据落地后转发——这次慢,但不会再翻车。
这个四拍节奏说明一个道理:消歧机制的优化目标不是"永不违例",而是在无关占多数时赌得快、在相关成规律时学得快。稳态下两种极端(全无关、全相关)都能收敛到接近最优,真正吃亏的是"偶尔相关"的混合模式——预测器来回翻转,违例和误等待交替出现,这类代码是 profile 里 machine_clears.memory_ordering 偏高的常客。
六、消歧与其他内存乱序机制的边界
LSQ 消歧管的是单核内部的程序序正确性,有几条边界容易混淆:
- 不管多核可见性:别的核什么时候看到我的 store,是 cache 一致性协议(MESI 家族)和内存模型(x86-TSO、ARM weak ordering)的事。LSQ 只保证"我自己这条核看到的 load/store 顺序语义正确"。
- 不管 memory fence:
mfence、lock前缀这类屏障指令会直接禁止 load 越过它们投机,相当于在 LSQ 里钉下一根"全员排队"的桩。 - 不管缺页与异常:load 触发 page fault 走的是精确异常路径(见 precise-exception-pipeline-flush),与消歧违例是两套独立的清空机制。
- 非临时/字符串指令特例:
rep movs、streaming store 这类指令往往绕过常规 forwarding 路径,消歧规则更保守。
把这几条边界理清,再回头看 lsu 的总览图,就能明白 LSQ 为什么和 TLB、L1D tag 阵列、fill buffer 并列成为访存流水线的四大件:TLB 管地址翻译、L1D 管数据存放、fill buffer 管 miss 在途,LSQ 管顺序正确性——四者缺一不可。
这一篇在知识体系里的位置
- 上游框架:cpu-out-of-order(乱序执行全景)、lsu(访存执行单元总览)、uop-pipeline-lsu-buffers(LSQ 容量作为流水线瓶颈)
- 同层互补:store-to-load-forwarding(消歧命中后的数据转发路径)、memory-dependence-prediction(投机策略的预测器半边)
- 机制同构:register-renaming(寄存器侧假依赖消除,与本篇内存侧动态消歧互为镜像)、branch-prediction(控制流投机,与内存投机共享"猜+验证+回滚"范式)
- 异常与恢复:precise-exception-pipeline-flush(另一套流水线清空机制)、rob(store 退休提交的依据)
总结
LSQ 访存消歧是乱序核心的内存裁判:load/store queue 按程序序记账,load 地址一出就和 store queue 里所有更老条目做 CAM 并发比较——地址已知就精确裁决(无冲突放行、精确重叠转发、数据未就绪等待),地址未知就投机先跑,等 store 地址就绪后反向检查年轻的已发射 load,赌错了以 load 重放或整线清空的代价回滚。一句话:它用"先斩后奏、事后抓包"换来了 load 的平均提前发射,是内存侧乱序性能的地基。