Meta 如何打造 TLX:面向大规模生产级 ML 的硬件原生 GPU 编译器
- TLX 是 Triton 的扩展,帮助工程师优化 GPU 性能,同时保留 Triton 高效的编程模型。
- TLX 引入了显式的 warp-group 和 cluster 级编排,让开发者无需牺牲开发效率就能用上新硬件能力。
- TLX 已在 RecSys 训练、RecSys 推理以及大规模 LLM 预训练中展现出显著的性能提升。
现代 GPU 架构越来越依赖 warp specialization、异步内存传输、tensor memory、cluster 级执行等面向执行的特性来优化性能。但这些特性也带来一个日益明显的问题:面向底层控制的编程模型和面向高效开发的编程模型之间存在鸿沟。为了弥合这一差距,我们构建了 Triton Low-Level Extensions(TLX),让工程师在保留 Triton 高效编程体验的同时,获得对 GPU 执行的显式控制。
如今,TLX 已支撑 Meta 从 AI 训练到大规模 LLM 预训练的各类生产工作负载,让工程师能够快速用上新硬件能力,而不牺牲开发效率。在 NVIDIA 和 AMD GPU 上,TLX 正在推动 GPU 性能的边界——通过结合最先进的 kernel、显式的执行编排以及感知模型结构的融合,实现远超单一库所能达到的端到端性能提升。
从 AI 模型到 GPU Kernel
要理解 TLX 的定位,可以从 AI 模型到最终执行的 GPU 指令这条路径入手。在 Meta,机器学习(ML)工作负载建立在以 PyTorch 为核心的统一软件栈上。模型代码经过图捕获、优化、编译和 lowering,最终变成运行在大规模加速器集群上的 GPU kernel。过去几年,Triton 已从一门实验性的 kernel 语言演进为这套软件栈的基础组件。目前相当一部分生产环境的 GPU kernel——无论由编译器生成还是手工优化——都是用 Triton 实现的。因此,这一层的改进能够广泛惠及训练和推理工作负载,kernel 性能正成为提升端到端系统效率越来越重要的抓手。

这一转变也改变了内核编写者的构成。内核优化不再是 GPU 专家的专属领域。ML 工程师可以常规地对工作负载做性能分析、定位瓶颈,然后通过自动调优、算子融合、内存布局优化或重构算法来优化最热的内核。得益于 Triton 的高效率,这些迭代往往几小时就能完成,而不是几天,让工程师的工作更贴近模型开发流程。GPU 内核开发由此逐渐成为 ML 工程师标准优化工具箱的一部分。
对于许多受内存带宽限制的工作负载,Triton 已经通过算子融合和编译器管理的内存访问优化提供了高效的基础。在这些优势之上,TLX 着手解决另一个互补的挑战:在现代 GPU 上协调执行组、异步数据搬运和共享资源。
问题所在:硬件进化快过编程模型
虽然 Triton 大幅提升了开发效率,但现代 GPU 架构的演进越来越强调执行编排,而不仅仅是计算本身。NVIDIA 的 Hopper 引入了 warp specialization 和 Tensor Memory Accelerator(TMA);Blackwell GPU 则更进一步,带来了 Tensor Memory(TMEM)、cluster 级执行、paired-CTA 执行以及日益增多的异步执行机制。这些能力并不是能被编译器优化轻易屏蔽的新指令,它们从根本上改变了高性能内核的组织方式。
举例来说,一个现代 FlashAttention 内核可能用一个 warp 组负责发起 TMA 传输,另一个 warp 组执行 tensor core 计算;一个 Blackwell GEMM 内核可能需要同时协调多个 warp 组、TMEM 分配和 cluster 资源。在这两种场景下,性能不仅取决于计算本身,还取决于多个执行主体之间的协作方式。
在 Meta 的 ML 基础设施中引入 Hopper 和 Blackwell 之后,我们反复遇到同一个问题:CUDA 虽然能够表达这些执行结构,但往往需要编写大量针对特定架构的调度代码。Triton 提供了生产力高出许多的编程模型,但现代硬件所需的许多执行关系却被隐藏在编译器抽象背后,开发者无法触及。
由此产生了越来越严重的编译器追赶问题:每一代新硬件都带来新的执行能力,而程序员要么苦等编译器支持,要么退而编写越来越特殊的实现。我们逐渐意识到,问题不只是缺少编译器特性,而是缺少一个合适的编程抽象。
缺失的中间层:为什么 SIMT 和 SIMB 都不够用
近期 GPU 上最关键的能力,既不在线程粒度上,也不在 block 粒度上。Warp specialization 将工作划分给多个协作的 warp 组;TMA 引入了专职的内存搬运代理;TMEM 带来了执行组之间新的通信模式;Cluster 执行则让多个 CTA 在共享的执行上下文中协作。围绕这些特性组织 kernel,意味着要思考多个执行代理如何协作、通信和同步——这种结构层级恰好介于 CUDA 和 Triton 之间。
这暴露出我们眼中缺失的一层抽象。CUDA 的 SIMT 模型粒度太细:它提供了完全的控制权,却要求开发者手动表达每一条执行关系。Triton 的 blocked 编程模型粒度太粗:它提升了开发效率,却把许多执行结构变成了编译器的隐式决策。现代硬件越来越需要介于两者之间的东西。
我们把这种模型称为 Multiple Instructions, Multiple Warps(MIMW)。MIMW 将 warp 组提升为编排的基本单元:程序员不再针对单个线程或整个 block 编程,而是直接表达多个执行代理如何协作、通信、同步和共享资源。这正是 Hopper 和 Blackwell 上许多优化最自然的表达层级,也是 TLX 所实现的抽象层。
图 2 展示了 GPU 编程模型的演进。CUDA 的 SIMT 模型直接在线程粒度上暴露执行细节,让开发者完全掌控调度、同步和内存搬移。Triton 走向 SIMB 模型,把抽象提升到分块张量计算的层面,提升了开发效率。MIMW 则处于这两者之间:它不把线程或张量分块作为主要执行抽象,而是将 warp group 提升为一等执行单元。

MIMW 的出现并非软件设计上的偏好,而是硬件演进的必然结果。Volta 和 Ampere 时代,tensor core 通过线程和 warp 级编程来使用;到了 Hopper,异步数据搬移(由 TMA 实现)和 warp group 执行(由 WGMMA 实现)成为高性能 kernel 的核心;Blackwell 更进一步,引入了 TMEM、寄存器重分配、cluster 执行和 paired-CTA MMA。每一代硬件都把更多跨 warp group——有时甚至跨 CTA——的协作推向编程模型层面,而不再只是编译器需要处理的事情。

要让 MIMW 落地,就需要把相互协作的 warp group 或 wave group 表达为一等执行任务,并显式控制共享内存 buffer 的访问、同步以及它们之间的交接。TLX 把这些能力融入 Triton 现有的张量编程模型,让开发者既能获得显式的执行控制,又能继续使用熟悉的高级张量操作。
TLX:补齐缺失的中间层
我们并不想用 TLX 再造一门独立的底层语言。TLX 是在 Triton 之上扩展了一层面向执行的构造:程序员继续用熟悉的 Triton 张量操作来表达计算,只有在需要显式控制执行、内存搬运或同步时才用到 TLX。换句话说,Triton 回答"做什么计算",TLX 回答"如何编排这些计算"。这一点通过一个简单的分块矩阵乘法最容易看清。在标准 Triton 中,执行遵循同步的加载—计算循环:每个分块被加载、使用,然后丢弃,之后才开始下一个分块。
# Standard Triton: synchronous load-compute loop semantics,
# with compiler-managed software pipelining
@triton.jit
def matmul_kernel(a_ptr, b_ptr, c_ptr, M, N, K, ...):
pid_m = tl.program_id(0)
pid_n = tl.program_id(1)
acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32)
for k in range(0, K, BLOCK_K):
a = tl.load(a_ptr + ...) # Load A tile from global memory
b = tl.load(b_ptr + ...) # Load B tile from global memory
acc += tl.dot(a, b) # Compute matmul
tl.store(c_ptr + ..., acc)
TLX 保留了同样的计算,但把执行结构显式地暴露出来:生产者 warp group 异步搬运数据,消费者 warp group 执行 Tensor Core 计算,同步则直接通过轻量级 barrier 表达。计算本身仍是 Triton,改变的只是编排层。最终得到的是一个深度流水线化的 kernel,能在不离开 Python、不放弃 Triton 自动调优基础设施的情况下,让内存搬运、计算和输出处理相互重叠。更重要的是,执行结构直接体现在源代码中,而不是藏在编译器的启发式规则里。
# 在 Blackwell 上使用 TLX:显式的 warp-group 编排与流水线
@triton.jit
def matmul_kernel(desc_a, desc_b, desc_c, M, N, K, ...):
buffers_a = tlx.local_alloc((BLOCK_M, BLOCK_K), tl.float16, NUM_STAGES)
buffers_b = tlx.local_alloc((BLOCK_K, BLOCK_N), tl.float16, NUM_STAGES)
acc = tlx.local_alloc((BLOCK_M, BLOCK_N), tl.float32, 1, tlx.storage_kind.tmem)
load_bars = tlx.alloc_barriers(num_barriers=NUM_STAGES, arrive_count=1)
dot_bars = tlx.alloc_barriers(num_barriers=NUM_STAGES, arrive_count=1)
with tlx.async_tasks():
# Warp group 0:生产者 — 通过 TMA 异步加载到共享内存
with tlx.async_task("default"):
# 等待上一次 matmul 完成
tlx.barrier_wait(dot_bars[num_k_tiles - 1], phase)
result = tlx.local_load(acc[0])
desc_c.store(offsets, result.to(tl.float16))
# Warp group 1:消费者 — 从共享内存执行 tensor-core 矩阵乘法
with tlx.async_task(num_warps=1):
for k in range(num_k_tiles):
buf = k % NUM_STAGES
# 等待 TMA 加载完成
tlx.barrier_wait(load_bars[buf], phase)
tlx.async_dot(buffers_a[buf], buffers_b[buf], acc[0],
use_acc=(k > 0), mBarriers=[dot_bars[buf]])
# Warp group 2:后处理 — 将结果写回全局内存
with tlx.async_task(num_warps=1):
for k in range(num_k_tiles):
buf = k % NUM_STAGES
# 等待消费者释放缓冲区
tlx.barrier_wait(dot_bars[buf], phase)
tlx.barrier_expect_bytes(load_bars[buf], ...)
tlx.async_descriptor_load(desc_a, buffers_a[buf], offsets, load_bars[buf])
tlx.async_descriptor_load(desc_b, buffers_b[buf], offsets, load_bars[buf])
TLX 在五个关键方面对 Triton 进行了扩展:
Warp-group 编排:TLX 将 warp group 视为一等执行单元。程序员可以为相互协作的 warp group 分配明确的角色——比如负责搬运数据的生产者 warp group、执行 tensor-core 计算的消费者 warp group,以及处理结果的后处理 warp group。
同步机制:TLX 将同步暴露在 warp-group 层面,而非线程层面。程序员可以用 mbarrier 这类硬件原语来表达协作执行组之间的依赖关系——比如软件流水线中的生产者-消费者模式。细粒度的线程级同步则交由底层执行模型和编译器处理,开发者只需专注于协调更大的执行结构,而这正是现代 GPU 性能的关键所在。
内存编排:TLX 让程序员可以直接使用 TMA、异步 tensor-core 操作、TMEM 等硬件能力。借助这些原语,内存搬运和计算可以在程序定义的执行结构内自然地重叠进行,同时省去了 CUDA 中通常需要的大量底层配置和簿记工作。
Cluster 执行:TLX 将 cluster 级执行作为一等编程原语暴露出来。多个 CTA 可以通过 distributed shared memory 和 cluster 级同步原语协同工作,实现原本需要访问全局内存才能完成的片上通信模式。
可选的 layout:与 CUDA 和 CUTLASS 不同,TLX 不要求程序员在表达计算之前显式指定 layout。编译器会自动推断合理的默认值,只有出于性能考虑需要覆盖默认值时,程序员才需要指定 layout。因此,一个正确的 kernel 完全可以在没有任何 layout 标注的情况下写出来,layout 调优可以在后续优化中逐步引入。
这带来了一个重要的好处:kernel fusion 变得容易得多。fusion 是最有效的 GPU 优化手段之一,因为它能消除中间数据的内存搬运和 kernel 启动开销。但在传统的 CUDA 式开发流程中,fusion 往往被 layout 管理所拖累——每个阶段可能采用不同的 tiling、swizzling 或 shared-memory 映射,程序员不得不手工协调算子边界两端的 layout。
由于 TLX 能自动推断布局,很多操作无需手动协调中间布局即可完成融合。编译器会在可能的情况下自动解决布局兼容性问题,只有当特定的布局选择能带来性能提升时,开发者才需要手动干预。这大幅降低了构建复杂融合 kernel 所需的工程投入,也让多阶段流水线的实现变得可行——否则这些流水线往往需要多个 kernel 或大量针对布局的基础设施。 综合来看,这些能力让 TLX 落在 Triton 的高生产率与 CUDA 的精细控制之间。开发者既保留了 Python、自动调优和分块张量编程的优势,又能直接掌控执行结构——而这些结构在现代 GPU 上日益决定着性能表现。TLX 在生产环境中的实际影响
过去几个月,TLX 已在 Meta 的机器学习基础设施中投入生产使用。三个部署案例——分别覆盖 RecSys 训练、RecSys 推理和大规模 LLM 预训练——从不同侧面展现了 TLX 的能力。| 案例 | 硬件 | TLX 解决的问题 | 核心成果 | 部署场景 |
| GEM 模型训练 | NVIDIA Blackwell | 异构 RecSys 基础模型要达到 roofline MFU,需要 warp specialization 和显式的张量内存控制,这超出了标准 Triton 的能力。 | 数千块 GPU 上实现 20-25% 的端到端 MFU | GEM 训练栈。 |
| Kernel 内广播优化(IKBO) | NVIDIA Hopper | 用户特征在每个候选批次中被重复复制多次,浪费带宽和算力;消除这种浪费需要基于 warp specialization 的多阶段融合。 | 协同设计的模型在计算密集型延迟上最多降低 2/3。 | RecSys 推理,早期→后期排序,GPU。 |
| 面向 LLM 预训练的分布式 Grouped GEMM | NVIDIA Blackwell | 专家并行的 MoE 层需要 grouped GEMM 并结合跨节点通信;现有实现在大规模场景下存在明显的性能损失。 | 在大规模集群上经过长期生产验证。 | LLM 预训练。 |
案例研究一:GEM 模型训练
训练 Meta 的 生成式广告模型(GEM)比训练 LLM 更难优化,因为输入形状更小、每层有 10 多个归一化操作、模块类型异构、架构多样,这些都限制了 MFU。通过在模型架构、定制 kernel、编译器优化和硬件调优等方面进行系统性的模型-kernel 协同设计,最新版本的 GEM 训练在数千块 NVIDIA Blackwell GPU 上完成了 O(10^24) 规模的总训练浮点运算,端到端 MFU 达到 20-25%。
TLX 在多 DSL 策略中的角色
我们在 Blackwell 上评估了三种编程模型——CUTLASS、CuTeDSL 和 TLX,发现 TLX 在大多数 kernel 上能提供生产力与性能的最佳平衡。它兼具 Triton 风格的简洁性、自动调优和可组合性,同时可以直接使用 Blackwell 的专属能力,如 async_dot、tensor memory 操作和 mbarrier 同步。
对于 GEM 中的 Generalized Dot Product Attention(GDPA)kernel,TLX 用远低于以往的实现复杂度达到了接近最优的性能:它将模型中众多类 attention 操作统一到单个 GPU kernel 中,从而加速训练,前向速度最高提升 2 倍。虽然不同 kernel 的需求各异,但对于 GEM 的大多数既要求开发效率又要求性能的工作负载,TLX 证明是合适的抽象层。
借助 TLX,我们得以超越单个 kernel 的优化,转向对模型更大的部分进行 kernel 化和融合。对于 GEM 这类工作负载,减少内存搬运往往比单纯优化计算带来更大收益,因此可组合性和融合是一等公民。为了加速这一过程,我们构建了 Agent for Compute Efficiency(ACE),一个自动化 profiling、分析和调优的 AI 辅助优化框架。ACE 缩短了 kernel 的优化周期,让工程师能把精力集中在更高层面的优化机会上,而不是陷入底层的性能调试。
案例研究二:RecSys 的 kernel 内广播优化
在 RecSys 推理中,同一用户的特征对所有被评分的候选物品都是相同的,但通常仍会在每个 batch 内复制数十次,以对齐候选物品的维度。经过多种候选与用户广播比例的验证,这种广播已成为内存带宽和算力的重大浪费来源,且开销随候选数量线性增长。
核内广播优化(In-Kernel Broadcast Optimization,IKBO)通过将广播下沉到 kernel 内部来消除这一低效:不再实际物化复制后的用户特征,而是让 kernel 以各自天然的、不匹配的 batch 大小消费用户和候选输入,在计算过程中隐式完成广播。这一方案依赖模型架构、推理 runtime 和 kernel 实现的协同设计。
TLX 为该优化的最后一环提供了基础组件
以我们的线性压缩 kernel 为例。在经过一系列优化——包括 matmul 分解、内存对齐和广播融合之后,剩余的瓶颈通过一个 warp 特化、多阶段的 TLX kernel 解决,在 NVIDIA H100 上实现了 4 倍加速。最终实现将整个计算收敛为单个常驻的 mega-kernel:生产者和消费者 warp 组通过 ping-pong 调度并发执行,用户与候选 GEMM 共享循环缓冲区,并借助 mbarrier 同步,各阶段之间无需清空流水线。Tile 级别的 release-acquire 同步还进一步实现了跨 CTA 的协调。
对于 FlashAttention,IKBO 协同设计通过在共享同一用户上下文的候选之间摊销 K/V 读取,将 kernel 从 I/O 受限转变为计算受限。TLX 在此基础上叠加了 FA3 风格的 warp 特化与常驻机制,消除了 RecSys 短查询长度下占主导的跨 CTA 启动停顿,使协同设计模型的计算密集型净延迟最多降低三分之二。若直接用 CUDA 表达这种执行结构,需要大量手工编排;而 TLX 让我们能在 Triton 的 Python 编程模型和自动调优框架中简洁地表达它。
如今,IKBO 正助力优化 Meta 的自适应排序模型,覆盖 GPU 和 Meta 训练与推理加速器(MTIA)。更广泛地看,它体现了我们在推荐系统推理思路上的转变:不再围绕广播开销做优化,而是直接在计算原语层面将其消除,从而无论候选数量多少,都能保证稠密交互的质量。
案例三:面向 LLM 预训练的分布式 Grouped GEMM
TLX 的生产影响力并不局限于推荐场景。一个基于 TLX 的分布式 grouped GEMM kernel 目前已部署在 Meta 的大规模 LLM 预训练基础设施中,在庞大的 GPU 集群上长时间持续稳定运行。该 kernel 负责加速 mixture-of-experts(MoE)模型所需的分组矩阵乘法,并通过紧密耦合计算与通信来降低端到端延迟。
在这个规模下,峰值吞吐只是问题的一小部分。可靠性、可调试性和长期性能稳定性同样关键。生产级 kernel 必须在数周的持续运行中保持性能,同时在模型、硬件和系统软件不断演进时依然易于维护。
TLX 恰好非常适合这类环境。它对 warp 专业化执行、显式内存编排和异步流水线的支持,满足了大规模分布式训练对性能的要求;同时,它与 Triton 的 Python 编程模型深度集成,保留了开发者高效迭代、验证和部署复杂 kernel 所需的生产力。
这次部署也凸显了 TLX 设计理念的一个重要方面:它的目标不只是追求极致的 kernel 性能,更是让先进的硬件能力能够真正落地到实际生产系统中。
深入了解 TLX Kernel
如果想更深入地了解 TLX kernel 的技术细节,请参阅我们在 PyTorch 博客上的配套文章:
- 核内广播优化:为 RecSys 推理协同设计 Kernel.
- TLX Block Attention:面向固定块稀疏自注意力的 Warp 专用 Blackwell Kernel.
- Fast 2-Simplicial Attention:TLX 中的硬件高效 Kernel.
- 用 TLX 实现 Cluster Launch Control.
- 实现“免费”的归一化:用 TLX 将 Norm 融合进 GEMM 和 Attention Kernel.
- 用 TLX 优化 Jagged Flash Attention:冲击 Blackwell 上的 SOTA FA4.
- 在 CDNA4 上用 TLX 优化 GEMM + 激活函数.
我们的心得:构建 GPU 编译器的几点建议
从真实业务负载出发,而不是跑分基准
TLX 的诞生是为了解决 Meta 的实际生产问题,而不是为了在跑分竞赛中夺冠。GEM MFU 项目和 IKBO 都印证了这一点:两者都是先有具体的痛点(GEM 的 MFU 偏低、RecSys 的广播开销),工具才随之而来。这种聚焦让我们的目标始终是真实世界的性能,而不是合成的跑分。
生产力和性能是相乘的关系,不是取舍关系
TLX 的性能通常与手工调优的 CUDA 持平,但工程师的迭代速度能快得多。一个只快一点点、却要多花三倍时间才能写完的 kernel,在集群规模下是净亏损。在 GEM 项目中,多 DSL 架构让我们可以选择 TLX 来快速迭代;在 IKBO 项目中,基于 TLX 的实现只花了几周,而不是几个月。
硬件特性只有用得上才有价值
WGMMA、TMA 和 TMEM 都是强大的硬件能力,但编程模型过于复杂,很少有人真正用起来。TLX 通过简洁的注解让它们变得触手可及。IKBO 中的 warp 特化融合和 GEM 中的多 DSL kernel,如果直接用 CUDA 写,复杂度会高到难以落地。
编译器也是用户体验的一部分
错误信息、调试支持和 profiling 集成,和代码生成质量同样重要。我们在开发者体验上的投入不亚于优化器。GEM 工程师排查 MFU 问题时,或 IKBO 工程师遇到 warp group 同步问题时,需要的是清晰的反馈,而不是晦涩难懂的编译器报错。
渐进演进胜过推倒重来
TLX 选择在 Triton 基础上扩展,复用了现有的生态、工具链和团队经验。GEM 团队可以在使用 TLX 的同时继续使用 CUTLASS 和 CuTeDSL;熟悉 Triton 的 IKBO 团队只需学习性能关键部分的 TLX 注解即可。推倒重来也许设计上更优雅,但可能永远无法上线。
TLX 的未来规划
TLX 还会走得更远,我们目前在做这几件事:
- 支持更多硬件:目前 TLX 面向 NVIDIA Hopper、Blackwell,以及 AMD Mi300 和 Mi350x。我们正在扩展对更多架构的支持,包括 NVIDIA 和 AMD 的新一代产品,以及 MTIA 这类自研加速器。MIMW 模型本身与硬件无关,难点在于如何高效地映射到不同的 ISA 上。GEM 已经可以同时运行在 GPU 和 MTIA 上,IKBO 也是如此。
- 更高层的抽象:TLX 让开发者直接控制 warp group。下一步我们想再次提升抽象层级——从更高层的模式自动推断 warp group 的编排方式,可以想象成一个帮你自动写注解的“auto-TLX”。我们从 GEM(多 DSL 选择)和 IKBO(三阶段 warp 特化)中学到的模式,都是自动化的候选对象。
- 与 PyTorch 2.x 集成:我们正在把 TLX 打造成 torch.compile 的后端。目标是写 PyTorch 代码就能自动得到 TLX 优化过的 kernel,常见模式无需手动注解。GEM 展示了系统化协同设计的潜力,IKBO 展示了针对特定模式优化的价值——我们希望让这一切自动发生。