Cross-Workload Kernel Dispatch

3D silicon teardown, 4D hardware diagnosis, per-family kernels, and continuous-predicate dispatch on NVIDIA H100 SXM5 and Huawei Ascend 910C.

PUBLISHED 2026-06-08 READ 28 MIN
目录 · 11 节
  1. 1 The Single-Kernel Failure Mode
  2. 2 Four Diagnostic Constraints
  3. 3 H100 SXM5 vs. Ascend 910C Teardown & GQA Decode
  4. 4 Ascend 910C FlashAttention Case Study
  5. 5 Specialized Family Kernels
  6. 5.1 H100 Triton Kernels
  7. 5.2 Ascend 910C Buffer Specialization
  8. 6 Continuous-Predicate Dispatch
  9. 7 Engineering Ladder & Real-Hardware Diagnostics
  10. 8 Verification Plan
  11. · Citation
Summary
  • 物理瓶颈随负载切换:同一算子跨越输入形状临界点后,主导延迟会在发射地板 τlaunch\tau_{\mathrm{launch}}、带宽屋顶 Peakbw\mathrm{Peak}_{\mathrm{bw}}、算力屋顶 Peakcomp\mathrm{Peak}_{\mathrm{comp}} 与片上容量边界之间迁移。
  • 双平台物理拆解与分布实证: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% 的长尾用例甚至慢于基线实现。

工程实践常把这种回落归因于调优轮数不足或分块网格过粗。只要把算子的理想执行时间写成三段式延迟下界,真正的原因就会清晰呈现。对任意输入负载 ww,理想延迟下界 Tideal(w)T_{\mathrm{ideal}}(w) 由发射地板 τlaunch\tau_{\mathrm{launch}}、带宽屋顶 Peakbw\mathrm{Peak}_{\mathrm{bw}} 与算力屋顶 Peakcomp\mathrm{Peak}_{\mathrm{comp}} 共同决定:

Tideal(w)=max⁡ ⁣(τlaunch,    Bytes(w)Peakbw,    FLOPs(w)Peakcomp)T_{\mathrm{ideal}}(w) = \max\!\left(\tau_{\mathrm{launch}},\;\; \frac{\mathrm{Bytes}(w)}{\mathrm{Peak}_{\mathrm{bw}}},\;\; \frac{\mathrm{FLOPs}(w)}{\mathrm{Peak}_{\mathrm{comp}}}\right)

这条下界把负载空间划分成三类互斥的优化目标。访存受限家族需要把有效 HBM 带宽逼近带宽屋顶 Peakbw\mathrm{Peak}_{\mathrm{bw}}。算力受限家族需要把矩阵计算单元利用率逼近算力屋顶 Peakcomp\mathrm{Peak}_{\mathrm{comp}}。发射受限家族的数据搬运与计算耗时均低于数微秒,唯一有效路径是减少启动与同步次数,使总耗时逼近发射地板 τlaunch\tau_{\mathrm{launch}}。

单一参数化内核无法同时满足这三类目标。GPU 的寄存器分配与 Shared Memory 声明在编译期确定。同样地,Ascend NPU 的片上 Unified Buffer 缓冲深度也在编译期确定。如果把重流水线路径与轻量路径写进同一内核的分支里,最重路径的资源占用会降低所有轻量路径的驻留线程块数。

为此,跨负载算子优化系统由三个职责分离的角色协作完成。四维画像器根据输入形状与硬件上限提取瓶颈特征,并把测试集划分为物理同质的负载家族。分族内核集合为每个家族独立编译结构特化的实现。连续谓词路由器在运行时按张量维度与轻量统计量选择对应内核,保证调用入口与单算子一致。

2. Four Diagnostic Constraints#

划分负载家族之前,四维画像器先对算子、负载集合与硬件上限三元组执行结构化诊断。每个维度都对应一类确定的硬件性能退化机制,且可直接映射为后续内核的结构决策。

01 瓶颈类型 · Bottleneck Regime
τlaunch Peakbw Peakcomp Launch Memory Compute
02 SM 占用与波次 · Wave Quantization
Wave 1 (100% SM) Wave 2 (Tail · 25% SM) Idle SMs · Tail Wave Overhead
03 负载分布偏度 · Load Skew
CTA 0 CTA 1 CTA 2 CTA 3 CTA 4 Barrier = max(CTA_i)
04 静态维度与片上边界 · On-Chip Cliff
SRAM / Reg Limit Reg Spill Occupancy Drop 4 CTAs/SM 2 CTAs Static Dim / Tile Size (BLOCK_M, BLOCK_K)
Figure 1: Four orthogonal diagnostic dimensions for operator analysis. 同一算子在跨负载运行时,会依次面对三区物理跃迁、SM 尾波空转、长尾负载偏度与片上容量断崖。这四个维度共同决定负载空间应当切分为哪些专门化内核家族。

维度一:瓶颈类型。 四维画像器首先比较负载 ww 的算术强度 AI(w)=FLOPs(w)/Bytes(w)\mathrm{AI}(w) = \mathrm{FLOPs}(w) / \mathrm{Bytes}(w) 与硬件拐点 Iridge=Peakcomp/PeakbwI_{\mathrm{ridge}} = \mathrm{Peak}_{\mathrm{comp}} / \mathrm{Peak}_{\mathrm{bw}}。如果访存下界与算力下界均不大于两倍发射地板 τlaunch\tau_{\mathrm{launch}},该负载归入发射受限家族。否则,系统依据算术强度位于硬件拐点左侧或右侧,将其归入访存受限或算力受限家族。

维度二:核心占用与波次量化。 设网格总块数为 NblocksN_{\mathrm{blocks}},芯片计算核心数为 NcoresN_{\mathrm{cores}},波次比定义为 wave_ratio=Nblocks/Ncores\mathrm{wave\_ratio} = N_{\mathrm{blocks}} / N_{\mathrm{cores}}。当波次比远小于 1 时,大部分核心处于空闲状态。当波次比略大于整数如 1.15 时,最后一个尾波仅使用 15% 的核心,却使端到端延迟接近翻倍。

维度三:负载分布偏度。 在变长序列注意力或稀疏专家路由中,不同线程块承担的计算量差异显著。全局同步延迟取决于耗时最长的单个线程块。当偏度比 skew_ratio=max⁡(Li)/mean(Li)\mathrm{skew\_ratio} = \max(L_i) / \mathrm{mean}(L_i) 超过 1.5 时,静态均分调度会导致大多数核心提前结束并空等长尾块。

维度四:静态维度与片上容量边界。 头维度 DD、地址对齐粒度与片上缓存上限构成硬性物理边界。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 上却会直接溢出。下表并列两者的核心硬件边界与封装拓扑。

PlatformDie TopologyBF16 PeakHBM Capacity & BWCompute CoresOn-Chip LimitIridgeI_{\mathrm{ridge}}Launch / Align
NVIDIA H100 SXM5 (GH100)Monolithic 814 mm² (CoWoS-S)989 TFLOPS80 GB (5+1 HBM3) · 3,350 GB/s8 GPC · 132 SMs228 KB SMEM/SM · 50 MB L22954 µs · 16 B
Huawei Ascend 910C (Da Vinci v2)Dual-Die Chiplet (2.5D Bridge)800 TFLOPS128 GB (8× HBM2e) · 3,200 GB/s48 AIC + 96 AIV192 KB UB/AIV · 512 KB L1/AIC25012 µ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)在不同负载家族下的硅片级行为差异。

REGIME DISPATCH
H100 SXM5 · 128 / 132 SMs ACTIVE · 2.86 / 3.35 TB/s
SM / CUBE HBM3 / HBM2E L2 / 192KB UB AIV / KV
DRAG TO ORBIT · SCROLL TO ZOOM · CLICK SILICON TO ISOLATE
SILICON TOPOLOGY Monolithic GH100 · 8 GPC / 132 SMs · 5+1 HBM3 (80 GB)
LIVE TELEMETRY 2.86 / 3.35 TB/s (85% SoL) · 128 / 132 SMs
PROFILER SIGNAL (ncu / nsys) ncu: dram__throughput 85.4% · sm__throughput 91% · +7.0× Speedup
KERNELBRIDGE DISPATCH Route F3: Split-KV Stage1 (S=8) + LSE Combine (wave_ratio → 0.97)
Figure 2: Interactive 3D silicon teardown of NVIDIA H100 SXM5 (GH100) and Huawei Ascend 910C (Dual-Die). 上方可实时切换 H100 SXM5(单颗 814 mm² GH100 主芯片、8 GPC / 132 SM、50 MB 分裂式 L2 交叉开关与 5 颗有效 + 1 颗熔断屏蔽的 5+1 HBM3 堆叠)与 Ascend 910C(双芯粒 2×[24 AIC + 48 AIV] = 48 AIC / 96 AIV、中央 Die-to-Die 硅桥、双 192 KB UB 脊柱与 8 颗 HBM2e 堆叠)。点击 F3 · Single-Kernel Fail 与 F3 · Dispatched Fix 可对比 H100 的 16/132 SM 饥饿 vs Split-KV+LSE 满载,以及 Ascend 910C 的 192 KB UB 溢出红警 vs 单缓冲双芯粒 Split-S 安全收敛。点击任意三维器件或下方层级按钮可隔离查看对应的 ncu / msprof 真机诊断指标。

接下来我们拆解 NVIDIA H100 80GB SXM5 上 FlashInfer-Bench 的 36 个 gqa_decode 用例。

H100 · FLASHINFER GQA Decode (36)
B·Hkv = 132 SMs F1 · Launch/Warp F2 · Stream Peakbw F3 · Split-KV + LSE 128 1K 16K 128K KV SeqLen L (log) 1 16 64 Batch B
ASCEND 910C · CANN v2.1 FlashAttn GQA (20)
192 KB UB Cliff (Buf=2) → F1 · Short F2 · Ping-Pong F3 · Buf=1 Split-S 256 1K 8K 32K Sequence Length S (log) 64 128 256 Head Dim D
Figure 3: Cross-platform workload distributions and physical partition boundaries. 左图展示 H100 SXM5 上 FlashInfer-Bench 的 36 个 gqa_decode 用例如何沿 132 SM 饱和线与长序列轴分裂为三个家族。右图展示 Ascend 910C 上 CANN-Bench v2.1 的 20 个 flash_attention 用例如何在单 AIV 核 192 KB 片上 UB 容量边界两侧发生合法性与性能跳变。

考虑典型的分组查询注意力配置:查询头数 Hq=32H_q = 32,键值头数 Hkv=8H_{kv} = 8,分组比 G=Hq/Hkv=4G = H_q / H_{kv} = 4,头维度 D=128D = 128,数值精度为 BF16。对批次大小 BB 与键值缓存长度 LL,单步解码的访存字节数与浮点计算量满足如下关系:

Bytes(B,L)≈2⋅B⋅Hkv⋅L⋅D⋅2  B,FLOPs(B,L)≈4⋅B⋅Hq⋅L⋅D\begin{aligned} \mathrm{Bytes}(B, L) &\approx 2 \cdot B \cdot H_{kv} \cdot L \cdot D \cdot 2\;\text{B}, \\ \mathrm{FLOPs}(B, L) &\approx 4 \cdot B \cdot H_q \cdot L \cdot D \end{aligned}

将两式相除,可以得到 gqa_decode 的理论算术强度:

AIGQA-decode≈G  FLOPs/ByteG=4⇒4–8  FLOPs/Byte≪IridgeH100=295\begin{aligned} \mathrm{AI}_{\mathrm{GQA\text{-}decode}} &\approx G\;\text{FLOPs/Byte} \\ G = 4 &\Rightarrow 4\text{–}8\;\text{FLOPs/Byte} \ll I_{\mathrm{ridge}}^{\mathrm{H100}} = 295 \end{aligned}

这一宏观算术强度远低于 H100 的硬件拐点 295。尽管如此,全部 36 个用例按批次大小 BB、缓存长度 LL 与长度偏度仍分裂为三个互斥家族。

家族 F1:小批次短缓存,共 12 个用例。 该家族的批次大小 BB 位于 1 到 8 之间,缓存长度 LL 位于 128 到 1,024 之间。总访存量仅为 0.5 到 16 MB,理想带宽耗时在 0.15 到 4.8 微秒之间,与 4 微秒的发射地板处于同一量级。如果在此区域套用两阶段 Split-KV 内核,额外的一次归约内核发射和中间张量写回会使总延迟增加超过 20%。因此,F1 需要单遍融合内核,在一个线程块内打包整组 GG 个查询头,省去切分缓冲与二次启动。

家族 F2:中大批次流式访存,共 12 个用例。 该家族的批次大小 BB 位于 16 到 64 之间,缓存长度 LL 位于 1,024 到 8,192 之间。基础线程块数 B⋅HkvB \cdot H_{kv} 达到 128 到 512,自然覆盖 132 个 SM,波次比落在 1.0 到 3.9 的高效区间。在此区域继续切分序列会破坏 L2 缓存局部性并增加归约开销。因此,F2 需要单阶段多级异步流式内核,每次读取一个 KV 块就在寄存器内复用 GG 次,把有效带宽推向 3,350 GB/s 上限。

家族 F3:小批次超长缓存与变长偏度,共 12 个用例。 该家族的批次大小 BB 位于 1 到 8 之间,缓存长度 LL 跨越 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 个用例。 该家族的序列长度 SS 位于 128 到 512 之间,批次大小 BB 位于 1 到 4 之间。基础任务块数远低于双芯粒 48 AIC / 96 AIV 的满载规模,且 12 微秒的发射与管线冷启动开销占比偏高。大尺寸分块会加剧核心间与双 Die 间负载不均。因此,F1 采用小尺寸分块与单缓冲结构,在单次 UB 驻留循环内完成计算,并把尾部维度对齐到 32 字节。

家族 F2:UB 双缓冲 Ping-Pong 区间,共 7 个用例。 该家族的序列长度 SS 位于 1,024 到 4,096 之间,头维度 DD 为 128。在行分块 Br=64B_r = 64 与列分块 Bc=64B_c = 64 的配置下,开启双缓冲 BUFFER_NUM = 2 时的单 AIV 片上工作集约为 148 KB,稳稳低于 192 KB 硬上限。此时 MTE2 数据预取、AIC 矩阵乘与 AIV 在线 Softmax 可以完全流水重叠,使算子进入算力受限区间并逼近双芯粒 800 TFLOPS BF16 算力屋顶。

家族 F3:192 KB UB 容量溢出悬崖,共 6 个用例。 该家族包含 8K 到 32K 的长序列或头维度 D=256D = 256 的大通道输入。如果沿用 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#

完成双平台的分布拆解后,我们为每个家族分别编写结构独立的内核。独立编译确保每个家族只保留自身必需的寄存器与片上缓存,避免重路径拖累轻路径。

INTERACTIVE DISPATCH · CLICK A WORKLOAD
ACTIVE ROUTE W1 (Decode B=16) → kernel_func1 (Vectorized Coalesced)
TARGET CEILING Peak_bw (有效带宽利用率 38% → 91%)
Figure 4: Multi-kernel routing onto the three-regime Roofline. 点击上方四类代表性负载,可以观察不同输入如何经由四维诊断路由至对应特化内核。绿色或彩色箭头标出性能从单一通用内核向带宽屋顶 Peakbw、算力屋顶 Peakcomp 或发射地板 τlaunch 的跃升方向。

5.1 H100 Triton Kernels#

首先实现面向 F1 与 F2 的单遍融合内核 gqa_decode_singlepass。同一个程序块一次性将同组的 GG 个查询头载入寄存器,随后沿页表遍历 KV 缓存,使每页 HBM 数据被复用 GG 次。编译器会按不同编译期参数将它分别特化为低寄存器占用的 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)
python

5.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>
cpp

6. 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 out
python

7. Engineering Ladder & Real-Hardware Diagnostics#

将上述分族方法落地到真实的 H100 SXM5 与 Ascend 910C 优化闭环时,工程迭代须遵循严格的六步阶梯——先锁死硬件物理尺子,再定宏观架构上限,最后才调 Tile 微参数:

  1. Step 0 锁死硬件物理边界:先明确核数、HBM 带宽、算力峰值、拐点 IridgeI_{\mathrm{ridge}}、SMEM/UB 上限、对齐粒度与发射地板。
  2. Step 1 四维画像与互斥分族:用物理尺子度量全部测试负载,按瓶颈类型、波次比、负载偏度与片上容量划出 F1 / F2 / F3。
  3. Step 2 架构与并行算法决策(决定 70%–80% 上限):决定网格切分(常规网格 vs Split-KV / Split-S)、单遍融合 vs 两阶段归约、片上复用与双缓冲深度。当仅有 16/132 个 SM 工作时,枚举任何 BLOCK_N 与 num_warps 都跨不过 12% 的带宽天花板;调参连续停滞两轮即必须退回此步换架构。
  4. Step 3 最小合法基线(Feasibility First):优先核算 SMEM / UB 不超限、满足 16B / 32B 对齐与边界 mask,跑通编译与精度后存档。
  5. Step 4 Tile 与微架构调优(榨干最后 20%–30%):调节 BLOCK_M/N/K、num_warps、num_stages、向量化加载与 Swizzle 消除 Bank 冲突。
  6. Step 5 真机 Profile 验收与连续路由组装:对照下表读取 ncu / nsys 或 msprof 硬件计数器,逼近 Roofline 即冻结当前家族内核并接入连续谓词路由器。
Hardware BoundaryBottleneckNVIDIA H100 (ncu / nsys)Ascend 910C (msprof)Structural Fix
Core SaturationSM / Core Starvationsm__warps_active, launch__grid_sizeblockDim vs 48 AIC / 96 AIVSplit-KV + LSE / Dual-Die Split-S
HBM BandwidthMemory-Bounddram__throughput.avg.pct_of_peakaic_mte2_ratio, hbm_read_bwGQA G×G\times reuse, 128b / 32B bursts
Matrix ComputeCompute-Boundsm__pipe_tensor_cycles_activeaic_mac_ratio, aiv_vec_ratioAlign MMA tiles, Cube⇄Vector Ping-Pong
On-Chip SRAMCapacity / Spilllaunch__registers_per_thread, l1texub_alloc_bytes ≤ 192 KB, mte2_waitBUFFER_NUM=1 + Bc=32 (F3 Safe)
Launch FloorHost Dispatch Gapnsys kernel duration vs 4 µs floorTask Wait Time vs 12 µs cold-startSingle-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 微秒。

SuitePlatformTarget MetricsBaseline
FlashInfer-Bench gqa_decodeNVIDIA H100 SXM5Geomean Speedup, Worst-20% Tail, %SoLFlashInfer
CANN-Bench v2.1 flash_attentionHuawei Ascend 910CPass Rate, %SoL, Official HAPCANN-Ops
Dispatch MicrobenchmarkH100 SXM5 & Ascend 910CHost 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

gqa flashinfer cann-bench roofline h100 ascend-910c teardown triton

Read next