汇编优化：一个字母如何让代码加速 3x

汇编中替换一字母，除法提速三倍：技术剖析

在汇编指令中更改单个字符，即可将除法操作时间缩短 66%。在现代 CPU 上的真实基准测试显示，虚假寄存器依赖如何将乱序执行潜力转化为瓶颈。我们剖析了影响性能的 x86-64 架构细节。

x86-64 寄存器的架构特性

现代 x86-64 处理器采用带有继承结构的寄存器层次结构。rax 寄存器（64 位）包含：

┌───────────────────────────────────────────────────────────────┐
│                           rax (64 位)                        │
├───────────────────────────────┬───────────────────────────────┤
│          (上部 32 位)         │           eax (32 位)        │
│                               ├───────────────┬───────────────┤
│                               │               │   ax (16 位) │
│                               │               ├───────┬───────┤
│                               │               │ah (8 位)│al (8 位)│
└───────────────────────────────┴───────────────┴───────┴───────┘

关键点：向寄存器的低位部分（ax、al）写入不会影响高位，而对 32 位寄存器（eax）的操作会完全覆盖上部 32 位。这会产生对流水线至关重要的隐藏依赖。

div/idiv 除法指令使用一对寄存器：

┌──────────┬────────────────┬──────────────┬─────────────────────┐
│ 大小     │ 被除数         │ 商位于       │ 余数位于            │
├──────────┼────────────────┼──────────────┼─────────────────────┤
│ 16 位    │ dx:ax          │ ax           │ dx                  │
├──────────┼────────────────┼──────────────┼─────────────────────┤
│ 32 位    │ edx:eax        │ eax          │ edx                 │
├──────────┼────────────────┼──────────────┼─────────────────────┤
│ 64 位    │ rdx:rax        │ rax          │ rdx                 │
└──────────┴────────────────┴──────────────┴─────────────────────┘

除法前，必须将对的上部清零。标准模式：

mod edx, 0
mov eax, 536700
div dword [denominator]

实验数据：3.7× 差异

测试循环处理了 2,073,600 次迭代（1920×1080），模拟像素渲染。每迭代周期数（减去循环开销后）：

┌────────┬──────────────┬──────────────┐
│        │ idiv（纯净） │ div（纯净）  │
├────────┼──────────────┼──────────────┤
│ 16 位  │ 22.2         │ 22.2         │
├────────┼──────────────┼──────────────┤
│ 32 位  │  6.0         │  6.0         │
├────────┼──────────────┼──────────────┤
│ 64 位  │ 26.2         │ 24.1         │
└────────┴──────────────┴──────────────┘

惊喜：相同输入数据的 32 位操作比 16 位操作快 3.7 倍。原因不是除法算法复杂度，而是微架构执行细节。

虚假依赖机制

处理器使用寄存器别名表（RAT）将逻辑寄存器映射到物理寄存器。值得注意的是：

• 向 32 位寄存器写入（mov edx, ...）完全覆盖 值，打破与先前操作的依赖
• 向 16 位寄存器写入（mov dx, ...）需要合并新数据与上位，产生虚假依赖

在 16 位变体中，依赖链如下：

div word → merge → mov dx → merge → div word → ...

每次迭代必须等待前一次完成，因为寄存器合并需求。在 32 位变体中，此链断开，处理器能够实现流水线执行。

关键性能指标

• 延迟：16 位 div 为 21–22 周期（结果就绪时间）
• 吞吐量：16 位 div 为 6 周期（操作间调度间隔）

操作相互依赖时，延迟成为瓶颈。对于独立操作，则受吞吐量限制。22/6 ≈ 3.7 的比率解释了加速原因。

假设验证：替换一字母

实验证实了理论。在 16 位上下文中，用 32 位指令替换 16 位指令：

; Before
mov dx, 0x0008
mov ax, 0x2B7C

; After
mov edx, 8
mov eax, 0x2B7C

结果惊人：

┌───────────────────────┬──────────────┬──────────────┐
│                       │ idiv（纯净） │ div（纯净）  │
├───────────────────────┼──────────────┼──────────────┤
│ 16 位（mov dx）       │ 22.2         │ 22.2         │
├───────────────────────┼──────────────┼──────────────┤
│ 16 位（mov edx）      │  7.0         │  7.0         │
└───────────────────────┴──────────────┴──────────────┘

指令中的一个字母 e 消除了虚假依赖，将执行时间从 22.2 降至 7.0 周期——正好达到除法器的吞吐量水平。

重要事项

• 寄存器大小选择至关重要：使用 32 位操作准备 16 位除法，消除不必要依赖
• 延迟 vs 吞吐量：依赖使性能受延迟限制，而非吞吐量限制
• 架构细节：理解 RAT 和部分寄存器合并对低级优化至关重要
• 除法器更快产生余数：x86 并行计算商和余数，允许更早使用 edx 而非等待 rax
• 测试必不可少：理论估算往往因微架构特性而与实际测量不符

开发者的实用建议

• 对于除法，即使用 16 位数据，也始终使用 32 位操作清零上部寄存器
• 避免在循环中混合寄存器大小
• 对于性能关键代码，检查编译器的汇编输出
• 注意除法器吞吐量超过延迟，但仅在无依赖时
• 在现代 CPU（Ice Lake 及更高版本）上，查阅 uops.info 规范获取当前指标

此实验展示了深入微架构知识如何揭示非显而易见的优化。只需交换指令中一个看似无用的字母，即可通过移除人为流水线限制获得三倍加速。对于系统程序员，这是一个提醒：即使在低级汇编中，优化机会也隐藏在对硬件的理解之中。

— Editorial Team