Last year we built megakernels. This year we deleted them: The road to Together Compiler
TL;DR · AI 摘要
Together AI 通过删除 megakernels 并采用新方法,实现了接近甚至超越原有性能的推理优化框架 Together Compiler。
核心要点
- 使用 CUDA Graphs 和 PDL 可恢复 98% 的 megakernel 性能,无需编写任何内核。
- 通过 multi-kernels 和 agent loops,性能可提升至原有 megakernels 的 1.7 倍。
- Together Compiler 是一个持续优化 AI 推理的框架,基于对现有编译器的深入研究和实验。
结构提纲
按章节快速跳转。
- §引言
AI 推理的异构性增加,需要更高效的优化框架来实现高性能。
Torch Compile 通过 Inductor 优化操作融合,但仍有性能差距。
Megakernels 虽然性能高,但难以扩展和生产化。
基于 agent 驱动的优化基础设施,构建了 Together Compiler。
思维导图
用一张图看清主题之间的关系。
查看大纲文本(无障碍 / 无 JS 友好)
- Together Compiler 的构建
- 背景与挑战
- AI 推理的异构性
- 性能优化需求
- 方法与工具
- Torch Compile
- CUDA Graphs
- PDL
- multi-kernels
- agent loops
- 成果与影响
- 98% 性能恢复
- 1.7 倍性能提升
- Llama 1B 1100 TPS
金句 / Highlights
值得收藏与分享的关键句。
With just CUDA Graphs and PDL on top of default Torch Inductor kernels, we could recover 98% of megakernel performance without writing a single kernel.
And with “multi-kernels” and agent loops, we could further beat our old megakernels by up to 1.7x, achieving over 1100 TPS for Llama 1B on H100.
Together Compiler’s journey, coming to a theater near you!
去年我们构建了巨内核。今年我们删除了它们:通往 Together Compiler 的道路
介绍
AI 推理正变得越来越异构。每周都会发布新的模型架构,推理流量在不同的批量大小和序列长度之间变化,硬件平台也在不断扩展。要在所有这些场景中实现峰值性能,需要能够跟上步伐的优化框架。
去年,我们帮助发布了一些首批 AI 巨内核,其中我们在单个高度融合的 GPU 内核中执行了整个模型的前向传递。它们达到了破纪录的速度,但很难投入生产。经过数月的努力,我们总共只实现了一个模型、一个批量大小和一个客户。
今年,我们审视了可以简化的地方,并发现了一些令人惊讶的事情。仅使用 CUDA 图和 PDL 在默认的 Torch Inductor 内核之上,我们就能恢复 98% 的巨内核性能,而无需编写任何内核。并且通过“多内核”和代理循环,我们甚至可以进一步超越我们之前的巨内核,达到 1.7 倍的性能提升,在 H100 上 Llama 1B 的吞吐量超过 1100 TPS。
在过去的两年里,我们一直在研究下一代推理优化系统应该是什么样子。在构建了一系列 GPU 编程和优化系统之后,我们来到了 Together Compiler,这是我们用于持续 AI 推理优化的框架。在本文中,我们将重新审视今天编译器背后的假设,分享挑战我们思维的实验,并解释塑造 Together Compiler 的经验教训。我们的旅程分为三个部分:
在第一部分中,我们将展示 Torch Compile 的启发式方法和基准测试如何留下了性能提升的空间,从而为构建一个截然不同的系统提供动力。
在第二部分中,我们将重新审视我们构建的巨内核,解释为什么它们并不总是最佳的优化目标,并将它们的性能提升分解为更简单的原语。
在第三部分中,我们将分享我们在构建代理驱动的优化基础设施过程中学到的“痛苦教训”,以及最终实现的生产系统。
Together Compiler 的旅程,即将在您附近的影院上映!
第一部分:Torch Compile
十多年以来,PyTorch 一直是 AI 开发的基础,提供了模块化、易于使用的抽象(如 nn.Module),这些抽象促进了快速实验。但这种模块化也带来了性能成本:将模型作为一系列单独操作执行会引入显著的启动开销,限制了重叠计算和内存移动的机会,并导致 GPU 资源利用率低下。为了解决这些低效问题,PyTorch 引入了 Torch Compile(“PyTorch 2.0”,由 Inductor 提供支持)来优化和融合操作,而 NVIDIA 开发了 CUDA Graphs 以减少内核启动开销。这些系统取得了巨大进展,但仍然存在显著的性能差距,这常常促使 Together 的研究人员发明了专门的实现,如 FlashAttention、ThunderKittens 和 Megakernels。
我们首先简要概述 Torch Compile 的工作原理,然后介绍我们在 Llama 1B 上研究 Inductor 内部机制时的发现。
Torch Compile 的工作原理
从高层次来看,Torch Compile 使用即时编译管道将 PyTorch 操作捕获到计算图中,优化该图,并生成可执行的 GPU 内核。关键组件包括:
- 图形捕获。TorchDynamo 通过追踪 Python 执行过程,将张量操作捕获到一种称为 FX 图的中间表示中。在追踪过程中,它使用假张量,这些张量携带形状、数据类型和步长等元数据,但不会分配或计算底层张量数据。这使得编译器可以在不实际在 GPU 上执行计算的情况下进行推理。生成的 FX 图可以在代码生成之前进行转换和优化。
- 操作和内核。Inductor 将捕获的图转换为自己的中间表示,其中操作被组织成几种类别,如逐点操作(例如激活函数)、归约操作(例如求和和 softmax)、扫描操作(例如累积和)和模板(例如 GEMM 和其他专用计算内核)。某些操作会调用来自 cuBLAS 等库或自定义 PyTorch 操作的现有实现。Inductor 将这些表示为外部内核(ExternKernel),其具体实现通常对融合机制是不透明的。
- 融合与优化。Inductor 使用一种贪婪的、成对的算法来决定哪些操作应融合到同一个内核中。其 can_fuse() 函数检查候选融合是否合法,而 score_fusion() 则使用诸如估计内存流量节省等启发式方法对融合机会进行排序。该算法反复应用有利的融合,可能将许多操作合并为一个内核。然而,这些决策基于局部启发式方法,而不是对所有可能的内核划分和执行策略进行全局搜索。例如,Inductor 可能会避免融合那些不共享内存访问的操作,即使一起执行它们可以提高 GPU 的利用率。
在我们的目标 Llama 1B 工作负载上,Inductor 提供了 669 TPS。如我们在第二部分中将展示的那样,这些生成的内核有时已经足够,只需进行小幅修改,就可以达到与 megakernels 相当的性能水平。然而,在不同的架构和更新的硬件上,Inductor 的启发式方法无法跟上。我们调查了 Inductor 最难以应对的地方,并提出了三个发现。
发现 #1:编译器启发式方法无法可靠地在不同工作负载之间选择最佳实现。
Inductor 提供了多个编译器调优标志,可以提升性能。我们发现,即使这些看似简单的配置也暴露了一个出人意料的大而复杂的搜索空间。
最佳优化取决于工作负载。Inductor 提供了一个冻结标志,用于告诉编译器模型权重在推理过程中不会改变。知道这一点后,编译器可以提前转换权重,以加快后续计算。一种这样的转换是将权重转换为 FP32 以执行某些优化,然后再将它们转换回原始的、低精度格式。我们发现,在较大的批量大小下,启用冻结标志可以将吞吐量提高 10–26%,此时 GPU 执行矩阵-矩阵乘法。然而,在批量大小为 1 的情况下,推理主要使用矩阵-向量乘法,启用相同的标志却导致了 49% 的性能下降。经过检查,我们发现对于矩阵-向量操作,FP32 转换并未被撤销,导致 GPU 处理的是更大的、32 位权重,而不是原始的低精度权重。换句话说,同样的编译器优化可以提升一种批量大小的性能,但对另一种批量大小的性能却有显著的负面影响。
电感器配置标志按季度划分,2022-2026
优化以不可预测的方式相互作用。截至2026年第三季度,Inductor暴露了607个调整标志,其中198个是在过去一年中添加的。这些标志控制从内核融合到内存访问模式和调度的一切。它们的效果并不是独立的:单独启用aggressive_fusion标志使Llama 1B的吞吐量减少了6 TPS,但同时启用combo_kernels、benchmark_fusion和triton.coalesce_tiling_analysis标志后,吞吐量反而提高了3 TPS。即使是很小的配置更改,也可能导致执行时间出现可衡量的微秒级差异。
结论:可能的优化和配置空间很大,我们应该系统地搜索它,而不是猜测应该设置哪些标志。
发现 #2:隔离状态下最快的内核在推理过程中不一定是最快的。
Inductor基于其基准测试工具进行优化决策。我们识别出两种不同的方式,这种基准测试会误导其决策,从而影响整体性能。
首先,它忽略了内核性能依赖于缓存行为。Torch Inductor在对单个内核进行基准测试之前会清除GPU的L2缓存,但在推理过程中,内核通常会重用从前序操作中缓存的数据。我们观察到,在Inductor的隔离基准测试中,与缓存重用可以减少内存流量的实时前向传递相比,时间慢了39–58%。
基准输入还可能以相反的方向扭曲缓存行为。例如,在对torch.embedding进行基准测试时,Inductor将token ID的张量初始化为零,导致每个token访问相同的嵌入向量。对于一个64K-token的序列,这使得内核比使用随机token ID时快了2.1倍,这是由于人为的高缓存重用。
内核
实时推理(µs)
Inductor基准(µs)
开销
Block-mask slice (KV indices)
1.22
1.92
+57.9%
Block-mask slice (block counts)
1.34
2.05
+52.4%
Fused QKV split / V-cache write
1.15
1.66
+44.5%
Embedding lookup / normalization
1.40
1.95
+38.8%
Inductor的隔离基准测试相比实时推理高估了内核执行时间
其次,基准测试开销可能导致内核选择不佳。许多解码内核仅在几微秒内执行,因此精确计时至关重要。我们发现,Inductor的基准测试工具报告了一个没有执行GPU工作的操作耗时2.5 µs,而其他测量结果超过了Nsight Systems报告的GPU执行时间约3.6 µs。这是因为工具包括了L2缓存刷新后的CPU启动开销,这导致Inductor记录了空闲时间。
随机输入在GLM 5.3上使MoE grouped-GEMM延迟高估了4–21%
这些差异导致了错误的编译器决策。在Llama 1B的输出投影GEMM中,Inductor选择了一个Triton内核,其运行时间为7.4 µs,而实时前向传递中cuBLAS的运行时间为6.4 µs,慢了15%。我们还观察到这一点在现代、数据依赖的架构上,如GLM 5.3这样的专家混合架构,其中PyTorch的默认基准测试可能比如果我们修改基准测试以使用真实输入的MoE grouped-GEMM内核(如上图所示)慢4-21%。
结论:准确的基准测试需要从真实输入数据的真实前向传递中进行测量。
发现 #3:Inductor留下了融合机会。
电感器(Inductor)的贪心配对融合算法会考虑两个内核是否可以合法地融合,然后评估融合是否能提高性能。尽管重复的配对融合可以将多个操作合并,但它可能会错过需要联合考虑更大内核组或不同执行配置的机会。
我们在Llama 1B上研究了Inductor的融合决策,发现了一些Inductor即使合并内核会带来好处,却仍然保持内核分离的例子。例如,我们发现两个连续的内核(一个逐元素激活内核和一个KV索引内核),它们简单到足以融合,但Inductor的启发式方法由于它们没有共享内存访问而拒绝融合。
内核1
内核2
操作
逐元素
索引/切片
网格
(6, 1, 1)
(8, 32, 1)
每个CTA的线程数
128
64
每个线程的寄存器数
35
96
总CTA数
6
256
Llama 1B解码中两个连续未融合内核的启动配置
由于Inductor通过估计的内存流量节省来评估候选方案,它看不到将这些内核合并的理由。然而,我们自己检查这些内核后发现,第一个内核只启动了六个CTA,这意味着GPU的132个SM中的大部分处于空闲状态。将这些操作合并为一次启动可以减少这种浪费。
结论:内核融合算法应考虑利用率,而不仅仅是内存。
这些发现所指向的内容
这些发现都突显了Inductor的限制,导致GPU利用率不足。聚焦于我们更广泛的目标,即构建下一代推理优化系统,我们转向了光谱的另一端:巨内核(megakernels)。如果我们完全移除编译器,手动控制堆栈的所有层级,性能提升实际上会来自哪里?通过理解这一点,我们希望找到一个中间地带,以最小的复杂性自动实现巨内核的性能。
第2部分:巨内核
自从我们引入巨内核以来,它们激发了越来越多关于下一代AI编译器和GPU执行系统的工作。在本节中,我们将重新审视我们为何构建它们,它们是如何工作的,以及在我们尝试将它们投入生产时发生了什么。
巨内核的动机是什么?我们观察到传统推理引擎存在三个效率低下来源,这些引擎通常使用诸如Torch Compile和CUDA Graphs等框架,将模型执行为一系列内核:
- 内核启动开销。每次启动内核都会产生调度和分发开销。CUDA Graphs显著减少了CPU启动开销,但并不能消除执行一系列独立GPU内核所涉及的所有成本。
- 重叠受限。传统内核边界可能会阻止操作之间的有效重叠。例如,当前层仍在计算时,下一层的权重可以从GPU内存中预取,从而允许内存传输和算术运算同时进行。
- 负载不平衡。GPU包含许多流式多处理器(SM),工作很少能完美地分布在它们之间。一些SM可能在其他SM完成其分配的线程块之前就完成任务,导致执行资源空闲。一个更灵活的调度器可以在SM可用时重新分配工作。
为了解决这些低效问题,我们围绕一个单一的持久 GPU 内核设计了 megakernel,该内核执行整个模型的前向传播。我们没有为每个操作启动新的内核,而是让线程块驻留在 GPU 上,并在其中安排连续的操作。我们使用了专用的 warp 来协调执行、管理资源(如共享内存),并将工作单元分配给不同的 SM。我们还将共享内存划分为固定大小的页面,允许操作在执行过程中动态分配和释放共享内存容量。
结果是一个高度优化的执行系统,能够消除中间内核启动,跨操作重叠工作,并动态管理 GPU 资源。在 Llama 1B 上,我们的 megakernel 实现了 990 TPS,比 Inductor 的 669 TPS 提高了 48%。但这也需要我们自己构建大量调度、同步和内存管理基础设施。
然后我们尝试将 megakernel 投入生产。
在 Together AI,2025 年下半年,我们的 🐐研究团队成员之一花费数月时间与生产推理引擎进行斗争:集成分页 KV 缓存、移植到 Blackwell GPU、调试竞态条件,以及处理在受控基准测试之外出现的许多实现细节。
经过所有这些努力后,我们总共只得到了一个 Llama 1B 的 megakernel,仅支持一个批次大小(1)、一种精度(BF16)和一个客户。
性能令人印象深刻。但灵活性却并不理想。
这次经历让我们提出了一个问题:megakernel 是否因为所有内容都在一个巨大的内核中运行而变得快速,还是因为它们启用了少数几个有价值的优化——消除了启动开销、重叠操作,并在 SM 之间平衡工作?
为了调查这个问题,我们从 Torch Compile 的 669 TPS 开始,逐一系统地剔除 megakernel 提供的每个优化。我们发现,仅使用两个 NVIDIA 原语和默认的 Inductor 生成的内核,我们就能达到与我们优化基线相当的性能。这个结果令人惊讶,因为许多研究小组已经构建了更为复杂的编译器和 megakernel 系统,但它们的性能却未能达到这一目标。最终,我们发现 megakernel 是系统错误的目标,原因主要有两点。
首先,消除内核启动开销和重叠操作并不需要 megakernel。其次,不同的硬件和现代模型架构暴露了 megakernel 的僵硬性和次优性。
消除内核启动开销和重叠操作并不需要 megakernel。
megakernel 提供了一个清晰的抽象,以实现计算和内存操作之间的细粒度重叠。实现这种重叠主要取决于三件事:最小化内核启动开销、减少空闲 SM 的尾部效应,以及将内存预取与计算重叠。我们将在下文详细探讨这些内容,以及为什么一个单一的持久内核并不是实现这三个目标所必需的。
启动开销。内核启动开销是昂贵的。在 PyTorch 中,GPU 操作通过 ATen 分发机制,根据输入形状、数据类型和布局选择一个高效的实现。对于 H100 Llama 1B 下投影操作,这需要花费 37 微秒,这超过了内核本身 15 微秒的 GPU 执行时间的两倍。完全移除 PyTorch 并启动纯 C++ 仍然需要大约每次启动 2 微秒,这在典型的前向传递中数百个内核上累积起来会变得显著。
37 微秒的文书工作,只为 15 微秒的实际工作
PyTorch 提出的解决方案是 CUDA 图表,这是一个驱动级功能,可以捕获一系列 GPU 操作,并以显著降低的 CPU 启动开销重新播放。作为交换,捕获的图表会占用 GPU 内存,启动开销减少到大约 1 微秒。通过这一改进,结合 Torch Compile,我们的 Llama 1B 性能提升到 864 TPS,达到 megakernel 的 87%。
为了进一步缩小差距,我们探索了程序化依赖启动(PDL),这是一种 CUDA 机制,允许后续内核在前一个内核完成之前开始执行。从概念上讲,PDL 允许硬件在 SM 变为空闲时,将下一个内核的线程块调度到 SM 中。当时,Torch Inductor 的 Triton 后端没有提供我们所需的 PDL 控制,因此我们将生成的内核编译为 PTX(NVIDIA 的低级 GPU 指令语言),并在每个生产者内核的末尾插入了两个指令:griddepcontrol.launch_dependents,并在消费者内核的开头插入 griddepcontrol.wait,以确保同步。通过这些小的修改,我们的性能达到了 953 TPS,达到 megakernel 的 96%。
对于 CUDA 图表和 PDL,启动开销仍然非零。然而,我们观察到 megakernel 也没有消除这些开销;它只是将启动开销转换为内核内部类似的同步成本。
启动/同步方法
H100 成本(ns)
B200 成本(ns)
正常,cudaLaunchKernelEx
2077
2496
CUDA 图表
1051
915
PDL
731
814
CUDA 图表 + PDL
645
642
Cooperative grid.sync()
1043
1281
Megakernel grid sync
646
795
H100 和 B200 上不同启动机制的同步成本
在上表中,成本是从第一个内核结束到第二个内核中同步原语(如果适用)结束的时间。对于 PDL,仅计算内核之间的时间,实际内核间隔分别为 577 ns 和 516 ns。有趣的是,B200 上的内核内同步比 H100 稍慢,因为 B200 被分成了两个独立的芯片。在单个芯片上测量的同步成本与 H100 上等效数量的 SM 的成本相匹配。
计算重叠。波量化发生在工作没有均匀分配到内核的 SM 上时,导致一些 SM 在最慢的完成之前处于空闲状态。megakernel 可以通过允许完成操作的 CTA 立即开始下一条指令,而不是等待整个网格完成,从而减少这种浪费。然而,由于层中存在固有的序列化点,任何内核结构都无法消除,因此这种优势在实践中是有限的。
在我们的 Llama 1B H100 megakernel 中,每层的五个生产者-消费者屏障边中的三个需要完整的屏障,第四个实际上也是完整的(次级内核的一个 CTA 依赖于前一个内核的 128 个 CTA):
边
屏障同步类型
down_proj → rms_qkv_rope_append
完整
rms_qkv_rope_append → attention_partial
细粒度(每个 CTA 等待前一个内核的 18–20 个 CTA)
attention_partial → o_proj
o_proj → rms_upgate_silu
rms_upgate_silu → down_proj
细粒度(每个 CTA 等待前一个内核的 128 个 CTA)
大多数内核边界都需要对前一个内核进行完整的网格同步,以完成其执行。
这一点非常重要,因为这意味着在一个层中,大多数计算 warp 通常无法继续执行,因为它们必须等待前一个指令的 CTA 完成。这些完整的屏障抵消了持久内核的优势,完整的内核网格同步成本与启动一个全新的内核相同。通过修改我们旧的 megaprofiler,以捕获计算 warp 的开始和结束(而不仅仅是 SM 首次进入时),我们可以看到有多少有用的计算工作是在之前完成的。下面展示了 megakernels 宣称的理想重叠与更现实的表示之间的对比。值得注意的是,只有注意力指令能够利用计算重叠。
内存重叠。我们之前的 megakernel 将每个 SM 的共享内存划分为页面,一个指令一旦完成使用这些页面,就会立即释放它们,使下一个指令可以在当前指令完成的同时,将数据预取到释放的空间中。然而,这种优化仅占前向传播完整执行时间的 3.3%。在没有任何内存预加载的情况下,我们的 TPS 仅从 990 略微下降到 961。
内存预加载有帮助,但效果不大。
尽管收益很小,我们仍好奇是否需要复杂的内存分页机制才能实现相同程度的内存预加载优势。为此,我们进一步推动 PDL 通过其指令的细粒度放置。通过在读取前驱输出的第一个读取操作之前插入 griddepcontrol.wait 指令,消费者内核可以在前一个内核仍在计算时预加载权重。这种简单的方法使 PDL 能够恢复高达 98% 的分页内存预加载收益。
megakernel 风格的预加载还会带来额外的成本,而 PDL 避免了这些成本。等待前一个操作完成的加载 warp 会驻留在 SM 上并进行轮询。这些轮询会使用计算 warp 用于 warp shuffle 的相同 SM 队列,当该队列满时,计算 warp 会停滞。在 Llama 1B 的 attention-oproj 边界,oproj 的加载 warp 在等待注意力操作完成时会进行轮询,相比朴素的 PDL,这增加了 1.3 微秒的开销。
早期权重预加载也可能毫无意义。只有当生产者内核让内存带宽空闲时,重叠内存加载才有帮助。在 Llama 1B 的 downproj-QKV 边界,带宽已经完全饱和,这意味着提前加载 QKV 的权重会减慢 downproj 2.2 微秒,但也会以类似程度加快 QKV 操作。因此,如果作为两个独立的内核启动且没有内存重叠,这对操作的总时间是相同的。
我们之前的 Hazy Megakernel 允许在立即下一个操作之外进行前瞻预加载。这使得 Llama 1B 的上投影可以在 oproj 和注意力操作仍在完成时开始加载权重。PDL 本身无法做到这一点,因为它假设执行是单一流。然而,启动专门的 L2 预加载内核可以实现类似的效果。
将所有这些结合起来,默认的 PyTorch Inductor 内核结合 CUDA 图和细粒度 PDL,能够在不编写单一内核或任何复杂内在函数的情况下,实现 975 TPS,达到手写且优化的 megakernel 基线的 98%。仅使用 CUDA 图和 PDL,megakernel 通过减少启动开销和最大化重叠所获得的每项优势都可以单独实现。
只需进行少量简单的添加,PyTorch 就可以实现与高度优化的 megakernel 相当的性能,用于 Llama 1B H100。
替代硬件和现代模型架构暴露了 megakernel 的僵硬性
在展示简单原语几乎可以恢复 megakernel 所有性能之后,一个更广泛的问题仍然存在:megakernel 是否有时不仅不必要,而且是次优的?我们发现,megakernel 的单体架构在硬件资源限制和现代模型架构需要灵活、非静态设计选择时是有害的。
持久内核强制硬件权衡。megakernel 在所有指令上强制使用固定的启动包络,限制了内核设计。从线程束数量到寄存器预算到集群形状,所有操作都必须匹配。寄存器在调度时按 CTA 分配,每个 SM 的寄存器文件大小为 65,536。我们的 H100 Llama-1B megakernel 使用了 20 个线程束(16 个计算线程束加上 4 个控制线程束),因为当批量为 1 的解码指令在更多线程束中分布时,它们的行会更早完成。然而,更重的张量核心 GEMM 最适合使用 12 个线程束。这是因为 Hopper 的 wgmma 在寄存器中进行累加,超过 12 个线程束后,最佳的瓦片不再适合寄存器内存。如果我们强制将此操作放入相同的 20 个线程束指令中,GEMM 的性能将降低 1.2 到 1.5 倍。虽然这在 Blackwell 上不是问题,因为 tcgen05 在张量内存中进行累加,但其他替代硬件如 AMD 仍会遇到相同的限制。
megakernel 还增加了 SM 指令缓存的压力,这是一个小的缓冲区,用于存储 SM 正在执行的机器代码。将整个模型打包成二进制文件代价高昂,生成的机器代码通常比指令缓存能容纳的要大。当新操作开始时,SM 会将前一个操作的指令逐出缓存,以腾出空间。这增加了额外的开销,因为当同一操作稍后重复时,内核必须从内存中重新获取被逐出的指令。
现代架构无法适应单一的包络。虽然 Llama 1B 是一个传统的密集型 MLP、基于 GQA 的 Transformer,但现代架构已经更加复杂,混合了注意力变体、稀疏专家和不同的并行方案,每种都有自己的首选启动配置。
Blackwell 上的 Kimi K3 说明了这一点。该模型交错使用 KDA 和 MLA 层,它们的张量核心指令在不同的 cta_group 模式下表现最佳(KDA 使用单个 CTA,MLA 使用 CTA 对)。PTX 禁止将这两种不同的模式混合到一个内核中,从而阻止 megakernel 同时以最高效的结构使用这两个内核。
内核有各种形状和大小。让我们不要强行将它们都塞进一个!
在推理过程中,不同的内核可能需要不同的并行方案,这会影响哪些配置是最理想的。对于 K3,我们有时希望 MoE GEMMs 以张量并行的方式运行,而注意力投影以数据并行的方式运行。在这样的配置中,TP GEMMs 处理的 token 数量是 ADP 投影的 8 倍,并且在不同的集群大小下表现最佳。将两者强制使用一个集群大小的单一内核会导致 5–19% 的性能下降。
在研究开源内核时,我们发现将操作从融合内核中分离出来有时比保持它们融合在一起更快。在专家路由不平衡的情况下,将 Kimi K3 的专家调度转移到 GPU 的复制引擎上,比 Mixture of Kitten 的 MoE 超大内核快了 6.9%。此外,FlashInfer 的 MegaMoE 通过将调度分离到自己的小内核中,而不是与 GEMM 融合在一起,运行速度提高了 17%。为了融合而融合并不总是最佳选择。
通过这些研究,我们意识到虽然超大内核很有趣,但并不总是最佳目标。与其将所有内容融合到一个持久内核中,我们发现更重要的是识别出一组正确的操作,将它们耦合并单独进行调优。
最初,我们构建了一个传统的、基于规则的编译器来解决这个问题。这涉及大量手动工作,包括 PTX 降低、对融合决策的动态规划、CTA 依赖关系跟踪以及细粒度的 PDL 插入。然而,虽然这在我们的 Llama1B 模型上有效,但我们发现它仍然过于僵硬,难以推广和扩展到任意的、现实世界的推理工作负载。
我们需要的是一个能够持续适应并快速探索优化空间的系统。在 3 月这些实验进行时,我们注意到编码代理在编写 GPU 内核方面变得非常强大。这促使我们形成了一个简单的初步想法:提前构建一个由代理生成的内核仓库,然后在编译过程中将 Torch 图中的操作映射到仓库中的优化实现并替换进来。我们发现这种方法效果不佳。一个内核的最佳优化取决于模型、工作负载以及其周围的操作,而静态注册表无法轻松应对这种情况。
此外,合成输入误导了代理。例如,一个代理编写了一个 top-k 索引器内核,将注意力分数分组到 2,048 个直方图桶中。该内核随后使用成对比较对包含第 2,048 大分数的桶中的候选者进行排序。在随机输入上,这运行时间为 20 微秒。但实际输入中包含许多来自 ReLU 的精确零,将候选者集中在同一个桶中,触发了二次工作,导致运行时间增加到 62 毫秒。代理需要真实数据和完整的执行上下文,才能生成在生产中有效的优化。
这些发现改变了我们的目标。我们如何构建一个以代理为中心的编译器,具备正确的基础设施,让代理能够高效且准确地优化前向传播?
第三部分:围绕代理构建基础设施
一旦我们决定让代理驱动优化,我们就思考代理需要哪些基础设施,以便在确保正确性的同时推理模型的前向传播。作为热爱底层系统的爱好者,我们最初认为一个严谨的结构是必不可少的。然而,随着代理能力的提升,我们发现这些假设是错误的,我们对委托给代理的任务也变得更加雄心勃勃。
实现最终系统经历了两个阶段。在第一阶段,我们构建了复杂的基础设施,以帮助代理对模型的前向传播进行推理。在第二阶段,我们专注于代理策略和上下文管理(知识中心、提示和研究图)的工具。在两种情况下,我们发现最佳选择是完全移除这些基础设施,让我们的代理自由活动:)
快乐且自由的代理
第一阶段:捕获用于联合优化的一系列内核
一个生产推理引擎会从 Python、C++ 和外部供应商库中跨数百万行代码调度内核。为了给代理提供一个清晰的执行视图,我们原本认为需要将每个内核的启动捕获到一个清晰的中间表示中,供代理在优化时使用。我们假设,没有这种结构,将很难应对现代引擎的混乱状况。
我们从 PyTorch 的 FX 图 IR 开始。然而,我们发现它对于现代推理引擎来说是不够的,因为许多内核调用对 PyTorch 来说是不透明的。例如,在 Kimi K2.6 上使用 TensorRT-LLM 时,解码器层中的 24 个内核中有 23 个是通过 C++ 调度的,并被视为“自定义 torch 操作”,这使得它们对 Torch Inductor 来说是不透明的。Inductor 只能将这些操作视为带有输入和输出张量的函数调用,但没有关于内核内在特性或细节的任何信息。因此,我们扩展了 PyTorch FX 图,创建了一个自定义的中间表示,我们称之为 BlockIR,并将其提供给代理。
Inductor 无法看到的内核
BlockIR:由于 FX 图无法显示所有内核,我们构建了自己的捕获系统,深入到了驱动程序级别。无论内核的来源如何,所有内核都会通过驱动程序的启动调用。通过使用低级别的跟踪工具,如 Nvidia 的 CUPTI 和 AMD 的 rocProf,我们捕获了每个内核的启动和参数缓冲区。我们将原始 GPU 指针替换为可以追溯到 Python 或 C++ 源代码中相应参数的符号引用。由于我们是从一个实时推理引擎中捕获的,每个启动也附带了它实际运行的输入数据。
{
"seq": 945, "event": "launch", "mark": 2,
"time_us": 1787159477656781,
"symbol": "_ZN12tensorrt_llm...fused_a_gemm_kernel...",
"module_sha": "f63caa0fd3398cc69a914fc8ac66787d5b00d99e",
"route": "cuLaunchKernelEx", "argsrc": "kp",
"grid": [132,1,1], "block": [256,1,1], "shmem": 197632,
"nattr": 1, "attr_stride": 72,
"attrs": "0600000000000000...",
"params": [
{"o":0,"off":0,"sz":8}, {"o":1,"off":8,"sz":8},
{"o":2,"off":16,"sz":8}, {"o":3,"off":24,"sz":4}
],
"pbuf_size": 28,
"pbuf":
"004060dfce750000 000000d2d3750000 009022add1750000 04000000",
"ptrs": [
{"o":0, "off":0, "v":"0x75cedf604000",
"base":"0x75cedf600000", "size":2097152},
{"o":1, "off":8, "v":"0x75d3d2000000",
"base":"0x75d3d2000000", "size":31457280},
{"o":2, "off":16, "v":"0x75d1ad229000",
"base":"0x75d1ad200000", "size":2097152}
]
}捕获到的内核启动数据示例。
这些捕获的信息很有用,但对代理和人类来说难以解释。因此,我们接下来对 PyTorch 的 TorchDispatchMode 进行了子类化,并跟踪了每个参数的声明和分配,将原始捕获的指针映射回源代码中的可读变量。经过这种重新映射后,我们最终得到了我们的 BlockIR(如下所示)——一种中间表示形式,它跟踪了前向传播中的每个内核和参数,并为代理提供了一种结构化的机制,用于推理内核启动的参数和参数。
rank: 1
allocations:
- id: alloc_00002
extent: 114688
members:
- operand: layer_in_hidden_states
offset: 0
extent: 114688
role: input
launches:
- id: launch_00000
grid: [132, 1, 1]
block: [256, 1, 1]
shmem: 197632
packed_size: 28
pointer_fields:
- offset: 16
width: 8
operand: layer_in_hidden_states
target:
kind: allocation_group
group: alloc_00000
member_offset: 0
- id: launch_00001
....
- id: launch_00002
....BlockIR 示例片段
虽然这方法运行良好,但我们在让代理从 BlockIR 的视角进行优化,并在生产流量中服务代理输出时遇到了挑战:
- 有限的优化空间。BlockIR 仅包含代理可以修改的一系列内核启动,这阻止了代理对主机端逻辑进行优化。例如,在 Kimi K3 中,通过重写 MLA 元数据规划步骤,将长序列在注意力过程中拆分到多个线程块中,可以将 MLA 内核的速度提高 1.7-2.5 倍。FX 图和 BlockIR 都无法表达这种优化,因为这种拆分是在任何内核启动之前在主机上决定的。
- 指针级别正确性的成本。BlockIR 依赖于在引擎启动期间将符号指针绑定到每个层的实时数据。虽然这通过严格的输入和输出指针匹配以及预确定的缓冲区偏移提供了正确性保证,但它使系统变得脆弱。
由于 BlockIR 跟踪了每次启动中的每个指针,所有优化都必须维护这种跟踪。这需要对诸如内核融合之类的优化进行谨慎处理,因为这会改变两个内核之间的参数存活集合。因此,融合需要将新内核的参数缓冲区的每个字节映射回它所替代的启动。当参数是干净类型(单个 int、指针或 bool)时,这很简单,但供应商内核可以传递任意参数结构,而我们的捕获系统对此没有可见性。当参数是一个结构体时,我们唯一拥有的只是一个不透明的字节缓冲区,我们必须对其进行分解并关联到已知的分配。
即使最初识别指针本身也很脆弱。PyTorch 的缓存分配器在单个层中为许多张量重用相同的地址,因此为了命名每个指针,我们将钩子的启动时间戳与 PyTorch 的分配器历史进行对齐。然而,由于这两个时间戳是由不同的时钟标记的,细微的差异可能导致错误。在 AMD 上的 GLM 5.3 中,这两个时钟的漂移高达 325 微秒,导致指针错误地指向了错误的分配,并错误地标记了内核实际读取或写入的缓冲区。
虽然这些问题是可以解决的,但我们发现代理花费了更多的时间在调试指针跟踪上,而不是识别优化点。我们决定简化流程。观察到最新前沿模型的改进以及上下文压缩的质量,我们让代理直接生成前向传播代码。没有捕获系统,没有 BlockIR,只有源代码。虽然在某些情况下(例如,代理需要进行形式验证推理时)详细的中间表示(IR)可能仍然很重要,但我们发现直接优化前向传播的源代码效果非常显著!
第二阶段:去除专家管理的上下文
现在,代理可以访问源代码修改和真实数据测量,但与大多数代理优化系统一样,我们假设它们仍然需要结构化的指导。我们构建了一个由专家整理的知识中心,为代理规定了用于记录发现和实验的数据结构,并创建了精选的优化策略来指导代理(例如,使用屋顶线成本模型或实际时钟测量对优化目标进行排序,并指导代理优先处理排名靠前的目标)。
这些选择在开发的某些阶段确实有所帮助。然而,随着编码代理的快速进步,我们重新审视了我们的假设。随着时间推移,我们逐步去除这些选择,发现我们为指导代理构建的框架现在反而可能限制了它们。虽然这些想法并非绝对有害,但代理对它们所获得的结构和上下文非常敏感,帮助与有害之间只有一条非常细的界限。我们下面将讨论具体的例子:
知识库:在 MiniMax-M3 第 3 层(B200,TP4,批量大小 1)上,10 次代理试验中相对于基线的加速。添加知识库会使集成的最终加速从 5.85× 降低到 4.75×(下降 19%),对单一策略的影响几乎可以忽略不计。通信:经常互相通信的代理可以达到基线的 7.72×,而通信较少的代理为 6.20×,没有通信的代理为 4.82×。专家策略:朴素集成(6.20×)比由六个专家编写策略构建的集成(4.92×)快 26%;这六个策略单独使用时的加速在 3.1× 到 4.3× 之间。
- 知识中心。我们的系统使用了一个知识中心,其中汇总了底层技术、开源和内部库中的内核,以及来自流行公共内核优化仓库的资料。在去除该知识中心后,我们发现其存在可能导致代理性能下降 25–31%。知识中心并未加速搜索,反而将代理固定在已知的优化模式上,阻碍了它们更有效地发现新方法。
- 专家策略。我们最初为每个并行代理分配了不同的书面策略(例如,聚焦融合、通信与计算重叠、巨内核)。最终,我们发现仅仅提示每个代理“尽可能让前向传播变快”比我们手动编写的指南效果更好。通过检查日志,我们发现规定优化顺序(例如,根据屋顶线或实际时钟对代理应优化的内核进行排序)可能导致系统陷入局部最优,因为优化工作的性能上限受到优化应用顺序的限制(参见阶段排序问题)。
- 研究和日志数据结构。为了防止代理重复失败的实验并帮助它们基于早期发现进行改进,我们最初强制代理以有向无环图(DAG)的结构来记录和记录其工作。为了进行优化,代理会在图中创建节点,表示假设、实验和候选内核。我们为代理提供了一个命令行接口(CLI),以便他们高效地查询和解析这一结构。在去除这一设计后,我们发现这增加了额外的管理任务,反而挤占了优化的时间。代理在每次试验中,将高达43%的CLI/工具调用时间用于研究追踪和数据结构检查,而这些时间对优化的贡献很小。
- 代理集成。并行运行代理的主要动机之一是探索优化空间中的多样化路径,并避免相位排序问题。为了防止代理收敛,我们假设较少的通信最为理想,让代理独立探索,然后定期集成他们的发现。然而,我们观察到这导致了并行代理之间显著的冗余,浪费了大量计算资源在重复的工作上。我们最终的方法采用了一个轻量级的消息板,以实现代理之间的快速和持续通信。
一个早期版本编译器的旧演示视频
在去除这些结构后,剩下的就是一个专注于两件事的最小系统:为代理提供高保真度的测量,并确保代理的高实验吞吐量。你可以通过我们之前的博客文章了解我们如何通过分层持久化引擎实现这一点。
这个最小系统就是今天Together Compiler的核心。在不到24小时的时间内,使用不超过两个节点,TKCC:
- 超越了手工调优的宏内核,生成的TPS高达我们宏内核基准的1.7倍。
- 在引擎排行榜上名列前茅,性能优于高度优化的基准模型最高达2.6倍,并在MiniMax M3.1-Flash上实现了1,111 TPS和在DeepSeek v4.1-Flash上实现了1,205 TPS的最先进的低延迟性能。
- 跨代码库和领域进行泛化,在天气建模、偏微分方程(PDEs)、时间序列和生物学等开源代码库中实现了最高达6.4倍的加速。
总结
从传统的基于规则的编译器驱动TKCC到今天基于代理的优化器,这是一条漫长的道路,但有三个教训特别突出。首先,优化需要高保真度的测量,错误的基准选择(例如使用随机数据)可能导致次优的内核选择。其次,并不存在适用于所有情况的单一内核。正确的优化策略因模型、硬件和工作负载而异,单一的策略无法代表这一空间。第三,围绕代理构建的系统应始终考虑到模型改进的能力。代理对所给的框架非常敏感,早期有助于代理的框架可能会在后期成为限制因素。
如果您的组织希望试用Together Compiler,请联系以获取早期访问权限!同时,我们的研究团队正在招聘,请访问我们的职业页面进行申请!