《大规模分布式计算深入解析》11.2 Velox 与 ClickHouse 执行栈

1 亿行按 2048 行一批是 48829 批,比按 1024 行切少一半批数、也就少一半每批固定开销;100 列宽表只读 3 列时列存只需 3% 的 IO,行存必须整行读。执行库与完整引擎的分界线,决定了这两笔账由谁来付。

11.2 Velox 与 ClickHouse 执行栈

同样做向量化执行,Velox 和 ClickHouse 处在两个不同的抽象层:前者是一个可以被别人嵌入的执行库,后者是一个自带存储、索引与服务端的完整引擎。这个差别决定了「谁负责规划、谁负责存储、谁负责调度」,也决定了批大小与列裁剪这两笔账由谁承担。

本节算两笔账:批切多大(1 亿行切成 48829 批,还是 97657 批),列存省多少 IO(100 列读 3 列是 3%)。两笔账都直接对应到可测的量。

执行库与完整引擎:一条责任分界线

能力VeloxClickHouse
SQL 解析与规划不提供,交给上层引擎自带
类型系统与向量化算子提供,可复用自带
存储格式与索引不提供,读上层给的数据自带列存与索引
调度与资源管理不提供自带
部署形态链接进宿主进程的库独立服务

Velox 的定位是把「算子怎么写才快」这件事产品化:上层引擎(不管是 Presto 系的还是自研的)不必再实现一遍 hash join、聚合、表达式求值,直接调用同一套向量化原语。它把执行与规划、存储解耦,代价是宿主必须自己解决元数据、切分与调度。

ClickHouse 的定位相反:把整条链路吃下来,从列存布局到索引到执行到服务端协议全部自持。好处是端到端可以针对自己的存储格式做深度优化,坏处是它的执行能力不能被别的引擎复用。

Velox 提供什么,不提供什么

层归属若缺失会怎样
表达式与函数Velox每个引擎各写一遍,语义漂移
向量化算子Velox重复实现 join、聚合、排序
内存池与生命周期Velox大批量下容易 OOM 或泄漏
表格式与统计宿主Velox 不知道数据长什么样
切分与并行调度宿主无法决定一个查询开多少任务
容错与重试宿主节点挂了查询就失败

这张表最重要的一列是「若缺失会怎样」。Velox 覆盖的三层是「写起来重复但不涉及部署」的部分;宿主负责的三层是「与具体环境绑定」的部分。判断一个团队该不该用执行库,就看它重复实现的痛苦是不是集中在前三层——如果痛点在调度与容错,引执行库并不解决问题。

批大小 2048:1 亿行切成 48829 批

行数    = 100,000,000
批大小  = 2,048
批数    = ceil(100,000,000 / 2,048)
        = ceil(48,828.125)
        = 48,829
参数计算结果
行数—100,000,000
批大小—2,048
批数ceil(1e8 / 2048)48,829(用例 94)
平均每批行数1e8 ÷ 48829约 2048(公式推导)

48829 而不是 48828,是向上取整的结果:最后一批只有 0.125×2048 = 256 行,仍然算一整批。这个零头在 4.8 万批里可以忽略,但它提醒一件事:批数由行数除以批大小决定,与列的宽度、类型都无关。

1024 与 2048:寄存器压力与调用摊销

1.2 节的口径是 1024 行一批。把同一份 1 亿行按 1024 切:

批大小批数每批固定开销总量单批列向量内存(int64)
1,02497,657(公式推导)基准的 2 倍8KiB(公式推导)
2,04848,829(用例 94)基准16KiB(公式推导)

批翻倍,批数减半,每批的固定开销(函数调用、循环建立、状态检查)总额也减半。这就是把批从 1024 抬到 2048 的直接收益:同样的数据,调度与调用次数少一半。

代价在另一头。一个 2048 行的 int64 列向量是 16KiB(公式推导:2048 × 8 字节),一个算子往往同时持有输入、输出与若干中间向量,几个加起来就逼近常见 L1 数据缓存的水位。批再大,向量就溢出到 L2,每次访存从几个周期变成十几个周期。

批大小调用摊销缓存局部性适用
256差,调用次数多好极宽表、单列过滤
1,024中好通用默认
2,048好中宽表扫描、聚合
8,192很好差,易溢出 L1简单算术、内存带宽受限

2048 不是普适最优,而是「调用摊销已经够好、缓存还没明显溢出」的折中。选择它需要一次实测:把批大小翻倍,如果耗时下降明显,说明还卡在调用开销上;如果持平或变慢,说明已经进入缓存受限区。

ClickHouse:列存 + 向量化 + 两级索引

ClickHouse 的执行栈可以按「读多少、跳多少、算多快」三层理解:

层机制解决的问题
存储布局列式,同列连续存放只读需要的列
索引稀疏主键索引 + 跳数索引跳过不需要的数据块
执行向量化,按块处理单核吞吐

稀疏主键索引的作用是「定位」,不是「精确查找」:它按固定行数间隔记录一条索引项,查询先按索引定位到可能命中的数据块,再在块内扫描。这决定了它擅长范围扫描与排序键前缀匹配,不擅长随机点查——点查要靠另一套机制(如主键索引加去重表)。

跳数索引解决的是「块内没有目标值」的判断:min-max、set、布隆一类索引让引擎在读块之前就能排除掉整块。它和 4.1 节的 zone map 是同一族思想,区别只在于作用粒度从文件降到了块。

用例 95:100 列只读 3 列 = 3% IO

总列数  = 100
读取列  = 3
IO 比例 = 3 / 100 = 0.03
存储布局实际读取IO 比例相对开销
行存全部 100 列(整行)100%1.0(基准)
列存3 列3%(用例 95)0.03(公式推导)

行存必须整行读,是因为一行的字段在磁盘上连续存放:要取第 7 列,就得把这一行的 100 个字段全读进来再丢掉 99 个。列存把同一列聚在一起,读 3 列就只碰 3 列的数据块。

把比例换成一个具体表:1TB 的表只读 3 列,列存读 0.03TB,约 30.7GiB(公式推导:1024 × 0.03);行存读满 1TB。两者相差约 33 倍(公式推导:1 ÷ 0.03)。

这个 33 倍会一路传导到下游:读得少,解压少、反序列化少、进 CPU 的数据少。所以列存的收益不止在 IO,还在它把后续每一环的输入都缩小了同样的比例。

列存优势消失的两种情形

情形原因结果
查询要读全部列没有列可裁列存退化为「按列拼行」,反而多一次重组
单行点查,每次只取一行列存要按列寻址再拼装行存或主键索引更合适

第一种情形在 SELECT * 的探查查询里非常常见:宽表全列扫描时,列存的优势归零,还要额外付出把列拼回行的成本。第二种情形是点查:列存为「一次读很多行的少数列」优化,点查恰恰是「一次读一行的所有列」,方向相反。

所以「列存一定比行存快」是错的,正确的说法是:列存为分析型访问模式优化,行存为事务型访问模式优化,中间地带要看具体的列命中比例。

两笔账的合成判据

观察到的现象该算的账结论
宽表查询慢,但只取少数列读列数 ÷ 总列数比例低却慢,说明没走列裁剪
批大小翻倍后耗时下降明显批数 × 每批固定开销还在调用开销区,可继续加大批
批大小翻倍后耗时不变或变慢列向量字节数 vs 缓存容量已进缓存受限区,应回调批大小
想复用算子但不想自建引擎责任分界表引执行库,但要自备规划与调度

判据的共同点是:先定位瓶颈在哪一层,再决定调哪个旋钮。批大小调的是「每批固定开销 vs 缓存」,列裁剪调的是「读多少列」,索引调的是「跳过多少块」;三者互不替代。

向量化原语:为什么按列比按行快

维度行式逐行列式按批
函数调用每行一次每批一次
类型判断每行都要判断批内类型一致,提到循环外
缓存利用一行横跨多列,跨度大一列连续,预取有效
SIMD 利用数据布局不支持天然按 lane 并行

批内类型一致是向量化的前提。行存里相邻两行可能来自不同的表、带着不同的类型标记,表达式求值必须先判断再运算;列存把同一列的同类型值排在一起,判断可以只做一次。2.1 节的表达式树解释在向量化版本里做的正是这件事:把逐行的判断与分派提到批的粒度上。

这也解释了为什么宽表的向量化收益更高:列越多,行存里「读一行跨过的列」越多,缓存行的有效载荷比例越低。

一条读路径:索引、裁剪、解压、执行

步骤作用省掉什么
分区裁剪按分区键排除目录整个分区的 IO
稀疏索引定位可能命中的块块之前的扫描
跳数索引排除块内无目标值解压与扫描
列裁剪只读需要的列无关列的 IO
向量化按批计算每行的调用开销

这五步是串联的,每一步都在缩小下一步的输入。如果第一步没做,后面四步都在为不必要的数据服务:读进来的分区里没有目标行,索引定位再准也没用。所以调优的顺序应该是从上游往下游,而不是一上来就调批大小。

三个常见误解

误解一:Velox 是一个可以直接用的查询引擎。 真相:它是执行库,提供算子、类型与向量化原语,SQL 解析、表格式、切分调度与容错都要宿主自己解决。

误解二:批越大,向量化越划算。 真相:批从 1024 抬到 2048 让批数从 97657 降到 48829、固定开销减半,但 2048 行的 int64 列向量已是 16KiB,再大会溢出缓存,收益反转。

误解三:列存一定比行存快。 真相:列存的收益等于「读列数 ÷ 总列数」,100 列读 3 列是 3%;读全部列时优势归零,单行点查时列存还要多付一次按列拼装的成本。

一句话总结本节

Velox 把向量化算子做成可复用的执行库,规划、存储与调度留给宿主;ClickHouse 则把列存、稀疏索引与向量化执行整条链路自持。1 亿行按 2048 行一批是 48829 批,比 1024 行一批的 97657 批少一半固定开销,代价是 16KiB 的列向量逼近缓存水位;100 列宽表读 3 列时列存只需 3% 的 IO,行存必须整行读——这两笔账分别由批大小与读列比例决定。

本节 lab

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

在 bd-engine-lab 中验证向量化批数与列裁剪的账本:

  • 源码:src/storage/Storage.java 与 src/storage/StorageSuite.java。
  • 运行:cd bd-engine-lab && mkdir -p out && javac -d out $(find src -name '*.java') && java -cp out lab.RunAll。
  • 断言:用例 94 验证 vectorBatches(100_000_000, 2048) = 48829,即 1 亿行按 2048 行一批向上取整为 48829 批;用例 95 验证 columnIO(100, 3) = 0.03,即 100 列宽表只读 3 列时 IO 比例为 3%。
  • 整卷 runner 的预期汇总为 TOTAL: 116 passed, 0 failed。

对应本节判断链:看到宽表查询慢 → 先看读了几列,100 列读 3 列应是 3% 的 IO → 再看批大小,1 亿行按 2048 切是 48829 批,比 1024 少一半调用 → 两者都正常仍慢,才去查索引是否跳过了数据块。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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