2.2 全阶段代码生成(Tungsten)
2.1 的 36ms 解释成本来自「每行走九个节点」。但解释执行还有一笔更隐蔽的账:算子与算子之间把中间结果完整写成元组。scan → filter → project 三个算子串起来,每行要在两条边界上各写一个元组、再读回来。行数一大,这笔搬运成本会超过表达式求值本身。
全阶段代码生成(whole-stage codegen,Spark Tungsten 的核心)做两件事:把一条 stage 内的算子融合成一个循环,把表达式编译成展开的代码。前者消除中间结果物化,后者消除逐节点分派。本节分别算这两笔账。
算子链之间发生了什么
没有融合时,每个算子是一个独立阶段:它从子算子拉一批数据,处理后写成自己的输出,再交给父算子。scan → filter → project 有两条算子边界:
| 边界 | 写入方 | 读出方 | 每行产生的数据 |
|---|---|---|---|
| scan → filter | scan | filter | 1 个完整元组 |
| filter → project | filter | project | 1 个完整元组 |
每行穿过一条 3 算子链,就要物化 2 个中间元组。这两个元组不是最终结果,只是为了让下一个算子能通过接口拿到数据;它们的唯一作用是「跨过算子边界」。
每行两个中间元组:1.024GB
lab 用例 13 把元组大小设为 64 字节,计算 800 万行的中间数据总量:
中间元组字节 = 行数 × (算子数 - 1) × 每元组字节
= 8,000,000 × 2 × 64
= 1,024,000,000 字节
= 1.024GB
| 边界 | 每行字节 | 800 万行合计 |
|---|---|---|
| scan → filter | 64B | 0.512GB(由总量拆分) |
| filter → project | 64B | 0.512GB(由总量拆分) |
| 合计 | 128B | 1.024GB(用例 13) |
1.024GB 是「写出来」的量。每个中间元组还要被下一个算子读回去,所以真实的内存流量是写入加读出。64 字节是按宽表元组估的模型参数;列越多、字段越宽,这个数字越大。
读写各一次:0.1024s
用例 14 把 1.024GB 的读写各算一次,按 20GB/s 的内存带宽折算搬运时间:
总流量 = 1.024GB × 2 = 2.048GB
搬运时间 = 2.048GB / 20GB/s
= 0.1024s
| 量 | 取值 |
|---|---|
| 中间数据 | 1.024GB |
| 读 + 写 | 2.048GB |
| 内存带宽 | 20GB/s |
| 搬运时间 | 0.1024s |
0.1024 秒是 102.4ms。把它摊到 800 万行,每行是 256 字节流量、约 12.8ns(公式推导);而融合后的计算成本是每行 6ns。也就是说,光是把中间元组搬进搬出,就比融合后的整行计算还贵一倍多。这就是算子融合真正的收益来源。
融合:把三个算子写成一个循环
融合后的执行不再有算子边界。scan 读出的列、filter 的判断、project 的计算在同一个循环里完成,中间值留在寄存器或栈上,不写成元组:
// 融合后的单循环:scan、filter、project 在同一遍完成
long out = 0;
for (int i = 0; i < rows; i++) {
long amount = price[i] * qty[i]; // project 的表达式
if (amount > 100 && "east".equals(region[i])) { // filter 的谓词
outAmount[out] = amount; // 直接写最终输出
out++;
}
}
循环里没有 next(),也没有中间元组。price[i] * qty[i] 算完立即参与判断,通过后直接写进输出数组;不通过就丢弃,连写回都省了。对 800 万行来说,这消除了 1.024GB 的中间数据与 2.048GB 的读写流量。
6ns/行:6ms 与 6 倍
融合不仅省搬运,也省掉了 2.1 的逐节点分派。lab 用例 12 给代码生成后的融合循环估了每行 6ns:
融合执行成本 = 行数 × 每行成本
= 1,000,000 × 6ns
= 6,000,000ns
= 6ms
| 执行方式 | 每行成本 | 100 万行总成本 |
|---|---|---|
| 解释 9 节点 | 9 × 4ns = 36ns(推算) | 36ms(用例 11) |
| 代码生成融合 | 6ns | 6ms(用例 12) |
| 加速比 | 6 倍 | 6 倍 |
每行 6ns 比单节点 4ns 还高,但总账反而快 6 倍:解释执行每行要走 9 个节点,融合后每行只走一遍展开的代码。节点分派、类型检查、中间元组读写全部消失,剩下的是一次紧凑循环。
Whole-stage 到底融合了什么
| 层次 | 未融合 | 全阶段代码生成 |
|---|---|---|
| 算子边界 | 每对算子一次调用与元组 | 融合进同一循环 |
| 表达式 | 逐节点树遍历 | 展开为直线代码 |
| 类型 | Object 装箱、运行时强转 | 原生类型、编译期确定 |
| 内存 | 中间元组堆上分配 | 寄存器、栈、输出数组 |
| 数据布局 | 行式元组 | 列式数组或 UnsafeRow |
「全阶段」的边界是 shuffle。一个 stage 内部可以融合,但遇到 shuffle、聚合或排序这种必须物化并跨节点传输的算子,融合就到此为止。stage 之间的数据仍然要落盘或走网络,代码生成管不到那一段。
代码生成的固定成本与回退
代码生成不是免费的,它把运行时开销换成了编译期开销与工程复杂度:
| 成本 | 表现 | 应对 |
|---|---|---|
| 编译时间 | 每次生成代码要几十毫秒量级 | 缓存生成结果,短查询回退解释 |
| 代码体积 | 表达式多时生成方法过大 | 超过阈值回退解释执行 |
| 调试困难 | 看不到原始算子边界 | 保留解释路径与生成代码日志 |
| 类型特化 | 复杂 UDF、未知类型难编译 | 回退到逐行/逐批解释 |
Spark 的 whole-stage codegen 有明确的分阶段与回退机制:如果一个 stage 生成的代码过大或包含不支持的表达式,就退回解释执行。这不是缺陷,而是工程上的必要妥协——代码生成必须保证语义正确,性能是第二位的。
什么时候该融合
| 场景 | 建议 | 原因 |
|---|---|---|
| 大扫描 + 简单过滤投影 | 融合 | 消除中间元组,收益最大 |
| 多算子窄依赖链 | 融合 | 边界越多,省下的物化越多 |
| 含 shuffle 的 stage | 只融合 stage 内 | 跨 stage 必须物化 |
| 极短查询 | 解释或缓存代码 | 编译成本摊不薄 |
| 复杂 UDF、动态类型 | 解释回退 | 编译器难以特化 |
判据的核心是「中间结果是否值得物化」。如果一条链上的中间结果只被父算子消费一次,物化就是纯浪费,应该融合;如果中间结果要被多个下游复用、要跨节点传输、要落盘,那它就必须物化,融合也无能为力。
融合前后的一次扫描账本
把 800 万行的一次 scan → filter → project 摊开,融合前后的差别只在「中间结果是否落成元组」:
| 项目 | 未融合 | 融合后 |
|---|---|---|
| 中间元组 | 1.024GB | 0 |
| 中间读写流量 | 2.048GB | 0 |
| 搬运时间(20GB/s) | 0.1024s | 0 |
| 每行计算 | 9 节点解释 | 6ns 展开循环 |
融合省掉的是中间结果,不是最终结果。最终投影结果仍然要写出去,但那部分输出在任何模型里都存在,不属于本节账本。判断融合收益时只看中间元组:它越大、被消费的次数越少,融合越划算。
列式布局为什么让融合更有效
64 字节的元组大约占一条缓存行。未融合时,每行要写一条缓存行、再读一条缓存行,两个算子边界就是两次往返;融合后循环按列连续访问,price[i]、qty[i]、region[i] 各自顺序推进,硬件预取器能把下一段数据提前拉进缓存。
| 布局 | 每行访存模式 | 缓存与预取 |
|---|---|---|
| 行式元组跨算子 | 写整行、读整行,地址跳跃 | 预取难,缓存行利用率低 |
| 列式数组融合 | 每列顺序扫描 | 预取友好,缓存行吃满 |
| UnsafeRow 融合 | 紧凑二进制、偏移访问 | 省对象头,仍需按行跳转 |
列式布局把「按行搬运」变成「按列扫描」,这是融合能省下 0.1024s 的底层原因。反过来说,如果数据本身是行式存储、算子又必须按行处理,融合的收益就会打折,此时更该先考虑存储格式与投影裁剪。
三个常见误解
误解一:代码生成的主要收益是减少 CPU 指令。 真相:更大的收益是消除中间结果物化——800 万行、每行 2 个 64 字节元组就是 1.024GB,读写一次按 20GB/s 要 0.1024s,比融合后的整行计算还贵。
误解二:Whole-stage 是给每个算子分别生成代码。 真相:它把一条 stage 内的算子链融合成一个循环,算子之间不再有调用和元组边界;遇到 shuffle 才断开。
误解三:代码生成总是更快。 真相:编译有几十毫秒量级的固定成本,短查询会被摊销反噬;表达式过大或类型不支持时还会回退解释执行。
一句话总结本节
全阶段代码生成把 3 算子链融合成一个循环:未融合时每行产生 2 个 64 字节中间元组,800 万行共 1.024GB,读写各一次、20GB/s 下搬运 0.1024s;融合后每行 6ns、100 万行 6ms,比解释执行 36ms 快 6 倍。融合的边界是 shuffle,短查询与复杂 UDF 仍需保留解释回退。
算子融合与代码生成边界
同一 stage 内的支持算子可融合。物理 Exchange 需要发布数据。不支持代码生成的算子也可能切断融合。
flowchart TD
A[物理计划] --> B[识别支持 codegen 的连续算子]
B --> C[生成循环、表达式和 NULL 判定]
C --> D{编译及执行可用}
D -->|是| E[运行融合 Scan Filter Project]
D -->|条件不满足| F[按所用引擎走非融合路径或报错]
E --> G[Exchange 或其他边界]
F --> G
G --> H[后续阶段消费数据]
本节 lab
在 bd-engine-lab 中验证代码生成与中间结果账本:
- 源码:
src/exec/Exec.java与src/exec/ExecSuite.java。 - 运行:
cd bd-engine-lab && mkdir -p out && javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。 - 断言:用例 12 验证「代码生成后每行 6ns,100 万行 6ms,比解释执行 36ms 快 6 倍」;用例 13 验证「3 算子链未融合,每行 2 个 64 字节中间元组,800 万行共 1.024GB」;用例 14 验证「1.024GB 读写各一次、20GB/s 带宽下搬运 0.1024s」。
- 整卷 runner 的预期汇总为
TOTAL: 116 passed, 0 failed。
对应本节判断链:看到解释执行仍慢 → 发现算子边界在物化中间元组 → 算出 800 万行 1.024GB、读写 0.1024s → 把算子链融合成单循环,消除元组与分派 → 100 万行从 36ms 降到 6ms,stage 边界与短查询保留回退。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。