跳转到正文
Retep's
返回

[TIL] TileLang 逐元素操作与向量化

编辑文章

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

本文按照官方教程,记录三个 TileLang 向量加法 kernel 的阅读体会:

for i in 0..N:
    c[i] = a[i] + b[i]

假设 dtype=float32,每个元素的计算需要 3 次内存 IO:

load a[i]  = 4 bytes
load b[i]  = 4 bytes
store c[i] = 4 bytes

即每次浮点加法搬运 12 字节,所以向量加法受内存带宽限制。

三种模式

区别在于每个线程承担的工作量。

V1:每线程一个标量

一个 block 覆盖 256 个元素,每个线程计算一个。

@tilelang.jit
def vector_add_v1(n: int, block_size: int = 256, dtype: str = "float32"):
    @T.prim_func
    def kernel(
        a: T.Tensor((n,), dtype),
        b: T.Tensor((n,), dtype),
        c: T.Tensor((n,), dtype),
    ):
        with T.Kernel(T.ceildiv(n, block_size), threads=block_size) as block_idx:
            for thread_idx in T.Parallel(block_size):
                i = block_idx * block_size + thread_idx
                c[i] = a[i] + b[i]

    return kernel

TileLang PrimFunc 直接反映这一点。例如,处理 2^20 个元素需要启动 4096=2^20/256 个 block。

bx = T.launch_thread("blockIdx.x", 4096)
tx = T.launch_thread("threadIdx.x", 256)

for thread_idx in T.parallel(256):
    i: T.int32 = bx * 256 + thread_idx
    c[i] = a[i] + b[i]

降级后,TileLang 将并行循环绑定到 CUDA 线程:

bx = T.launch_thread("blockIdx.x", 4096)
tx = T.launch_thread("threadIdx.x", 256)

c_1[bx * 256 + tx] = a_1[bx * 256 + tx] + b_1[bx * 256 + tx]

生成的 CUDA 是标量形式:

extern "C" __global__ void __launch_bounds__(256, 1) kernel_kernel(const float* __restrict__ a, const float* __restrict__ b, float* __restrict__ c) {
  c[((((int)blockIdx.x) * 256) + ((int)threadIdx.x))] = (a[((((int)blockIdx.x) * 256) + ((int)threadIdx.x))] + b[((((int)blockIdx.x) * 256) + ((int)threadIdx.x))]);
}

PTX 也是标量形式:

	.reg .b32 	%r<8>;
	.reg .b64 	%rd<11>;
	.loc	1 20 0

	ld.param.b64 	%rd1, [kernel_kernel_param_0];
	ld.param.b64 	%rd2, [kernel_kernel_param_1];
	ld.param.b64 	%rd3, [kernel_kernel_param_2];
	.loc	1 21 3
	cvta.to.global.u64 	%rd4, %rd3;
	cvta.to.global.u64 	%rd5, %rd2;
	cvta.to.global.u64 	%rd6, %rd1;
	mov.u32 	%r1, %ctaid.x;
	shl.b32 	%r2, %r1, 8;
	mov.u32 	%r3, %tid.x;
	or.b32 	%r4, %r2, %r3;
	mul.wide.u32 	%rd7, %r4, 4;
	add.s64 	%rd8, %rd6, %rd7;
	ld.global.nc.b32 	%r5, [%rd8];
	add.s64 	%rd9, %rd5, %rd7;
	ld.global.nc.b32 	%r6, [%rd9];
	add.f32 	%r7, %r5, %r6;
	add.s64 	%rd10, %rd4, %rd7;
	st.global.b32 	[%rd10], %r7;
	.loc	1 22 1
	ret;

warp 内仍然能合并访存:相邻线程读取相邻浮点数。但每线程只从 a、b 各加载一个标量,再向 c 存储一个标量。

N = 1,048,576、block_size = 256 时,启动配置为:

1,048,576 / 256 = 4096 blocks

V2:线程粗化与向量化

第二版为每线程分配八个相邻元素:

@tilelang.jit
def vector_add_v2(
    n: int,
    block_size: int = 256,
    num_per_thread: int = 8,
    dtype: str = "float32",
):
    @T.prim_func
    def kernel(
        a: T.Tensor((n,), dtype),
        b: T.Tensor((n,), dtype),
        c: T.Tensor((n,), dtype),
    ):
        with T.Kernel(T.ceildiv(n, block_size * num_per_thread), threads=block_size) as block_idx:
            for thread_idx, j in T.Parallel(block_size, num_per_thread):
                i = (block_idx * block_size + thread_idx) * num_per_thread
                c[i + j] = a[i + j] + b[i + j]

    return kernel

每个 block 覆盖 256 * 8 = 2048 个元素,每个线程在本地计算八个。

base = (block_id * 256 + thread_id) * 8
c[base + 0] = a[base + 0] + b[base + 0]
...
c[base + 7] = a[base + 7] + b[base + 7]

PrimFunc 包含二维并行循环:

bx = T.launch_thread("blockIdx.x", 512)
tx = T.launch_thread("threadIdx.x", 256)

for thread_idx in T.parallel(256):
    for j in T.parallel(8):
        i: T.int32 = (bx * 256 + thread_idx) * 8
        c[i + j] = a[i + j] + b[i + j]

关键是 j 是连续的内层维度,TileLang 可以识别每线程持有一个连续的八元素切片。降级后的设备 IR 清楚体现了这一点。

c_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8] =
    a_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8] +
    b_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8]

切片形式是向量化的关键。生成的 CUDA 使用 256 位向量加载和存储:

ulonglong4 v_ = tl::load_global_256(
    &(*(ulonglong4*)(a + blockIdx.x * 2048 + threadIdx.x * 8)));

ulonglong4 v__1 = tl::load_global_256(
    &(*(ulonglong4*)(b + blockIdx.x * 2048 + threadIdx.x * 8)));

*(float2*)(&(__1.x)) = tl::add2(*(float2*)(&(v_.x)), *(float2*)(&(v__1.x)));
*(float2*)(&(__1.y)) = tl::add2(*(float2*)(&(v_.y)), *(float2*)(&(v__1.y)));
*(float2*)(&(__1.z)) = tl::add2(*(float2*)(&(v_.z)), *(float2*)(&(v__1.z)));
*(float2*)(&(__1.w)) = tl::add2(*(float2*)(&(v_.w)), *(float2*)(&(v__1.w)));

tl::store_global_256(
    &(*(ulonglong4*)(c + blockIdx.x * 2048 + threadIdx.x * 8)), __1);

八个 float32 共 32 字节,即 256 位:

8 floats * 4 bytes = 32 bytes

因此 CUDA 使用 ulonglong4,四个 64 位分量合计 256 位。PTX 中同样如此:

{
	.reg .b32 	%r<7>;
	.reg .b64 	%rd<21>;
	.loc	1 20 0

	ld.param.b64 	%rd17, [kernel_kernel_param_0];
	ld.param.b64 	%rd18, [kernel_kernel_param_1];
	ld.param.b64 	%rd19, [kernel_kernel_param_2];
	.loc	1 22 5
	mov.u32 	%r2, %ctaid.x;
	shl.b32 	%r3, %r2, 11;
	mov.u32 	%r4, %tid.x;
	shl.b32 	%r5, %r4, 3;
	or.b32 	%r6, %r3, %r5;
	mul.wide.u32 	%rd20, %r6, 4;
	add.s64 	%rd5, %rd17, %rd20;
	.loc	1 22 5
	.loc	2 77 3, function_name $L__info_string0, inlined_at 1 22 5
	.loc	2 21 3, function_name $L__info_string1, inlined_at 2 77 3
	mov.b32 	%r1, 1;
	mov.b64 	%rd6, 0;
	// begin inline asm
	{
  .reg .pred p;
	.loc	2 23 3, function_name $L__info_string1, inlined_at 2 77 3
  setp.ne.b32 p, %r1, 0;
	.loc	2 24 3, function_name $L__info_string1, inlined_at 2 77 3
  mov.b64 %rd1, %rd6;
	.loc	2 25 3, function_name $L__info_string1, inlined_at 2 77 3
  mov.b64 %rd2, %rd6;
	.loc	2 26 3, function_name $L__info_string1, inlined_at 2 77 3
  mov.b64 %rd3, %rd6;
	.loc	2 27 3, function_name $L__info_string1, inlined_at 2 77 3
  mov.b64 %rd4, %rd6;
  @p ld.global.v4.u64 {%rd1, %rd2, %rd3, %rd4}, [%rd5];
}

此版本启动:

1,048,576 / 2048 = 512 blocks

相比 v1,v2 具有:

V3:显式寄存器暂存

第三版与 v2 的工作形状相同,都是 256 * 8,但显式写出暂存。先复制当前 block 的数据,循环内部就不必再关心 block_idx。

@tilelang.jit
def vector_add_v3(
    n: int,
    block_size: int = 256,
    num_per_thread: int = 8,
    dtype: str = "float32",
):
    @T.prim_func
    def kernel(
        a: T.Tensor((n,), dtype),
        b: T.Tensor((n,), dtype),
        c: T.Tensor((n,), dtype),
    ):
        with T.Kernel(T.ceildiv(n, block_size * num_per_thread), threads=block_size) as block_idx:
            A_register = T.alloc_fragment((block_size * num_per_thread), dtype)
            B_register = T.alloc_fragment((block_size * num_per_thread), dtype)
            C_register = T.alloc_fragment((block_size * num_per_thread), dtype)
            s_start = block_idx * block_size * num_per_thread
            s_end = (block_idx + 1) * block_size * num_per_thread

            # load 8 values from a into A_register
            T.copy(a[s_start:s_end], A_register)

            # load 8 values from b into B_register
            T.copy(b[s_start:s_end], B_register)

            # for i in 0..8:
            #   C_register[i] = A_register[i] + B_register[i]
            for thread_idx, j in T.Parallel(block_size, num_per_thread):
                i = (thread_idx * num_per_thread) + j
                C_register[i] = A_register[i] + B_register[i]

            # store C_register to c
            T.copy(C_register, c[s_start:s_end])

    return kernel

PrimFunc 使用 fragment:

A_register = T.alloc_fragment((2048,), dtype)
B_register = T.alloc_fragment((2048,), dtype)
C_register = T.alloc_fragment((2048,), dtype)

T.copy(a[s_start:s_end], A_register)
T.copy(b[s_start:s_end], B_register)

for thread_idx, j in T.Parallel(256, 8):
    i = thread_idx * 8 + j
    C_register[i] = A_register[i] + B_register[i]

T.copy(C_register, c[s_start:s_end])

降级后的 IR 为每线程分配长度为 8 的局部缓冲区:

A_register = T.alloc_buffer((8,), scope="local")
B_register = T.alloc_buffer((8,), scope="local")
C_register = T.alloc_buffer((8,), scope="local")

A_register_1[0:8] = a_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8]
B_register_1[0:8] = b_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8]

for i in T.unroll(8):
    C_register_1[i] = A_register_1[i] + B_register_1[i]

c_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8] = C_register_1[0:8]

CUDA 同样使用向量化加载和存储:

float A_register[8];
float B_register[8];
float C_register[8];

*(ulonglong4*)(A_register + 0) = tl::load_global_256(...);
*(ulonglong4*)(B_register + 0) = tl::load_global_256(...);

#pragma unroll
for (int i = 0; i < 8; ++i) {
  C_register[i] = A_register[i] + B_register[i];
}

tl::store_global_256(..., *(ulonglong4*)(C_register + 0));

当 tile 需要复用、变换或参与更复杂计算时,这种风格很有用。但纯向量加法中,每个值只使用一次,显式局部数组未必有帮助,还可能增大寄存器压力。我的理解是 V3 主要展示不同 API 风格,不一定是性能优化。

深入 V2

下面重点分析最有启发性的 v2。整体路径为:TileLang 源码 → PrimFunc → IR → CUDA → PTX → SASS → 在我的 5060Ti 上执行。

TileLang 源码为:

@tilelang.jit
def vector_add_v2(
    n: int,
    block_size: int = 256,
    num_per_thread: int = 8,
    dtype: str = "float32",
):
    @T.prim_func
    def kernel(
        a: T.Tensor((n,), dtype),
        b: T.Tensor((n,), dtype),
        c: T.Tensor((n,), dtype),
    ):
        with T.Kernel(T.ceildiv(n, block_size * num_per_thread), threads=block_size) as block_idx:
            for thread_idx, j in T.Parallel(block_size, num_per_thread):
                i = (block_idx * block_size + thread_idx) * num_per_thread
                c[i + j] = a[i + j] + b[i + j]

    return kernel

用 T.Tensor((n,), dtype) 声明缓冲区

这些语句声明逻辑缓冲区:

a: T.Tensor((n,), dtype)
b: T.Tensor((n,), dtype)
c: T.Tensor((n,), dtype)

随后降级为一维全局缓冲区:

a = T.match_buffer(a_handle, (1048576,), strides=(1,))
b = T.match_buffer(b_handle, (1048576,), strides=(1,))
c = T.match_buffer(c_handle, (1048576,), strides=(1,))

用 T.Kernel(...) 描述 kernel 元信息

启动形状为:

T.ceildiv(n, block_size * num_per_thread)

每块处理 256 * 8 个元素,因此需要 512 个 block,总块数在编译期具体化。PrimFunc 为:

bx = T.launch_thread("blockIdx.x", 512)
tx = T.launch_thread("threadIdx.x", 256)

降级后,函数属性中记录相同的启动配置:

T.func_attr({
    "thread_extent": {
        "blockIdx.x": 512,
        "threadIdx.x": 256,
        "threadIdx.y": 1,
        "threadIdx.z": 1,
    },
    ...
})

CUDA 层为:

extern "C" __global__ void __launch_bounds__(256, 1) kernel_kernel(...)

__launch_bounds__(256, 1) 告知 CUDA 编译器:每块最多 256 个线程,并以每 SM 至少一个 block 的约束进行资源规划。

T.Parallel(block_size, num_per_thread)

这一行:

for thread_idx, j in T.Parallel(block_size, num_per_thread):

创建二维并行迭代空间,也就是嵌套循环。

thread_idx in 0..255
j          in 0..7

重要的是布局:thread_idx 映射到 threadIdx.x,j 变成每线程连续的向量分量。因此降级后的 IR 不再保留嵌套标量循环,而变成向量切片:

c_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8] =
    a_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8] +
    b_1[bx * 2048 + tx * 8 : bx * 2048 + tx * 8 + 8]

概念上:

for this CUDA thread:
    load 8 contiguous floats from a
    load 8 contiguous floats from b
    add them elementwise
    store 8 contiguous floats to c

CUDA 向量加载

接着看 CUDA 特有的内存搬运。生成代码先从 a 加载八个浮点数,通过类型转换将地址解释为 256 位向量指针,让辅助函数执行 256 位全局加载。

ulonglong4 v_ = tl::load_global_256(
    &(*(ulonglong4*)(a + blockIdx.x * 2048 + threadIdx.x * 8)));

ulonglong4 包含四个 64 位无符号值,共 32 字节。float32 是 4 字节,正好对应 num_per_thread = 8。这就是这些超参数会影响代码生成的原因。

CUDA 加法

接着每次相加两个浮点数:

*(float2*)(&(__1.x)) = tl::add2(*(float2*)(&(v_.x)), *(float2*)(&(v__1.x)));
*(float2*)(&(__1.y)) = tl::add2(*(float2*)(&(v_.y)), *(float2*)(&(v__1.y)));
*(float2*)(&(__1.z)) = tl::add2(*(float2*)(&(v_.z)), *(float2*)(&(v__1.z)));
*(float2*)(&(__1.w)) = tl::add2(*(float2*)(&(v_.w)), *(float2*)(&(v__1.w)));

每个 ulonglong4 分量为 64 位,float2 也是 64 位,即两个 float32,所以四次调用覆盖八个浮点数:

__1.x -> elements 0,1
__1.y -> elements 2,3
__1.z -> elements 4,5
__1.w -> elements 6,7

结果重新打包到 __1。

CUDA 存储

最后:

tl::store_global_256(
    &(*(ulonglong4*)(c + blockIdx.x * 2048 + threadIdx.x * 8)), __1);

用一次 256 位存储写回八个 float32 结果。

PTX:参数与寄存器

下面看生成的 PTX。

.visible .entry kernel_kernel(
    .param .u64 .ptr .align 1 kernel_kernel_param_0,
    .param .u64 .ptr .align 1 kernel_kernel_param_1,
    .param .u64 .ptr .align 1 kernel_kernel_param_2
)
.maxntid 256
.minnctapersm 1
{
    .reg .b32 %r<7>;
    .reg .b64 %rd<21>;

三个参数是 a、b、c 的地址,寄存器声明预留临时寄存器:

指针和向量分量需要 64 位寄存器。线程/block ID 与偏移可以先用 32 位,进行指针运算时再扩展。

PTX:加载 kernel 参数

ld.param.b64 %rd17, [kernel_kernel_param_0];
ld.param.b64 %rd18, [kernel_kernel_param_1];
ld.param.b64 %rd19, [kernel_kernel_param_2];

将三个指针参数加载到寄存器:

%rd17 = a
%rd18 = b
%rd19 = c

PTX:计算基准偏移

mov.u32 %r2, %ctaid.x;
shl.b32 %r3, %r2, 11;
mov.u32 %r4, %tid.x;
shl.b32 %r5, %r4, 3;
or.b32  %r6, %r3, %r5;
mul.wide.u32 %rd20, %r6, 4;

这是以下表达式的降级形式:

element_offset = blockIdx.x * 2048 + threadIdx.x * 8
byte_offset = element_offset * 4

为什么使用移位?

2048 = 2^11, so blockIdx.x * 2048 becomes shl by 11
8    = 2^3,  so threadIdx.x * 8 becomes shl by 3
4    = sizeof(float32), so byte offset multiplies by 4

编译器使用 or.b32,因为 block 部分和线程部分占据不重叠的位:

blockIdx.x << 11
threadIdx.x << 3

在这个布局中,按位 OR 等价于相加。

PTX:a 的地址

add.s64 %rd5, %rd17, %rd20;

它计算:

%rd5 = a + byte_offset

PTX:向量加载

生成的内联汇编包含:

@p ld.global.v4.u64 {%rd1, %rd2, %rd3, %rd4}, [%rd5];

对应以下操作的 PTX 版本:

tl::load_global_256(...)

加载四个 64 位值:

4 * 64 bits = 256 bits = 32 bytes = 8 float32 values

b 也使用相同模式。

PTX:加法与存储

之后,四个 64 位数据块以打包的 float32 对进行相加:

add.rn.f32x2 %rd13, %rd1, %rd7;
add.rn.f32x2 %rd14, %rd2, %rd8;
add.rn.f32x2 %rd15, %rd3, %rd9;
add.rn.f32x2 %rd16, %rd4, %rd10;

每条 f32x2 指令处理一个 64 位寄存器中打包的两个 float32,四条指令覆盖八个元素。

然后计算输出地址:

add.s64 %rd12, %rd19, %rd20;

并存储四个 64 位数据块:

@p st.global.v4.u64 [%rd12], {%rd13, %rd14, %rd15, %rd16};

因此,这份 PTX 中的 v2 在内存操作和打包算术两个层面都实现了向量化。


编辑文章
分享文章:

上一篇
[TIL] GPU 共享内存 Swizzle
下一篇
[Book Club] FlashAttention:具备 IO 感知的快速、省内存精确注意力