TileLang 与 Triton
使用 TileLang 和 Triton 编程一段时间后,我觉得最有趣的区别不只是语法,而是它们希望你在哪个层次思考问题。
Triton 通常让你思考:
一个 program 实例如何处理一块元素?
TileLang 通常让你思考:
要在 GPU 内存层次中搬运哪些 tile,并对它们执行什么操作?
这个区别看似细微,却改变了代码的组织方式。
Triton 更像分块 SPMD 编程:手动计算偏移、创建 mask、加载向量或矩阵、执行块操作并存储结果。TileLang 更像 tile 级调度语言:声明 kernel 启动结构,分配 shared 或 fragment 缓冲区,在不同内存作用域间复制 tile,再调用 T.gemm 等操作。下面看几个例子。
示例 1:向量加法
向量加法很简单,未必需要 TileLang,但它能清楚展示 API 差异。
Triton 写法:
import triton
import triton.language as tl
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n_elements, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offsets = pid * BLOCK + tl.arange(0, BLOCK)
mask = offsets < n_elements
x = tl.load(x_ptr + offsets, mask=mask, other=0.0)
y = tl.load(y_ptr + offsets, mask=mask, other=0.0)
tl.store(out_ptr + offsets, x + y, mask=mask)
def add(x, y):
out = torch.empty_like(x)
grid = lambda meta: (triton.cdiv(x.numel(), meta["BLOCK"]),)
add_kernel[grid](x, y, out, x.numel(), BLOCK=1024)
return out
每个 Triton program 负责一块连续元素,基本流程是:
- 获取 program ID。
- 生成偏移向量。
- 用 mask 处理尾部。
- 加载、计算、存储。
这是 Triton 的基本节奏。tl.arange 表示一块元素,x + y 等操作应用于整个块。
TileLang 的同一思路更像一个带 block 上下文和并行循环的 kernel 体:
import tilelang
import tilelang.language as T
from tilelang import jit
@jit
def add(N: int, block: int = 256, dtype: str = "float32"):
@T.prim_func
def add_kernel(
A: T.Tensor((N,), dtype),
B: T.Tensor((N,), dtype),
C: T.Tensor((N,), dtype),
):
with T.Kernel(T.ceildiv(N, block), threads=block) as bx:
for i in T.Parallel(block):
gi = bx * block + i
if gi < N:
C[gi] = A[gi] + B[gi]
return add_kernel
这里用 T.Kernel 声明 grid,用 T.Parallel 描述块内工作。对于向量加法,它与 Triton 表达的是同一个简单想法。
但思维模型不同。Triton 将块表示为一个向量值:
offsets = pid * BLOCK + tl.arange(0, BLOCK)
x = tl.load(x_ptr + offsets, mask=mask)
TileLang 将块表示为启动上下文,再描述其中的并行工作:
with T.Kernel(T.ceildiv(N, block), threads=block) as bx:
for i in T.Parallel(block):
C[bx * block + i] = A[bx * block + i] + B[bx * block + i]
对于逐元素 kernel,我通常觉得 Triton 更直接,因为相比 SIMD 模型中的纯 if-else,我更习惯 mask 语法。
示例 2:矩阵乘法
矩阵乘法更能体现设计差异。
小型 Triton matmul kernel 通过指针运算和块张量构建:
@triton.jit
def matmul_kernel(
A,
B,
C,
M: tl.constexpr,
N: tl.constexpr,
K: tl.constexpr,
stride_am: tl.constexpr,
stride_ak: tl.constexpr,
stride_bk: tl.constexpr,
stride_bn: tl.constexpr,
stride_cm: tl.constexpr,
stride_cn: tl.constexpr,
BM: tl.constexpr,
BN: tl.constexpr,
BK: tl.constexpr,
):
pid_m = tl.program_id(0)
pid_n = tl.program_id(1)
offs_m = pid_m * BM + tl.arange(0, BM)
offs_n = pid_n * BN + tl.arange(0, BN)
offs_k = tl.arange(0, BK)
acc = tl.zeros((BM, BN), dtype=tl.float32)
for k0 in range(0, K, BK):
a = tl.load(
A + offs_m[:, None] * stride_am + (k0 + offs_k[None, :]) * stride_ak,
mask=(offs_m[:, None] < M) & (k0 + offs_k[None, :] < K),
other=0.0,
)
b = tl.load(
B + (k0 + offs_k[:, None]) * stride_bk + offs_n[None, :] * stride_bn,
mask=(k0 + offs_k[:, None] < K) & (offs_n[None, :] < N),
other=0.0,
)
acc += tl.dot(a, b)
tl.store(
C + offs_m[:, None] * stride_cm + offs_n[None, :] * stride_cn,
acc,
mask=(offs_m[:, None] < M) & (offs_n[None, :] < N),
)
重要对象是这些块张量:
a的形状为[BM, BK]。b的形状为[BK, BN]。acc的形状为[BM, BN]。
你显式通过指针表达式构造张量。编译器看到静态块形状后,在类型和形状匹配时,可以将 tl.dot 降级为高效矩阵指令。
TileLang 的 matmul 通常围绕内存层次组织:
@jit
def matmul(M: int, N: int, K: int, BM: int = 128, BN: int = 128, BK: int = 32):
@T.prim_func
def matmul_kernel(
A: T.Tensor((M, K), "float16"),
B: T.Tensor((K, N), "float16"),
C: T.Tensor((M, N), "float16"),
):
with T.Kernel(T.ceildiv(N, BN), T.ceildiv(M, BM), threads=128) as (bx, by):
A_s = T.alloc_shared((BM, BK), "float16")
B_s = T.alloc_shared((BK, BN), "float16")
C_f = T.alloc_fragment((BM, BN), "float32")
T.clear(C_f)
for ko in T.Pipelined(T.ceildiv(K, BK), num_stages=3):
T.copy(A[by * BM, ko * BK], A_s)
T.copy(B[ko * BK, bx * BN], B_s)
T.gemm(A_s, B_s, C_f)
T.copy(C_f, C[by * BM, bx * BN])
return matmul_kernel
代码以具名 tile 缓冲区为中心:
A_s:共享内存中的Atile。B_s:共享内存中的Btile。C_f:fragment/寄存器内存中的累加器 tile。
循环表达的是:沿 K 块建立流水线,将全局 tile 拷到共享内存,用共享内存 tile 做乘法并累加到 fragment,最后将结果写回全局内存。这是不同的抽象边界。
API 差异
内存放置
Triton 暴露块值,代码仍然接近地址计算:
ptrs = A + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak
a = tl.load(ptrs, mask=mask, other=0.0)
TileLang 暴露 tile 的搬运:
A_s = T.alloc_shared((BM, BK), "float16")
T.copy(A[by * BM, ko * BK], A_s)
Triton 的形状由张量表达式携带,TileLang 的形状由 tile 缓冲区携带。
Triton 的内存放置通常是隐式的:代码写出加载操作,但分配由编译器完成。TileLang 将内存放置纳入源程序,T.alloc_shared、T.alloc_fragment、T.copy、T.Pipelined 都是程序本身的重要组成。
因此,Triton kernel 常像带显式 mask 和指针运算的 NumPy 块程序,你围绕一个 program 及其持有的块张量思考。TileLang 更显式,也更接近 CUDA 编程,例如 C++ 中需要显式分配和管理内存。
步长
Triton 示例通常显式传入 stride,因为 kernel 往往需要支持任意 PyTorch 张量布局:
ptrs = A + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak
a = tl.load(ptrs, mask=mask, other=0.0)
步长运算直接出现在 kernel 中,清楚表明物理地址不一定等同于逻辑 [row, col] 坐标。
TileLang 示例常省略 stride,因为 T.Tensor((M, K), dtype) 默认描述紧凑布局的逻辑张量:
A: T.Tensor((M, K), "float16")
T.copy(A[by * BM, ko * BK], A_s)
这里 A[by * BM, ko * BK] 是逻辑 tile 起点。复制范围由 A_s 推导,默认行主序地址计算由张量形状推导。对于非连续、带 padding、转置或其他自定义布局,stride 并没有消失,而是需要通过 tensor/buffer 布局或显式索引表示。
对于简单的带步长全局张量,可以把布局附着在缓冲区本身。具体写法取决于 TileLang 版本,但概念上类似:
@T.prim_func
def kernel(
A: T.Buffer((M, K), "float16", strides=(stride_am, stride_ak)),
C: T.Buffer((M, N), "float16", strides=(stride_cm, stride_cn)),
):
with T.Kernel(T.ceildiv(N, BN), T.ceildiv(M, BM), threads=128) as (bx, by):
row = by * BM
col = bx * BN
x = A[row, col]
C[row, col] = x
索引仍然是逻辑的:
x = A[row, col]
物理地址则根据缓冲区的 stride 元数据推导,大致为:
x = A.data[row * stride_am + col * stride_ak]
这与常见 Triton 风格存在重要差异。在 Triton 中,逻辑到物理的映射通常直接出现在指针表达式中:
ptr = A + row * stride_am + col * stride_ak
x = tl.load(ptr)
在 TileLang 中,如果缓冲区携带布局,源代码可以继续使用逻辑索引。对于更特殊的布局,例如 tensor core 操作使用的共享内存 swizzle,通常通过布局标注或专门分配的缓冲区表示,而非将原始全局张量当成普通带步长矩阵。
因此,Triton 默认更容易看到物理布局;TileLang 则让常见紧凑布局读起来像逻辑 tile 搬运。
掩码
Triton 在加载和存储位置显式写出边界 mask:
a = tl.load(
A + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak,
mask=(offs_m[:, None] < M) & (offs_k[None, :] < K),
other=0.0,
)
TileLang 的 T.copy 通常可以依赖编译器合法化保证边界安全:
T.copy(A[by * BM, ko * BK], A_s)
T.copy(C_f, C[by * BM, bx * BN])
因为 A、C、A_s、C_f 都有已知形状,编译器可以为边缘 tile 插入检查,并在证明完全不越界时移除。对 matmul 来说,越界输入应视为零填充,越界输出则不写入,因此很自然。
但这只是内存安全 mask,不一定等于算法需要的 mask。Softmax 或 attention 的无效位置通常需要设为 -inf,而不是 0.0。在 TileLang 中仍要显式表达:
valid = T.all_of(row < M, col < N, col <= row)
score = T.if_then_else(
valid,
score,
-T.infinity("float32"),
)
对应的 Triton 写法是:
score = tl.where(valid, score, float("-inf"))