《大规模分布式计算深入解析》10.3 计算下推与本地性重建

存算分离拿走了本地性,只能靠缓存、调度亲和与下推重建。本节用 100 万行在存储层聚合到 100 行、传输量降 99.99% 说明杠杆,用 10GB 数据走网络 100MB/s 需 100 秒、本地缓存 2000MB/s 仅 5 秒的 20 倍差距,收束判断链。

10.3 计算下推与本地性重建

10.1 说对象存储没有目录,10.2 说缓存能补回一部分延迟,但两者都还没有回答一个更根本的问题:计算节点和数据的距离变远之后,怎么让查询仍然跑得快。HDFS 时代靠「把任务调度到数据所在节点」解决,存算分离之后这条路径断了,必须用别的方式把本地性重建出来。

重建有三条路:把数据搬到计算旁边(缓存)、把计算搬到数据旁边(下推与调度亲和)、以及让传输的量本身变小(下推)。本节算清三条路的账,并收束成一个可执行的判断链。

本地性是怎么丢的

本地性(data locality)的本质是「读数据不经过网络」或者「只经过很短的网络」。它带来两个好处:延迟低,且不占用跨机带宽。存算分离把存储做成独立服务后,这两个好处同时消失:

部署形态数据位置读路径本地性
本地盘计算节点磁盘本地 IO完整
HDFS 共存同机 DataNode本地短路读大部分保留
存算分离远端对象存储网络 GET消失
存算分离 + 缓存本地 SSD 或缓存集群本地或近端网络部分重建

本地性不是「有没有」的开关,而是「重建到什么程度」的问题。缓存能把热数据拉回本地,下推能让冷数据少传,调度亲和能让任务尽量落在缓存命中的机器上。三者叠加,才能接近原来的体验。

三条重建路径

路径做法减少的是生效前提主要限制
缓存热数据放本地或近端网络往返命中率高、数据可缓存容量有限、失效复杂
调度亲和任务调度到缓存所在节点跨机传输调度器知道缓存位置缓存位置易变、调度滞后
下推谓词、聚合在存储层执行传输的数据量存储层能执行该操作表达式与算子受限

三条路的优先级不是并列的:下推改变的是「要传多少」,缓存改变的是「传多快」,亲和改变的是「谁来传」。传输量降一个数量级,比传输速度提升一倍更有效,所以下推通常排在第一位。

下推的层次:从谓词到聚合

下推不是一个动作,而是一组分层的操作,越往下推收益越大、限制也越多:

下推内容下推位置减少的量实现难度
列裁剪文件读取层未选列的 IO低
谓词过滤文件读取层 / 存储引擎不满足条件的行低到中
聚合存储引擎分组前的明细行中
LIMIT存储引擎超出上限的行低
Join存储引擎或广播侧参与 join 的行高

越靠后的操作越难下推,因为它们依赖更多上下文:聚合要知道分组键与聚合函数,join 要知道另一侧的数据。工程上的常见做法是「能下推的尽量下推,不能下推的靠缓存与亲和兜底」,而不是追求全部下推。

存储层聚合:100 万行到 100 行

聚合下推是最能体现杠杆的场景。明细有 100 万行,按某个维度聚合后只有 100 行。如果先把 100 万行拉回引擎再聚合,网络上传的是 100 万行;如果在存储层聚合,网络上只有 100 行。lab 用例 91 算的是传输量的下降比例:

传输量下降 = 1 - 聚合后行数 ÷ 原始行数
           = 1 - 100 ÷ 1,000,000
           = 1 - 0.0001
           = 0.9999
           = 99.99%
量取值来源
原始行数1,000,000用例 91
聚合后行数100用例 91
传输量下降99.99%用例 91
剩余传输比例0.01%公式推导

99.99% 的下降不是「快了一点」,而是把问题换了一个量级:原来要传一百万行,现在只传一百行,网络不再是瓶颈,瓶颈回到存储层的聚合能力上。这也是为什么列式存储、数据湖表格式都在把聚合与谓词往下推——它们比引擎更清楚数据怎么组织。

但聚合下推有前提:聚合必须是「可分解的」。SUM、COUNT、MIN、MAX 可以先局部聚合再合并;COUNT(DISTINCT) 需要近似 sketch 或二次聚合;依赖全量排序的窗口函数基本无法下推。下推前先问一句:这个算子能不能被拆成「局部结果 + 合并规则」。

网络 100 秒 vs 本地 5 秒

即使不下推,数据放在哪里也决定了读取时间。lab 用例 92 用同一份 10GB 数据对比两条路径:

double net = Storage.readSeconds(10.0, 100.0);    // 10GB ÷ 100MB/s = 100s
double cached = Storage.readSeconds(10.0, 2000.0); // 10GB ÷ 2000MB/s = 5s
double ratio = net / cached;                       // 20 倍
路径数据量带宽耗时相对
网络读对象存储10GB100MB/s100 秒1 倍
本地缓存读10GB2000MB/s5 秒快 20 倍
差值是纯等待10GB—95 秒公式推导

20 倍的差距全部来自「数据在哪」,与查询逻辑、算子实现无关。这也说明为什么缓存值得投入:同样一条查询,命中缓存与回源是 5 秒和 100 秒的区别。但缓存只能覆盖装得下的那部分数据,装不下的仍要走网络,所以缓存与下推必须配合。

若一条查询要重复读 10 次同一份 10GB 数据,网络路径合计 1000 秒,缓存路径合计 50 秒(公式推导,按单流串行估算)。重复读越多,缓存的摊薄效果越明显;只读一次的场景,缓存几乎没有意义。

下推不能做什么

下推有明确的边界,越界会得到错误结果或更差的性能:

场景能否下推原因
简单比较过滤可以存储层能求值
用户自定义函数通常不可以存储层没有该函数实现
跨表 join部分可以需要另一侧数据或广播
全局排序不可以需要看到全部数据
窗口函数多数不可以依赖分区内的完整序列
COUNT(DISTINCT)需改写要 sketch 或二次聚合

下推的第一原则是正确性,第二才是性能。把不能下推的表达式硬塞给存储层,常见后果是语义偏差(比如空值处理、字符集、时区不一致);把能下推的留在引擎侧,则白白多传了数据。判断标准是「存储层的求值语义是否与引擎完全一致」,不一致就不下推。

下推的代价

下推不是免费的,它把计算移出了引擎的观测范围:

代价表现应对
存储侧资源聚合与过滤消耗存储层 CPU评估配额与并发上限
表达能力UDF、复杂表达式无法下推拆出可下推的简单部分
语义差异空值、时区、字符集口径不同下推前逐项对齐
可观测性外部服务出错难定位保留开关与抽样复核

原本能在执行计划里看到的过滤行数、聚合耗时,下推后变成了存储侧的黑盒指标。所以生产上通常保留下推开关:出问题时能一键回退到引擎侧执行,用性能换可诊断性。这个开关也是灰度下推的安全网。

缓存装不下时

10.2 的结论是命中率上限由容量决定。当下推之后剩余的数据仍装不下缓存,可选的余地只有三个:

选择做法代价
只缓存热分区按访问频次筛子集冷分区仍走网络
提高缓存周转缩短 TTL、更激进的淘汰命中率下降
接受回源用带宽与并发压时间成本随扫描量上升

这三条都不改变「要读多少」,只改变「怎么读」。真正的降本仍然要回到下推与裁剪:把 100 万行变成 100 行,缓存装得下、网络也传得快,三条路才形成闭环。

三段组合的一个算例

把本节两个用例放进同一条查询:

原始:100 万行全部回源,网络要传 100 万行
下推聚合:存储层输出 100 行,传输量降 99.99%
结果若为 10GB:命中缓存读 5 秒,未命中走网络 100 秒
阶段手段作用
读之前分区裁剪、列裁剪少读文件、少读列
读的时候谓词与聚合下推少传行
传的时候缓存与亲和少走网络、走近端

三段各管一段,不能互相替代。只做下推不做缓存,剩下的 10GB 仍要 100 秒;只做缓存不做下推,缓存里装的是 100 万行的明细,很快被挤爆。这也是判断链要把下推排在第一位的算术原因。

在哪下推:三个执行位置

同一个谓词,可以下推到三个不同的位置,收益与可控性各不相同:

位置例子减少的量可控性
文件格式层Parquet 的 row group 统计、bloom filter整个 row group 或文件高,标准成熟
存储引擎层表格式的 partition pruning、聚簇整个分区或文件中,依赖表设计
远端计算服务对象存储旁的 SQL 下推服务明细行低,依赖服务能力

文件格式层是最稳的一层:Parquet 的 min/max、bloom filter 是标准的一部分,任何引擎都能用,不依赖特定服务。存储引擎层依赖表怎么分区、怎么聚簇,设计得好收益巨大,设计得差就形同虚设。远端计算服务能力最强,但把正确性托付给了外部系统,必须做结果校验。

调度亲和:把任务搬到缓存旁

下推解决不了的部分,还可以靠「把任务放到数据附近」:

调度依据需要的信息收益风险
缓存位置每个节点的缓存清单命中即本地读清单滞后会调度错
历史访问上次任务读过的节点复用局部性访问模式变化后失效
一致性哈希key 到节点的映射稳定、可预测扩缩容时要迁移
随机调度无负载均衡本地性为零

调度亲和与弹性是矛盾的:把任务钉在缓存所在节点,扩缩容时就得迁移缓存或放弃亲和。多数系统的折中是「软亲和」:优先调度到缓存命中的节点,没有就退化为普通调度,而不是为了本地性排队等待。

判断链:先下推、再缓存、后亲和

把三条路收束成一个可执行的顺序:

步骤问题动作判断依据
1传输量能不能变小下推谓词、列裁剪、聚合算子在存储层语义一致
2剩下的数据能不能装下加缓存、预热热分区命中率能否过 80%
3装不下的怎么读得快调度亲和、近端缓存缓存位置是否稳定
4都不行加带宽、合并小文件单位成本是否可接受

这个顺序不能倒:先加缓存再下推,缓存里装的是全量数据,容量很快见底;先做亲和再下推,任务被钉在少数节点上,扩缩容失去弹性。下推把数据量降下来,缓存才装得下,亲和才有意义。

三条路都做完,还可以回到 10.1 的账本:合并小文件、加元数据层、把 List 次数降下来。本地性重建是一个组合问题,不是单点优化。

三个常见误解

误解一:存算分离之后,本地性就没救了。 真相:本地性可以靠缓存、调度亲和与下推部分重建,10GB 数据本地缓存读 5 秒、网络读 100 秒,差别在路径而不在查询本身。

误解二:下推就是把 SQL 发给存储层执行,推得越多越好。 真相:下推受语义一致性约束,UDF、全局排序、多数窗口函数不能下推,硬推会得到错误结果或更差的性能。

误解三:聚合下推只省了网络带宽。 真相:100 万行聚合到 100 行让传输量降 99.99%,瓶颈从网络转移到存储层的聚合能力,收益是量级变化而不只是带宽节省。

一句话总结本节

存算分离丢掉了本地性,重建靠三条路:下推把传输量变小,100 万行聚合到 100 行降 99.99%;缓存把数据搬近,10GB 本地 2000MB/s 读 5 秒、网络 100MB/s 读 100 秒,差 20 倍;调度亲和把任务放到缓存旁。顺序必须是先下推、再缓存、后亲和,因为只有数据量降下来,缓存才装得下,亲和才有意义。

本节 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。
  • 断言:用例 91 验证「100 万行在存储层聚合到 100 行,传输量下降 99.99%」;用例 92 验证「10GB 走网络 100MB/s 需 100 秒,本地缓存 2000MB/s 需 5 秒,快 20 倍」。
  • 整卷 runner 的预期汇总为 TOTAL: 116 passed, 0 failed。

对应本节判断链:存算分离后读得远又读得多 → 三条重建路径分别作用于传输量、传输速度与执行位置 → 聚合下推 100 万行到 100 行降 99.99%,本地缓存比网络快 20 倍 → 先下推、再缓存、后亲和,都不行才加带宽。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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