跳转到正文
Retep's
返回

[TIL] TileLang EP-01:初探

编辑文章

本文由英文原文翻译。代码、公式与技术名称保留原文。

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 负责一块连续元素,基本流程是:

  1. 获取 program ID。
  2. 生成偏移向量。
  3. 用 mask 处理尾部。
  4. 加载、计算、存储。

这是 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),
    )

重要对象是这些块张量:

你显式通过指针表达式构造张量。编译器看到静态块形状后,在类型和形状匹配时,可以将 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 缓冲区为中心:

循环表达的是:沿 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"))

参考资料


编辑文章
分享文章:

上一篇
[TIL] 学习笔记:卷积
下一篇
[TIL] 学习笔记:Softmax Attention