《大规模分布式计算深入解析》11.1 DuckDB:单机 Morsel 与向量化

100 个 morsel、4 线程、每块 25ms,DuckDB 的并行时间是 625ms,相对串行 2500ms 正好 4 倍线性扩展。进程内执行删掉了网络与协调,morsel 队列让并行度由线程数而非数据分区决定,这是单机引擎在 1TB 以内能打的账本。

11.1 DuckDB:单机 Morsel 与向量化

前十章把执行引擎拆成了算子、优化器、格式与存算分离几层,但那些机制大多长在分布式引擎里:计划要分发、数据要 shuffle、任务要协调。DuckDB 走的是另一条路——把同样的向量化与 morsel 并行塞进一个进程内库,不启动服务、不组集群、不做网络交换。它在单机上的强势不是「算子写得更巧」,而是「少付了几笔与数据量无关的固定成本」。

本节沿一条判断链走:现象是同一条分析查询单机库比集群快一个量级;机制是执行路径上没有网络与协调;账本是 100 个 morsel、4 线程、625ms;判据是数据能不能装进一台机器。

进程内:执行路径上没有网络

环节分布式引擎进程内引擎
客户端接入网络协议 + 解析一次函数调用
计划分发序列化后发给 executor同进程内指针传递
中间数据交换shuffle 落盘 + 网络传输共享内存或直接引用
资源协调申请、心跳、任务状态机线程池,没有外部协调者
容错任务重试、血缘重算进程崩溃即全部失败

这张表每一行都是一笔固定开销,与数据量无关。查询越小,固定开销占比越高。GB 级查询在集群上跑,大部分时间花在「把活派下去」而不是「干活」;同一个查询在进程内跑,这几行直接消失。

反过来看,这张表也解释了为什么单机引擎的上限那么硬:它把容错那一行换成了「没有」。省下来的成本是真的,失掉的能力也是真的。

Morsel 队列:并行度与数据划分解耦

1.3 节讲过 morsel 驱动的调度模型。DuckDB 的用法有一个关键差别:它不需要为了让 4 个线程都有活干,而把数据物理切成 4 份文件。

做法并行度来源需要预切分数据倾斜处理
按文件或分区并行分区数是,分区数就是上限分区不均就空转
按 morsel 队列线程数否,运行时切块线程做完就取下块,自动摊平

解耦的意义是:并行度由线程数决定,不由存储布局决定。同一个 parquet 文件可以被 4 个线程消费,也可以被 16 个线程消费,切块在运行时完成。于是「加线程」变成一个不需要重写数据的操作,而这在按文件并行的引擎里是做不到的——文件数就是天花板。

用例 93 的账:100 × 25 ÷ 4 = 625ms

morsel 数   = 100
线程数      = 4
每块耗时    = 25ms
每线程块数  = ceil(100 / 4) = 25
总时间      = 25 × 25ms = 625ms
参数计算结果
串行总时间100 × 25ms2500ms(公式推导)
4 线程总时间ceil(100/4) × 25ms625ms(用例 93)
加速比2500 ÷ 6254.0 倍(公式推导)

625ms 是理想线性扩展:100 能被 4 整除,没有尾块;每块耗时相同,没有倾斜。这两个条件在真实查询里都不会严格成立,所以 4 倍是上限而不是预期值。它的价值在于给出一个可对照的基准——如果实测明显偏离 625ms,偏离的量就是倾斜与尾块的代价。

线程继续加:325ms 与尾部效应

把线程从 4 加到 8,还是那 100 个 morsel:

线程数每线程块数总时间加速比
425625ms(用例 93)4.0 倍(公式推导)
8ceil(100/8) = 13325ms(公式推导)7.69 倍(公式推导)
16ceil(100/16) = 7175ms(公式推导)14.3 倍(公式推导)

8 线程那一行值得细看:100 = 12×8 + 4,四个线程拿 13 块、四个拿 12 块,总时间由拿 13 块的那条决定,所以是 325ms 而不是 312.5ms。加速比 7.69 而不是 8,差的那一点就是尾块。这与 1.3 节「块数要远多于 worker 数」是同一个约束,只是 worker 从机器换成了线程。

再往上加线程会撞上第二堵墙:内存带宽。多核共享同一条内存通路,向量化算子的吞吐最终受限于取数速度而不是核数。本节不给具体的拐点核数,只给判据:当加线程不再带来接近线性的收益时,瓶颈已经从并行度转移到内存带宽或 IO,此时继续加线程只会让上下文切换变多。

向量化与 morsel 是两件事

1.2 节讲过向量化:一次处理一批而不是一行,把每行的调用开销摊薄。morsel 解决「谁来并行」,向量化解决「单核多快」,两者常被混为一谈,但账要分开算:

机制作用维度收益来源失效条件
向量化单核吞吐每行摊销的调用与分支开销下降批太小、选择率极低
morsel多核并行线程数 × 单核吞吐块太少、倾斜严重
列存IO 总量只读需要的列查询确实要读全部列

三者是相乘关系,不是相加。没有列存,向量化读进来的数据里大半用不上;没有向量化,并行只是把单核的低效复制到更多核;没有 morsel,列存和向量化都只能用一个核跑。少一项,另外两项的收益都要打折。

不适用边界:三条硬约束

约束表现后果
数据超过单机内存/磁盘中间结果放不下溢写,严重时直接失败
需要多机容错单进程崩溃等于全丢没有副本、没有任务重试
高并发写入单写者模型写写冲突,吞吐上不去

这三条不是「性能差一点」,而是「做不了」。DuckDB 能处理比内存大的数据,靠的是溢写,但那是降级运行,不是设计目标;它没有任何机制在机器挂掉后把查询接着跑完。所以选型的第一个问题不是「快不快」,而是「失败一次的代价能不能接受」。

1TB 以内的性价比

把固定成本摊到不同数据量上,结论会变得很直观:

数据量固定开销占比单机可行性建议
GB 级极高完全可行单机,不必起集群
百 GB 级高可行单机优先
1TB 级中取决于磁盘与内存单机可试,先评估容错要求
10TB 以上低通常不可行分布式

这张表的核心不是「1TB」这个数字,而是「固定开销 ÷ 数据量」这个比值。同一个集群跑 10GB 查询时固定开销占大头,跑 10TB 时几乎可以忽略;所以「单机更快」永远是有条件的,条件就是数据量还没大到让固定开销显得便宜。1TB 附近是这条曲线的拐点区间:单机放得下,但余量已经不宽裕,需要按最坏情况估算中间结果。

一条查询在一个 morsel 里走完

morsel 最容易误解的一点是:它不是「一段数据」,而是「一段数据加一条流水线」。线程拿到 morsel 后,从扫描到过滤到聚合全部做完,中间结果不跨线程。

阶段每个 morsel 内做什么中间结果放在哪
扫描读该块对应的行组列向量,线程私有
过滤按谓词筛行选择向量(行下标列表)
聚合更新本线程的哈希表线程私有哈希表
合并查询结束时汇总各线程结果只合并一次

只有最后一步需要跨线程。前三个阶段都在线程私有的内存里完成,没有锁、没有队列、没有同步点。这是 morsel 驱动与「算子间并行」最大的区别:后者在每两个算子之间插一个 Exchange,每个 Exchange 都是一次同步。

代价是内存放大:4 个线程就有 4 份私有聚合表。并行度越高,内存里同时存在的中间状态越多,这也是单机引擎在内存紧张时首先要降并行度的原因——不是线程不够快,是状态放不下。

与分布式引擎的对照:同一查询的两条路径

步骤单机引擎分布式引擎
读数据本地文件远端对象存储或 HDFS
过滤线程内完成各 executor 本地完成
join线程私有哈希表shuffle 后按分区建表
聚合线程私有 + 一次合并分区聚合 + 最终合并
结果直接返回汇总到协调节点

两条路径的算子是一样的,差的是「数据怎么到算子面前」。分布式引擎多出的每一步都是为了把数据搬到正确的位置:按 key 重分布、落盘、跨网络传输。单机引擎不需要搬,因为所有数据本来就在同一台机器的地址空间里可达。

这张表也解释了 11.2 节那笔 shuffle 入场费的来源:它不是算法成本,是搬运成本。

溢写:单机引擎的第二条路

数据超过内存时,单机引擎不会立刻失败,而是把中间结果写到本地磁盘再读回:

数据量 vs 可用内存行为主要代价
远小于全内存处理无
略大于分区后分批处理一次写加一次读
远大于多轮溢写写读放大,可能多轮

溢写把「随机访问内存」换成「顺序写盘加随机读盘」:前者是纳秒级,后者是毫秒级,差了几个数量级。所以「能溢写」不等于「溢写无所谓」,它保证查询能跑完,不保证跑得快。6.2 节的 sort-merge spill 是同一族机制,区别只在触发点是排序还是哈希表装不下。

三个常见误解

误解一:DuckDB 快是因为它的算子实现比 Spark 好。 真相:两者同属向量化一派,差距主要在固定成本——进程内执行没有网络、序列化与资源协调,这几项在小查询上占大头。

误解二:单机引擎的并行度受限于数据分区数。 真相:morsel 队列在运行时切块,4 线程与 16 线程消费同一份文件,并行度由线程数决定,不需要预切分数据。

误解三:线程加得越多越快,625ms 可以一路除下去。 真相:100 个 morsel 分给 8 线程是 ceil(100/8)=13 块、325ms,加速比 7.69 而非 8;再往上会撞上内存带宽,收益递减。

一句话总结本节

DuckDB 把向量化与 morsel 并行放进一个进程内库:100 个 morsel、4 线程、每块 25ms 时总时间 625ms,相对串行 2500ms 是理想 4 倍线性扩展;并行度由线程数而非数据分区决定,执行路径上没有网络与协调,这是它在 1TB 以内性价比高的原因;代价是超内存、需多机容错、高并发写入三类场景直接失效。

DuckDB 的流水线生命周期

来源算子产生 data chunk,阻塞 sink 完成后才能驱动依赖的下一条 pipeline。取消时停止分发后续工作。

flowchart LR
    P[Pipeline 调度与依赖] --> W[Worker 执行任务]
    W --> S[Source 产出 DataChunk]
    S --> O[向量算子]
    O --> K[阻塞 Sink 接受并归并]
    K --> F[Finalize]
    F --> N[依赖 Pipeline 可执行]
    P -. 取消 .-> W

上游实现参照

DuckDB 1.4.4 执行路径

本节 lab

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

在 bd-engine-lab 中验证单机 morsel 并行的账本:

  • 源码: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。
  • 断言:用例 93 验证 morselTimeMs(100, 4, 25) = 625,即 100 个 morsel、4 线程、每块 25ms 时总时间为 625ms;实现按「块数除以线程数向上取整再乘每块耗时」计算,与公式推导 100×25/4 = 625ms 一致。
  • 整卷 runner 的预期汇总为 TOTAL: 116 passed, 0 failed。

对应本节判断链:看到同一条查询单机比集群快一个量级 → 拆开执行路径,发现网络、序列化与协调是固定开销 → 按 100 个 morsel、4 线程算出 625ms、加速 4 倍 → 数据装得进单机就用单机引擎,装不下或需要多机容错才上分布式。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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