softmax kernel 实战:用 warp 内归约(__shfl_xor_sync)写一个数值安全的高性能 softmax
更新时间:2026-10-01。在 warp 级原语 里我们学过
__shfl_xor_sync这类 shuffle 指令怎么在寄存器层面做线程间交换,在 FlashAttention 显存分块 里见过 online softmax 怎么把归一化藏进分块循环。这一篇把两件事落到同一个具体问题上:亲手写一个能在生产里用的 softmax kernel——它出现在 LLM 推理的每一层 attention 里,也是 GPU kernel 面试与性能优化的经典入门题。
本文要回答的问题
- 朴素 softmax 为什么会数值溢出,减去行最大值为什么数学上等价却工程上必需?
- warp 内归约(warp reduction)用
__shfl_xor_sync怎么在 5 步内求出 32 个线程的最大值与和? - 经典两遍(two-pass)softmax 要读几遍数据,瓶颈到底在算力还是带宽?
- FlashAttention 式 online(单遍)softmax 怎么把 max 和 sum 边算边修正,省掉了什么、付出了什么?
- 实际写 kernel 时 block 大小、向量加载、尾元素处理有哪些坑?
一、数值安全:为什么必须先减 max
softmax 的数学定义很简短:对一行 n 个数 x_i,输出 p_i = exp(x_i) / Σ exp(x_j)。公式直接翻译成代码会踩一个经典坑:exp 增长极快,exp(89) 就超出 FP32 上限变成 inf,而 LLM 里 attention logits(Q·K^T 除以 √d 之后)出现几十的数值稀松平常。分子分母同时 inf 或 inf/inf,输出就是一整行 NaN。
修复手段是利用一个恒等式:softmax 对「全体元素同加一个常数」不变。取 m = max(x),改写为 p_i = exp(x_i - m) / Σ exp(x_j - m)。减完最大值之后,指数部分的输入被压到 (-∞, 0],exp 输出落在 (0, 1],上溢彻底消失;分母至少含一个 exp(0)=1,也不会除零。这就是「数值安全 softmax」,所有生产实现的起点。
注意这不是近似:数学上严格相等,只是浮点路径换了一条不炸的路。代价是必须先知道全行的 max——这正是后面「两遍 vs 单遍」分歧的根源。
顺带澄清两个常见误解。其一,减 max 只能防上溢,不能防下溢:x_i - m 非常负时 exp 会下溢成 0,但这对 softmax 是无害的——那个位置的权重本来就趋近于零,输出 0 是正确结果,而且分母里恒有 exp(0)=1 兜底,不会出现 0/0。其二,不要用「对 logits 整体乘一个缩放系数」来替代减 max:乘法会改变 softmax 的分布形状(温度效应),数学上不再等价;只有加减常数才保持输出不变。推理框架里 attention 的 1/√d 缩放是温度的一部分,必须照算,不能当作数值手段挪用。
二、warp 归约:32 个线程 5 步求 max 与 sum
一个 block 处理一行是 softmax kernel 最常见的映射:行内每个元素(或每几个元素)由一个线程负责,行级 max 与 sum 就是一次块内归约。CUDA 里归约的最内层一定是 warp 归约——利用 __shfl_xor_sync,线程直接从同 warp 其他线程的寄存器读值,不碰 shared memory、不需要同步指令:
__inline__ __device__ float warpReduceMax(float v) {
#pragma unroll
for (int offset = 16; offset > 0; offset >>= 1)
v = fmaxf(v, __shfl_xor_sync(0xffffffff, v, offset));
return v; // 32 个线程现在都持有全 warp 的最大值
}蝶形交换的含义:offset=16 时线程 i 与 i^16 交换,每对线程拿到对方一半的最大值;offset 逐次折半,5 轮(log2(32))之后 32 个线程手里的值完全相同。求和版本把 fmaxf 换成 + 即可,过程一字不差。block 大于 32 线程时,每个 warp 先各自归约,把 warp 结果写进一小块 shared memory,再由第一个 warp 做第二轮归约——两层结构,shared memory 用量只有 32 个 float,几乎不担心 shared memory bank conflict。这套「warp 内 shuffle + warp 间 shared」的两层归约是 CUDA 里所有块级归约(softmax、LayerNorm、RMSNorm 共用同一骨架)的标准件,写熟一次到处复用。
上图的关键点在于:归约结束后每个线程都有结果,不需要广播。这直接决定了两遍实现里第二趟循环可以立刻用上行级 max 和 sum,没有任何同步开销。
三、经典两遍实现:先找 max,再算 exp 和 sum
两遍(two-pass,也有人叫 three-pass,把最后除以 sum 单算一趟)的结构:
- 第一遍读全行,warp/block 归约出 max
m; - 第二遍再读全行,算
exp(x_i - m)并归约出 sums; - 每个元素写回
exp(x_i - m) / s。
// pass 1: row max
float local_max = -INFINITY;
for (int i = tid; i < n; i += stride)
local_max = fmaxf(local_max, x[i]);
float m = blockReduceMax(local_max);
// pass 2: sum of exp
float local_sum = 0.f;
for (int i = tid; i < n; i += stride)
local_sum += __expf(x[i] - m);
float s = blockReduceSum(local_sum);
// write back
for (int i = tid; i < n; i += stride)
x[i] = __expf(x[i] - m) / s;这个 kernel 的本质是纯带宽活:每元素两次读、一次写,算术强度只有约 1 FLOP/byte 出头,远低于 GPU 的算力带宽比(参考 GPU 显存层级与带宽),跑分永远贴着显存带宽上限。所以优化方向不是「算得更快」,而是「少读几遍数据」。
还有一个值得知道的变体判断:很多人以为必须先把 max 找出来才能开始算 exp,于是把「找 max」和「算 exp 求和」写成两个独立 kernel,中间夹一次全局同步。这在单 block 管一行时是浪费——同一个 block 内用 shared memory 存 max、加一次 __syncthreads 就能接着第二趟,没必要拆 kernel。只有当行大到必须多个 block 协作(grid 级归约)时,才需要考虑拆 kernel 或用 cooperative groups 的 grid sync;那种规模在 attention 之外的场景才偶尔出现。
四、online softmax:一边扫一边修正的 FlashAttention 式单遍
online softmax(Milakov & Gimelshein 2018,后被 FlashAttention 用作核心部件)把两遍合成一遍:维护运行中的 m_running 和 s_running,每处理一个新元素(或新分块)时,如果发现更大的值,就用指数缩放因子把旧的部分和「折算」到新基准上:
float m = -INFINITY, s = 0.f;
for (int i = tid; i < n; i += stride) {
float v = x[i];
float m_new = fmaxf(m, v);
// 旧 sum 按 exp(m - m_new) 折算,新元素贡献 exp(v - m_new)
s = s * __expf(m - m_new) + __expf(v - m_new);
m = m_new;
}
// warp 归约时同理:合并 (m1,s1) 与 (m2,s2)数学依据:Σ exp(x_j - m_new) = exp(m_old - m_new) × Σ exp(x_j - m_old),也就是基准移动一次,历史部分和乘一个缩放因子即可,不用回头重读数据。代价是每元素多算一到两次 exp 和一次乘加——但前面说过这活瓶颈在带宽,多出来的算力开销几乎免费,省下的那一遍读可是实打实 33% 的显存流量。
两种实现的对比:
| 维度 | 两遍实现 | online 单遍 |
|---|---|---|
| 全行读次数 | 2 次 | 1 次 |
| 显存流量/元素 | 2 读 + 1 写 | 1 读 + 1 写 |
| 每元素 exp 次数 | 1(写回时) | 2-3(含缩放) |
| 寄存器/同步开销 | 低 | 略高(归约要合并二元组) |
| 典型应用 | 独立 softmax kernel、行短时 | FlashAttention 分块内、行很长时 |
在 FlashAttention 里 online 版本是必选项而非优化项:K/V 按块流进 SRAM,根本放不下整行 logits,「先存全行再找 max」物理上不可能,只能边算边修正。行很短(比如 n ≤ 1024 且能塞进寄存器/shared)时两遍版本代码更简单,收益也不差,工业界两个都在用。
五、工程细节:向量加载、尾元素与 block 选择
把骨架变成能打的 kernel,还有几处绕不开的细节:
- 向量化加载:行连续时优先
float4一次读 16 字节,每个线程处理 4 个元素,显存事务数降为四分之一。这是 softmax 这种带宽型 kernel 上性价比最高的一招。 - 尾元素:n 不是 4 的倍数时,尾部单独走标量路径;越界线程用
-INFINITY(max 归约)和0(sum 归约)作幺元参与,不污染结果。 - block 映射:一行一个 block 最直观;行很短时(如 n=128)可以一个 warp 管一行、一个 block 装 8-16 行,提高 SM 占用率。注意 block 内 SIMT 分支分歧 会拖慢归约,长度差异大的行尽量按长度 bucket 分 batch。
- 精度:attention 场景 logits 常是 FP16/BF16,归约的 max 和 sum 务必升到 FP32 累加,输出再降回去,否则长序列下分母累加误差会肉眼可见。
- 写回融合:除以 sum 那一步可以融合进下游(比如 attention 里直接乘 V),少一次中间张量写读——这正是 warp specialization 流水线 里常见的算子融合思路。
这些细节每一条单看都不起眼,叠在一起就是「教科书实现」和「cuBLAS 级别实现」的差距。
最后给一个自测清单,写完 kernel 之后逐条过:一是用 n = 1、n = 31、n = 33、n = 4097 这类边界行长测正确性(覆盖 warp 边界、向量尾部、非对齐三种坑);二是构造含 ±80 以上大数的输入验证数值安全;三是和 PyTorch 的 torch.softmax 在 FP32 下对拍,误差应低于 1e-6 量级;四是拿 Nsight Compute 看 dram__bytes,确认实际显存流量和「几遍读一遍写」的理论账对得上——流量超了通常意味着缓存没吃到或者越界读写把行读穿了。
这一篇在知识体系里的位置
本篇是 warp 级优化系列的动手篇:前置是 warp 级原语(shuffle 指令本身)和 CUDA 线程层级(block/warp 映射),并行阅读 FlashAttention 显存分块 看 online softmax 在完整 attention 里的角色,进阶可接 warp specialization 流水线 与 Tensor Core 矩阵加速——softmax 算清之后,下一步就是把 QK^T 和 PV 两个 GEMM 也搬进同一个 kernel。
总结
softmax kernel 的全部学问浓缩成三句话:减 max 保证数值安全是数学恒等变换而非近似;warp 内归约用 __shfl_xor_sync 5 步蝶形交换即可让 32 个线程同时拿到行级 max 与 sum,全程不碰 shared memory;两遍实现读两次数据、online 单遍边扫边用 exp(m_old - m_new) 折算历史部分和只读一次——因为 softmax 是纯带宽型算子,少读一遍就是 33% 的显存流量,这正是 FlashAttention 选择 online 路线的根本原因。