目录 · 11 节
- 1 The Single-Kernel Failure Mode
- 2 Four Diagnostic Constraints
- 3 H100 SXM5 vs. Ascend 910C Teardown & GQA Decode
- 4 Ascend 910C FlashAttention Case Study
- 5 Specialized Family Kernels
- 5.1 H100 Triton Kernels
- 5.2 Ascend 910C Buffer Specialization
- 6 Continuous-Predicate Dispatch
- 7 Engineering Ladder & Real-Hardware Diagnostics
- 8 Verification Plan
- · Citation
- 物理瓶颈随负载切换:同一算子跨越输入形状临界点后,主导延迟会在发射地板 、带宽屋顶 、算力屋顶 与片上容量边界之间迁移。
- 双平台物理拆解与分布实证:NVIDIA H100 SXM5(单颗 814 mm² GH100、132 SM、5+1 HBM3)上 FlashInfer-Bench 的 36 个
gqa_decode用例沿 132 SM 饱和线分裂为三个家族;Huawei Ascend 910C(双芯粒 48 AIC + 96 AIV、8× HBM2e)上 CANN-Bench v2.1 的 20 个flash_attention用例在单 AIV 核 192 KB 片上 UB 容量边界两侧形成硬断崖。 - 六步工程阶梯与连续路由:先锁死硬件物理尺子,再将四维画像、架构级特化内核与连续物理谓词路由拆为三个模块,并配合
ncu/msprof真机指标定位瓶颈,在不硬编码用例编号的前提下消除跨负载长尾退化。
单点最优的内核往往只赢在一张静态形状表里。跨负载的性能退化,本质上是硬件主导瓶颈在不同区域发生切换的结果。
1. The Single-Kernel Failure Mode#
在 LLM 推理与训练场景中,同一个算子经常面临跨度极大的输入分布。某个内核在中等批次形状上可以达到 88% 的 HBM 带宽利用率。然而,当它运行在包含单条短请求、高并发批处理与 128K 长上下文的完整测试集上时,整体几何平均加速比会显著下降。最差 20% 的长尾用例甚至慢于基线实现。
工程实践常把这种回落归因于调优轮数不足或分块网格过粗。只要把算子的理想执行时间写成三段式延迟下界,真正的原因就会清晰呈现。对任意输入负载 ,理想延迟下界 由发射地板 、带宽屋顶 与算力屋顶 共同决定:
这条下界把负载空间划分成三类互斥的优化目标。访存受限家族需要把有效 HBM 带宽逼近带宽屋顶 。算力受限家族需要把矩阵计算单元利用率逼近算力屋顶 。发射受限家族的数据搬运与计算耗时均低于数微秒,唯一有效路径是减少启动与同步次数,使总耗时逼近发射地板 。
单一参数化内核无法同时满足这三类目标。GPU 的寄存器分配与 Shared Memory 声明在编译期确定。同样地,Ascend NPU 的片上 Unified Buffer 缓冲深度也在编译期确定。如果把重流水线路径与轻量路径写进同一内核的分支里,最重路径的资源占用会降低所有轻量路径的驻留线程块数。
为此,跨负载算子优化系统由三个职责分离的角色协作完成。四维画像器根据输入形状与硬件上限提取瓶颈特征,并把测试集划分为物理同质的负载家族。分族内核集合为每个家族独立编译结构特化的实现。连续谓词路由器在运行时按张量维度与轻量统计量选择对应内核,保证调用入口与单算子一致。
2. Four Diagnostic Constraints#
划分负载家族之前,四维画像器先对算子、负载集合与硬件上限三元组执行结构化诊断。每个维度都对应一类确定的硬件性能退化机制,且可直接映射为后续内核的结构决策。
维度一:瓶颈类型。 四维画像器首先比较负载 的算术强度 与硬件拐点 。如果访存下界与算力下界均不大于两倍发射地板 ,该负载归入发射受限家族。否则,系统依据算术强度位于硬件拐点左侧或右侧,将其归入访存受限或算力受限家族。
维度二:核心占用与波次量化。 设网格总块数为 ,芯片计算核心数为 ,波次比定义为 。当波次比远小于 1 时,大部分核心处于空闲状态。当波次比略大于整数如 1.15 时,最后一个尾波仅使用 15% 的核心,却使端到端延迟接近翻倍。
维度三:负载分布偏度。 在变长序列注意力或稀疏专家路由中,不同线程块承担的计算量差异显著。全局同步延迟取决于耗时最长的单个线程块。当偏度比 超过 1.5 时,静态均分调度会导致大多数核心提前结束并空等长尾块。
维度四:静态维度与片上容量边界。 头维度 、地址对齐粒度与片上缓存上限构成硬性物理边界。NVIDIA H100 SXM5 的单个 SM 拥有 228 KB Shared Memory 与 256 KB 寄存器文件,对齐粒度为 16 字节。Huawei Ascend 910C 虽然通过双芯粒封装把总计算阵列扩大到 48 AIC + 96 AIV,但单个 Vector 核仍仅拥有 192 KB Unified Buffer(每 AIC 配 512 KB L1),且 MTE 搬运指令严格要求 32 字节对齐。分块工作集一旦越过上限,在 GPU 上会引发寄存器溢出与占用率骤降,在 Ascend 910C 上则会直接触发片上内存溢出错误。
3. H100 SXM5 vs. Ascend 910C Teardown & GQA Decode#
在进入算子分族前,必须先锁死两颗芯片的物理尺子。同一形状在不同硬件边界下会落入截然不同的家族:例如 B=2, L=64K 在 132 SM 的 H100 上严重欠饱和,而 D=256 在 228 KB SMEM 的 H100 上合法,在 192 KB UB 的 Ascend 910C 上却会直接溢出。下表并列两者的核心硬件边界与封装拓扑。
| Platform | Die Topology | BF16 Peak | HBM Capacity & BW | Compute Cores | On-Chip Limit | Launch / Align | |
|---|---|---|---|---|---|---|---|
NVIDIA H100 SXM5 (GH100) | Monolithic 814 mm² (CoWoS-S) | 989 TFLOPS | 80 GB (5+1 HBM3) · 3,350 GB/s | 8 GPC · 132 SMs | 228 KB SMEM/SM · 50 MB L2 | 295 | 4 µs · 16 B |
Huawei Ascend 910C (Da Vinci v2) | Dual-Die Chiplet (2.5D Bridge) | 800 TFLOPS | 128 GB (8× HBM2e) · 3,200 GB/s | 48 AIC + 96 AIV | 192 KB UB/AIV · 512 KB L1/AIC | 250 | 12 µs · 32 B |
下面可以通过可交互的三维芯片物理拆解视图,直接观察 H100 SXM5(单颗 GH100 主芯片、5 颗有效 + 1 颗熔断屏蔽的 5+1 HBM3、50 MB 分裂式 L2 交叉开关)与 Ascend 910C(双芯粒 2×[24 AIC + 48 AIV]、中央 Die-to-Die 硅桥、双 192 KB UB 脊柱与 8 颗 HBM2e)在不同负载家族下的硅片级行为差异。
ncu / msprof 真机诊断指标。
接下来我们拆解 NVIDIA H100 80GB SXM5 上 FlashInfer-Bench 的 36 个 gqa_decode 用例。
gqa_decode 用例如何沿 132 SM 饱和线与长序列轴分裂为三个家族。右图展示 Ascend 910C 上 CANN-Bench v2.1 的 20 个 flash_attention 用例如何在单 AIV 核 192 KB 片上 UB 容量边界两侧发生合法性与性能跳变。
考虑典型的分组查询注意力配置:查询头数 ,键值头数 ,分组比 ,头维度 ,数值精度为 BF16。对批次大小 与键值缓存长度 ,单步解码的访存字节数与浮点计算量满足如下关系:
将两式相除,可以得到 gqa_decode 的理论算术强度:
这一宏观算术强度远低于 H100 的硬件拐点 295。尽管如此,全部 36 个用例按批次大小 、缓存长度 与长度偏度仍分裂为三个互斥家族。
家族 F1:小批次短缓存,共 12 个用例。 该家族的批次大小 位于 1 到 8 之间,缓存长度 位于 128 到 1,024 之间。总访存量仅为 0.5 到 16 MB,理想带宽耗时在 0.15 到 4.8 微秒之间,与 4 微秒的发射地板处于同一量级。如果在此区域套用两阶段 Split-KV 内核,额外的一次归约内核发射和中间张量写回会使总延迟增加超过 20%。因此,F1 需要单遍融合内核,在一个线程块内打包整组 个查询头,省去切分缓冲与二次启动。
家族 F2:中大批次流式访存,共 12 个用例。 该家族的批次大小 位于 16 到 64 之间,缓存长度 位于 1,024 到 8,192 之间。基础线程块数 达到 128 到 512,自然覆盖 132 个 SM,波次比落在 1.0 到 3.9 的高效区间。在此区域继续切分序列会破坏 L2 缓存局部性并增加归约开销。因此,F2 需要单阶段多级异步流式内核,每次读取一个 KV 块就在寄存器内复用 次,把有效带宽推向 3,350 GB/s 上限。
家族 F3:小批次超长缓存与变长偏度,共 12 个用例。 该家族的批次大小 位于 1 到 8 之间,缓存长度 跨越 16K 到 128K,变长批次中的偏度比可达 2.4。如果不沿序列维切分,网格规模仅有 8 到 64 个线程块,超过一半的 SM 处于空闲状态。同时,最长的 128K 请求会阻塞整个批次的结束同步。因此,F3 采用两阶段动态 Split-KV 内核。第一阶段将每个长序列拆为多个并行块,使总块数对齐 132 个 SM。第二阶段再由数值稳定的 Log-Sum-Exp 归约内核合并局部结果。
4. Ascend 910C FlashAttention Case Study#
将目标平台切换为 Huawei Ascend 910C 双芯粒封装(每 Die 含 24 AIC + 48 AIV,整卡合计 48 AIC + 96 AIV、800 TFLOPS BF16 与 8 颗 HBM2e 合计 3,200 GB/s)后,CANN-Bench v2.1 的 20 个 flash_attention 用例呈现出截然不同的主导约束。Da Vinci v2 架构将矩阵计算单元 AIC 与向量计算单元 AIV 按 1:2 物理分离,中间数据须经由 MTE2 与 MTE3 搬运通道显式进出单 AIV 仅 192 KB 的 Unified Buffer。片上容量上限、32 字节对齐与双芯粒负载均衡因此成为首要分族依据。
家族 F1:短序列轻负载,共 7 个用例。 该家族的序列长度 位于 128 到 512 之间,批次大小 位于 1 到 4 之间。基础任务块数远低于双芯粒 48 AIC / 96 AIV 的满载规模,且 12 微秒的发射与管线冷启动开销占比偏高。大尺寸分块会加剧核心间与双 Die 间负载不均。因此,F1 采用小尺寸分块与单缓冲结构,在单次 UB 驻留循环内完成计算,并把尾部维度对齐到 32 字节。
家族 F2:UB 双缓冲 Ping-Pong 区间,共 7 个用例。 该家族的序列长度 位于 1,024 到 4,096 之间,头维度 为 128。在行分块 与列分块 的配置下,开启双缓冲 BUFFER_NUM = 2 时的单 AIV 片上工作集约为 148 KB,稳稳低于 192 KB 硬上限。此时 MTE2 数据预取、AIC 矩阵乘与 AIV 在线 Softmax 可以完全流水重叠,使算子进入算力受限区间并逼近双芯粒 800 TFLOPS BF16 算力屋顶。
家族 F3:192 KB UB 容量溢出悬崖,共 6 个用例。 该家族包含 8K 到 32K 的长序列或头维度 的大通道输入。如果沿用 F2 的双缓冲与 Bc = 64 模板,单核片上工作集飙升至约 256 KB,直接撞穿 192 KB UB 硬墙并触发编译或运行期的 UB_ALLOC_OVERFLOW 错误(如 Figure 2 中红色警报状态所示)。因此,F3 必须将模板切换为单缓冲 BUFFER_NUM = 1,收窄列分块至 Bc = 32 将工作集压回 112 KB 以内,同时沿序列维执行跨双 Die 的 Split-S 切分以打满 48 AIC / 96 AIV 与 8 颗 HBM2e 通道。
5. Specialized Family Kernels#
完成双平台的分布拆解后,我们为每个家族分别编写结构独立的内核。独立编译确保每个家族只保留自身必需的寄存器与片上缓存,避免重路径拖累轻路径。
5.1 H100 Triton Kernels#
首先实现面向 F1 与 F2 的单遍融合内核 gqa_decode_singlepass。同一个程序块一次性将同组的 个查询头载入寄存器,随后沿页表遍历 KV 缓存,使每页 HBM 数据被复用 次。编译器会按不同编译期参数将它分别特化为低寄存器占用的 F1 二进制与三级异步流水的 F2 二进制。
import triton
import triton.language as tl
@triton.jit
def gqa_decode_singlepass(
Q, K_cache, V_cache, PageTable, SeqLens, Out,
stride_qb, stride_qh, stride_qd,
stride_kp, stride_kh, stride_kl, stride_kd,
stride_pt_b, stride_pt_p,
sm_scale,
G: tl.constexpr, D: tl.constexpr,
PAGE_SIZE: tl.constexpr, BLOCK_N: tl.constexpr,
):
b = tl.program_id(0)
kv_h = tl.program_id(1)
seq_len = tl.load(SeqLens + b)
offs_g = tl.arange(0, G)
offs_d = tl.arange(0, D)
q_ptrs = Q + b * stride_qb + (kv_h * G + offs_g[:, None]) * stride_qh + offs_d[None, :] * stride_qd
q = tl.load(q_ptrs).to(tl.float32) * sm_scale
m_i = tl.full([G], -float("inf"), dtype=tl.float32)
l_i = tl.zeros([G], dtype=tl.float32)
acc = tl.zeros([G, D], dtype=tl.float32)
for start_n in range(0, seq_len, BLOCK_N):
offs_n = start_n + tl.arange(0, BLOCK_N)
mask_n = offs_n < seq_len
page_idx = tl.load(PageTable + b * stride_pt_b + (offs_n // PAGE_SIZE) * stride_pt_p, mask=mask_n, other=0)
page_off = offs_n % PAGE_SIZE
k = tl.load(K_cache + page_idx[:, None] * stride_kp + kv_h * stride_kh + page_off[:, None] * stride_kl + offs_d[None, :] * stride_kd, mask=mask_n[:, None], other=0.0).to(tl.float32)
v = tl.load(V_cache + page_idx[:, None] * stride_kp + kv_h * stride_kh + page_off[:, None] * stride_kl + offs_d[None, :] * stride_kd, mask=mask_n[:, None], other=0.0).to(tl.float32)
qk = tl.where(mask_n[None, :], tl.sum(q[:, None, :] * k[None, :, :], axis=2), -float("inf"))
m_new = tl.maximum(m_i, tl.max(qk, axis=1))
p = tl.exp(qk - m_new[:, None])
alpha = tl.exp(m_i - m_new)
l_i = l_i * alpha + tl.sum(p, axis=1)
acc = acc * alpha[:, None] + tl.sum(p[:, :, None] * v[None, :, :], axis=1)
m_i = m_new
out = (acc / l_i[:, None]).to(Out.dtype.element_ty)
tl.store(Out + b * stride_qb + (kv_h * G + offs_g[:, None]) * stride_qh + offs_d[None, :] * stride_qd, out)python针对 F3 的超长缓存与高偏度负载,我们编写两阶段 Split-KV 内核。第一阶段沿第三网格维切分 KV 序列,每个程序块只处理一段连续分片,并输出局部归一化结果与精确的 Log-Sum-Exp 标量。
@triton.jit
def gqa_decode_f3_splitkv_stage1(
Q, K_cache, V_cache, PageTable, SeqLens, MidOut, MidLSE,
stride_qb, stride_qh, stride_qd,
stride_kp, stride_kh, stride_kl, stride_kd,
stride_pt_b, stride_pt_p,
stride_mo_b, stride_mo_h, stride_mo_s, stride_mo_d,
stride_lse_b, stride_lse_h, stride_lse_s,
sm_scale, num_splits,
G: tl.constexpr, D: tl.constexpr,
PAGE_SIZE: tl.constexpr, BLOCK_N: tl.constexpr,
):
b = tl.program_id(0)
kv_h = tl.program_id(1)
s_id = tl.program_id(2)
seq_len = tl.load(SeqLens + b)
chunk = tl.cdiv(seq_len, num_splits)
kv_start = s_id * chunk
kv_end = tl.minimum(kv_start + chunk, seq_len)
offs_g = tl.arange(0, G)
offs_d = tl.arange(0, D)
if kv_start >= kv_end:
tl.store(MidLSE + b * stride_lse_b + (kv_h * G + offs_g) * stride_lse_h + s_id * stride_lse_s, -float("inf"))
return
q = tl.load(Q + b * stride_qb + (kv_h * G + offs_g[:, None]) * stride_qh + offs_d[None, :] * stride_qd).to(tl.float32) * sm_scale
m_i = tl.full([G], -float("inf"), dtype=tl.float32)
l_i = tl.zeros([G], dtype=tl.float32)
acc = tl.zeros([G, D], dtype=tl.float32)
for start_n in range(kv_start, kv_end, BLOCK_N):
offs_n = start_n + tl.arange(0, BLOCK_N)
mask_n = offs_n < kv_end
page_idx = tl.load(PageTable + b * stride_pt_b + (offs_n // PAGE_SIZE) * stride_pt_p, mask=mask_n, other=0)
page_off = offs_n % PAGE_SIZE
k = tl.load(K_cache + page_idx[:, None] * stride_kp + kv_h * stride_kh + page_off[:, None] * stride_kl + offs_d[None, :] * stride_kd, mask=mask_n[:, None], other=0.0).to(tl.float32)
v = tl.load(V_cache + page_idx[:, None] * stride_kp + kv_h * stride_kh + page_off[:, None] * stride_kl + offs_d[None, :] * stride_kd, mask=mask_n[:, None], other=0.0).to(tl.float32)
qk = tl.where(mask_n[None, :], tl.sum(q[:, None, :] * k[None, :, :], axis=2), -float("inf"))
m_new = tl.maximum(m_i, tl.max(qk, axis=1))
p = tl.exp(qk - m_new[:, None])
alpha = tl.exp(m_i - m_new)
l_i = l_i * alpha + tl.sum(p, axis=1)
acc = acc * alpha[:, None] + tl.sum(p[:, :, None] * v[None, :, :], axis=1)
m_i = m_new
lse = m_i + tl.log(l_i)
tl.store(MidOut + b * stride_mo_b + (kv_h * G + offs_g[:, None]) * stride_mo_h + s_id * stride_mo_s + offs_d[None, :] * stride_mo_d, acc / l_i[:, None])
tl.store(MidLSE + b * stride_lse_b + (kv_h * G + offs_g) * stride_lse_h + s_id * stride_lse_s, lse)python第二阶段内核 gqa_decode_f3_lse_combine 读取各分片的局部结果与 Log-Sum-Exp 标量,在全局最大值偏移下重新加权归一化并写回最终输出。
@triton.jit
def gqa_decode_f3_lse_combine(
MidOut, MidLSE, Out,
stride_mo_b, stride_mo_h, stride_mo_s, stride_mo_d,
stride_lse_b, stride_lse_h, stride_lse_s,
stride_ob, stride_oh, stride_od,
num_splits, MAX_SPLITS: tl.constexpr, D: tl.constexpr,
):
b = tl.program_id(0)
h = tl.program_id(1)
offs_s = tl.arange(0, MAX_SPLITS)
offs_d = tl.arange(0, D)
mask_s = offs_s < num_splits
lse = tl.load(MidLSE + b * stride_lse_b + h * stride_lse_h + offs_s * stride_lse_s, mask=mask_s, other=-float("inf"))
m_max = tl.max(lse, axis=0)
w = tl.where(mask_s, tl.exp(lse - m_max), 0.0)
w = w / tl.sum(w, axis=0)
mo = tl.load(MidOut + b * stride_mo_b + h * stride_mo_h + offs_s[:, None] * stride_mo_s + offs_d[None, :] * stride_mo_d, mask=mask_s[:, None], other=0.0)
out = tl.sum(w[:, None] * mo, axis=0).to(Out.dtype.element_ty)
tl.store(Out + b * stride_ob + h * stride_oh + offs_d * stride_od, out)python5.2 Ascend 910C Buffer Specialization#
在 Ascend 910C 上,我们通过编译期模板参数 BUFFER_NUM、BR 与 BC 隔离三个家族的单 AIV 片上资源占用。Host 端切分程序先核算单核片上字节数不超过 192 KB,并将任务块均匀映射到双芯粒的 48 AIC / 96 AIV,再按家族分发到对应实例化二进制。
template <int32_t BUFFER_NUM, int32_t BR, int32_t BC>
class FlashAttnGqaKernel {
public:
__aicore__ inline void Init(GM_ADDR q, GM_ADDR k, GM_ADDR v, GM_ADDR out, const FaTiling &t) {
// Enforce UB_bytes <= 192 KB and 32-byte alignment at host tiling time
pipe.InitBuffer(inQueK, BUFFER_NUM, BC * t.alignedD * sizeof(half));
pipe.InitBuffer(inQueV, BUFFER_NUM, BC * t.alignedD * sizeof(half));
pipe.InitBuffer(scoreBuf, BUFFER_NUM, BR * BC * sizeof(float));
pipe.InitBuffer(outQueO, 1, BR * t.alignedD * sizeof(half));
}
__aicore__ inline void Process(const FaTiling &t) {
for (int32_t pos = t.kvStart; pos < t.kvEnd; pos += BC) {
CopyInKV(pos); // MTE2: GM -> L1/UB (32B aligned)
ComputeScoreAndP(); // AIC Cube QK^T -> AIV Online Softmax
AccumulatePV(); // AIC Cube P*V -> AIV rescale
}
CopyOutO(); // MTE3: UB -> GM
}
private:
AscendC::TPipe pipe;
AscendC::TQue<AscendC::QuePosition::VECIN, BUFFER_NUM> inQueK, inQueV;
AscendC::TQue<AscendC::QuePosition::VECOUT, 1> outQueO;
AscendC::TBuf<AscendC::TPosition::VECCALC> scoreBuf;
};
// Independent binaries per family:
// F1 (Short-Seq): FlashAttnGqaKernel<1, 32, 64>
// F2 (UB Ping-Pong): FlashAttnGqaKernel<2, 64, 64>
// F3 (UB-Safe Long): FlashAttnGqaKernel<1, 32, 32>cpp6. Continuous-Predicate Dispatch#
最后一步是将独立编译的家族内核组装为统一入口。连续谓词路由器只读取输入张量维度、序列长度统计量与硬件常量,不引用任何测试集用例编号。同时,路由器必须保留一条经过全量校验的兜底分支,保证任意未见形状都能合法执行。
当估算访存耗时落入两倍发射地板且最大序列长度不超过 1,024 时,路由器调用轻量级 F1 内核。当波次比低于 0.75 且最大序列达到 4,096,或偏度比达到 1.6 时,路由器调用两阶段 F3 内核并按 SM 数量动态对齐切分数。其余高并发输入统一进入 F2 多级流式内核,该路径同时充当全量安全兜底。
import math
from dataclasses import dataclass
import torch
@dataclass(frozen=True)
class H100Specs:
num_sms: int = 132
hbm_bw_gbps: float = 3350.0
launch_floor_us: float = 4.0
def choose_wave_aligned_splits(B: int, H_kv: int, max_seq: int, num_sms: int = 132) -> int:
base_ctas = B * H_kv
if base_ctas >= num_sms:
return 1
target_splits = math.ceil(num_sms / base_ctas)
max_useful = max(1, max_seq // 512)
return max(1, min(16, target_splits, max_useful))
def gqa_decode_dispatch(
q: torch.Tensor,
k_cache: torch.Tensor,
v_cache: torch.Tensor,
page_table: torch.Tensor,
seq_lens: torch.Tensor,
hw: H100Specs = H100Specs(),
) -> torch.Tensor:
B, H_q, D = q.shape
_, H_kv, PAGE_SIZE, _ = k_cache.shape
G = H_q // H_kv
sm_scale = 1.0 / math.sqrt(D)
out = torch.empty_like(q)
# Continuous physical features only (no hardcoded workload IDs)
max_seq = int(seq_lens.max().item())
mean_seq = float(seq_lens.float().mean().item())
skew_ratio = max_seq / max(1.0, mean_seq)
wave_ratio = (B * H_kv) / hw.num_sms
est_bytes = 2.0 * B * H_kv * mean_seq * D * q.element_size()
est_bw_us = (est_bytes / (hw.hbm_bw_gbps * 1e9)) * 1e6
# Route F1: launch-bound single-pass kernel
if est_bw_us <= 2.0 * hw.launch_floor_us and max_seq <= 1024:
gqa_decode_singlepass[(B, H_kv)](
q, k_cache, v_cache, page_table, seq_lens, out,
*q.stride(), *k_cache.stride(), *page_table.stride(),
sm_scale, G=G, D=D, PAGE_SIZE=PAGE_SIZE, BLOCK_N=32,
num_warps=2, num_stages=1,
)
return out
# Route F3: wave-aligned Split-KV + LSE combine for long or skewed KV
if (wave_ratio < 0.75 and max_seq >= 4096) or (skew_ratio >= 1.6 and max_seq >= 2048):
num_splits = choose_wave_aligned_splits(B, H_kv, max_seq, hw.num_sms)
if num_splits > 1:
max_splits_pow2 = 1 << (num_splits - 1).bit_length()
mid_out = torch.empty((B, H_q, num_splits, D), device=q.device, dtype=torch.float32)
mid_lse = torch.empty((B, H_q, num_splits), device=q.device, dtype=torch.float32)
gqa_decode_f3_splitkv_stage1[(B, H_kv, num_splits)](
q, k_cache, v_cache, page_table, seq_lens, mid_out, mid_lse,
*q.stride(), *k_cache.stride(), *page_table.stride(),
*mid_out.stride(), *mid_lse.stride(),
sm_scale, num_splits, G=G, D=D, PAGE_SIZE=PAGE_SIZE, BLOCK_N=64,
num_warps=4, num_stages=2,
)
gqa_decode_f3_lse_combine[(B, H_q)](
mid_out, mid_lse, out,
*mid_out.stride(), *mid_lse.stride(), *out.stride(),
num_splits, MAX_SPLITS=max_splits_pow2, D=D,
num_warps=2,
)
return out
# Route F2 & verified safe fallback: pipelined streaming kernel
gqa_decode_singlepass[(B, H_kv)](
q, k_cache, v_cache, page_table, seq_lens, out,
*q.stride(), *k_cache.stride(), *page_table.stride(),
sm_scale, G=G, D=D, PAGE_SIZE=PAGE_SIZE, BLOCK_N=64,
num_warps=4, num_stages=3,
)
return outpython7. Engineering Ladder & Real-Hardware Diagnostics#
将上述分族方法落地到真实的 H100 SXM5 与 Ascend 910C 优化闭环时,工程迭代须遵循严格的六步阶梯——先锁死硬件物理尺子,再定宏观架构上限,最后才调 Tile 微参数:
- Step 0 锁死硬件物理边界:先明确核数、HBM 带宽、算力峰值、拐点 、SMEM/UB 上限、对齐粒度与发射地板。
- Step 1 四维画像与互斥分族:用物理尺子度量全部测试负载,按瓶颈类型、波次比、负载偏度与片上容量划出 F1 / F2 / F3。
- Step 2 架构与并行算法决策(决定 70%–80% 上限):决定网格切分(常规网格 vs Split-KV / Split-S)、单遍融合 vs 两阶段归约、片上复用与双缓冲深度。当仅有 16/132 个 SM 工作时,枚举任何
BLOCK_N与num_warps都跨不过 12% 的带宽天花板;调参连续停滞两轮即必须退回此步换架构。 - Step 3 最小合法基线(Feasibility First):优先核算 SMEM / UB 不超限、满足 16B / 32B 对齐与边界 mask,跑通编译与精度后存档。
- Step 4 Tile 与微架构调优(榨干最后 20%–30%):调节
BLOCK_M/N/K、num_warps、num_stages、向量化加载与 Swizzle 消除 Bank 冲突。 - Step 5 真机 Profile 验收与连续路由组装:对照下表读取
ncu/nsys或msprof硬件计数器,逼近 Roofline 即冻结当前家族内核并接入连续谓词路由器。
| Hardware Boundary | Bottleneck | NVIDIA H100 (ncu / nsys) | Ascend 910C (msprof) | Structural Fix |
|---|---|---|---|---|
| Core Saturation | SM / Core Starvation | sm__warps_active, launch__grid_size | blockDim vs 48 AIC / 96 AIV | Split-KV + LSE / Dual-Die Split-S |
| HBM Bandwidth | Memory-Bound | dram__throughput.avg.pct_of_peak | aic_mte2_ratio, hbm_read_bw | GQA reuse, 128b / 32B bursts |
| Matrix Compute | Compute-Bound | sm__pipe_tensor_cycles_active | aic_mac_ratio, aiv_vec_ratio | Align MMA tiles, Cube⇄Vector Ping-Pong |
| On-Chip SRAM | Capacity / Spill | launch__registers_per_thread, l1tex | ub_alloc_bytes ≤ 192 KB, mte2_wait | BUFFER_NUM=1 + Bc=32 (F3 Safe) |
| Launch Floor | Host Dispatch Gap | nsys kernel duration vs 4 µs floor | Task Wait Time vs 12 µs cold-start | Single-pass fused kernel (F1) |
8. Verification Plan#
后续实验将按三项正交指标验证跨负载分派的有效性。第一项在 H100 SXM5 的 36 个 gqa_decode 用例上比较单一内核与多家族分派,重点观测分家族加速比与最差 20% 尾部加速比。第二项在 Ascend 910C 的 20 个 flash_attention 用例上统计编译通过率、Roofline 达峰率与官方 HAP 综合分,验证双缓冲与单缓冲分族如何跨越 192 KB 的 UB 容量边界并在双芯粒间保持均衡。第三项测量 Host 端连续谓词路由开销,确认纯静态物理量判断在端到端延迟中的占比低于 1 微秒。
| Suite | Platform | Target Metrics | Baseline |
|---|---|---|---|
FlashInfer-Bench gqa_decode | NVIDIA H100 SXM5 | Geomean Speedup, Worst-20% Tail, %SoL | FlashInfer |
CANN-Bench v2.1 flash_attention | Huawei Ascend 910C | Pass Rate, %SoL, Official HAP | CANN-Ops |
| Dispatch Microbenchmark | H100 SXM5 & Ascend 910C | Host Routing Latency (µs) | Single Kernel |
Citation#
@article{zhang2026crossworkload,
author = {Jerry Zhang},
title = {Cross-Workload Kernel Dispatch},
journal = {jerry609 Research Notes},
year = {2026},
url = {https://jerry609.github.io/blog/cross-workload-kernel-roofline-outline}
}bibtex