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 组。

这组数字是特定机器、特定编译器、单次运行的结果。Windows 的电源策略、后台进程、散热状态都会影响频率,重复运行会有波动。它适合用来看趋势和量级,不适合当作跨机器的跑分。

高主频低 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 也可能差百分之几十。同一颗芯片装在不同笔记本里,散热和功耗策略不同,长时间负载下的实际频率也会差出一截。

最后,性能优化要落到具体瓶颈。先测,再改,再测。凭直觉改代码,很容易把瓶颈从分支换成缓存,从缓存换成内存带宽,看起来改了很多,实际没变快。

今天就能验证的五个练习

  1. 把上面的程序原样编译运行,确认五组输出和文章里的量级接近。如果差别很大,先检查是不是用了不同的编译参数。
  2. 用 -O0 和 -O2 各编译一次,比较 A 组和 E 组的差异,理解优化级别改变了什么。
  3. 把 D 组的分支条件从奇偶改成「每四次跳一次」,再改成完全随机,观察耗时如何变化。
  4. 写一个空函数,用 clock() 测一亿次调用的总时间,算出每次调用的纳秒数;再加上一个参数和一个局部变量,看开销涨多少。
  5. 查自己 CPU 的规格页,找到基础频率、最大加速频率和缓存大小,再用一段已知指令数的循环估算实际 IPC 量级。

这五个练习不需要性能计数器,一台普通电脑加一个 C 编译器就能做完。它们能让你对「周期」这件事有手感。

小结

主频是节拍,不是速度。一条指令要经过取指、译码、执行、访存、写回五段,流水线让多段重叠,提高的是吞吐不是单条延迟。数据冒险、控制冒险、结构冒险会让流水线停顿,分支猜错的惩罚尤其明显。超标量和乱序执行把 IPC 推到 1 以上,但依赖链和内存访问仍然是天花板。

下一篇专门讲缓存。上面所有「数据量一大就变慢」的现象,根子都在一次 cache miss 要等多久。那篇会用指针追逐测出本机各级缓存的真实延迟。

下一篇:缓存,从一次 miss 的代价开始算。