3GHz 的意思是每秒 30 亿个时钟周期。一亿次循环,如果每轮只花 3 个周期,理论上 0.1 秒就该跑完。这个算法很直观,也很容易被推翻。
本机是一颗 8 核 12 线程的 x86 处理器,型号 Intel Core 5 210H,厂商给的基础频率是 2.2GHz。我写了一段一亿次的空转循环,循环体里只有一个随机分支和一次累加,用 C 的 clock() 计时,gcc 16.2 加 -O2 编译。跑出来 0.145 秒。按 2.2GHz 折算,每轮 3.2 个周期;按它实际加速到的频率折算,接近 6 个。
同一台机器上,把随机分支换成按奇偶交替的可预测分支,时间掉到 0.024 秒。再换成完全什么都不做的循环,编译器把整个循环算成了闭式公式,0.000 秒。三个数字,三种结果,都不是「3GHz 每秒 30 亿条指令」能解释的。
这篇就拆开看:一个时钟周期到底能做什么,流水线为什么能重叠,什么情况下会停顿,以及为什么买 CPU 时只看主频会被坑。
主频是节拍,不是指令数
主频的单位是赫兹,3GHz 表示时钟每秒跳动 30 亿次。每一次跳动叫一个周期,周期是 CPU 内部的一个节拍。指令在节拍上一步一步往前走,但一条指令通常要花好几个周期,而且不同指令花的周期数不一样。
衡量实际速度的指标是 IPC,Instructions Per Cycle,每周期完成的指令数。它不是常数,取决于程序、编译器和 CPU 架构。把主频和 IPC 放在一起,才有完整的公式:执行时间等于指令数除以「主频乘 IPC」。主频只提供分母的一部分。
还有一个反向指标叫 CPI,Cycles Per Instruction,每条指令平均花几个周期。CPI 等于 IPC 的倒数。一段依赖很重的代码,CPI 可能是 3 到 5;一段循环展开良好、数据都在缓存里的代码,CPI 可以接近 0.5,因为现代 CPU 一个周期能发射多条指令。
所以「3GHz 比 2.5GHz 快」只在同一架构、同一程序、同一散热条件下才勉强成立。跨架构比主频,就像拿两个不同齿轮比的发动机比转速,数字有意义,结论没有。
五级流水线:一条指令怎么走完全程
最经典的五级流水线把一条指令拆成五段:取指、译码、执行、访存、写回。取指从内存或指令缓存里拿指令;译码把机器码翻译成内部的控制信号;执行做算术和逻辑运算;访存读写数据;写回把结果存回寄存器。
如果一条一条串行执行,每条指令要等五拍。流水线的做法是让五段同时工作:第一拍取第一条,第二拍译码第一条并取第二条,第三拍执行第一条、译码第二条、取第三条。理想情况下,每个周期都有一条指令完成。
这里要分清两个概念。单条指令从进入到完成仍然要五拍,这叫延迟,没有变短;但整体每秒完成的指令数提高了,这叫吞吐。流水线优化的是吞吐,不是单条指令的延迟。这也是为什么主频提高能让吞吐上升,却不代表单个操作更快多少。
现实里流水线不止五级。现代桌面核可能有十几级,把取指、译码、执行再切细,以便跑更高的主频。级数越多,每级的工作越少,频率越容易拉高;但一旦猜错方向或者等数据,要冲刷的级数也越多,代价更大。
三种冒险:流水线为什么会停下来
流水线最怕的是「下一拍要用的东西还没准备好」。这类冲突叫冒险,分三种。
数据冒险是前后两条指令用了同一个寄存器,后一条要等前一条算完。比如先算 a = b + c,下一句马上用 a 乘 2。硬件有转发机制,可以把刚算出的结果直接送给下一条,不必等写回,但遇到乘法、除法这种多周期指令,还是要等。依赖链越长,停顿越多。
控制冒险是遇到了分支。取指阶段还不知道该往哪走,硬件只能先猜。猜对了继续,猜错了就把已经取进来的指令全部作废,从正确地址重新取。这个动作叫冲刷,代价是十几个周期。
结构冒险是两条指令同一拍要用同一个硬件资源,比如只有一个乘法器却要同时做两次乘法,或者取指和访存争抢同一个缓存端口。硬件要么加资源,要么让其中一条等一拍。现代 CPU 通过分离指令缓存和数据缓存、增加执行单元来减少这种冲突,但不可能完全消除。
分支预测:猜错一次要付多少
分支预测器的工作是猜「这个 if 走哪边」。它记录历史,看这个分支上次走了哪里、前几次的模式是什么,甚至用全局历史和相关表来推断。循环末尾的分支最好猜,因为模式固定:连续跳回很多次,最后一次不跳。随机分支最难猜,历史没有规律。
猜错的代价叫误预测惩罚。现代处理器的流水线有十几级,猜错后要把后面已经取指、译码、甚至部分执行的指令全部丢掉,再从正确地址重新填充流水线。典型惩罚在十几个周期,深度流水线的架构可能更高。这个数字来自公开的架构资料,具体到某一颗芯片要看厂商手册,本机没有性能计数器,未在本机实测,不报精确值。
这正好解释了实测里的那组差距:可预测的奇偶分支 0.024 秒,随机分支 0.145 秒,差了六倍。代码量几乎一样,多的那部分时间基本都花在冲刷和重新取指上。分支预测不是玄学,它直接决定一段代码能不能跑满流水线。
超标量和乱序执行:IPC 从哪来
如果每个周期只能取一条、执行一条,IPC 的上限就是 1。现代 CPU 早就超过了这个限制。超标量指一个周期取多条、译码多条、发射多条;常见宽度是四到六条。乱序执行指指令不必按程序顺序执行,只要数据依赖满足,后面的指令可以先做。
乱序执行需要重命名寄存器,把逻辑寄存器映射到更多的物理寄存器,避免假依赖;还需要重排序缓冲区,保证退休时按程序顺序提交,异常和中断不会乱。分支预测配合推测执行,让 CPU 在还没确定分支时就把两条路都往前走,猜对了就赚到,猜错了就回滚。
这些机制让 IPC 可以大于 1,但也让「周期数」变得难以手算。同一段代码在不同微架构上的 IPC 可能差一倍。写性能敏感的代码时,能控制的是依赖链、分支可预测性、内存访问模式,控制不了硬件的发射宽度和预测器实现。
所以优化循环的方向很具体:减少循环携带的依赖,让每轮能并行;把不可预测的分支改成无分支运算或者查表;把数据放在缓存里,减少访存停顿。这三件事比换一颗主频高 0.2GHz 的芯片更有效。编译器已经生成足够多独立指令时,乱序窗口再大也用不上,瓶颈会回到取指带宽。
本机实测:五种循环的真实耗时
下面这段程序可以直接编译运行。核心是用 volatile 阻止编译器把结果优化掉;volatile 告诉编译器「这个变量随时可能被外部改变,每次都要真的读写」,代价是每轮多一次内存访问。
#include <stdio.h>
#include <stdint.h>
#include <time.h>
static volatile uint64_t sink;
static double elapsed_ms(clock_t t0, clock_t t1) {
return (double)(t1 - t0) * 1000.0 / CLOCKS_PER_SEC;
}
int main(void) {
const uint32_t N = 100000000u;
clock_t t0, t1;
volatile uint64_t v = 0;
uint64_t acc = 1;
uint64_t sum = 0;
uint64_t plain = 0;
uint32_t x = 2463534242u;
/* A: 纯空循环 */
t0 = clock();
for (uint32_t i = 0; i < N; i++) plain++;
t1 = clock();
sink = plain;
printf("A plain-loop : %7.3f s %5.2f ns/iter\n",
elapsed_ms(t0, t1) / 1000.0, elapsed_ms(t0, t1) * 1000000.0 / N);
/* B: 计数器 volatile */
t0 = clock();
for (uint32_t i = 0; i < N; i++) v++;
t1 = clock();
printf("B volatile-counter : %7.3f s %5.2f ns/iter\n",
elapsed_ms(t0, t1) / 1000.0, elapsed_ms(t0, t1) * 1000000.0 / N);
/* C: 带依赖的累加 */
t0 = clock();
for (uint32_t i = 0; i < N; i++) acc = acc * 3 + (uint64_t)i;
t1 = clock();
sink = acc;
printf("C dependent-accum : %7.3f s %5.2f ns/iter\n",
elapsed_ms(t0, t1) / 1000.0, elapsed_ms(t0, t1) * 1000000.0 / N);
/* D: 可预测分支 */
t0 = clock();
for (uint32_t i = 0; i < N; i++) {
if (i & 1u) sum += 1;
else sum += 2;
}
t1 = clock();
printf("D predictable-branch : %7.3f s %5.2f ns/iter\n",
elapsed_ms(t0, t1) / 1000.0, elapsed_ms(t0, t1) * 1000000.0 / N);
/* E: 不可预测分支 */
t0 = clock();
for (uint32_t i = 0; i < N; i++) {
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
if (x & 1u) sum += 1;
else sum += 2;
}
t1 = clock();
sink = sum;
printf("E unpredictable-branch: %7.3f s %5.2f ns/iter\n",
elapsed_ms(t0, t1) / 1000.0, elapsed_ms(t0, t1) * 1000000.0 / N);
printf("sink=%llu\n", (unsigned long long)sink);
return 0;
}
编译命令和本机实际输出:
gcc -O2 hw_pipeline.c -o hw_pipeline.exe
.\hw_pipeline.exe
A plain-loop : 0.000 s 0.00 ns/iter
B volatile-counter : 0.024 s 0.24 ns/iter
C dependent-accum : 0.066 s 0.66 ns/iter
D predictable-branch : 0.024 s 0.24 ns/iter
E unpredictable-branch: 0.145 s 1.45 ns/iter
sink=17560225680856035329
A 组是 0.000 秒,因为编译器发现 plain 只是从 0 加到 N 减一,直接算成公式,循环根本不存在。这提醒一件事:测性能时先确认循环没有被优化掉,否则测的是空气。
B 组每轮只有一次 volatile 自增,0.24 纳秒。按标称 2.2GHz 算,一个周期是 0.45 纳秒,这相当于每轮半个周期,说明测试期间核心实际跑在更高的加速频率上。笔记本的标称频率是基础值,不是一直保持的值。
C 组的依赖乘法每轮 0.66 纳秒,约等于三倍 B 组。64 位乘法的延迟通常就是三个周期左右,后一轮必须等前一轮乘完,乱序执行也插不进去。D 组因为分支可预测,和 B 组持平;E 组因为分支随机,每轮 1.45 纳秒,六倍于 D 组。
高主频低 IPC,和低主频高 IPC
两条路都能提高性能,但代价不同。高主频靠深流水线和更激进的电路,单位时间的周期多;低主频靠更宽的发射、更大的缓存和更好的预测,每个周期做更多事。把它们放在一起看:
高主频、低 IPC
4GHz 但平均 IPC 只有 0.8,等效 32 亿条指令每秒。深流水线拉高了频率,也拉高了误预测惩罚和功耗。分支密集、依赖重的代码在这里容易掉速,散热一差就降频。
低主频、高 IPC
2.5GHz 但平均 IPC 能到 2.5,等效 62.5 亿条指令每秒。宽发射、大缓存、强预测器让每个周期做更多事,代价是芯片面积大、设计复杂,低频下能耗也不低。
真实产品往往在中间找平衡:服务器核追求吞吐和能效,桌面核追求单线程响应,手机核在几瓦的预算里做取舍。同一个架构的大核和小核,主频和 IPC 都不一样,调度器要根据负载把任务放过去。
这也是为什么「同频对比」在评测里经常出现。把两颗芯片锁到同一频率,才能看出微架构的差异;不锁频直接比,主频、缓存、内存、散热全混在一起,结论很难归因。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 主频很高但程序不快 | IPC 低,可能卡在依赖链、分支或内存访问 | 先确认循环没被优化掉,再看每轮耗时和依赖关系 |
| 循环计时是 0.000 秒 | 结果没被使用,编译器做了闭式求解或删除 | 加 volatile 或把结果写到外部可见的变量,再看汇编 |
| 分支随机后明显变慢 | 预测失败,流水线被反复冲刷 | 统计分支的可预测性,尝试改成无分支写法 |
| 函数调用多就掉速 | 调用和返回有固定开销,参数和局部变量还要压栈 | 测空函数调用每轮耗时,判断是否该内联或减少调用层次 |
| 依赖链长的循环很慢 | 乘法、除法等长延迟指令串行,乱序也填不满 | 画数据依赖图,看能否拆成多条独立链 |
| 数据量一大就变慢 | 缓存装不下,访存停顿主导 | 看工作集大小和缓存容量,按下一篇的方法测延迟 |
| 笔记本拔电后编译变慢 | 功耗策略限制频率,散热或电池供电触发降频 | 比较插电和拔电时的实际频率与耗时 |
| 同主频两颗 CPU 差距大 | 微架构、缓存、内存子系统和编译器优化不同 | 看同频评测和实际负载,不要只比型号数字 |
边界与代价
流水线不是越深越好。级数增加能提高主频,但每级的锁存器开销、时钟分布功耗和误预测惩罚都上升。到了某个点,频率带来的收益被冲刷代价和功耗吃掉,厂商就会停在那里,转而在宽度、缓存和预测器上做文章。
IPC 也不是越高越好。更宽的发射需要更多的执行单元、寄存器堆和旁路网络,芯片面积和功耗都涨。编译器如果生成不了足够多的独立指令,宽发射就填不满,多出来的硬件在闲置。
测量本身有很多干扰。编译器优化、电源管理、后台进程、内存频率、散热状态,都会让同一段代码在不同时间跑出不同结果。单次测量只能看量级,要看趋势至少重复几次,取中位数,并且记录编译参数和运行环境。
跨架构比较主频没有意义。x86 和 ARM 的指令长度、译码方式、流水线深度都不同,同一个 3GHz 不能直接换算。即便是同一家厂商,不同代际的 IPC 也可能差百分之几十。同一颗芯片装在不同笔记本里,散热和功耗策略不同,长时间负载下的实际频率也会差出一截。
最后,性能优化要落到具体瓶颈。先测,再改,再测。凭直觉改代码,很容易把瓶颈从分支换成缓存,从缓存换成内存带宽,看起来改了很多,实际没变快。
今天就能验证的五个练习
- 把上面的程序原样编译运行,确认五组输出和文章里的量级接近。如果差别很大,先检查是不是用了不同的编译参数。
- 用
-O0和-O2各编译一次,比较 A 组和 E 组的差异,理解优化级别改变了什么。 - 把 D 组的分支条件从奇偶改成「每四次跳一次」,再改成完全随机,观察耗时如何变化。
- 写一个空函数,用
clock()测一亿次调用的总时间,算出每次调用的纳秒数;再加上一个参数和一个局部变量,看开销涨多少。 - 查自己 CPU 的规格页,找到基础频率、最大加速频率和缓存大小,再用一段已知指令数的循环估算实际 IPC 量级。
这五个练习不需要性能计数器,一台普通电脑加一个 C 编译器就能做完。它们能让你对「周期」这件事有手感。
小结
主频是节拍,不是速度。一条指令要经过取指、译码、执行、访存、写回五段,流水线让多段重叠,提高的是吞吐不是单条延迟。数据冒险、控制冒险、结构冒险会让流水线停顿,分支猜错的惩罚尤其明显。超标量和乱序执行把 IPC 推到 1 以上,但依赖链和内存访问仍然是天花板。
下一篇专门讲缓存。上面所有「数据量一大就变慢」的现象,根子都在一次 cache miss 要等多久。那篇会用指针追逐测出本机各级缓存的真实延迟。
下一篇:缓存,从一次 miss 的代价开始算。