欢迎光临
我们一直在努力

GEMM 后端选型:从底层概念到工程决策——cuBLASLt 与 CUTLASS 的取舍

先把问题问对

聊 CUTLASS,多数资料会直接堆它的特性:"NVIDIA 的 C++ 模板库、分层 tiling、用 Swizzle 消 bank conflict……"。这些都对,但只回答了"CUTLASS 是什么"。

真正要紧的问题是另一个:给定一个 workload 和一块特定代次的 GPU,在某个时间点上,这个矩阵乘该放在"控制力 ↔ 易用性"这条光谱的哪个位置?这个选择又要付出多少工程和维护代价?

GEMM 是这条光谱上最典型的战场。要把这件事讲清楚,得先有一套共同的词汇——所以这篇先打地基,把 GPU 计算、Tensor Core、混合精度、算子融合这些绕不开的概念过一遍;再把 cuBLAS、cuBLASLt、CUTLASS 串起来,中间拆开 CuTe 看清"白盒"的内部机制;最后落到一个能直接拿去做技术决策的框架。


一、先把地基打好:几个绕不开的概念

1. GEMM 为什么是主战场

GEMM 是 General Matrix Multiply,通用矩阵乘,数学形式是 C = α·A·B + β·C。它之所以是性能的命脉,是因为深度学习里几乎所有的重计算最后都归约成它:Attention 里的 QKV/O projection 是矩阵乘,FFN 的 gate/up/down 是矩阵乘,连卷积都能通过 im2col 摊成矩阵乘。一个 Transformer 推理里,绝大部分的 FLOPs 和相当比例的端到端延迟,都消耗在这些 GEMM 上。

结论很直接:谁能把 GEMM 跑得又快又省显存,谁就掌握了整个模型的吞吐和延迟。优化 GEMM 后端,本质上就是在优化整个推理服务的性能上限。这也是为什么这一层值得这么多人反复死磕。

2. GPU 的内存与计算层级:tiling 的由来

一块 GPU 由许多 SM(Streaming Multiprocessor,流多处理器)组成,每个 SM 里有 Tensor Core——专门做小块矩阵乘累加的硬件单元,是现代 GPU 算力的主要来源。

内存是分层的,从快到慢、从小到大大致是:寄存器 → Shared Memory(SMEM,片上、SM 内线程共享)→ L2 Cache → HBM 全局显存。越往外,延迟越高、带宽越紧张。

核心矛盾就在这里:Tensor Core 算得飞快,但数据从 HBM 搬上来很慢。 如果每个数据从显存搬上来只用一次就扔掉,算力会被访存活活拖死,这种状态叫 memory-bound(访存受限)。

解法叫 tiling(分块):把大矩阵切成能装进 SMEM 和寄存器的小块,搬上来之后反复复用,把"算的量 ÷ 搬的量"这个比值(算术强度,arithmetic intensity)拉高,让计算去掩盖访存延迟。CUTLASS 那套分层 tiling,本质就是把这个复用做到极致——它的每一层 tile 都对应 GPU 的一层存储和一层线程组织。

与其每算一个数就跑一趟远处的大仓库(显存)取货,不如一次搬一整箱(一个 tile)到手边的工作台(SMEM/寄存器),就地反复用——搬一次、用很多次,把"搬得慢"摊薄到可以忽略。tile 切多大、怎么分层,本质就是在抠"搬一次到底能用多少次"。

线程也是分层的:thread(单线程)→ warp(32 个线程,调度的基本单位)→ warpgroup(Hopper 引入,4 个 warp)→ thread block / CTA(共享同一块 SMEM)→ cluster(Hopper 引入,多个 CTA 协作)→ grid。tile 的分层正好嵌套在这套线程层级上。

顺带说一个后面要反复用到的细节:SMEM 在硬件上被切成多个 bank(存储体,通常 32 个)。如果一个 warp 里的多个线程同时访问落在同一个 bank 的不同地址,就会触发 bank conflict,硬件被迫把这些访问串行化,白白吃掉带宽。怎么排布 SMEM 数据来躲开这件事,是高性能 kernel 的一个关键细节。

3. Tensor Core 与指令演进:版本代差的根源

理解 GPU 后端的"代差",关键是理解怎么"喂" Tensor Core,而喂它的指令是逐代演进的:

  • Ampere 及以前:mma.sync(warp 级矩阵乘)、ldmatrix(高效把数据加载进寄存器)、cp.async(global → shared 的异步拷贝,让搬数据和算数据能重叠)。
  • Hopper:wgmma(warpgroup 级、一次吃更大一块的矩阵乘)配合 TMA(Tensor Memory Accelerator,硬件级的异步批量数据搬运单元,不再需要占用大量线程去手动搬数据)。
  • Blackwell:tcgen05(第五代 Tensor Core 指令),以及原生支持的低精度块缩放数据类型(NVFP4 / MXFP4 等)。

这里有一个贯穿全文的关键点:新指令往往是新硬件性能的钥匙,而厂商库要过一段时间才能把它们用透。 这正是后文"新架构上该手写"的物理原因。

架构和 SM 版本(compute capability)的对照,正文里会反复出现:

架构SM 版本代表硬件
Ampere SM80 / SM86 A100
Ada SM89 RTX 4090
Hopper SM90 H100
Blackwell SM100 / SM120 等 B200、RTX 5090(SM120)、Thor

后面提到 SM89、SM120、SM100,指的就是这些。

4. 混合精度:为什么"灵活指定精度"是个真需求

数值格式从宽到窄大致是:FP32 → TF32 → FP16 / BF16 → FP8(E4M3 / E5M2)→ FP4(NVFP4 / MXFP4)。位数越少,Tensor Core 吞吐越高、显存和带宽占用越低,但精度越差、越容易溢出或下溢。

实践里的通用做法是混着用:用低精度存权重、做乘法(省显存、提吞吐),但用高精度做累加(通常 FP32),防止误差在长链路里越滚越大。一个典型配置就是"FP8 E4M3 输入 / FP32 累加 / FP16 输出"。

顺带分清两个常被混淆的 16 位格式:BF16 的指数位和 FP32 一样多,动态范围大、不容易溢出,代价是尾数少、精度略低;FP16 反过来。大模型训练和推理里现在更偏好 BF16,就是因为它稳。

所以"能不能独立指定输入、输出、累加器各自的精度"是个实打实的需求——而老接口(按经典 BLAS 约定设计的那种)根本表达不了这种灵活组合。这一点是下面 cuBLASLt 的核心卖点。

5. Epilogue 与算子融合:为什么"融进 epilogue"能省钱

一个 GEMM kernel 通常分两段:主循环(mainloop,做乘累加)和收尾(epilogue,做缩放、加 bias、过激活函数、类型转换、写回显存)。

设想一个常见场景:GEMM 算完,把结果写回显存,再起一个新 kernel 把它读回来做 GELU 激活。这中间多了一整趟"写出去 + 读回来"的显存往返——而访存恰恰是最稀缺的资源。

算子融合(fusion) 就是把激活、bias 这些后处理直接塞进 epilogue,趁数据还在寄存器/SMEM 里时就做完,再一次性写回。省下来的不是算力,是访存往返。这就是后面 FlashRT 给 SigLIP 的 FFN 把 GELU 融进 epilogue 的全部意义。

把视野再放大一点:FlashAttention 把整条注意力计算融成一个 kernel,和 GEMM 的 epilogue fusion 是同一种哲学——尽一切可能减少和 HBM 的往返。理解了这一层,很多算子优化的动机就都通了。

6. 生态坐标:这些东西在整个栈里的位置

把这层讲清楚,才知道每个名字各自管什么。自底向上:

模型
↓
深度学习框架 / 推理引擎
PyTorch / vLLM / TensorRT-LLM / SGLang
↓
算子调用层
aten / custom op / TensorRT plugin / vLLM custom kernel
↓
GEMM 后端
cuBLAS / cuBLASLt / CUTLASS / Triton / 手写 CUDA
│
└── CUTLASS 内部
↓
CuTe
– Layout 代数
– Tensor / Shape / Stride
– TiledCopy
– TiledMMA
– MMA_Atom
– Copy_Atom
– Pipeline 描述
↓
PTX / SASS / CUDA intrinsic
mma.sync / wgmma / tcgen05 / ldmatrix / cp.async / TMA
↓
硬件
Tensor Core / SMEM / Register / L2 / HBM / TMA

横向上还有一条编译器路线:Triton、torch.compile。它们和 CUTLASS 的优化思路同源(tiling、预取、流水线),区别在于把大量决策交给编译器,用更低的开发成本换接近手写的性能。

历史脉络也值得知道:cuBLAS 继承了几十年的 BLAS 接口约定;cuBLASLt 是它面向 AI 场景拉出来的强化分支;CUTLASS 从 2017 年开源,走"白盒模板"路线,后来用 CuTe 重构了抽象,2025 年的 CUTLASS 4 又加上了 Python 的 CuTe DSL。整条线的方向很一致:在不丢性能的前提下,把 kernel 编写做得越来越易用。 这个方向,恰恰会反过来影响下面整个选型逻辑。


二、整条选型光谱

有了上面的词汇,就能把 GEMM 后端摆成一条连续光谱。它从来不是"调库 vs 手写"的二选一,而是每往下走一格,都用易用性换控制力:

层级代表你交出去的你拿回来的典型代价
调库(黑盒) cuBLAS 全部细节 稳定、零维护 形状不友好时性能打折
调库(灰盒) cuBLASLt 大部分细节 灵活精度 + 启发式选 kernel + 部分融合 新精度/新架构支持滞后
模板(白盒) CUTLASS / CuTe 几乎不交 tile、流水线、epilogue 全可控 学习曲线陡、编译慢、要人维护
手写 PTX 内联汇编 什么都不交 极限性能 几乎不可维护,只在最热点用

旁边那条正交的编译器轴(Triton / torch.compile / CuTe DSL),可以理解为"用编译器自动做掉光谱中下层的一部分决策"。

我自己的默认做法是:从光谱最上面开始,只有当一个 workload 的经济性能证明"再往下走一格划算"时,才往下走。 越往下,性能上限越高,但每一格都在透支工程预算和长期维护能力。下面把中间几档讲透。

三、cuBLASLt:默认就该用的那一档

cuBLASLt 是 cuBLAS 面向 AI/ML 的强化版。它和老 cuBLAS 的差距,集中在三件对深度学习真正重要的事上:

1. 灵活的混合精度。 老 cuBLAS 的接口按经典 BLAS 约定设计,混合精度场景下很别扭。cuBLASLt 允许独立指定输入、输出、累加器的精度——"BF16 输入 / FP32 累加 / FP16 输出"这种组合可以直接表达,正是 Transformer 推理里最常见的需求。

2. 启发式选 kernel。 老 cuBLAS 按预定义规则静态匹配 kernel;cuBLASLt 内置启发式,会针对当前的问题规模(M、N、K 加数据类型)从候选里挑性能最好的那个,相当于把"调参"内化进了库里。在 FP16/BF16 上,它通常比老 cuBLAS 更快、显存占用更低。

3. 部分 epilogue 融合。 它能把 bias、激活这类后处理融进 GEMM,省掉一趟显存往返,对延迟敏感的链路有实际收益。

真正能看出对边界的掌握的,是知道它什么时候不该用。一个容易被忽略的细节:FP8 场景下,除非是小 batch,否则更倾向于关掉 cuBLASLt,因为 FP8 的优化路径它不一定跟得上,专门实现的 FP8 GEMM kernel 往往更快。这也是下面 FlashRT 案例的伏笔——同一个团队,在不同精度和不同架构上做了完全相反的选择。

所以立场很明确:FP16/BF16、形状常规、不在最热点上的 GEMM,默认 cuBLASLt。 它是"聪明的默认值"——省心、够快、零维护。宝贵的工程预算,应该留给真正值得手写的地方。

四、CUTLASS:白盒的威力,以及它的代价

如果说 cuBLASLt 是"点菜,厨师按他的理解给你做好",那 CUTLASS 就是"给你食材和菜谱模板,火候、调味、配菜你自己定"。它是一套**"所见即所得"的高性能算子实现范式**:软件架构足够简单,让你能做正向研发和极深的定制优化,代价是你得自己对每一层负责。

它的性能从哪来

CUTLASS 的高性能不是魔法,是围绕 Tensor Core 指令(mma / wgmma / tcgen05)叠出来的一整套多级优化。有了第一部分的地基,这几条就都能落地理解:

  • 分层 Tiling:Thread Block Tile → Warp Tile → Thread Tile,逐层匹配第一部分讲的内存与线程层级,把数据局部性吃干榨净。
  • Swizzle 消 bank conflict:用 Swizzle 重排 SMEM 的数据布局来躲开前面说的 bank 冲突,关键是不靠 padding,所以不浪费 SMEM 容量。(Swizzle<B,M,S> 三个参数到底怎么定,第五部分拆 CuTe 时展开。)
  • 多级流水线:用 cp.async 做异步预取(multi-stage),用计算掩盖访存;到 Hopper 上演进成 Warp Specialized / 生产者-消费者模型——一部分 warp 专职用 TMA 搬数据,一部分专职用 WGMMA 喂 Tensor Core,计算和访存彻底重叠。
  • Block Swizzle(光栅化顺序):改变线程块的发射顺序,把长方形矩阵的遍历"折"成接近正方形,显著提升 L2 命中率。这是个几乎零成本、纯靠调度顺序就能拿到的收益。
  • Predicated Iterator:用位掩码预计算边界条件,避免在内层循环里反复做标量判断,把指令效率压到底。(说人话:矩阵边上总有除不尽的残块,与其在循环里每搬一步都停下来问一句"我越界没",不如提前用一张对照表标好哪些该搬、哪些跳过,照表跑就行。)

架构演进:从手撕模板到 Python

CUTLASS 的版本代差,正好对应着第一部分讲的指令演进:

维度CUTLASS 2.x(Ampere 及以前)CUTLASS 3.x(Hopper)CUTLASS 4.x(2025+)
编程风格 重度模板配置,手写 tile/类型/对齐 引入 CuTe 抽象,弱化线程视角,代码更简洁 新增 CuTe DSL(Python 原生)
核心指令 ldmatrix / mma.sync / cp.async TMA + WGMMA Blackwell tcgen05 + NVFP4/MXFP4 块缩放
流水线 Single / Pipelined / Multistage Persistent + Ping-pong / Cooperative 同上,Python 侧编译提速约 100×
上手 陡,靠手动调参 中等 接近 Triton 的写感,编译时间大幅下降

这里有个必须知道的现状:CUTLASS 已经到了 4.x,最大的变化是引入了 CuTe DSL——一个 Python 原生的 kernel 编写接口,暴露 layout、tensor、hardware atom 这些 CuTe 的核心概念,号称在不牺牲性能的前提下把编译时间降到 C++ 模板的约 1/100,目前覆盖 Ampere 到 Blackwell。如果还把 CUTLASS 理解成"只能用 C++ 手撕模板",就落后了一代。这个变化的战略含义放到最后讲。

它的代价

白盒的另一面是责任。CUTLASS 学习曲线陡、C++ 模板编译慢(改几个参数就要等很久)、写出来的 kernel 要有人长期维护。一个团队里能真正改 CUTLASS kernel 的人通常是个位数,这本身就是一种集中化风险。所以"上 CUTLASS"从来不是纯技术决策,而是一个关于团队资源和长期负债的决策。

五、拆开 CuTe:白盒到底"白"在哪

第四部分说 CUTLASS 给你"控制力",但控制力具体落在哪几个决策上?CUTLASS 3.x 之后,这些决策都通过 CuTe 这套抽象来表达。把它拆开,就能看清"白盒"到底白在哪——以及它凭什么既比手写 PTX 省力、又能精确到每个 Byte 怎么搬。

核心是一套 Layout 代数

CuTe 最关键的革新,是把"数据怎么排布"和"线程怎么映射到数据"统一抽象成同一种东西——Layout 对象,由 Shape(形状)和 Stride(步长)描述。在此之上用 Compose、Inverse、Product 这些代数运算,去推导"哪个线程负责哪块数据"。

这套代数带来两个直接价值:

  • 解耦:TiledCopy 和 TiledMMA(搬运和计算的两个核心构件)的构造,和具体 Tensor 的 Layout 无关——只要 Shape 对得上就能跑,Stride 怎么变它不管。
  • 跨架构:Volta、Ampere、Hopper 的 MMA 指令数据排布各不相同,但代数系统把这些差异屏蔽掉了,换一个 MMA_Atom 就能切到另一代架构。这正是前面说 CUTLASS 3.x "弱化线程视角、代码更简洁"的底层原因。

Layout 说穿了就是一个"编号换地址"的小公式——你报一个逻辑坐标("第 3 行第 5 个"),它告诉你这东西在内存里实际排第几位。Shape 管"一共多少、排成什么形状",Stride 管"坐标每加 1,地址往后跳几格"。所谓"代数",就是把这种公式当乐高拼:线程怎么分工是一条公式,数据怎么摆是另一条,两条一拼,"哪个线程该碰哪块数据"就直接算出来了,不用人脑去数。也正因为搬运和计算的代码只认"这块多大"、不认"它具体怎么摆",换个摆法、甚至换一代显卡,上层逻辑都不用动,只换最底层那块小积木(MMA_Atom)。

一条数据搬运的全链路

一个 GEMM 的数据流动,可以画成一条四段式链路,每一段都由一个 CuTe 构件负责:

Global Memory → Shared Memory → Register → Tensor Core
│ │ │ │
TiledCopy TiledCopy ldmatrix gemm()
(cp.async) (cp.async) (TiledCopy) (TiledMMA)

CuTe 的全部工作,就是用 Layout 代数把这条链路上每一段的"谁搬哪一块、搬到哪、落地后怎么排"自动算出来。下面三个,就是这条链路上你能亲手拧的旋钮,也正是"白盒"四个字的落点。

旋钮一:TiledCopy + cp.async(Global → Shared)

负责把数据异步预取进 SMEM。它有两个关键参数:Tiler_MN(一次 Copy 的形状,只看源/目标 Tensor 的 Shape、不管 Stride,借此和 Layout 解耦)和 TiledLayout_TV(把"线程 ID + 线程内元素坐标"复合映射到 Tiler_MN 里的位置)。

它最硬的约束是访存连续性:ValLayout 对应的元素必须在物理地址上连续,否则直接编译报错(Layout is incompatible with this CopyOp)。行主序下用 ValLayout=(1,8),每个线程搬连续 8 个 half(128 bit,一次向量化拷贝);列主序就得转成 (8,1)。

再叠一层 Cache Line 对齐:GPU 的 Cache Line 是 128 Byte。让每 8 个连续线程各搬 8 个 half,合起来正好覆盖 128 Byte、填满一个 Cache Line,零浪费;要是每 4 个线程只覆盖 64 Byte,就白白浪费一半 L2 带宽,性能直接掉。

cp.async 就是"边搬边算、不用干等"。那条"连续性约束"是说:你派给一个线程搬的那几个数,必须在内存里挨着放,否则一次装不进、直接报错。"Cache Line 对齐"则是——搬运车一趟固定拉一箱(128 Byte),让一组线程正好凑满一整箱最划算;只凑了半箱,就等于白跑了半趟运力。

旋钮二:ldmatrix(Shared → Register)

Hopper 之前,把数据从 SMEM 装进寄存器主要靠 ldmatrix(Hopper 上 WGMMA 能直接从 SMEM 取操作数,这也是编程模型变化的一部分)。它有两个选择维度:

  • x1 / x2 / x4:由 TiledMMA 决定。比如 SM80 的 16×8×8 配上 ValLayout (1,2,1),一个 warp 要处理 16×16×8、含 4 个 8×8 子块,所以选 x4。
  • 带不带 trans:由 SMEM 里矩阵是行主序还是列主序决定。行主序行内连续,按行加载、用不转置的指令(如 LDSM_N);列主序列内连续,得边加载边转置、用带 trans 的(如 LDSM_T)。

底层原理是:ldmatrix 要求每个 8×8 子块的每一行内部连续,但 8 行的起始地址可以不连续——这正是 CuTe 通过 TiledCopy 自动算地址的基础。

x1/x2/x4 就是"这一趟搬 1 块、2 块还是 4 块",搬多少由这组线程这一轮要算多大决定。带不带 trans,看数据在内存里是横着码还是竖着码——竖着码的,搬的时候得顺手"转个身"摆正,否则喂给 Tensor Core 时方向对不上。

旋钮三:Swizzle<B, M, S>(消 bank conflict)

第四部分说"用 Swizzle 躲 bank 冲突、不靠 padding",这里就是它的三个旋钮(以 half 为例):

  • M:新"元素"由 2^M 个基本元素组成(M=3 → 8 个 half = 16 Byte)。
  • S:简化后的 bank 数为 2^S(S=3 → 8 个新 bank,每个 16 Byte 宽)。
  • B:以 2^B 行为单位做 XOR 重映射。约束是 B ≤ S。

取值跟着 Layout 走:(8,32):(32,1) 选 Swizzle<2,3,3>,以 4 行为单位就能消掉 4-way 冲突;(8,64):(64,1) 就得选 Swizzle<3,3,3>,以 8 行为单位才能消掉 8-way 冲突。比起 padding,它一个字节的额外空间都不花。

bank conflict 就像一个班同时去储物柜取东西,本该一人一柜、互不耽误;可要是好几个人的东西恰好挤在同一个柜子里,就只能排队一个个来,慢。Padding 是"多摆几排空柜子把人岔开"(费地方),Swizzle 是"不加柜子,按一条固定的错位规则重排谁用哪个柜",让同时来取的人永远不撞在一个柜上。M/S/B 就是这条错位规则的三个旋钮。

这三件事,cuBLAS 全部替你(在黑箱里)定死了;CuTe 让你一个一个亲手拧。这就是"白盒"和"调库"最本质的区别。

CuTe 往上接什么

CuTe 本身只是"数据结构 + 代数"的工具包,得被组织成完整 kernel 才有价值。它的抽象自下而上分几层:

层次组件干什么
硬件指令 MMA_Operation + MMA_Traits 封装单条 MMA 指令的硬件特性
原子能力 MMA_Atom warp 级的一次 MMA 调用
块状能力 TiledMMA block 级 MMA,由执行单元排列 × 值排列组合而成
线程视角 ThrMMA 通过 partition_A/B/C 拿到本线程负责的数据块
执行 cute::gemm() 循环调用 MMA_Atom 完成矩阵乘

这五层就是从"一块砖"一路放大到"一整面墙"——最底下是硬件的一条指令(一块砖),往上是一个 warp 的一次乘法(一手能码的几块砖),再往上是一整块 tile 的乘法方案(怎么砌一面墙),然后是"我这个线程负责墙的哪一截",最后 gemm() 一圈圈循环把整面墙砌完。

再往上,最直接的下游是 CUTLASS 3.x 的 Collective 模式:CollectiveMainloop 把 TiledCopy(搬运)和 TiledMMA(计算)组装起来,落地多级流水线和 Warp Specialization(就是第四部分说的"一部分 warp 搬数据、一部分喂 Tensor Core");CollectiveEpilogue 把结果从寄存器写回,并在这里做融合(bias、激活、量化反量化)——正好接上第一部分讲的 epilogue fusion。

再往上才是 PyTorch、TensorRT-LLM、vLLM 和顶级算子。FlashAttention-3 在 Hopper 上直接基于 CuTe 开发,因为它要精细控制 WGMMA 和 TMA、还要对异步流水做极致的 ping-pong 调度——这种程度的控制,Triton 或传统 CUDA 很难优雅地拿下。这也顺带回答了一个常见疑问:既然有更好写的 Triton,为什么顶级算子还往 CuTe 上写。答案就在后面的选型框架里。

六、案例拆解:FlashRT 是怎么选的

看完 CuTe 的内部机制,回到工程决策层面——一个真实推理引擎会怎么用这些控制力?光讲框架是空的,FlashRT(机器人模型 Pi0.5 的推理引擎)的 GEMM 选型,恰好把前面所有道理都串起来了。

判断一:按矩阵形状做 tile 特化

FlashRT 发现模型里的矩阵乘根本不是一种形状,于是在 CUTLASS 上针对每种形状量身定制了 tile:

用途矩阵特点tile 策略设计意图
QKV / O projection 方正的大矩阵 256×256×128 大方形 tile 一口吃多点,打满 Tensor Core
FFN Gate / Up 又高又窄 128×256,跨 2 个 SM 协作 两个 SM 合作搬数据
FFN Down 又宽又矮 256×128 宽 tile 宽矩阵专门优化
SigLIP FFN Up 算完还要做 GELU 256×128 + GELU 融进 epilogue 省掉一趟显存往返

全用 cuBLAS 的话,这些形状共享同一套"通用"策略;用 CUTLASS,每种形状都拿到了定制方案。这正是白盒的价值——这些 tile shape、跨 SM 协作、epilogue 融合,落到代码里就是第五部分那套 TiledMMA + CollectiveEpilogue 的组合。但注意,它值得,是因为这些都是形状固定、已知、且在推理热点上的 GEMM。

判断二:按硬件代次反向选型

这是整个案例里最关键的一步。同一个引擎,在不同卡上做了相反的选择:

RTX 4090 (SM89,成熟架构): cuBLASLt FP8 GEMM → 调库
Thor / RTX 5090 (SM100/SM120,新架构): CUTLASS FP8 + FP4 GEMM → 手写模板

逻辑非常清楚:

  • 4090 是成熟架构,cuBLASLt 已经把它优化透了,自己手写不一定比库快——这时候继续往光谱下面走是纯亏。
  • Thor / 5090 是新架构,cuBLASLt 还没来得及针对新硬件做极致优化,而 CUTLASS 能第一时间用上新指令(TMA、WGMMA,乃至 Blackwell 的 tcgen05),第一时间吃到新硬件红利。

背后是一个做基础设施必须内化的洞察:性能前沿会随硬件代次往前移动。 同一个 workload,在新卡上"该手写",过两年硬件成熟、库追上来之后,可能就"该退回去调库"了。选型不是一次性动作,是一个随硬件生命周期滚动的决策。

七、落到一个可执行的选型框架

把上面的判断收敛成一套实际在用的决策流程。面对一个新的 GEMM(或任意密集算子),依次问:

  • 它在热点上吗? 冷路径直接 cuBLASLt 甚至 cuBLAS,别浪费工程预算。只有打了 profile、确认是瓶颈的算子才往下走。
  • 硬件成熟还是全新? 成熟架构优先信库(大概率已经追上);全新架构上,CUTLASS / CuTe 往往是第一时间摸到新指令的唯一路径。
  • Triton / torch.compile 能不能用 10% 的成本拿到 90% 的性能? 大多数情况能。能用编译器解决就别手撕——把 CuTe 留给编译器啃不动、又必须精细控制 WGMMA / TMA / 流水线调度的形状(比如特定的 MoE 算子、定制 Attention)。这就是第五部分那个问题的答案:Triton 是"自动档",开发快但难压到极致;CuTe 是给追求"手自一体"的项目准备的赛车改装工具包。
  • 形状是固定已知,还是动态的? 固定已知才值得做深度 tile 特化(像 FlashRT 那样);形状一直变,cuBLASLt 的启发式选择反而更省心。
  • 精度路径对不对? FP16/BF16 默认 cuBLASLt;FP8/FP4 这种新精度,库的支持往往滞后,自己实现或用专门 plugin 可能更快——记得那个 FP8 关掉 cuBLASLt 的细节。
  • 谁来维护它? 这是最容易被忽略、却最要命的一问。作者离职了谁接?CUDA 版本升级了谁改?下一代架构出来了谁迁移?一个没人能维护的 CuTe kernel,是负债不是资产。
  • 最后是投资回报这道总闸:手写 kernel 比库多榨出的通常是 10–20%。这 10–20% 值不值一个高级工程师一个季度的投入加上持续维护?答案完全取决于 workload 的经济性——一个跑在万卡集群上、7×24 服务的推理热点 GEMM,0.5% 都值得抠;一个一天跑几次的离线任务,20% 也未必划算。这笔账只有站在平台全局的视角才算得清。

    八、收尾:前沿在移动,技能是站位

    整个 GEMM 生态可以这么定位:cuBLASLt 是 cuBLAS 在 AI 领域的强化版,靠灵活的混合精度 API 和启发式选 kernel,为 FP16/BF16 推理提供省心的最优解;CUTLASS / CuTe 是连接底层 PTX 指令和上层框架调用的"软硬件抽象中间件",向下用 Layout 代数屏蔽 mma/ldmatrix 的复杂编址,向上让你写出超越 cuBLAS 的白盒算子。 PyTorch、TensorRT-LLM、vLLM 的底层算子大量集成了这两者,FlashAttention 这类顶级算子的工程基础也建立在 CuTe 之上。

    但还有一个更大的趋势值得盯着:Python DSL 路线(CuTe DSL、Triton、torch.compile)正在系统性地压缩"控制力"和"易用性"之间的鸿沟。过去想要 CUTLASS 级别的控制,就得交 C++ 模板元编程那份沉重的学费;CuTe DSL 出来之后,越来越能在 Python 里拿到接近手写的性能,编译时间还砍掉一个数量级。这直接改变了上面框架里第 3 问的答案——"该不该手撕 CuTe"的门槛在持续抬高。

    所以这套体系真正的落点不在于能背出多少优化手段,而在于:理解整条光谱、清楚每一档的代价、能根据 workload 经济性和硬件代次动态地选位置,并且看得见这条光谱本身正在因为工具链演进而收窄。 库永远是默认值,手写永远是一笔需要用经济账和硬件时机去论证的投资——这才是做 ML 平台时该守住的性能底线。

    赞(0)
    未经允许不得转载:171主机测评 » GEMM 后端选型:从底层概念到工程决策——cuBLASLt 与 CUTLASS 的取舍
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址