《大规模分布式计算深入解析》2.2 全阶段代码生成(Tungsten)

全阶段代码生成把算子链融合成一个循环,省掉虚调用与中间元组物化。3 算子链 800 万行算出每行 2 个 64 字节元组共 1.024GB,读写一次、20GB/s 下搬运 0.1024s;融合每行 6ns、100 万行 6ms,比解释 36ms 快 6 倍,lab 三用例断言。

2.2 全阶段代码生成(Tungsten)

2.1 的 36ms 解释成本来自「每行走九个节点」。但解释执行还有一笔更隐蔽的账:算子与算子之间把中间结果完整写成元组。scan → filter → project 三个算子串起来,每行要在两条边界上各写一个元组、再读回来。行数一大,这笔搬运成本会超过表达式求值本身。

全阶段代码生成(whole-stage codegen,Spark Tungsten 的核心)做两件事:把一条 stage 内的算子融合成一个循环,把表达式编译成展开的代码。前者消除中间结果物化,后者消除逐节点分派。本节分别算这两笔账。

算子链之间发生了什么

没有融合时,每个算子是一个独立阶段:它从子算子拉一批数据,处理后写成自己的输出,再交给父算子。scan → filter → project 有两条算子边界:

边界写入方读出方每行产生的数据
scan → filterscanfilter1 个完整元组
filter → projectfilterproject1 个完整元组

每行穿过一条 3 算子链,就要物化 2 个中间元组。这两个元组不是最终结果,只是为了让下一个算子能通过接口拿到数据;它们的唯一作用是「跨过算子边界」。

每行两个中间元组:1.024GB

lab 用例 13 把元组大小设为 64 字节,计算 800 万行的中间数据总量:

中间元组字节 = 行数 × (算子数 - 1) × 每元组字节
             = 8,000,000 × 2 × 64
             = 1,024,000,000 字节
             = 1.024GB
边界每行字节800 万行合计
scan → filter64B0.512GB(由总量拆分)
filter → project64B0.512GB(由总量拆分)
合计128B1.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)
代码生成融合6ns6ms(用例 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.024GB0
中间读写流量2.048GB0
搬运时间(20GB/s)0.1024s0
每行计算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

下载卷五 Java 8 实验 · 实验运行与版本说明

在 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 边界与短查询保留回退。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图