‹ 返回博客本页内容

在本文中,我们解释为什么 SGLang(以及整个 ML 基础设施)正在转向更大的 GPU 内核,称为 megakernel,以及它与普通内核的区别。我们为 Muse Spark Open从零开始用 CUDA C++ 和 PTX 构建了一个,在 Blackwell GPU 上把解码速度从 517 → 1,109 tok/s 。

目标是让 GPU 的每个部分都保持忙碌。即使使用投机解码,我们的基线也只能达到 517 tok/s。我们的 megakernel 通过将每一层(attention + MoE)作为单个内核运行,并采用极致的延迟隐藏,使每次内存加载都与其他工作重叠,从而实现了 1,109 tok/s。

Decode tokens per second, one request at a time: baseline 517, megakernel 1,109, 2.1 times as fast

Muse Spark Open 在八块 GB300 上。GSM8K

目录

首先,什么是 megakernel?

普通 GPU 内核只做一件事。 它运行一个操作,比如一次矩阵乘法或一次 attention 计算,作为一个由相同线程块组成的网格,运行在不同的核心(SM)上。服务引擎将模型作为这样一串内核来运行:对于 Muse Spark Open 的每个解码步骤,SGLang 会启动大约 1,450 个内核。如果没有正确优化,GPU 会在两个连续内核之间排空并重新填充。在这段时间里,许多 SM 可能处于空闲状态。而当我们观察一个 SM 内部时,许多线程/warp 也可能处于空闲状态。为了实现完整的内存带宽,我们还必须 充分 利用 GPU 的所有部分。这要求我们设计硬件原生的算法,以实现比传统 ML 框架通常允许的更细粒度的重叠。

CPU 在 1960 年代就遇到过这个问题。 早期机器运行 批处理作业:一个作业独占整台机器,当它等待磁带或磁盘时,处理器就闲置着。 多道程序设计 通过同时在内存中保留多个作业,并在当前作业等待 I/O 时运行另一个作业,解决了这个问题。操作系统由此发展,原生支持多道程序设计——使其更快、更易用。

CPUs went from batch jobs to multiprogramming to operating systems; GPUs went from one kernel per operation to megakernels

图 1. CPU 编程的演进,以及 GPU 所处的位置

megakernel 就是 GPU 的多线程/多道程序设计。 megakernel 通过一个单一内核来解决这个问题,该内核驻留在每个 SM 上并同时运行许多不同的作业:一些 warp 可以在前一个操作完全结束之前就提前运行后续操作。GPU 有许多可以同时工作的引擎,其中包括张量核心、批量复制引擎(TMA)、加载单元和 NVLink,而 megakernel 的任务就是让它们全部保持忙碌。它已经具备了操作系统的第一批组件:

操作系统megakernel
一个进程一个内核,在完成之前持有所有 GPU 资源
线程warp,每个阶段分配一个作业;无抢占
等待 I/O忙等待数据被写入
DMA由 mbarrier 跟踪的 TMA 批量复制
进程间消息通过 NVLink 直接存储到另一个 GPU 的内存
性能分析器内核记录自己的时间戳

模型

Muse Spark Open 是一个传统的 MoE 模型,每个 token 被路由到 256 个专家中的 8 个。专家以 4 位 NVFP4 存储(某些层为 bf16)。它有 62 个解码层:46 层对最后 2,048 个 token 使用滑动窗口 attention,16 层使用全局 attention。此外,我们还有 pooler 和 unpooler 块。 Pooler 是一个投影,在专家之前缩小每个 token 的向量,而 unpooler 在之后将其恢复。我们通过张量并行(TP8)将模型拆分到八块 GPU 上,因此每块 GPU 持有每一层的一个切片。

One decoder layer in six steps, with five numbered stops where it waits for the other GPUs; the expert steps are marked as known only after the router runs

图 2. 八块 GPU 上的一个解码层,以及我们内核的一次启动所覆盖的范围:从该层的 attention 到下一层的 qkv 投影和 KV 写入。在每个编号的停靠点,每块 GPU 都要等待来自所有其他 GPU 的数据。

每个停靠点持续到最慢的 GPU 到达为止。即使我们完美地分配工作,GPU 之间也可能最多相差 4 µs。

一种新的张量并行

The expert GEMMs across eight GPUs: vanilla TP splits GEMM 1 on N and GEMM 2 on K and ends with one bf16 all-reduce; ours splits both on N, with an fp4 all-gather after GEMM 1 and a bf16 all-gather after GEMM 2

这里在 MoE GEMM 之间有一个额外的通信步骤,这在普通 TP 实现中是没有的。EP 是运行推理的标准方式,但由于不均衡,GPU 上激活的专家数量可能差异很大。两个 MoE GEMM 的权重都在 N 维度上分片,导致每个 GEMM 之后进行一次 all-gather。与普通 TP 相比,这是一个额外的通信步骤,普通 TP 在中间维度上对两个 GEMM 进行分片,导致一次 all-reduce

尽管多了一个通信步骤,这种设计的通信量比普通 TP 更少,并且能更好地扩展到更大的批次大小。它还可以实现与 EP 逐位相同,以匹配训练数值。

Megakernel

每层一次启动

代码位于 facebookresearch/sgl-muse-mega我们的内核每次启动都从某一层的 attention 运行到下一层的 qkv 投影和 KV 写入,即图 2 中的括号部分。这也是最好的起点:attention 读取的大部分内容——KV 历史——都是在更早的步骤中写入的,不依赖任何东西,因此新的启动可以在它一落地时就开始加载,而无需等待上一层的输出就绪。

当然,第一层和最后一层的算子略有不同。一个内核在 144 个 SM 上各放置一个由十二个 warp 组成的线程块(它们以四个为一组启动,并在适用时利用分布式共享内存来降低延迟归约开销)。在内核内部,每个 warp 针对自己等待的数据自行同步,并继续工作。后文我们还会解释为什么止步于每层一个内核,而没有采用覆盖整个模型的 megakernel。

十二个 warp,各司其职

warpattention稠密 GEMM专家 GEMMall-reduce、all-gather
0KV 加载权重加载权重加载下一算子权重加载
1KV 加载激活加载张量核心
2张量核心张量核心缩放因子
3指令缓存预热发送
4-7attention、合并epilogue、发送SwiGLU接收、求和 / 归一化
8-11attention、合并SwiGLU接收、求和 / 归一化

Attention 与全局层的张量核心路径相同;在滑动窗口层中,warp 4-11 各自加载自己的 KV。稠密 GEMM 包括 out-projection、pooler、router、unpooler 以及下一层的 qkv。

性能

One decode step: baseline takes 12.9 ms (draft 1.16, verify 10.9) with 1,450 kernels; Megakernel takes 5.9 ms (draft 0.44, verify 5.3) with 97 kernels

TP8 下单个 GSM8K 请求 20 步的中位数。

投机解码

Muse Spark Open 使用 DFlash V2 作为草稿模型。每一步中,草稿模型一次猜测接下来的 15 个 token,大模型则一次对 16 个 token 进行校验。我们还会校验由草稿模型生成的 token 树,而非线性链,效果略好。

小米 突破了每秒 1,000 个 token ,凭借 MiMo-V2.5-Pro ,每步校验 8 个 token,平均接受 6.3 个。我们校验 16 个,接受 6.6 个。校验 16 个 token 的成本更高,因为它们会激活更多专家,但我们发现用 16 个 token 达到这一接受长度比用 8 个更实用。

每步校验的 token 数接受长度
MiMo-V2.5-Pro(小米)86.3
Muse Spark Open(我们的)166.6

Megakernel 内部

我们的代码针对大模型包含 8000 行 CUDA + PTX。下面介绍我们在开发过程中发现的一些关键思路。

1. 在所有缓存中预取权重

权重从不依赖上一层。Warp 0 可以在当前算子尚未完成时就去读取下一算子的权重。这是确保我们获得高内存带宽利用率的关键——始终有在途的内存加载。对于把这些权重放在哪里,我们有几种选择:共享内存、L2 缓存,或两者兼用!

Three places a prefetched weight can wait: straight into the shared-memory ring while the current op runs; into L2 for what does not fit, like the speculatively prefetched experts; or both, with the ring refilling from L2 instead of HBM

共享内存

一旦 warp 0 完成当前算子权重的加载,它就可以在其余 warp 使用这些权重的期间保持空闲。在这段时间里,我们可以开始加载下一算子的权重——例如,在 attention 仍在运行时,四分之一的 o_proj 权重就已经被加载到共享内存中!

放入 L2,用于放不下的部分

另一种选择是把这些权重加载到 L2 缓存中。两者在容量上差别很大:环形缓冲区每 SM 容纳 5 × 32 KB 的权重,整个 GPU 约 23 MB,而 GB300 的 L2 约容纳 135 MB。但 L2 中的任何内容仍然需要第二次、短得多的搬运进入共享内存,而且 L2 还要与所有其他在途内容共享。它们也可以叠加使用。在一层接近尾声时,环形缓冲区已经持有下一层 qkv 权重的前一部分,但 qkv 投影必须等到该层最后的归一化产生其输入后才能开始。因此,就在 warp 1 等待归一化之前,它向 L2 请求其余的 qkv 权重;当归一化结果到达时,环形缓冲区从 L2 而非 HBM 重新填充。权重流本身以 evict-first 缓存提示加载,因此它们穿过 L2 时不会挤掉必须保留的内容。

投机式专家预取

并非所有专家都会被加载,因此无法在 router 运行之前预取它们。专家占我们加载字节的大部分,所以加载更多专家可能代价高昂。但正如关于专家卸载的研究所观察到的,连续步骤的路由往往相似。因此,在 attention 运行期间,warp 3 会查找该层在上一步使用了哪些专家,并把最常用的 14 个专家在本 GPU 上的切片拉入 L2,每 GPU 约 50 MB。router 的表一落地,每个块在读取表的同时也会把自己的第一个专家 tile 预取到 L2,而已经在 L2 中的专家会排在专家 GEMM 的 tile 列表前面,这样拿到第二个 tile 的块就能更早到达它。猜错会消耗一些带宽,但 GPU 反正是空闲的,而且这能在 5.3 ms 的步进时间中节省约 0.2 ms。

2. 指令缓存——大内核的诅咒!

更大的内核并不总是更好。随着内核变大,会出现一种有趣的开销。 我们做了一个简单实验:把两个内核的代码背靠背拼接起来,不加任何额外的同步,看看结果性能是否确实是两者之和。

并非如此。我们写了两段 100 KB 的直线代码。单独反复运行时,每段耗时 12.4 µs;背靠背拼接后,每段耗时 19.5 µs,每一对都比两者之和多出 14 µs。

我们首先怀疑的是 寄存器溢出. ptxas 往往无法在不同代码段中最佳地复用寄存器,导致寄存器溢出和性能下降。对此没有简单的解决办法——只能手动重写部分代码,寄希望于编译器更喜欢某个版本。但在本例中,我们没有发现寄存器溢出——根本原因完全是另一回事——指令缓存!

Two blocks of code run back to back: 20 KB + 100 KB fit in an SM's instruction cache of about 128 KB, and the 100 KB block runs at its solo 12.4 µs; 100 KB + 100 KB do not fit, and every pass takes 19.5 µs

图 3。 GB300 上每轮的耗时中位数,每个 SM 运行相同的块。当两个块能一起放入指令缓存时,100 KB 的块以其单独运行时的速度运行。

大小很重要

我们发现,把其中一个块缩小到 20 KB 后,100 KB 的块又恢复到了单独运行时的速度。一个 SM 只缓存约 128 KB 的指令,因此两个 100 KB 的块会不断互相逐出,每一轮都要重新取回自己的代码。

我们的内核远比那个缓存大:每个内核有215-314 KB的机器码,因为每个内核都包含一层的所有阶段。GPU通过和数据相同的L2缓存来取指令,而一次启动只会把内核代码的前32-64 KB带到SM附近。窗口之外的一切都在首次使用时逐行取回:如果还在L2中,代价很低;如果必须从内存取,就很慢。而且L2在两次启动之间只保留我们代码的一部分。放任不管的话,一个滑动窗口内核在两次运行之间会从L2中丢失约十分之一的代码;而全局注意力内核只在大约每四层运行一次,丢失的代码超过一半。主要元凶是我们自己的专家预取,也就是那条必须留在L2中的流。在没有任何东西保护代码的情况下,预取是净损失:关掉它反而让步进更快。

首先,少运行一些代码

在小内核中,展开循环是免费的;在我们的内核中,每一份展开的副本都是窗口之外的更多代码。因此,不携带逐元素寄存器状态的循环保持不展开。不展开的循环发出相同的副本并以相同的顺序等待,所以输出逐位相同,而且如果我们展开某些循环,代码会缩小约50KB。

然后,每次启动都把我们的代码当作数据来读

每次启动开始时,少数块中的一个warp会从内核代码的每128字节行中读取一个字,从而把整个内核拉入L2。一个缓存提示要求L2把每一行保留在其周围数据之前:

// simplified version of code warming logic
for (unsigned line = lane; line < code.bytes / 128; line += 32)
    sink ^= load_evict_last(code.base + line * 128);   // one word per 128-byte line

读取者是分散在少数几个SM中的一个warp。每个读取者都读取全部代码;把它们分摊给多个读取者反而更慢,因为 GB300的两个裸片 各自在L2中保留自己的副本。我们每次启动都预热,而不是每步只预热一次,因为代码在L2中连一步都撑不过去。

对必须快的代码做试运行

对于某些延迟受限的情况,L2离SM仍然太远。有些短代码段正好位于关键路径上:几个warp等待数据,然后必须快速完成。这些warp把它们的循环运行两次:第一次是在数据仍在到达时做一次 试运行 ,使用相同的指令和加载,但没有等待也没有输出;然后从SM的指令缓存中真正运行。GEMM 1的收尾、专家输出的合并以及每层末尾的归一化都这样开始。我们更愿意精确预取这些指令,但我们几乎无法控制 ptxas 如何排布机器码,也无法控制源代码的哪些部分最终相邻。试运行恰好触及真正运行会执行的代码行。

// simplified: the norm at the end of a layer, on the warps that wait for its row
#pragma unroll 1                        // one copy of the code, run twice: unrolled, the dry pass would warm a copy
for (int pass = 0; pass < 2; ++pass) {  //   the real pass never runs
    const bool dry = pass == 0;
    if (!dry) wait_until_ready(row);    // the dry pass runs while the row is still landing
    float4 x = load(row, lane);         // the same loads and math on both passes
    float4 y = rms_norm(x, weight);
    if (!dry) { store(out, y); publish(out_ready); }  // only the real pass writes and signals
}

在少数情况下,这能为每次这样的操作节省0.5-1 µs。

3. 多种线程同步方式

一个megakernel一生中大部分时间都在等待同一块或另一块GPU上的另一个线程仍在产生的数据。让我们看看跨线程同步数据依赖的不同方式:

Where threads meet to synchronize: two warps in the same SM wait on an mbarrier in shared memory; warps on two SMs of one GPU meet at a flag in HBM, polled; a warp on another GPU stores over NVLink straight into this GPU's HBM, where the reader polls for the data

SM内部:mbarrier

mbarrier是共享内存中的硬件计数器。TMA拷贝在字节到达时向其报告,等待它的warp由硬件挂起而不是自旋,而一个集群的四个块可以通过分布式共享内存互相通知对方的mbarrier。我们的共享内存加载和SM内部的交接都运行在mbarrier上。

其他地方:忙等待

对于由同一GPU上其他SM的线程写入的数据,或由另一块GPU通过NVLink写入的数据,硬件中没有任何可等待的东西:没有中断,没有等待地址。warp必须轮询,一遍又一遍地加载一个标志直到它改变,而每次轮询都有代价。在我们的微基准测试中,一次GPU作用域的acquire轮询耗时141-145 ns,同一节点内两块GPU之间的单向标志大约需要1.9 µs,而当其SM正在流式传输权重时,轮询的加载会在批量拷贝后面排队1.0-2.6 µs。自旋的warp还会从做有用工作的warp那里占用发射槽和内存请求。忙等待并不理想,但这是硬件给我们的全部。

内存栅栏

GPU之间教科书式的交接是:写入数据,发出一个 内存栅栏,然后设置一个标志;读取者轮询该标志,然后读取数据。在GB300上,我们尝试的每一种系统作用域release(fence.release.sys, fence.acq_rel.sys 或一个 st.release.sys 标志)都编译成同一个重量级屏障, MEMBAR.ALL.SYS。即便是范围更窄的GPU级栅栏,在空闲SM上也要0.4 µs,而当SM有批量(TMA)加载在途时需要3.6-4.0 µs,因为它要等待那些加载落地。我们一直处于这种情况:专家GEMM在同一个SM仍在加载该GEMM的权重时,就逐tile把结果发送给其他GPU,而每一个这样的栅栏大约耗时3.6 µs,在每一层的两次专家交换(第3和第4个停靠点)中都是如此。

Fence-free data synchronization: with a weight stream in flight, the fence before the flag takes 3.6-4.0 µs; when the data is its own flag, the reader starts as soon as the data lands

无栅栏:让数据成为自己的标志

用某个表示“空”且生产者从不写入的值填充接收缓冲区。生产者直接把数据存入读取者的缓冲区,没有栅栏也没有标志,读取者轮询直到没有槽位为空。这就是TensorRT-LLM和FlashInfer的Lamport式all-reduce背后的技巧,我们把它用于层内每一次跨GPU交接。在bf16 gather中,“空”是全位为1(FFFF),这是一个舍入永远不会产生的NaN:

Four slots of a receive buffer: all empty before any store; two values landed and the reader keeps polling; all four landed and the reader goes

每种数据选择自己的“空”:例如all-reduce使用+0,并把真正的+0写成−0,后者位不同但值相同。

复用缓冲区仍然需要栅栏,但每层只需要一个,且不在关键路径上。专家交换的缓冲区有两份副本,逐层交替:空闲副本在使用另一份时被重置为“空”。其余交接的槽位由读取者在使用后立即重置。

4. 更快的起草

通过激进融合,起草模型变得 快了2.6倍,从每步1.16 ms降到仅440 us。SGLang把起草作为175个内核运行。使用类似的megakernel栈,我们把起草的五层各作为一次启动运行,就像验证层一样:它的注意力、投影、MLP和allreduce。这样,我们有8次启动而不是175次。此外,我们把起草和验证模型放在同一个CUDA图中,消除了任何主机开销,并让一切都在GPU上运行!

性能分析

对 Nsight Systems 或 PyTorch profiler 来说,我们的内核在每一层就是一根长条,因此它自己给自己计时。在每个作业的开始和结束时,warp 的 lane 0 读取 GPU 的纳秒时钟,并把它存进自己的一个槽位:一次普通存储,没有原子操作,没有同步。

// storing timestamps of different events in stamp array
__device__ __forceinline__ uint64_t now() {
    uint64_t t;
    asm volatile("mov.u64 %0, %%globaltimer;" : "=l"(t) :: "memory");
    return t;
}
#define STAMP(event) if (lane_id() == 0) stamps[blockIdx.x * 256 + (event)] = now()

STAMP(kGemmBegin);
expert_gemm(...);
STAMP(kGemmEnd);

打时间戳的开销是 2.8%。 这些时间戳为每次层启动增加约 2.5 µs,占一步的 2.8%,并且让输出保持逐位相同;一个构建标志可以把它们编译掉。

完美重叠

图 4 展示了我们的 megakernel,每个算子一行。只要某个线程能运行它,一切就立刻开始

Measured timeline of one sliding-window layer, one row per operation: every operation's loads go out ahead of it, inside the waits, and GEMM 2 starts on some blocks while GEMM 1 still runs on others

图 4. 在我们的基准测试中,4,096 token 上下文下,我们的滑动窗口层逐算子展开。每根条是运行该算子的各块的中位数(当并非全部 144 个块都运行时,括号中给出其数量),即 45 个带 NVFP4 专家的滑动窗口层、一次验证 pass 的 19 次重放和两块 GPU,合成路由设为我们在 GSM8K 上测得的每层 49 个专家。蓝色标记的是加载被发出的时刻,而不是它们落地的时刻。淡色条标记的是只在部分块上运行的算子:GEMM 1 延伸到其最慢的十分之一,GEMM 2 从其最早的十分之一开始;淡蓝色表示下一层的旧 KV 在 L2 中等待,直到其注意力读取它。

  • 加载提前发出。 注意力在该层的输入到达之前就开始加载旧的 KV 行。在它旁边,可能的专家从 0.7 到 15 µs 流入 L2,贯穿停靠点 1 的大约一半时间,而路由器和池化器在停靠点 1 的数据到达前约 7 µs 发出它们的权重。在停靠点 4 附近,反池化器的权重、下一层的第一批 qkv 权重及其旧 KV 行被发出。
  • GEMM 2 在 GEMM 1 结束前就开始。 提前完成 GEMM 1 的块在约 45 µs 时发出它们的第一个 GEMM 2 权重 tile,早于停靠点 3 的数据到达,因此专家权重从一个块从 GEMM 1 流入 GEMM 2。最早的十分之一的块在 47 µs 开始 GEMM 2,而最慢的十分之一的块直到 50 µs 仍在运行 GEMM 1 的张量核心。
  • GEMM 2 和合并之后的空隙。 各块在 55 到 64 µs 之间的任意时刻完成 GEMM 2(第 10 到第 90 百分位),而合并要等待来自每块 GPU 的 GEMM 2 输出,因此它在 65 µs 开始;反池化器随后等待每块 GPU 的合并。从 GEMM 2 到该层结束,时间戳显示一个块平均约有 12.5 µs 没有工作,几乎占其全部空闲时间的一半。这条链就是我们接下来要研究的地方。
  • 下一层的注意力无法更早开始。 PDL 在 79 µs 启动下一层,比我们的第一个块退出早约 4 µs,但它的块只有在我们的块离开其 SM 之后才落地,即 84 µs,所以更早启动它不会让任何东西更早开始。相反,我们在 65 µs 把它的旧 KV 行预取进 L2,让它们在那里等待其注意力。

接下来要做什么

更大的批次

目前,megakernel 只支持 batch size 为 1 的投机解码。我们接下来会把 megakernel 扩展到更大的批次。更大的批次让问题更容易:有更多 token 在途时,前一个算子的一部分输出已经就绪,而其余输出仍在到达,因此 warp 可以立即开始处理那些就绪的部分,而不必在每个停靠点等待。只有一个请求时,每一次等待都暴露在外;请求更多时,几乎总有就绪的工作。

迈向 GPU 的操作系统

我们的 megakernel 仍是一个粗糙的操作系统:就像 IBM 的 OS/360 MFT,“固定任务数的多道程序设计”,它在每个阶段给每个 warp 分配一个固定的作业,在编译时选定。更一般的形式是 GPU 上的虚拟机:每个算子的代码按 warp 编写,每次交接由计数器跟踪,以及一个调度器,把任何就绪的工作交给任何空闲的 warp。 Flapping Airplanes 描述了这样一台机器:一个虚拟机“接管 GPU 并在其上调度不同的工作负载”,把整个训练运行放进一个内核里。它所需的大部分东西已经在我们的内核里:每个算子的按 warp 代码、GPU 内部交接的计数器,以及跨 GPU 作为自身标志的数据。剩下的一步是在运行时而非编译时决定哪个 warp 运行什么。

然而,在极端低延迟的设置下(一个请求),没有哪一种重叠策略能处处奏效。一个权重是进入共享内存、进入 L2 还是两者都进,它提前多远以及用哪个缓存提示:我们逐个算子自行决定,通过尝试多个版本并保留测得最快的那个。通用调度器必须为这些逐算子的选择留出空间,而编码智能体已经擅长探索这个搜索空间。