《大规模分布式计算深入解析》2.3 JIT 与向量化原语(DuckDB/Velox)

JIT 与向量化两条路线:20ms 编译摊到 800 万行是 2.5ns/行,1 万行短查询 JIT 20.01ms,解释 0.36ms;SIMD 4 路理论 4 倍、实际 2.7 倍;三模型总账 408/11.52/48ms;批 1024×8×4B=32KB,lab 八用例。

2.3 JIT 与向量化原语(DuckDB/Velox)

前两节各给了一条加速路线:2.2 用代码生成把解释的 36ms 压到 6ms,1.2 用批处理把 360ms 的调用压到 3.516ms。现实中的引擎通常两条都走,只是侧重点不同:Spark Tungsten 偏运行时代码生成,DuckDB 与 Velox 偏向量化原语加列式存储。它们不是互斥选项,而是同一笔预算的两种花法。

这一节把五件事放进同一张账:JIT 的 20ms 编译成本怎么摊销、短查询为什么会被它反噬、SIMD 的 4 路理论为什么只兑现 2.7 倍、三种执行模型的总账各是多少、批大小为什么要卡在 32KB 的 L2 临界,最后给出按行数选模型的判据。

JIT 的固定成本:20ms

JIT 在查询执行前把表达式或整条流水线编译成机器码。编译本身要花时间,lab 用例 15 取 20ms 作为一次编译的固定成本。这笔钱本身不产生任何一行结果,必须先摊到后续处理的行上:

摊销成本 = 编译时间 / 行数
         = 20ms / 8,000,000
         = 20,000,000ns / 8,000,000
         = 2.5ns/行
行数摊销成本(20ms / 行数)说明
8,000,0002.5ns/行用例 15
1,000,00020ns/行公式推导
10,0002µs/行公式推导

摊销成本与行数成反比:800 万行时 2.5ns/行,只占 6ns/行执行成本的一部分;1 万行时变成 2µs/行,比整行执行贵三个数量级。JIT 适不适合,先看这笔固定成本能不能被行数摊薄。

短查询反噬:20.01ms 对 0.36ms

用例 16 把短查询的账算到底。JIT 路径是 20ms 编译加 1ns/行的执行;解释路径是 2.1 的 9 节点、每节点 4ns。两边都处理 1 万行:

JIT 总耗时  = 20ms + 10,000 × 1ns
            = 20ms + 0.01ms
            = 20.01ms

解释总耗时 = 10,000 × 9 × 4ns
            = 360,000ns
            = 0.36ms
路径编译执行总耗时
JIT20ms0.01ms20.01ms
解释00.36ms0.36ms

JIT 反而慢约 55.6 倍(20.01 / 0.36)。这不是 JIT 的代码质量差,而是固定成本在 1 万行上根本摊不开。用同一组参数可以推出盈亏平衡点:

JIT 总成本 < 解释总成本
20ms + 行数 × 1ns < 行数 × 36ns
20ms < 行数 × 35ns
行数 > 571,429

盈亏平衡点在 57 万行左右(公式推导)。低于它,解释更划算;高于它,JIT 的编译成本开始被摊薄。这个推导只用用例 15、16 的参数,不含缓存与分支差异,但量级足够指导选型。

SIMD:4 路理论,2.7 路实际

向量化的第二层收益来自 SIMD:一条指令同时处理多个值。lab 用例 17 给出 4 路宽度的理论上限——4 倍加速。但真实执行受内存带宽约束,用例 18 用 0.675 的带宽因子折算:

实际加速 = 理论加速 × 带宽因子
         = 4 × 0.675
         = 2.7 倍
约束取值对加速的影响
SIMD 宽度4 路理论上限 4 倍
带宽因子0.675实际只能兑现 2.7 倍
差额1.3 倍被访存等待吃掉

理论加速是上限,不是承诺。当算子已经接近内存带宽上限时,再加 SIMD 宽度只会让计算单元等数据;4 路变 8 路,理论翻倍,实际可能只多几个百分点。DuckDB 与 Velox 之所以同时强调列式布局与压缩,就是因为带宽才是那条更硬的约束。

三模型总账:408ms、11.52ms、48ms

用例 19 把三种模型放进同一个 800 万行、3 算子、每行计算 1ns 的场景:

模型调用/调度分支计算总耗时
火山360ms40ms8ms408ms
向量化3.516ms08ms11.52ms
Push40ms08ms48ms

计算成本统一按每行 1ns、800 万行共 8ms,这是三模型可比的前提。把各项占比拆开(占比为各项除以总耗时,公式推导),能看清每种模型的瓶颈在哪:

模型调度/分支占比计算占比结论
火山400 / 408 ≈ 98%2%几乎全花在控制流
向量化3.516 / 11.52 ≈ 30.5%69.5%计算成为主成本
Push40 / 48 ≈ 83.3%16.7%调度仍是大头

这张表解释了为什么向量化在总账里领先:它把调度压到 30.5%,让 8ms 的计算成为主体;火山有 98% 的时间在付调用与分支,计算只占 2%。Push 居中,40ms 的 morsel 调度仍然明显。

这里要把口径说清楚:用例 19 的 Push 是单线程调度账本——800 个 morsel、每个 50µs 调度,合计 40ms,再加 8ms 计算。1.3 的 2000ms 是另一套口径:8 个 worker、每块 20ms 的处理时间。两者不能混用;前者用于三模型同口径对比,后者用于并行时间估算。

吞吐对比:19.61M 与 694.7M 行/秒

把总耗时换算成吞吐,差距更直观。用例 20 用的是「行数除以秒数」:

火山吞吐   = 8,000,000 / 0.408s      ≈ 19.61M 行/秒
向量化吞吐 = 8,000,000 / 0.01151585s ≈ 694.7M 行/秒
模型总耗时吞吐
火山408ms19.61M 行/秒
向量化11.52ms(精确 11.51585ms)694.7M 行/秒

端到端差距约 35.4 倍(公式推导),不是调度账本里的 102 倍。原因在分母:向量化的 11.52ms 里有 8ms 是计算,占 69.5%,这部分无法再靠减少调用消除;火山的 408ms 里计算只有 8ms,调度优化空间看起来很大,但一旦把计算加回来,收益就被计算下限压缩。这就是优化越往后越难的根本原因。

批大小与 L2:32KB 的临界

1.2 把批大小设为 1024,但没有解释这个数从哪来。用例 21 给出工作集账本:批大小乘以列数、再乘以每值字节数:

单批字节 = 批大小 × 列数 × 每值字节
         = 1024 × 8 × 4B
         = 32,768B
         = 32KB
批大小单批工作集(8 列 × 4B)状态
102432KB压在 L2 临界
4096128KB超出 L2,收益递减

32KB 是这批参数下的临界点,不是所有场景的常数。列宽从 4B 变成 8B,1024 行就是 64KB(公式推导),已经越过临界;列数从 8 增到 16,同样翻倍。所以“批大小 1024”必须和“列数、列宽”一起看,宽表要把批调小,窄表可以适当调大。

批太小,调用摊薄不充分;批太大,工作集溢出 L2,算子反复访问内存。最优批大小是这两条曲线的交点,而不是某个固定值。

模型选择判据

用例 22 把前面的账收敛成按行数的三段判据:

行数推荐模型理由
< 100,000火山启动成本低,JIT 的 20ms 摊不开
100,000 – 1,000,000Push + morsel并行收益显现,调度占比可控
≥ 1,000,000向量化调用次数降 102 倍,计算成为主体

这三段不是硬边界,而是三条账本的交点。10 万行以下,20ms 编译与批启动都显得贵;10 万到 100 万行,morsel 并行开始有用,JIT 在 57 万行左右才追平解释;100 万行以上,向量化的 102 倍调用压缩才充分发挥。

判据还要叠加四个修正项:选择率极低时扫描侧仍要扫描全部行,向量化收益打折;列很宽时批工作集溢出 L2,要减小批;数据强倾斜时 morsel 要更细;硬件带宽不足时 SIMD 的理论倍数兑现不了。

把五笔账串成一条判断链

环节问题看的数结论
现象同一查询换模型差几十倍408ms 对 11.52ms执行模型是主变量
机制成本花在调用、编译还是计算火山控制流 98%、向量化计算 69.5%火山输在控制流
账本固定成本能否摊薄2.5ns/行、55.6 倍短查询别用 JIT
硬件SIMD 能兑现多少4 路对 2.7 倍带宽是硬约束
判据该选哪个模型10 万、100 万、32KB按行数与工作集分流

这张表就是本节的判断链:先看现象确认模型选择重要,再拆机制找出成本项,用账本验证固定成本是否摊得开,用硬件约束修正理论收益,最后落到行数与批大小的判据上。任何一步跳过,都会得到“向量化一定快”或“JIT 一定快”的片面结论。

三个常见误解

误解一:JIT 编译后的代码更快,所以任何查询都该用 JIT。 真相:1 万行短查询 JIT 总耗时 20.01ms,解释只需 0.36ms,JIT 反而慢约 55.6 倍;盈亏平衡点在 57 万行左右。

误解二:SIMD 有 4 路宽度就能拿到 4 倍加速。 真相:受内存带宽约束,4 路理论在 0.675 的带宽因子下只兑现 2.7 倍,算子是访存受限时加宽 SIMD 几乎没有收益。

误解三:向量化把调度从 360ms 降到 3.516ms,端到端就该快 102 倍。 真相:加回 8ms 计算后总账是 11.52ms,端到端约 35.4 倍;计算下限会压缩所有调度优化的最终收益。

一句话总结本节

JIT 的 20ms 编译摊到 800 万行是 2.5ns/行,但 1 万行短查询要 20.01ms、比解释的 0.36ms 慢约 55.6 倍,盈亏平衡点在 57 万行;SIMD 4 路理论受 0.675 带宽因子约束只兑现 2.7 倍;三模型总账为火山 408ms、向量化 11.52ms、Push 48ms,吞吐 19.61M 对 694.7M 行/秒;批 1024×8 列×4B 是 32KB 的 L2 临界,按行数分为 10 万以下火山、10 万至 100 万 Push、100 万以上向量化。

本节 lab

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

在 bd-engine-lab 中验证 JIT 摊销、SIMD 约束、三模型总账与选型判据:

  • 源码: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。
  • 断言:用例 15 验证「20ms 编译摊销到 800 万行为 2.5ns/行」;用例 16 验证「1 万行短查询 JIT 总耗时 20.01ms,解释只需 0.36ms」;用例 17 验证「4 路 SIMD 理论加速 4 倍」;用例 18 验证「带宽因子 0.675 下实际加速 2.7 倍」;用例 19 验证「三模型总账火山 408ms、向量化 11.52ms、Push 48ms」;用例 20 验证「火山吞吐 19.61M 行/秒、向量化 694.7M 行/秒」;用例 21 验证「批 1024 × 8 列 × 4B = 32KB」;用例 22 验证「10 万以下选火山、100 万以下选 Push、以上选向量化」。
  • 整卷 runner 的预期汇总为 TOTAL: 116 passed, 0 failed。

对应本节判断链:同一查询三种模型相差约 35 倍 → 拆出调用、编译与计算三类成本 → 用 2.5ns/行、55.6 倍、2.7 倍、408/11.52/48ms 四组账本验证 → 用 32KB 的 L2 临界修正批大小 → 按 10 万、100 万行两个交点选择模型,并用选择率、列宽、倾斜与带宽做二次修正。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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