本文按照官方教程,记录三个 TileLang 向量加法 kernel 的阅读体会:
v1:每个 CUDA 线程一个元素。v2:每个线程八个连续元素。v3:每线程八个连续元素,并通过显式局部 fragment 暂存。
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 具有:
- 八分之一的 block 数量。
- 每线程八个元素的有效工作。
- 向量化全局加载和存储。
- 更低的逐元素标量索引开销。
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 的地址,寄存器声明预留临时寄存器:
%r为 32 位寄存器。%rd为 64 位寄存器。
指针和向量分量需要 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 在内存操作和打包算术两个层面都实现了向量化。