Skip to content

FlashDecoding 与 Split-K 并行解码

解析 Decode 阶段 SM 闲置瓶颈、Split-KV 分块 LSE 归约与 FlashMLA 演进。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 FlashDecoding?

FlashAttention 在一次性读入长文章(Prefill 阶段)时快如闪电,可到了逐字往外蹦(Decode 阶段)时却突然变慢——因为此时新生成的 Query 长度只有 1,原本按 Query 分块的并行度瞬间萎缩,导致 GPU 上一百多个计算核心绝大部分都在干等发呆。

FlashDecoding 的解法干脆利落:既然 Query 切不动,那就把长长的历史 KV Cache 切成很多段(Split-K) 分给闲置的核心并行算局部注意力,最后再按精确的 LogSumExp 公式一步合并,把长上下文解码速度直接拉满。

01 问题从何而来:FlashAttention 一进 Decode 就“罢工”了? ​

读完 FlashAttention,很多人都会觉得注意力算子已经天下无敌了。可真把模型拿去做 64K 长文档对话测试,你会发现一个极其反直觉的现象:读入 64K 提示词(Prefill)飞快,可轮到一个字一个字往外吐答案(Decode)时,显卡慢得像老牛拉破车!

打开 NVIDIA Nsight 性能剖析器一看,你会惊掉下巴:一块价值几十万、拥有 132 个计算核心(SM)的 H100 显卡,竟然有超过 120 个核心完全处于闲置状态,利用率不到 10%!

问题出在 FlashAttention-2 的“派活逻辑”上。它把并行任务分给了 (Batch, 注意力头数, Query 块数)。在 Prefill 阶段,一次进来 64,000 个 Query 词,随便一拆就是几百上千个任务块,132 个 SM 忙得脚不沾地;可进入 Decode 阶段,每次只吐 1 个新词(Nq=1),Query 块数直接坍缩成 1!再加上如今主流模型都用了 GQA(分组查询注意力),比如 Llama-3-70B 只有 8 组 KV 头,单用户对话时,整张 H100 上总共只能派出区区 8 个任务块——8 个人干活,124 个人围观!

类比 · 百人图书馆里,只派 8 个人翻十万页大辞典

想象一家拥有 132 名顶级图书管理员(H100 的 132 个 SM)的超级图书馆。现在来了一位读者,提了 1 个新问题(Nq=1),需要去翻阅书架上足足 10 万页的历史笔记(超长 KV Cache)。

按照 FlashAttention-2 的老规矩,一个问题只能派给对应组里的那一位管理员从第 1 页闷头翻到第 10 万页。结果就是:8 名管理员累得满头大汗、翻得极慢,而另外 124 名管理员双手插兜站在旁边发呆,整座图书馆 94% 的检索吞吐(HBM 显存带宽)全浪费了!

核心设问

既然 Decode 时新来的词只有 1 个、没法再拆 Query,我们能不能把那本厚厚的历史 KV Cache 拆成几十段,让全车间上百个 SM 同时并发去翻,最后再把大家的结果零误差地精准合二为一?

02 核心直觉与生活类比 ​

2023 年底,Tri Dao 团队给出了简洁到令人拍案叫绝的答案——FlashDecoding(Stanford CRFM Blog ↗),核心招式就叫 Split-KV(沿 KV 序列维度切分并行)。

类比 · 撕书并行检索 + 账单精确合并

回到刚才那座图书馆,FlashDecoding 换了一套两步走的新流程:

  1. 第一步(Split-KV 并行分块):把 10 万页的历史笔记撕成 16 册,每册约 6250 页,立刻发给 16 位闲着的管理员同时去翻!每组 8 个头 × 16 册 = 128 个并行任务,132 名管理员瞬间全员上岗!每位管理员独立用 Online Softmax 算完自己那册的“局部加权答案” o(s),并在小纸条上写下这册的“总权重对数得分(LSE)” L(s);
  2. 第二步(精确归约合并):16 个人几乎同时交卷后,只需挑出 1 名汇总员,花不到 3% 的时间收齐这 16 张极小的纸条,按照各册的总权重比例把 16 份局部答案一加权,瞬间得到最终结果——而且跟一个人老老实实从第 1 页翻到第 10 万页算出来的答案,数学上一分不差!

沿着这个思路,后续的工业级算子把这种“极致压榨硬件”的精神推向了新高度:

  • FlashDecoding++(arXiv:2311.01282 ↗):发现大家在算 Softmax 时总要等局部最大值同步,干脆提前根据统计规律约定一个“统一安全天花板常数”,省去同步等待,顺带把极扁平的矩阵乘法(FlatGEMM)彻底加速;
  • FlashInfer(arXiv:2501.01005 ↗):解决“同批里有人聊了 100 字、有人聊了 6 万字”的严重偏科问题,按页统一重新切分任务,让每个 SM 分到的页数绝对一样多;
  • DeepSeek FlashMLA:借力 DeepSeek-V2/V3 的 MLA 矩阵吸收架构,把全部 128 个 Query 头打包成一块厚实的矩阵共同读取一份压缩后的潜向量 KV,在 H800 上直接干到了 3000 GB/s 的恐怖显存带宽!
类比 · 为什么把 GQA / MLA 的多个头“捆在一起算”这么关键?

如果 1 个词只配 1 个 Query 向量去乘历史 Key,相当于拿一根细牙签去撬矩阵,GPU 上威力无穷的 Tensor Core(张量核心) 根本懒得启动,只能退化到慢吞吞的普通计算单元。而 GQA 里 8 个头(MLA 里更是多达 128 个头!)共享同一份历史 KV,把它们捆成一整排向量一起去乘 KV,既把显存读取量瞬间砍掉 8–128 倍,又刚好凑够了唤醒 Tensor Core 的最低门槛!

03 把关键公式读成人话 ​

FlashDecoding 之所以能“先撕开各算各的,再精确合回来”,全靠 LogSumExp(LSE)归约恒等式。假设历史 KV 被撕成了 S 段,第 s 段交上来的小纸条记录了局部归一化输出 o(s) 和局部对数总权重 L(s)=log⁡∑j∈Iseaj,那么全局合并只需要两行公式:

Lglobal=Lmax+log⁡(∑s=1SeL(s)−Lmax),w(s)=eL(s)−Lglobalofinal=∑s=1Sw(s)o(s)

把公式读成直觉:- 你可以把 eL(s) 想象成第 s 册笔记里所有句子“重要程度(注意力指数得分)的总和”。因为指数非常容易大到超出电脑浮点上限,所以我们全程只记它的对数 L(s);

  • 汇总员先找出 S 册里最大的 Lmax 作为标尺(防止算指数时溢出爆炸),算出全书的总重要度对数 Lglobal;
  • 权重 w(s)=eL(s)−Lglobal=eL(s)∑reL(r),其实就是第 s 册笔记在整个上下文里占的话语权百分比!把每册的局部答案按它的话语权加权求和,答案分毫不差。

再看一眼并行任务块数量的对比,你就秒懂它为什么能救活整张 H100:

NCTAFA2=B×Hkv×1⟶NCTAFD=B×Hkv×S

把公式读成直觉:- 在单用户(B=1)、GQA-8(Hkv=8)下,老算法只派了 8 个任务块,132 个 SM 闲着 124 个;

  • FlashDecoding 只要把历史 KV 切成 S=16 段,任务块立刻从 8 暴涨到 128 个,H100 瞬间满血复活,显存读取速度直接逼近 3 TB/s 物理天花板!
  • 而且阶段二汇总的工作量极小——不管历史上下文是 8K 还是 128K,汇总员都只需要读 S 张小纸条(通常几 KB),耗时不到整个解码步的 3%,性价比高得离谱。

04 它在模型里怎么工作 & 与上下游的关系 ​

FlashDecoding 补齐了大模型推理链路里最关键的一块拼图:

  • 与 FlashAttention 组成“双打搭档”:Prefill 读提示词时,Query 很长,引擎自动跑 FlashAttention-2/3 沿 Query 维度并行;一旦进入 Decode 逐词吐字,引擎立刻无缝切换为 FlashDecoding 沿 KV 维度并行。
  • 与 PagedAttention 与 KV Cache 压缩 深度融合:历史 KV 在显存里并不是一整块连续数组,而是散落的分页物理块,甚至被量化成了 FP8 或 INT4;现代解码算子(如 FlashInfer)直接按页切分 Split-KV,边从 HBM 读量化页边在寄存器里现场反量化,把 GPU Roofline 的带宽上限榨到极致。
  • 支撑超长上下文与推理调度:没有 Split-KV,长上下文模型 写起字来就会卡成幻灯片;它直接决定了 推理服务调度系统 中 Decode 实例池的最低 TPOT 延迟。

05 演化对比与避坑备忘 ​

算子方案解决什么痛点?(说人话)适用场景
FlashAttention-2省显存、提速 Prefill,但 Decode 小 Batch 九成核心闲着训练、Prefill 阶段
FlashDecoding (Blog ↗)沿 KV 序列切分并行 + LSE 精准合并,全卡 SM 动起来长上下文低并发 Decode 标配
FlashDecoding++ (arXiv ↗)预先约定最大值省去 Softmax 同步,优化扁平小矩阵进一步压榨中小 Batch 延迟
FlashInfer (arXiv ↗)给长短悬殊的混合请求按页均匀派活,完美兼容 CUDA GraphvLLM / SGLang 生产服务主力
DeepSeek FlashMLA把 MLA 的 128 个头捆绑读低秩缓存,H800 带宽逼近极限DeepSeek-V2/V3 等 MLA 模型

实际写代码或调优 Decode 算子,有三个避坑点一定要牢记:

  1. 大 Batch 时别盲目把切分数 S 设太大:Split-KV 是为了救“活跃任务块不够塞满 SM”的急。如果你的在线服务同时有 64 个用户在 Decode,64 × 8 已经有 512 个任务块,本来就把显卡塞得满满当当了;这时候硬切 16 份反而多出十几倍的中间结果读写和汇总开销,速度不升反降!一定要根据当前 Batch 大小动态决定切分数。
  2. 中间临时结果千万别偷懒存成 FP16:第一阶段写进显存工作区的局部输出 o(s) 和 L(s) 体积非常小,务必保留 FP32 单精度。一旦偷懒压成 FP16,遇到某一段权重特别大、另一段权重特别小时,第二阶段一汇总就会出现肉眼可见的精度崩坏。
  3. 当心变长 Batch 里的“空分片”炸出 NaN:如果同批里某条短序列长度还不够切出来的段数,尾部多出来的空分片必须把局部 L(s) 填成 −∞、输出填成 0,否则归约公式一算 exp(-inf - (-inf)) 立刻吐出一片 NaN。
  4. 开启 CUDA Graph 时记得静态预分配工作区:线上低延迟解码通常把整步前向录制成 CUDA Graph 来消除 CPU 发射延迟,此时 Split-KV 的中间缓冲张量地址不能每步动态 malloc,必须按最大切分数提前静态预分配好。

想查阅 Split-KV 精确 LSE 归约的完整数学证明、双阶段数据流架构图以及原生支持 GQA 的可运行 PyTorch flash_decoding_split_kv 代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

FlashAttention-2 彻底解决了训练与推理 Prefill 阶段的二次显存与 IO 瓶颈,但在大语言模型自回归推理的 Decode(逐词生成) 阶段却意外遭遇滑铁卢:当上下文长度达到 32K–128K、同时并发请求数 B 较小时,直接调用 FlashAttention-2 会导致 90% 以上的 GPU 流多处理器(SM)彻底闲置,显存带宽利用率暴跌至不足 10%。FlashDecoding(Dao et al., 2023,Stanford CRFM Blog ↗)通过在 KV 序列长度维度引入 Split-K 并行切分与两阶段精确 LogSumExp(LSE)归约合并,在零数值近似的前提下瞬间拉满全部 GPU SM 与 HBM 带宽,并进一步演进出 FlashDecoding++、FlashInfer 与 DeepSeek FlashMLA 等新一代推理核心算子。

直观理解

FlashAttention-2 把每个查询词(Query)包给一位工人,让他独自从头到尾翻完一整本十万字的笔记(KV Cache)。在 Prefill 阶段,一次来了几千个查询词,几百个工人(GPU SM)忙得热火朝天;可一进入 Decode 阶段,每次只来了 1 个新词,如果还按老规矩派工,整间一百多号人的大车间里只有寥寥几个人在闷头狂翻十万字笔记,其余上百号人全在旁边嗑瓜子围观!FlashDecoding 把这本厚笔记撕成几十本薄册子(Split-KV),全车间上百号人同时各读一册并记下自己的局部最高分与加权结果,最后只需一个人花一瞬间把几十张小纸条精确合并成最终答案。

起源背景与演进脉络 ​

Decode 阶段的并行度塌缩(Occupancy Collapse) ​

在 FlashAttention-2 中,CUDA 网格(Grid)的线程块(CTA / Thread Block)按三个维度启动:

NCTAFA2=B×Hq×⌈NqBr⌉

在训练或 Prefill 阶段,Nq 可达数千至数万,因此 ⌈Nq/Br⌉ 轻松达到上百,即便 B=1 也能生成远超 GPU 物理 SM 数量(如 A100 有 108 个 SM,H100 有 132 个 SM)的线程块。然而在自回归 Decode 阶段:

  1. Query 长度坍缩为 1:每条序列每次前向仅输入 1 个新 Token(即 Nq=1),导致 ⌈Nq/Br⌉=1;
  2. GQA 进一步压缩独立并行头数:现代模型广泛采用 GQA(分组查询注意力),例如 Llama-3-70B 仅有 Hkv=8 个键值头(每 8 个 Query 头共享 1 组 KV)。为了复用 HBM 读取,同一 KV 组内的 g=Hq/Hkv 个 Query 头通常打包进同一个线程块,使得单条请求的活跃线程块仅剩 Hkv=8 个!
  3. 带宽墙与 SM 饥饿双重打击:当 B=1 时,H100 上 132 个 SM 里仅有 8 个在干活(利用率 6.1%)。Decode 本身是极端 显存带宽受限(Memory-Bound) 的算子,极少的活跃线程块根本无法发射足够多的并发内存事务去隐藏数百时钟周期的 HBM 访存延迟,致使实测有效带宽远低于硬件峰值。

核心原理与数学推导 ​

1. 两阶段 Split-KV 切分与精确 LSE 归约证明 ​

FlashDecoding 打破“单线程块串行扫完全部 Nkv”的束缚,沿历史 KV 序列维度将索引集合 {1,…,Nkv} 均匀切分为 S 个互不相交的分片(Splits)I1,I2,…,IS,每片长度为 Nsplit=⌈Nkv/S⌉。此时启动的线程块数量扩展为:

NCTAFD=B×Hkv×S

通过动态选取 S 使 NCTAFD 达到 GPU SM 数量的整数倍(避免 Wave Quantization 尾浪浪费),即可瞬间拉满整张显卡的 HBM 吞吐。整个计算分为两个顺序 CUDA Kernel:

阶段一(Parallel Split-KV Attention Kernel):第 s∈{1,…,S} 个分片在片上 SRAM 中对查询 q∈Rd 与分片键值 (K(s),V(s)) 执行标准分块 Online Softmax,得出该分片的局部归一化输出 o(s) 与局部对数配分函数(Log-Sum-Exp, LSE) L(s):

m(s)=maxj∈Isaj,ℓ(s)=∑j∈Iseaj−m(s),L(s)=m(s)+log⁡ℓ(s)=log⁡∑j∈Iseajo(s)=1ℓ(s)∑j∈Iseaj−m(s)vj=∑j∈IseajvjeL(s)

其中 aj=q⊤kj/d。阶段一仅需将极小的中间缓冲 o(s)∈Rd 和标量 L(s)∈R 写回 HBM 临时工作区(总计仅 O(BHqSd) 字节,与 Nkv 无关)。

阶段二(Exact LSE Reduction Kernel):启动 B×Hq 个轻量化归约线程块,读入全部 S 个分片的 (o(s),L(s)),首先以数值稳定的方式求全局对数配分函数:

Lmax=max1≤s≤SL(s),Lglobal=Lmax+log⁡(∑s=1Sexp⁡(L(s)−Lmax))

随后以重加权系数 w(s)=exp⁡(L(s)−Lglobal) 线性汇总所有局部输出:

ofinal=∑s=1Sw(s)o(s)=∑s=1SeL(s)∑r=1SeL(r)⋅∑j∈IseajvjeL(s)=∑j=1Nkveajvj∑t=1Nkveat

分子分母中的 eL(s) 严格约去!这证明 Split-KV 两阶段归约在实数域上与全局单遍注意力完全数学恒等,不引入任何近似误差。由于 S 通常仅为 16–128,阶段二耗费的时间微乎其微(一般不足总耗时的 3%)。

2. GQA 头打包与 Tensor Core 唤醒 ​

当单条请求采用 MHA(g=1)且 Nq=1 时,qK⊤ 退化为矩阵-向量乘(GEMV),无法直接喂给需要至少 M≥8 或 16 行矩阵维度的 Tensor Core(WMMA / WGMMA)。在 GQA 架构中(如 g=Hq/Hkv=8),FlashDecoding 将共享同一 KV 头的 g 个 Query 向量纵向拼接为矩阵 Qg∈Rg×d:

  • 访存直接砍掉 g 倍:同一份 KV 分片仅从 HBM 读入 SRAM 一次,供全部 g 个头复用;
  • 激活 Tensor Core:当 g≥8(或在 投机解码 验证多个草稿 Token 时 g⋅Nq≥16),QgK(s)⊤ 可直接调用 Tensor Core 矩阵乘指令,配合高内存级并行彻底打满硬件性能。

3. 前沿演进:FlashDecoding++、FlashInfer 与 DeepSeek FlashMLA ​

  1. FlashDecoding++(Hong et al., 2023,arXiv:2311.01282 ↗):指出原生两阶段归约仍存在 Softmax 同步等待与极扁平矩阵乘(FlatGEMM,如 M∈[2,8])效率低两大痛点,提出 Unified Max Value 异步免同步 Softmax(离线统计历史分数的经验安全上界常数 cmax 替代实时求 max,仅在极端越界时触发修正)以及双缓冲 FlatGEMM 优化。
  2. FlashInfer(Ye et al., 2025,arXiv:2501.01005 ↗):在生产级连续批处理下,同批内各请求的 Nkv 长度可能相差百倍(有的 128 Token,有的 64K Token)。若对每条请求均采用相同的 S 切分,短请求所在 SM 瞬间空闲而长请求严重拖尾。FlashInfer 设计了全局负载均衡的分页 Split-KV 调度器:预先在 CPU/轻量内核中将全部不规则长度的 KV 页均匀分配给固定数量的 CTA,并完美兼容静态内存地址要求的 CUDA Graph。
  3. DeepSeek FlashMLA(GitHub ↗):面向 DeepSeek-V2/V3 的 MLA(多头潜在注意力) 矩阵吸收(Matrix Absorption)解码形态。此时全部 Hq=128 个 Query 头共享同一条极窄的低秩潜向量缓存(dc=512 加上解耦 RoPE dr=64,总维度 576,且 K 与 V 复用同一份 512 维潜向量!)。FlashMLA 将 128 个 Query 头打包成高算术强度矩阵,结合 Hopper 架构 TMA 异步预取、WGMMA 流水线与动态 Split-KV 负载均衡,在 NVIDIA H800 上实现了 3000 GB/s HBM 带宽利用率与 580 TFLOPS FP16/BF16 算力。

架构与数据流图 ​

以下流程图展示了 FlashDecoding 沿 KV 序列维度执行 Split-KV 两阶段并行计算与精确 LSE 归约的完整 GPU 数据流:

图表加载中...

相关优化模式与横向对比表 ​

解码注意力算子并行维度归约机制变长批负载均衡GQA / MLA 适配核心硬件特性与适用场景
FlashAttention-2B×Hq×⌈Nq/Br⌉单块 Online Softmax无逐头计算Prefill 与训练最优;Decode 小 Batch 严重闲置 SM
FlashDecodingB×Hkv×S两阶段 Exact LSE 归约固定/启发式 S原生 GQA 打包长上下文低并发 Decode 提速 4–8×
FlashDecoding++B×Hkv×S统一最大常数免同步 Softmax启发式切分GQA + FlatGEMM消除 Softmax 同步开销,小 Batch 吞吐再提 1.3–2×
FlashInfer统一变长块级虚拟任务网格两阶段 / 持久化归约全局显式均衡Paged/Radix/GQA/MLA工业级 Serving 默认引擎(vLLM/SGLang),兼容 CUDA Graph
DeepSeek FlashMLAB×S(128 头整组打包)动态 Split-KV LSE 归约变长动态切分MLA 吸收形态专精Hopper TMA + WGMMA,压榨出近理论极限的 HBM 带宽

核心 PyTorch 参考实现 ​

以下纯 PyTorch 实现完整演示了支持 GQA 头分组共享的 FlashDecoding 两阶段 Split-KV 并行计算与精确 LSE 归约,并与标准 scaled_dot_product_attention 验证浮点数值完全等价:

python
import math
import torch
import torch.nn.functional as F


def flash_decoding_split_kv(
    Q: torch.Tensor,         # (B, H_q, 1, D)
    K: torch.Tensor,         # (B, H_kv, N_kv, D)
    V: torch.Tensor,         # (B, H_kv, N_kv, D)
    num_splits: int = 8,     # 沿 N_kv 维度的切分数 S
) -> torch.Tensor:
    """
    教学级 FlashDecoding (Split-KV + Exact LSE Reduction) 实现,原生支持 GQA。
    Pass 1 模拟各 SM 并行处理不同 KV 分片,Pass 2 按 LogSumExp 精确归约。
    """
    B, H_q, N_q, D = Q.shape
    _, H_kv, N_kv, _ = K.shape
    assert N_q == 1 and H_q % H_kv == 0
    g = H_q // H_kv          # 每个 KV 头对应的 Query 组大小
    scale = 1.0 / math.sqrt(D)

    # 将 Q 重排为 (B, H_kv, g, D),同一组 g 个头共享一份 K/V 访存
    Q_grouped = Q.squeeze(2).view(B, H_kv, g, D).float()

    # 若 N_kv 较短,限制有效切分数避免产生空分片
    S = min(num_splits, N_kv)
    split_size = math.ceil(N_kv / S)

    # HBM 临时工作区:保存每个分片的局部归一化输出 O^(s) 与局部 LSE L^(s)
    partial_O = torch.empty((B, H_kv, S, g, D), device=Q.device, dtype=torch.float32)
    partial_L = torch.empty((B, H_kv, S, g, 1), device=Q.device, dtype=torch.float32)

    # ===== 阶段一:Parallel Split-KV Attention (各分片在 GPU 上完全并行) =====
    for s in range(S):
        start = s * split_size
        end = min(start + split_size, N_kv)
        if start >= N_kv:
            partial_O[:, :, s].zero_()
            partial_L[:, :, s].fill_(float("-inf"))
            continue

        K_s = K[:, :, start:end, :].float()           # (B, H_kv, L_s, D)
        V_s = V[:, :, start:end, :].float()           # (B, H_kv, L_s, D)

        # 局部打分:(B, H_kv, g, L_s)
        scores = torch.matmul(Q_grouped, K_s.transpose(-1, -2)) * scale
        m_s = scores.max(dim=-1, keepdim=True).values # (B, H_kv, g, 1)
        exp_s = torch.exp(scores - m_s)               # 局部未归一化指数权重
        l_s = exp_s.sum(dim=-1, keepdim=True)         # 局部分母

        # 局部归一化输出 O^(s) 与局部对数配分函数 L^(s) = m^(s) + log(l^(s))
        partial_O[:, :, s] = torch.matmul(exp_s, V_s) / l_s
        partial_L[:, :, s] = m_s + torch.log(l_s)

    # ===== 阶段二:Exact LSE Reduction Kernel (沿 S 维度精确合并) =====
    L_max = partial_L.max(dim=2, keepdim=True).values                     # (B, H_kv, 1, g, 1)
    # 全局 L_global = L_max + log(sum_s exp(L^(s) - L_max))
    exp_diff = torch.exp(partial_L - L_max)                               # (B, H_kv, S, g, 1)
    L_global = L_max + torch.log(exp_diff.sum(dim=2, keepdim=True))       # (B, H_kv, 1, g, 1)

    weights = torch.exp(partial_L - L_global)                             # (B, H_kv, S, g, 1)
    O_final = (weights * partial_O).sum(dim=2)                            # (B, H_kv, g, D)
    return O_final.view(B, H_q, 1, D).to(Q.dtype)


if __name__ == "__main__":
    torch.manual_seed(42)
    B, H_q, H_kv, N_kv, D = 2, 32, 8, 4096, 128
    Q = torch.randn(B, H_q, 1, D)
    K = torch.randn(B, H_kv, N_kv, D)
    V = torch.randn(B, H_kv, N_kv, D)

    out_fd = flash_decoding_split_kv(Q, K, V, num_splits=16)
    # 参考实现:展开 GQA 后调用 PyTorch 精确 SDPA
    K_rep = K.repeat_interleave(H_q // H_kv, dim=1)
    V_rep = V.repeat_interleave(H_q // H_kv, dim=1)
    out_ref = F.scaled_dot_product_attention(Q, K_rep, V_rep, is_causal=False)

    max_diff = (out_fd - out_ref).abs().max().item()
    print(f"Max absolute diff vs PyTorch SDPA: {max_diff:.2e}")
    assert torch.allclose(out_fd, out_ref, atol=1e-5)

工程实践与常见陷阱 ​

工程实践

  1. 自适应选择切分数 S(避免过度切分与 Wave Quantization):并非 S 越大越好!当 B 很大(如大批量在线服务 B=64,Hkv=8)时,原始线程块数已达 512,远超 H100 的 132 个 SM,此时强行设 S=16 反而会徒增 16 倍的中间工作区读写与阶段二归约开销。生产内核(如 FlashAttention-2.5+ 与 FlashInfer)通常按 num_splits=max(1,⌊SM_Count⋅k/(B⋅Hkv)⌋) 动态启发式选值。
  2. 与 PagedAttention 及 FP8 KV Cache 融合:在真实服务中,切分边界应尽量与 PagedAttention 的物理块大小(如 16 或 64 Token)整数对齐,使每个分片顺滑遍历固定数量的物理页;搭配 FP8/INT4 KV 实时反量化融合(De-quantize in Register),可将 Decode 有效吞吐再翻倍。
  3. 兼容 CUDA Graph 的静态工作区预分配:由于 Decode 单步极短,Python 侧 Kernel Launch 开销占比可观,线上通常开启 CUDA Graph 捕获整张前向图。此时中间缓冲 partial_O 与 partial_L 必须按最大 num_splits 静态预分配,切分元信息(Metadata)则以固定地址张量传入。

常见陷阱

  1. 短分片导致空分片 NaN 污染:当 Nkv 小于固定设定的 S,或采用不等长 Batch 中存在极短序列时,尾部某些分片可能分配到 0 个有效 Token。此时其局部 LSE 必须严格填为 −∞、局部输出填为 0,且归约阶段必须使用 L_max 防护,否则 exp(-inf - (-inf)) 会直接污染整行输出产生 NaN。
  2. 阶段一输出类型截断造成归约精度漂移:切勿在阶段一将 partial_O 提前截断为 FP16/BF16 写入 HBM 工作区后再在阶段二做 LSE 归约!由于各分片权重差异可能跨越多个数量级,中间缓冲 partial_O 与 partial_L 务必保持 FP32 精度,待最终合并完毕后再一次性转回 BF16/FP16。
  3. 忽略变长 Batch 下的长尾 SM 拖慢:若同批内 31 条请求的上下文长度是 512,唯独 1 条是 64K,按每条请求统一固定分片数会导致 31 条的线程块 0.1 ms 结束,整个 GPU 却要苦等那条 64K 序列的分片跑完。面对高度异构的序列长度分布,应优先采用 FlashInfer 或 FlashMLA 的全局负载均衡块调度策略。

参考文献 ​

  • Dao, T. (2023). FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning. ICLR 2024. arXiv:2307.08691 ↗(奠定 FlashDecoding 依赖的分块 Online Softmax 框架)
  • Dao, T., Haziza, D., Massa, F., & Sizov, G. (2023). Flash-Decoding for Long-Context Inference. Stanford CRFM Blog ↗(首次提出沿 KV 序列维度 Split-KV 与 LSE 归约的解码加速方法)
  • Hong, K., Dai, G., Xu, J., et al. (2023). FlashDecoding++: Faster Large Language Model Inference on GPUs. MLSys 2024. arXiv:2311.01282 ↗(提出 Unified Max Value 异步 Softmax 与 FlatGEMM 优化)
  • DeepSeek-AI (2024). DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model. arXiv:2405.04434 ↗(提出多头潜在注意力 MLA 及其矩阵吸收解码形态)
  • Ye, Z., Chen, L., Lai, R., et al. (2025). FlashInfer: Efficient and Customizable Attention Engine for LLM Inference Serving. MLSys 2025. arXiv:2501.01005 ↗(面向变长分页 KV 的全局负载均衡 Split-KV 与 JIT 算子引擎)
  • DeepSeek-AI (2025). FlashMLA: Efficient MLA Decoding Kernels for Hopper GPUs. GitHub: deepseek-ai/FlashMLA ↗(针对 MLA 架构极致优化的 Hopper 异步 Split-KV 解码算子)