FlashDecoding:decode 阶段 split-KV 并行原理、归并与 FlashDecoding++ 改进全解
更新时间:2026-10-01。在 FlashAttention 显存分块 里我们学过 prefill 阶段注意力怎么靠 tiling 和 online softmax 避免 O(N²) 显存,在 KV cache 推理显存 里算过 decode 每步都要把整条 KV cache 从 HBM 搬一遍的账。这一篇回答一个更刁钻的问题:decode 阶段每步只有 batch 个 query 向量,batch 小的时候 GPU 几百个 SM 大部分在围观——FlashDecoding 怎么用 split-KV(也叫 split-K)把长 KV 沿序列维切开并行,再把各段的部分注意力结果归并成正确答案。
本文要回答的问题
- decode 阶段的注意力和 prefill 有什么本质区别,为什么 batch 小的时候 SM 占用率会塌掉?
- FlashDecoding 的 split-KV 怎么切、每段算出的「部分 softmax」长什么样?
- 多段部分结果归并(reduce)为什么只需要 log-sum-exp 修正,代价是多少?
- split 数该怎么选,切多了会付出什么代价?
- FlashDecoding++ 相对原版改了哪两件事,收益从哪来?
一、decode 为什么饿卡:并行维度的塌缩
先回顾两个阶段的不对称。prefill 处理 prompt 时,一次有 N 个 token 的 query,注意力是 Q(N×d) × K^T(d×N) 的矩阵乘,N 动辄几千,FlashAttention 可以沿 query 维切出大量 tile,每个 SM 都有活干。decode 每步每个请求只产生 1 个 query 向量,注意力退化成 q(1×d) × K^T(d×L) 的矩阵-向量乘(GEMV),L 是已缓存的 KV 长度。
并行度塌缩就发生在这里。一个 batch=1、32 头、d_head=128 的 decode step,整个注意力 kernel 能用的并行单元是「32 个头 × 128 维内积的归约树」——FlashAttention 风格的 kernel 一般按 head 划分 thread block,32 个 block 对一张有 80-132 个 SM 的卡(A100 108 个、H100 132 个)意味着超过三分之二的 SM 完全空闲。而 decode 本身又是访存 bound:每步要读整个 KV cache(账见 KV cache 推理显存),计算量却极小。算力闲、带宽也未必吃满——GEMV 的访存模式依赖足够多的并发 warp 来隐藏 HBM 延迟,block 太少连带宽都压不满。
把数字落实:A100 的 HBM 带宽 2 TB/s 上下,要想靠并发访存把带宽压到接近峰值,经验上需要几百个活跃 warp。decode GEMV 只有 32 个 block(每 block 4-8 个 warp),活跃 warp 一两百,实测带宽利用率常常只有 40%-60%。也就是说 decode 单步时延不仅被「必须读完整 KV」决定,还被「读得不够快」进一步放大。batch 越小、KV 越长,这个病越重——而长上下文趋势(32K、128K)恰好把 KV 越拉越长。
有人反问:把 batch 开大一点不就行了?问题在于在线 serving 的 batch 由流量决定,低峰期 batch 天然小;离线批处理可以攒 batch,但显存里 KV cache 已经占了大头(GQA 的省法见 GQA/MQA 与 KV 节省),batch 上限被显存卡死。靠堆 batch 解决 occupancy 是把问题推给别人,FlashDecoding 的思路是在 batch 维之外再造一个并行维度。
再补一个容易被低估的细节:decode 的时延是「每步都付一次」的。生成一条 512 token 的回复就要跑 512 个 decode step,单步如果因为 occupancy 不足慢 0.3 毫秒,端到端首字之后的生成时间就白白多出 150 毫秒以上——用户对「打字机速度」的感知恰恰由这一段决定。而 prefill 只付一次,慢 10% 也不过几十毫秒。这就是为什么 decode kernel 的优化优先级在线上系统里常年排在最前,也是 FlashDecoding 这类「看起来只省零点几毫秒」的技术值得专门成文的原因。
二、split-KV:沿 KV 序列维再造一个并行轴
FlashDecoding 的核心观察:decode 注意力对 KV 序列维是可结合的——把 KV 沿长度 L 切成 S 段,每段独立算「这一段内的注意力」,最后把 S 个部分结果归并,数学上与整段算完全等价。这个性质来自 online softmax 的 rescaling 技巧,正是 FlashAttention 显存分块 里 tiling 内部用的那套,只是 FlashDecoding 把它从「单个 block 内部的循环」提升到了「block 之间的并行切分」。
切法很直白:KV cache 长度 L,切成 S 段,每段长度 L/S(最后一段吃余数)。kernel 的 grid 从「batch × heads」扩成「batch × heads × S」,每个 block 处理一个 (请求, 头, KV 段) 三元组。block 数一下从 32 变成 32×S——S=8 就是 256 个 block,A100 的 SM 终于都有活干了。
每个 block 输出三样东西:
- 部分加权和
O_s:本段内softmax(q·K_s^T) · V_s的结果,但 softmax 的分母只对本段求和,所以是「未归一化」的; - 本段最大值
m_s:数值稳定用的 running max; - 本段指数和
l_s:softmax 真正的分母候选,Σ exp(x_i - m_s)。
上图读法:同一份 q 广播到 S 个 block,每个 block 只管自己的 KV 段,互不通信地算出三元组 (O_s, m_s, l_s),交给第二个归并 kernel 汇总。这是一个典型的 split-K 两阶段结构——第一段 kernel 把并行度拉满,第二段 kernel 做跨段归约。注意两段之间有一次 kernel 边界(或者 atomic/信号量做段内同步),这是 split-K 结构逃不掉的固定开销。
为什么这件事在 prefill 里不这么干?prefill 的 query 维本来就够宽,tile 多到用不完,再切 KV 维只会白白增加归并开销。split-KV 是专门为「query 维塌缩到 1」的 decode 场景准备的补丁——这也解释了 FlashDecoding 的定位:它不是 FlashAttention 的替代,而是 decode 特化的补充,vLLM、FlashInfer、TensorRT-LLM 里的 decode kernel 都是这套结构。
三、归并的数学:log-sum-exp 修正为什么便宜
归并 kernel 要解决的问题:S 个部分结果各自带着不同的最大值基准 m_s,直接相加是错的。修正公式一句话能写完。全局最大值 m* = max(m_s),每个部分结果按 exp(m_s - m*) 重新缩放:
- 全局分母:
l* = Σ_s l_s · exp(m_s - m*) - 全局输出:
O = Σ_s O_s · exp(m_s - m*) / l*
这其实就是 online softmax 合并两个块的公式推广到 S 个块,正确性由 softmax 对「指数平移不变性」保证。工程上关心的是代价:归并 kernel 要读写 S × d_head 个浮点数(每段一个 O_s)外加 S 个 (m, l),以 b=1、h=32、d_head=128、S=8、FP32 中间结果算,单步归并流量约 32 × 8 × (128+2) × 4B ≈ 133 KB——对比 KV cache 本身动辄几百 MB 的读取量,归并的流量开销在千分之一量级,几乎免费。
用一个具体数字走一遍归并过程,帮助建立直觉。设 S=4,四段的 m_s 分别是 3.1、2.7、3.4、2.9,对应的 l_s 是 12.0、9.5、11.2、10.1。全局 m* = 3.4,四段缩放因子依次是 exp(-0.3)≈0.74、exp(-0.7)≈0.50、exp(0)=1、exp(-0.5)≈0.61。全局分母 l* ≈ 12×0.74 + 9.5×0.5 + 11.2 + 10.1×0.61 ≈ 31.0,各段的 O_s 按同一组因子缩放后相加再除以 31.0 即得最终输出。整个归并就是几十次乘加——它对算力的需求低到可以忽略,瓶颈从来不在公式本身。
真正要付的代价不在流量而在同步:归并 kernel 必须等第一段 kernel 的所有 block 写完才能动手,两个 kernel 之间是一次全设备级的隐式同步。S 段里只要有一段拖尾(比如最后一段吃了余数、或者某段所在的 SM 被别的流抢走),整个归并就被最长的那段钉住。这就是下一节 split 数选择的出发点。
另一个容易忽视的点:部分结果 (O_s, m_s, l_s) 要落显存(FP32 累积防止精度损失),对显存带宽极敏感的长 KV 场景,有的实现会把归并进同一个 kernel 的第二阶段(persistent kernel + 原子计数器,最后一个完成的 block 顺带做归并),省掉一次 kernel 启动和中间结果回写。FlashInfer 的 decode kernel 就是这类融合实现,小 batch 下能再抠出 5%-15% 的时延。
四、split 数怎么选: occupancy 与归并开销的平衡
S 不是越大越好。切得越碎,block 越多、occupancy 越高,但每段的有效工作越少,固定开销(kernel 启动、q 的重复加载、归并流量线性增长)占比越大;而且 S 超过「SM 数 / (b × h)」之后,多出来的 block 本来也排不上队,纯属白切。
经验公式就一条:S ≈ SM 数 / (batch × heads),再向上取整到 2 的幂。几个典型配置:
| 场景 | b × h | SM 数 | 建议 S | block 总数 |
|---|---|---|---|---|
| 在线低峰,7B GQA | 1 × 8 | 108 | 16 | 128 |
| 在线中峰,70B GQA | 16 × 8 | 132 | 1-2 | 128-256 |
| 离线大批量,7B | 256 × 8 | 108 | 1 | 2048 |
| 长上下文 128K,b=4 | 4 × 8 | 132 | 4-8 | 128-256 |
注意最后一行:长 KV 场景即使 batch 不小,也可能还想切几段——因为单 block 顺序扫 32K 个 token 的 KV,单个 block 的执行时间太长,少数拖尾 block 决定整体时延,切几段能拉平负载。这就是负载均衡视角:S 不仅管 occupancy,还管尾延迟。
工程上的标准做法是自适应选 S:kernel 启动前根据当前 batch、头数、KV 长度查一张预调优的表(或按上面的公式现算),不同请求混部时甚至可以逐请求取不同 S。FlashInfer 和 TensorRT-LLM 都是这么做的——S 不是编译期常量,而是每个 decode step 动态决定的调度参数。给一条可直接执行的建议:如果你在自己写 decode kernel,先按公式定 S,再对 S ∈ {1, 2, 4, 8, 16} 做一轮离线扫描,画出「S - 单步时延」曲线,拐点通常非常明显。
五、FlashDecoding++:把归并和负载再抠一层
FlashDecoding 把 decode 的 occupancy 问题解掉之后,剩下的损耗集中在两处:归并 kernel 的固定开销,以及 KV 长度不均时的负载倾斜。FlashDecoding++(2023 年底的工作,与原版同年)针对这两点做了改进。
第一项改进是统一最大值(unified max value)。原版的归并必须等所有段算完、拿到全局最大值 m* 才能缩放——归并卡在关键路径上。FlashDecoding++ 观察到 attention logits q·k^T 的数值范围其实有先验上界(q 和 k 的元素经过 LayerNorm 后幅值有界),干脆用一个预先统计的常数 M 替代 running max:每段直接以 M 为基准算 exp(x - M),部分结果天然同尺度,归并退化成纯加法,不再需要等最大值、不再需要逐段 rescale。省掉的是归并里的一次全局通信和对应的同步等待。
第二项改进是细粒度负载均衡。原版按定长切 KV,变长场景(不同请求 KV 长度差几倍,continuous batching 里这是常态,见 PagedAttention 与 vLLM)定长切会让短请求的段先算完干等。FlashDecoding++ 引入动态任务划分,把 KV 段的工作按 SM 实时可用性分发,配合 flat 化的 GEMV 实现(把 head 维和 d_head 维拍平进同一个 block 内循环,减少 kernel 间切换),在 llama 级别模型上报告的端到端 decode 加速相对原版 FlashDecoding 再进一步,相对 HuggingFace 基线最高到 4.8 倍。
把两代方案放一张表收尾:
| 维度 | FlashAttention decode | FlashDecoding | FlashDecoding++ |
|---|---|---|---|
| 并行轴 | batch × heads | 增加 KV split | 同左,切分动态化 |
| 归并 | 无 | log-sum-exp 修正 | 统一 max,归并退化为加法 |
| 变长 KV 负载 | 无关 | 定长切,有倾斜 | 动态划分,倾斜小 |
| 适用场景 | batch 大 | batch 小、KV 长 | 变长混部、小 batch |
| 代表实现 | FA2 decode kernel | FlashInfer / TRT-LLM | 研究原型,思路被吸收 |
值得说明的是,「统一最大值」这招有数值安全的前提:M 必须不小于真实 logits 的最大值,否则 exp(x - M) 会溢出。论文的做法是按模型离线校准一个安全的 M,工程实现里会留余量并配 fallback——这也是为什么生产框架普遍先用 log-sum-exp 归并(稳妥、通用),把 unified-max 当作特定模型上的可选项。与之配套的 KV cache INT4 量化 会让 logits 分布更分散,用 unified-max 时校准要重新做,两者叠加时别直接套旧常数。
六、落地检查单:什么时候该上 split-KV
把全篇收束成几条可执行的判断:
- batch × heads ≥ SM 数的 2 倍:decode kernel 已经能喂饱卡,split-KV 收益为零,别加归并开销。
- batch × heads < SM 数,且 KV 长度 ≥ 4K:split-KV 的主场,按
S ≈ SM/(b×h)起步扫描。 - 变长混部 + continuous batching:优先选带动态划分的实现(FlashInfer 的 decode path),别自己写定长切。
- 单步时延里归并 kernel 占比超过 10%:S 开太大了,或者该换融合归并的 persistent kernel。
- 中间结果精度:部分 O_s 与 l_s 用 FP32 落显存,不要因为省带宽改成 BF16,归并误差会在长 KV 场景累积放大,出现过真实的输出漂移事故。
- 上线后回归监控:按 batch 分桶统计 decode 单步时延,低 batch 桶应明显改善;若高 batch 桶变慢,多半是自适应选 S 的表没标定好。
- 投机解码(Medusa/EAGLE 这类多头草稿)让每个请求每步带多个 query:query 维不再塌缩到 1,split-KV 的必要性下降,按实测重新评估 S。
最后提醒一个搭配关系:投机解码(speculative decoding)类方案让每个 decode step 处理一棵草稿 token 树,query 数从 1 变成几到几十,此时注意力的形状介于 GEMV 和 GEMM 之间,split-KV 的最优 S 会显著变小,但 tree attention 的掩码让各段工作量不再均匀,动态划分的价值反而上升。选型时别把「用了投机解码」当成关掉 split-KV 的理由,正确动作是重新扫一遍 S。
这一篇在知识体系里的位置
- 前置原理:FlashAttention 显存分块 的 online softmax 与 rescaling 是 split-KV 归并公式的直接来源;KV cache 推理显存 给出 decode 每步必读完整 KV 的访存账,是本篇「为什么饿卡」的定量基础。
- 显存侧配合:GQA/MQA 与 KV 节省 和 KV cache INT4 量化 压缩的是 KV 的体积,本篇压缩的是读 KV 的时间,两者正交可叠加。
- 系统侧落地:PagedAttention 与 vLLM 的变长混部场景正是 FlashDecoding++ 动态划分要解决的问题域;CUDA streams 异步重叠 的 stream 级并发机制与 split-KV 的段级并发共用同一套「藏延迟」方法论。
总结
FlashDecoding 的全部学问是一句话:decode 阶段 query 维塌缩成 1、block 数喂不饱 SM,于是沿 KV 序列维切 S 段并行算部分注意力,再用 log-sum-exp 修正把 S 个 (O_s, m_s, l_s) 归并成精确结果——归并流量只有 KV 读取的千分之一,换来 occupancy 拉满;split 数按 SM 数/(batch×heads) 取、切多了被归并开销反噬;FlashDecoding++ 再用「统一最大值」把归并退化成纯加法、用动态任务划分治变长负载倾斜,把 decode 这最后一段饿卡路径彻底喂饱。