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 倍
| 路径 | 数据量 | 带宽 | 耗时 | 相对 |
|---|---|---|---|---|
| 网络读对象存储 | 10GB | 100MB/s | 100 秒 | 1 倍 |
| 本地缓存读 | 10GB | 2000MB/s | 5 秒 | 快 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
在 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 倍 → 先下推、再缓存、后亲和,都不行才加带宽。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。