夜雨聆风一个 1992 年的 C 程序，穿越三十余年，可能会在你的处理器上测出了新答案。
一个 1992 年的 C 程序，穿越三十余年，可能会在你的处理器上测出了新答案。
1. FLOPS 是什么？
FLOPS = FLoating-point Operations Per Second（每秒浮点运算次数）。
通俗地讲：你的处理器一秒钟能做多少次浮点数运算。
为什么强调"小数点"？因为整数运算（1+1=2）和浮点运算（3.14159 × 2.71828 = ?）在硬件上走的是两条完全不同的路。浮点运算要处理指数、尾数、规格化、舍入——每一步都得靠专门的电路来完成。所以 FLOPS 衡量的是处理器最"重"的计算能力。
我们经常看到的 MFLOPS（Mega-FLOPS）是百万次/秒，GFLOPS（Giga-FLOPS）是十亿次/秒，TFLOPS（Tera-FLOPS）是万亿次/秒。
2. 理论 FLOPS 怎么算？
一个处理器的理论峰值 FLOPS 可以精确算出来：
理论 FLOPS = 核心数 × 每核心每周期浮点指令数 × 主频
以一颗 16 核处理器为例，每核每周期可执行 16 次单精度浮点运算（2 条 256-bit FMA），最大加速频率 5.4 GHz：
16 核 × 16 FLOP/cycle × 5.4 GHz = 1382.4 GFLOPS ≈ 1.38 TFLOPS
双精度减半（256-bit 寄存器只能装 4 个 double），所以双精度理论峰值大约 691 GFLOPS。
你会在 CPU 规格里看到"1 TFLOPS"这种数字，甚至不需要跑任何程序，拿纸笔就能算出来。
那问题来了：理论值和实际一致吗？
其实差得远。
3. 理论很美，现实很骨感
理论峰值 FLOPS 的假设是：
所有核心都在跑浮点运算，没有停顿 数据永远在寄存器里等着，不需要访存 每条 FMA 指令都完美流过流水线，没有任何气泡 分支预测 100% 正确，缓存全部命中
这些假设同时成立的唯一场景是：不存在。
真实程序里会怎样？
内存墙：数据要从内存加载过来，延迟是寄存器访问的 100–200 倍 [^3] 分支误判：if/else 预测错了，流水线得清空重来 指令混合：不可能 100% 都是 FMA，还得做加减乘除、搬运数据 依赖链：后一条指令要等前一条的结果，流水线只能干等着 散热降频：全核满载 → 发热 → 撞功耗墙 → 自动降频。笔记本散热约束下，全核满载时撑不到标称最大频率
所以需要实测 FLOPS，用一个程序真正跑一遍，算出来到底是多少。
4. 如何实测 FLOPS？—— 从 Linpack 到 flops.c
业界最有名的浮点性能测试是 LINPACK —— 解一个巨大的稠密线性方程组，是 TOP500 超算排名的官方基准。但 LINPACK 测的不光是浮点算力，也在测内存带宽。
还有一个更纯粹的方案：flops.c [ https://github.com/Kivy-CN/flops ]
这个程序最初由 Al Aburto 在 1992 年于美国海军海洋系统中心（NOSC，位于加利福尼亚州圣地亚哥）编写 [^4]，总共约 1500 行 C 代码。思路极其朴素：
选 8 个不同的定积分计算题，每道题里的四则运算次数都是预先数好的。掐表跑一遍，用"总浮点操作数 ÷ 耗时"算出实测 MFLOPS。
5. flops.c 的巧妙设计
5.1 八个计算模块
程序设计了 8 个独立模块，每个模块算一个定积分——比如 ∫sin(x)dx、∫cos(x)dx、∫tan(x)dx、用泰勒级数求 π 等等。
每个模块里每次循环迭代的浮点运算次数是一个个数过的：
除法在这里很关键——FDIV 比乘法慢得多（现代 CPU 上可能仍然慢 3–10 倍 [^2]），所以混合不同除法占比的模块可从不同角度观察性能。模块 7 有 25% 的除法，算是"除法密集型"；模块 3、4、6、8 完全不含除法，测纯算术吞吐。
5.2 自适应校准：机器快慢都公平
程序启动时不知道你这台电脑有多快。如果是 1992 年的 486，循环 15625 次可能就要几秒；如果是 2025 年的 16 核处理器，15625 次连眨眼都来不及。
所以 flops.c 有一个自适应校准循环：先跑一次，如果时间太短就把循环次数翻倍，一直翻到至少跑满 15 秒为止。最终循环数可能是 512,000,000（5.12 亿次），这样测量结果才有统计意义。
5.3 四个综合指标
跑完 8 个模块后，程序输出四个加权 MFLOPS 值：
MFLOPS(1)：模块 2+3 的加权组合，9.6% FDIV，和老版本兼容 MFLOPS(2)：模块 1+3+4+5+6+7 的加权组合，9.2% FDIV，不含难以向量化的模块 2 MFLOPS(3)：同样的组合但把 FDIV 降到 3.4% MFLOPS(4)：模块 3+4+6+8，0% FDIV，纯加减乘
这四条线让你看到处理器在不同指令混合下的表现——有点像测汽车油耗：市区、高速、综合、满载爬坡，四个工况各跑一遍。
6. 从 C 到全世界——这段代码的漂流记
flops.c 在 1992 年诞生后，很长一段时间就静静躺在 Al Aburto 的 FTP 目录里。直到有一天——
Brian Olson 和 flops 的故事
Brian Olson 的父亲在洛斯阿拉莫斯国家实验室（Los Alamos National Laboratory）工作。1992 年，他父亲拿到了这份 flops.c 的代码——当超算中心的工程师们拿到一台新机器时，就花一分钟跑一下这个小程序，看一眼它到底有多快。Brian 从他父亲那里得到了这份代码，2014 年把它放到了 GitHub 上（github.com/brianolson/flops）。
在项目的 README 里，Brian 这样写道（以下是原文和忠实的中文翻译）：
One day my dad worked on supercomputers at Los Alamos National Laboratory and sometimes he would spend a minute running a little test to see about how fast a new supercomputer was. That test is here as flops.c very much as I received it in 1992. Your phone is probably much faster than the fastest supercomputer of 1992.
很久以前，我的父亲在洛斯阿拉莫斯国家实验室从事超算工作。有时候他要花上一分钟来跑一个小小的测试程序，估一下一台新超算大概有多快。这个测试程序就在这里——flops.c，几乎和我 1992 年拿到它时一模一样。如今你口袋里的那台手机，大概比 1992 年全世界最快的超级计算机还要快。
This isn't a very good benchmark, but it's simple and easy. It runs a few basic numeric algorithms with a known number of adds, subtracts, multiplies, and divides, and figures out how many floating point operations per second your CPU can do. It doesn't take advantage of multi-core or SIMD instructions. It doesn't exercise the memory system and probably all fits in L1 cache. It just tests how fast your CPU can do math (and that your compiler isn't terrible at making that happen).
这并不是一个很好的基准测试，但它足够简单。它跑几个基础的数值算法，每一次加法、减法、乘法、除法的次数都精确可知，然后算出你的 CPU 每秒能做多少次浮点运算。它不用多核，不用 SIMD 指令，也不考验内存系统。所有的计算大概全都在 L1 缓存里完成。它只做一件事——测你的 CPU 算数学有多快（以及你的编译器有没有拖后腿）。
Over the years I transliterated flops.c into other languages to test them and their compilers and interpreters. Python has a pretty slow interpreter, around 1–5% of the speed of C. Javascript got amazingly good and can run 80–90% of the speed of C. Java got to that speed around 2007 or 2008. The Go compiler is surprisingly good for a newer language. Julia is a newer language that should have the potential for running full speed but apparently still needs some tweaking (as of 2018-05).
这些年来我把 flops.c 一一转译成了其他语言，用来测试它们的编译器和解释器。Python 的解释器相当慢，大约只有 C 速度的 1%–5%。JavaScript 进步惊人，能跑到 C 的 80%–90%。Java 大概在 2007 到 2008 年间达到了这个水平。Go 的编译器对于一个新兴语言来说质量出奇地好。Julia 理论上具备跑满全速的潜力，不过显然还需要一些打磨（以上评价截至 2018 年 5 月）。
Brian 转译的版本包括：
flops.c—— 原始的 C 版本flops.java—— Javaflops.js/flops.html—— JavaScript（在浏览器里就能跑）flops.go—— Goflops.jl—— Juliaflops.py—— Python
这些代码能够用来对比不同语言和运行时的底层效率：
| 1–5% |
Python 的数字特别扎眼——同样的算法，解释型 Python 只有 C 的 1%–5% 速度。Python 选择了灵活性和动态性，而不是极致速度。需要速度的时候，Python 生态里有 NumPy、Cython、Numba 这些加速方案。
7. 2025 年的升级
2021 年前后，我把 Brian 仓库里的 Python 2 版本适配到了 Python 3，建了一个衍生仓库（github.com/Kivy-CN/flops），同时在 README 里加了 Brian 原始故事的中文说明。当时这个版本还比较简单，只做了最基本的 Python 3 兼容。
到了 2026 年，发现这个项目还有很大的升级空间。
原版 flops.c 发布于 1992 年，那时候：
CPU 是单核心的（Intel 80486 时代） 没有 pthreads，多线程还是个新鲜概念 计时用的是 getrusage()系统调用，精度到毫秒输出格式固定，没有 JSON，没有 CLI 参数
三十多年后的今天，彻底翻新了一遍，覆盖 C、Go、Python、Rust 四种语言：
C 版本 (flops.c V3.0)
C11 标准，清理了所有 K&R 遗留语法，用上了现代类型系统 POSIX pthreads 多线程并行——8 个模块中 7 个可并行，自动按线程数分割迭代区间；模块 2 因循环依赖保持串行 clock_gettime(CLOCK_THREAD_CPUTIME_ID)：纳秒级精度，而且测的是每线程的 CPU 时间而非墙钟时间，多核场景下计时更准命令行参数： -j N（线程数）、-t SEC（运行时长）、--json、--all-modes--all-modes自动对比单线程 vs 多线程，输出加速比表格JSON 输出：方便脚本和 CI/CD 解析
Go 版本 (flops.go V3.0)
全新重写，基于 goroutine + sync.WaitGroup并行flag标准库 CLI，和 C 版参数对齐同样提供 --json、--all-modes单文件 go build就行，零外部依赖
Python 版本 (flops.py V3.0)
三种并行模式： --mode mp（默认）：ProcessPoolExecutor，真正的多核并行——绕过全局解释器锁（GIL）--mode thread：ThreadPoolExecutor，有意展示 GIL 的瓶颈效应--mode numpy：NumPy 向量化，把一个块的循环完全交给底层 C 来跑argparse CLI： -j、-t、--mode、--all-modes、--json、--repeat N--repeat N统计模式：多次运行后输出 mean/min/max/stddev对比模式：一条命令同时跑 serial / mp / thread / numpy 四种策略
Mode Workers MFLOPS(1) MFLOPS(2) MFLOPS(3) MFLOPS(4) Wall(s)
serial 1 40.33 38.68 34.91 33.13 21.20
mp 4 43.22 104.80 96.72 93.75 12.10
thread 4 41.34 42.83 38.93 38.23 20.27
-----------------------------------------------------------------------------------
Speedup vs serial serial: 1.00x mp: 2.83x thread: 1.15x
一目了然：
多进程（mp）4 核加速 2.83 倍 → GIL 不是问题 多线程（thread）几乎零加速 → GIL 把性能掐死了 NumPy 块内向量化 + 多进程分摊，理论上可以更猛
Rust 版本 (flops_rs V3.0)
基于 rayon 并行迭代器 + clap derive CLI + serde JSON cargo build --release编译，运行时性能接近 C完整支持 8 模块、 --all-modes对比模式
测试套件 (test_flops.py)
40+ 测试覆盖：
C：单核、2/4/all 核、 --all-modes、--json、加速比分析Go：单核、2/4 核、 --all-modes、--jsonPython：serial / mp(2,4) / thread(4) / numpy Rust：有 cargo 时自动编译测试 交叉验证：C vs Python vs Go 全部 8 模块数值一致性（全通过） 加速比效率分析：单核 vs 多核，算并行效率百分比
8. 在你的电脑上跑一次
git clone https://github.com/Kivy-CN/flops.git
cd flops
make # 编译 C + Go，运行完整测试
make compare # 单核 vs 多核对比
make test# 40+ 测试的完整套件
或者手动编译各语言版本：
# 编译 C 版本
gcc -std=c11 -O2 -pthread -lm flops.c -o flops
# 单线程基准
./flops -j 1
# 全核并行
./flops -j $(nproc)
# 对比模式 — 看加速比
./flops --all-modes -j $(nproc)
# JSON 输出（方便脚本解析）
./flops --json -j 4
# Go 版本
go build -o flops_go flops.go && ./flops_go -j $(nproc)
# Python 对比所有模式
python3 flops.py --all-modes -j 4
# Rust 版本
cd flops_rs && cargo build --release && ./target/release/flops -j $(nproc)
# 一键构建 + 测试
make && make test
9. 一些有趣的观察
"1992 年的超算不如你的手机"
1992 年世界最快的超级计算机是 Cray Y-MP C90，标称峰值大约 16 GFLOPS [^1]。上面那颗 16 核笔记本处理器的理论峰值约 1,382 GFLOPS——是它的 86 倍。有的手机的CPU的FLOPS峰值可能也超过了 1 TFLOPS。
多线程 scaling 不是线性的
10 核加速 7.19 倍——为什么不是 10 倍？因为：
模块 2 有循环依赖（ s = -s; sa = sa + s），只能串行——这就是阿姆达尔定律线程创建/销毁、上下文切换有开销 所有核心共享同一块 L3 缓存和内存带宽 散热和功耗管理可能导致部分核心降频（特别是移动平台）
除法算得慢
模块 7（25% FDIV）在所有模块里 MFLOPS 最低——因为一次浮点除法比乘法多花好几倍时间。这也是为什么编译器优化里有一条铁律：能改写成乘以倒数，就绝不做除法。
10. 局限性
flops.c 是一个微观基准（micro-benchmark），它有意识地排除了：
内存带宽：所有数据都在寄存器里，完全适配 L1 缓存 SIMD 指令：没有用 SSE/AVX/NEON，纯标量运算 真实世界的复杂性：没有 IO、网络、系统调用、多进程通信
所以它的 MFLOPS 数字会比真实应用程序高不少。但它仍然有价值：
测量 CPU 的纯算术上限——其他任何程序都不会超过这个数字 快速评判编译器质量——不同优化选项（-O0/-O2/-O3/-march=native）的性能差异一目了然 对比语言运行时效率——同样的算法，Python 为什么这么慢，Go 和 Rust 又各有啥特点 教学价值——展示浮点运算、流水线、指令混合、并行效率这些概念
如果想测更真实的性能，应该搭配 LINPACK（内存+计算混合）、STREAM（纯内存带宽）和 SPEC CPU（完整应用场景）一起用。
附：一点混乱的编年史
从 500 FLOPS 到 1,000,000,000,000,000,000 FLOPS，用了 80 年。你口袋里手机的计算能力，可能都远远超过了 1992 年整个星球上最快的超级计算机。
而 flops.c，这个跨越了 33 年的小程序，至今仍然能编译、运行，准确告诉你——这台机器算数学到底有多快。项目地址：github.com/Kivy-CN/flops
参考出处
[^1]: Cray Y-MP C90 峰值约 16 GFLOPS —— C916 配置（16 处理器），来源：Fred Gannett's Cray FAQ Part 5；Wikipedia "Cray C90"。
[^2]: 现代处理器上浮点除法比乘法慢约 3–10 倍 —— 参考 Agner Fog, "Instruction tables: Lists of instruction latencies, throughputs and micro-operation breakdowns for x86 and ARM microprocessors," https://agner.org/optimize/。例如 Zen 4 架构中 FMUL 延迟约 4–5 周期，FDIV 延迟约 11–20 周期（单精度到双精度）。
[^3]: 内存访问延迟约 100–200 倍于寄存器 —— 参考 Hennessy & Patterson, "Computer Architecture: A Quantitative Approach," 6th ed., 2017, Table 2.3：L1 寄存器 ~0.25ns，DRAM ~50–100ns。
[^4]: Al Aburto, flops.c V2.0, 1992. 原始代码头注释标注作者邮箱 aburto@nosc.mil（NOSC = Naval Ocean Systems Center）。Brian Olson 的 GitHub 仓库保留了原始代码：https://github.com/brianolson/flops 。
[^5]: ENIAC 约 500 FLOPS —— Wikipedia "ENIAC"："ENIAC was able to process about 500 FLOPS." 来源引用自 Wikipedia ENIAC 词条注 36。
[^6]: Cray-1 峰值 160 MFLOPS —— Wikipedia "Cray-1" infobox；Russell, R.M. (1978). "The CRAY-1 Computer System." Commun. ACM 21(1): 63–72. doi:10.1145/359327.359336。
[^7]: IBM Roadrunner 于 2008 年 5 月 25 日突破 1 PFLOPS —— Wikipedia "Roadrunner (supercomputer)"；Barker et al. (2008), "Entering the petaflop era: The architecture and performance of Roadrunner," SC08。
[^8]: Frontier 超算于 2022 年 5 月突破 1 EFLOPS —— Wikipedia "Frontier (supercomputer)"；ORNL 新闻稿 "Frontier supercomputer debuts as world's fastest, breaking exascale barrier," May 30, 2022。
