昇腾 Triton 算子进阶:迁移、调试与自动调优
昇腾 Triton 算子进阶:迁移、调试与自动调优
一句话让Agent变成昇腾专家,昇腾任务轻松搞定。评测入口:请按这个开源仓接入昇腾图谱 https://gitcode.com/agent0/kg-tools
适用:已在 GPU 上跑通 Triton 算子,要把它落到昇腾 NPU 上
前置:CANN 与 Triton-Ascend 已装好,机器有一张 910B 或 950 系列卡
口径:接口、约束与默认值核对自 Triton-Ascend、AscendNPU IR 与 Triton 官方文档,2026-11 核对
一份在 GPU 上跑通的 Triton kernel 搬到 NPU,源码改动通常是个位数行。工作量集中在参数和判断上:grid 怎么切、块开多大、片上内存够不够、调优结果凭什么可信。这些问题的答案来自同一个前提——NPU 的核数、存储层级与执行模型和 GPU 不同。
一、迁移
1.1 不变的部分与要换的接口
@triton.jit 等写法不变,语义不变(tl.load、tl.store、tl.program_id ),kernel[grid](...) 等调用形式不变,@triton.autotune 与 @triton.jit 等装饰顺序也不变。同一份 kernel 源码在两个平台上的差别只有 host 侧的设备接口与分核参数。
设备接口按表替换:
| 位置 | GPU 写法 | 昇腾写法 |
|---|---|---|
| 导入 | import torch | import torch + import torch_npu |
| 设备 | device="cuda" | device="npu" |
| 张量判断 | x.is_cuda | x.is_npu |
| 流与当前设备 | torch.cuda.Stream、torch.cuda.current_device() | torch.npu.Stream、torch.npu.current_device() |
| 数据类型 | uint8 / fp64 | 无对应计算通路,换 int32 / fp32 |
表格最后一行是硬约束。uint8 到 uint32、fp64 在 NPU 上没有对应的计算通路,迁移时保留原 dtype 会停在编译期。
kernel 内部有三处需要留意,它们决定正确性与性能:
- grid 取值范围:最多 3 维,单个维度与 program 总数都封顶 65535。
- 片上内存使用:一块数据必须整块搬进 UB 才能参与计算,容量有上限。
- 搬运与计算的排布:由
multibuffer控制,默认开,占双份片上内存。
1.2 grid 与多核并行
grid 的形态与上限
grid 是一个 tuple,长度即维度数,最多 3 维,写成 (x,)、(x, y) 或 (x, y, z)。每个维度的上限是 65535,x*y*z 得到的 program 总数同样封顶 65535,因为核号在底层用 uint16 表达。单块元素数另有一条 < 65536 的限制。
目标轴的选择
轴的选择决定访存连续性。二维张量 (M, N) 按 M 切分,一个 program 负责一整行,行内地址连续,一次 tl.load 搬走一段相邻内存;按 N 切分,同一个 program 的相邻元素在地址上相隔 N 个位置,搬运退化成非连续访问。
并行轴合并
轴数超过 3 时先合并。四维张量 (B, H, M, N) 无法直接映射,做法是把互不依赖的轴乘成一个,在 kernel 内用整除与取余反解:
pid = tl.program_id(0)
n_m = tl.cdiv(M, BLOCK_M)
b, h, m = pid // (H * n_m), (pid // n_m) % H, pid % n_m
Triton-Ascend 在运行时会把多维 grid 展平成一维:flat_pid = pid_x + pid_y * grid_x + pid_z * grid_x * grid_y。2D 与展平后的 1D 没有性能差异,多维写法省掉的是手工反解,代价是多一层索引计算。
用满物理核
grid 的大小与物理核数有三种关系:
| 关系 | 运行时行为 | 后果 |
|---|---|---|
| grid < 物理核数 | 部分核空闲 | 算力闲置 |
| grid = 物理核数 | 一轮下发,每核接一个 program | 最优 |
| grid > 物理核数 | 分批调度,多轮下发 | 每轮带核启动与初始化开销 |
物理核数从运行时接口读。逐元素与归约算子取 num_vectorcore,含矩阵乘的融合算子取 num_aicore:
import triton.runtime.driver as driver
props = driver.active.utils.get_device_properties(device_id)
props["num_vectorcore"] # Vector 核数
props["num_aicore"] # Cube 核数
num_vectorcore 通常是 num_aicore 的两倍,因为一个 AI Core 含 1 个 Cube 核与 2 个 Vector 核。核数查询要走一趟运行时,放在模块初始化时取一次,不要写在每次前向里。
完整示例:按行分核与核数封顶
按行切分与核数封顶合在一起,是一段完整的 kernel 与 host 侧代码:
"""二维张量按行分核:grid 取物理核数,核内跨步领行。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.runtime.driver as driver
@triton.jit
def scale_rows(x_ptr, out_ptr, n_row, n_col, scale, BLOCK_N: tl.constexpr):
pid, stride = tl.program_id(0), tl.num_programs(0)
offs = tl.arange(0, BLOCK_N)
mask = offs < n_col
for row in range(pid, n_row, stride): # 每个核隔 stride 领一行
base = row * n_col
x = tl.load(x_ptr + base + offs, mask=mask)
tl.store(out_ptr + base + offs, x * scale, mask=mask)
def scale(x, s):
n_row, n_col = x.shape
out = torch.empty_like(x)
props = driver.active.utils.get_device_properties(x.device.index or 0)
grid = (min(n_row, props["num_vectorcore"]),) # 核数封顶
scale_rows[grid](x, out, n_row, n_col, s,
BLOCK_N=triton.next_power_of_2(n_col))
return out
x = torch.randn(2048, 4096, device="npu")
out = scale(x, 2.0)
assert torch.allclose(out, x * 2.0, atol=1e-5), "结果与 PyTorch 不一致"
print("PASSED")
grid 取 min(行数, 核数):行数少于核数时按行数开,避免启动一批只领到空任务的核;行数多于核数时按核数开,多出来的行由核内循环分掉。BLOCK_N 取 next_power_of_2(n_col),块大小必须是 2 的幂,非 2 的幂会报 block size must be power of 2。
1.3 片上内存与行内二次切分
约束:UB 容量与搬运对齐
tl.load 的结果整块搬进 UB。一个块的所有活跃张量同时占 UB:输入两份、输出一份、中间结果若干份,再乘数据类型。910B 的 UB 是 192 KB,fp32 下 16384 个元素占 64 KB,进出两份 128 KB,开双缓冲再翻一倍到 256 KB,编译期直接报 UB overflow。
搬运的粒度同样吃容量之外的账。tl.load 与 tl.store 各是一次 DMA,地址按 512 B 对齐时效率最高:fp32 的块大小取 128 的倍数,fp16 与 bf16 取 256 的倍数,都正好凑满 512 B。对齐不足时一次搬运被拆成几次,指令数与同步次数跟着涨。
缩小 block 不可行
块大了放不下,直觉是调小。这条路的代价有两笔:
- grid 跟着块数涨:按
cdiv(n, BLOCK)开 grid 的写法里,块数翻倍,grid 同步翻倍,超过物理核数后转入多轮下发,每轮都有核启动与初始化开销。 - 单次搬运变小:数据量减半后,指令与同步的固定开销摊到更少的数据上,MTE2 的有效带宽下降。
行内二次切分
可行做法是保住外层块,在 kernel 内部再切一刀。外层 BLOCK_N 对应一整行,这个值不变,grid 不变;行内按 SUB_N 分段循环,UB 只需要容纳一段:

"""行内二次切分:外层一行不动,行内按 SUB_N 分段,UB 只放一段。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.runtime.driver as driver
@triton.jit
def scale_rows(x_ptr, out_ptr, n_row, n_col, scale,
BLOCK_N: tl.constexpr, SUB_N: tl.constexpr):
pid, stride = tl.program_id(0), tl.num_programs(0)
sub = tl.arange(0, SUB_N)
for row in range(pid, n_row, stride):
base = row * n_col
for col in range(0, BLOCK_N, SUB_N): # 行内再切,UB 只放 SUB_N
offs = col + sub
mask = offs < n_col
x = tl.load(x_ptr + base + offs, mask=mask)
tl.store(out_ptr + base + offs, x * scale, mask=mask)
def scale(x, s):
n_row, n_col = x.shape
out = torch.empty_like(x)
props = driver.active.utils.get_device_properties(x.device.index or 0)
block = triton.next_power_of_2(n_col)
grid = (min(n_row, props["num_vectorcore"]),)
scale_rows[grid](x, out, n_row, n_col, s, BLOCK_N=block, SUB_N=block // 4)
return out
# 一行 16384 个 fp32 是 64KB,进出各一份、双缓冲再翻倍,超过 192KB 的 UB
x = torch.randn(512, 16384, device="npu")
out = scale(x, 2.0)
assert torch.allclose(out, x * 2.0, atol=1e-5), "结果与 PyTorch 不一致"
print("PASSED")
两个方案的差别只在 UB 里同时存在几份数据。grid 与核数分配完全相同,BLOCK_N 也相同,新增的只有 SUB_N 与它带来的那层循环。
行内循环的连带影响
行内切分顺带解决第二个问题。多缓冲的重叠发生在相邻迭代之间,kernel 里没有循环就没有可迭代的相邻块,multibuffer 开关不起作用。行内循环提供了这个循环体。
代价要提前算清:需要整块统计量的算子(softmax、layernorm)不能靠一段算完。要么扫两遍,第一遍累计统计量,第二遍重新 load 再归一化,GM 读两次;要么用在线更新公式(Welford)逐段推进,让统计量与数据同步走完一遍。
1.4 昇腾的硬件架构
一个 AI Core 由两类子核组成,各自带一套片上存储。这套结构决定两件事:分核时看哪个核数,块大小受谁约束。

- AIC(Cube 子核):Cube Core 做矩阵乘,Scalar Core 管标量与地址计算;存储是 L1 Buffer 512 KB、L0A / L0B 各 64 KB、L0C 128 KB(950 为 256 KB)。
- AIV(Vector 子核):Vector Core 做逐元素与归约,Scalar Core 同上;存储是 Unified Buffer 192 KB(950 为 248 KB,预留 8 KB)。
- GM:HBM,所有单元共享,AI Core 之间的片上存储互不可见。
Cube 侧的数据走 GM → L1 → L0A/L0B → L0C → GM,Vector 侧走 GM → UB → GM。同一句 tl.load 落到哪条通路,由编译器按算子语义决定,调用方无法指定。
迁移上的两个结论:
- 逐元素与归约算子只碰 UB,块大小受 192 KB 约束,分核看
num_vectorcore。 - 矩阵乘类算子只碰 L1 与 L0,块大小受 L1 的 512 KB 与 L0C 的 128 KB 约束,分核看
num_aicore。
L1、L0A、L0B、L0C 在 Triton 里没有对应接口。数据从 GM 进 L1、从 L1 进 L0,全部由编译器在 HIVM 那一层插入(编译链路的五层结构见上一篇)。这是 Triton 与 AscendC 在迁移成本上的分界:Triton 的块大小只需满足 UB 容量,AscendC 要同时满足四级存储的容量与对齐。
1.5 multibuffer 与流水重叠
机制与生效条件
multibuffer 控制片上缓冲的份数。单缓冲时一个块的处理是 load → compute → store 三段串行;多缓冲给同一份逻辑缓冲分配两份物理空间,第 i+1 块的搬运与第 i 块的计算在时间上重叠,MTE2 与 Vector 同时忙。

三个性质决定它什么时候有用:
- 默认开:A2 / A3 上不写这个参数也走多缓冲;910_95 默认关。
- kernel 里要有循环:重叠发生在相邻迭代之间,没有迭代就没有可重叠的对象。
- 占双份片上内存:同一块数据两份物理缓冲,可用容量按一半算。块大小贴着 UB 上限时,开多缓冲会直接编译失败。
两种开启方式
- 写进
triton.Config的字典:随块大小一起交给 autotune,由实跑结果选。 - 调用时按关键字传:不走 autotune,一次调用定死。
写进 Config 的写法:
"""方式一:multibuffer 写进 Config,随块大小一起交给 autotune 选。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.backends.ascend.runtime # 启用 Ascend 的 autotune 扩展
@triton.autotune(configs=[
triton.Config({"BLOCK": 4096}), # 默认开
triton.Config({"BLOCK": 4096, "multibuffer": False}), # 显式关
], key=["n"])
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
x = tl.load(x_ptr + offs, mask=mask)
y = tl.load(y_ptr + offs, mask=mask)
tl.store(out_ptr + offs, x + y, mask=mask)
def add(x, y):
out = torch.empty_like(x)
grid = lambda meta: (triton.cdiv(out.numel(), meta["BLOCK"]),)
add_kernel[grid](x, y, out, out.numel()) # 调用处不写 BLOCK
return out
x = torch.randn(98432, device="npu"); y = torch.randn(98432, device="npu")
assert torch.allclose(add(x, y), x + y), "结果与 PyTorch 不一致"; print("PASSED")
调用时传的写法:
"""方式二:调用时直接指定 multibuffer,不进 kernel 函数签名。"""
import torch
import torch_npu
import triton
import triton.language as tl
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
x = tl.load(x_ptr + offs, mask=mask)
y = tl.load(y_ptr + offs, mask=mask)
tl.store(out_ptr + offs, x + y, mask=mask)
def add(x, y, multibuffer=True):
out = torch.empty_like(x)
grid = (triton.cdiv(out.numel(), 4096),)
add_kernel[grid](x, y, out, out.numel(),
BLOCK=4096, multibuffer=multibuffer)
return out
x = torch.randn(98432, device="npu"); y = torch.randn(98432, device="npu")
assert torch.allclose(add(x, y), x + y), "结果与 PyTorch 不一致"; print("PASSED")
multibuffer 不是 kernel 的入参,不进函数签名。它写在 Config 的字典里,或作为调用时的关键字参数,编译器在生成 IR 时读取。
何时关闭
- UB 已被块大小占满,多缓冲直接撑爆容量。
- kernel 内有跨迭代依赖,编译器无法安全地提前发起下一块的搬运。
- 瓶颈在 atomic 或标量循环,不在 MTE2 与 MTE3。
二、调试
迁移完成后先确认结果对不对。调试手段有三种,成本从低到高:
tl.static_print:编译时打印常量,无运行时开销。tl.device_print:运行时打印张量,有运行时开销,量随核数与块数放大。TRITON_INTERPRET=1:kernel 在 CPU 上逐元素执行,能插断点,慢。
2.1 打印:编译期与运行期
两种打印的执行时机不同:
| 接口 | 执行时机 | 能打什么 | 开销 |
|---|---|---|---|
tl.static_print | 编译时 | tl.constexpr 参数、常量表达式 | 无 |
tl.device_print | 运行时 | 张量、变量 | 有,进总耗时 |
两者都由 TRITON_DEVICE_PRINT=1 打开,TRITON_DEBUG=1 一并开启(含 IR 转储)。
device_print 的第一个参数是字符串前缀,必填,且必须是编译期常量。运行时输出会按核分组并标出核号,前缀负责的是另一件事:同一个 kernel 里有多处打印、或者多个 kernel 同时在跑时,靠它分辨哪一行由谁打出。只写 "debug" 等于没写。打印长度有上限,超长的张量会被截断;每个线程的 GM 打印缓冲是 16 KB,写满即丢。
"""两种打印:static_print 看编译期常量,device_print 看运行时张量。"""
import torch
import torch_npu
import triton
import triton.language as tl
@triton.jit
def scale_rows(x_ptr, out_ptr, n_col, scale, BLOCK_N: tl.constexpr):
pid = tl.program_id(0)
tl.static_print("row_scale/BLOCK_N =", BLOCK_N) # 编译期,只打常量
offs = tl.arange(0, BLOCK_N)
mask = offs < n_col
base = pid * n_col
x = tl.load(x_ptr + base + offs, mask=mask)
tl.device_print("row_scale/x =", x) # 运行时,必须带前缀
tl.store(out_ptr + base + offs, x * scale, mask=mask)
x = torch.randn(8, 128, device="npu")
out = torch.empty_like(x)
scale_rows[(8,)](x, out, 128, 2.0, BLOCK_N=128)
assert torch.allclose(out, x * 2.0), "结果与 PyTorch 不一致"
print("PASSED")
static_print 在编译阶段输出,BLOCK_N 每变一次打印一次,不进运行时的 kernel。device_print 每核每块都打一遍,输出打印在 HiIPU Print 区块内,量随 grid 与块数放大。
2.2 CPU 解释器
TRITON_INTERPRET=1 让 kernel 在 CPU 上逐元素执行,不经过编译与 NPU 下发。解释器逐条执行 kernel 的 Python 语句,中间变量都是可读的 Python 对象,breakpoint() 可以直接停在 kernel 内部。
用途与代价
用途有两个:定位精度问题时提供一份不受硬件影响的基准;定位逻辑问题时比 device_print 少一轮编译。
慢是它的边界。逐元素解释执行,几万元素的 kernel 要跑几十秒,只做正确性验证,不做性能测量。
覆盖不到编译期
tl.constexpr 的推导、UB 溢出、Pass 报错都发生在编译链路里,解释器一律不触发,它只回答「这段逻辑算出来的数对不对」。反过来,解释器里算错的结果一定是 kernel 逻辑错,与硬件无关。
"""CPU 解释器调试:TRITON_INTERPRET=1 时 kernel 在 CPU 上逐元素执行,可插断点。"""
import torch
import triton
import triton.language as tl
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
x = tl.load(x_ptr + offs, mask=mask)
y = tl.load(y_ptr + offs, mask=mask)
total = x + y
# breakpoint() # 解释器模式下取消注释,(Pdb) p total 看中间值
tl.store(out_ptr + offs, total, mask=mask)
x = torch.randn(4096)
y = torch.randn(4096)
out = torch.empty_like(x)
add_kernel[(4,)](x, y, out, 4096, BLOCK=1024)
assert torch.allclose(out, x + y), "结果与 PyTorch 不一致"
print("PASSED")
TRITON_INTERPRET=1 python interpret_debug.py
断点命令
断点停在 kernel 内部之后,p total 看当前块的中间结果,n 单步,c 继续到下一个 program。用完执行 unset TRITON_INTERPRET 或设成 0;忘了取消的症状是后续所有测试都慢得反常,而 npu-smi 上看不到占用。
2.3 精度对比
对比需要两个结果:Triton 在 NPU 上的输出,与一份基准。基准可以是 PyTorch 的等价算子、CPU 解释器的输出,或同一个 kernel 在 GPU 上的结果。
判据是 torch.testing.assert_close,容差按 dtype 定:
| dtype | rtol | atol | 说明 |
|---|---|---|---|
| float32 | 1e-5 | 1e-5 | 严格 |
| float16 | 1e-3 | 1e-3 | 尾数 10 位 |
| bfloat16 | 5e-3 | 5e-3 | 尾数 7 位,动态范围同 fp32 |
| int8 / int16 / int32 / int64 | — | — | 用 torch.equal,要求逐位相等 |
| bool | — | — | 搬回 CPU 再比,避免设备间的表示差异 |
assert_close 的判据是 |cal - ref| <= atol + rtol * |ref|,两个容差相加构成一条动态边界。
"""按 dtype 选容差的精度对比:浮点用 assert_close,整数与布尔要求逐位相等。"""
import torch
def accuracy_comparison(cal, ref):
assert cal.dtype == ref.dtype, f"dtype 不一致: {cal.dtype} vs {ref.dtype}"
if cal.dtype == torch.float32:
torch.testing.assert_close(cal, ref, rtol=1e-5, atol=1e-5, equal_nan=True)
elif cal.dtype == torch.float16:
torch.testing.assert_close(cal, ref, rtol=1e-3, atol=1e-3, equal_nan=True)
elif cal.dtype == torch.bfloat16:
torch.testing.assert_close(cal.to(torch.float32), ref.to(torch.float32),
rtol=5e-3, atol=5e-3, equal_nan=True)
elif cal.dtype in (torch.int8, torch.int16, torch.int32, torch.int64):
assert torch.equal(cal, ref), "整数结果不相等"
elif cal.dtype == torch.bool:
assert torch.equal(cal.cpu(), ref.cpu()), "布尔结果不相等"
else:
raise ValueError(f"不支持的类型: {cal.dtype}")
if __name__ == "__main__":
for dtype in (torch.float32, torch.float16, torch.bfloat16):
a = torch.randn(1024, dtype=dtype)
accuracy_comparison(a * 2.0, a + a) # 两种写法结果应当一致
print("PASSED")
超出容差的两类原因:
- 精度不够:fp16 累加丢有效位,kernel 内升 fp32 算,写回时再
.to(tl.float16)。 - 库函数是近似实现:NPU 的
tl.exp按近似公式算,softmax 一类算子差在 1e-7 量级属正常。
三、自动调优
@triton.autotune 在 NPU 上的语义与社区版一致,可调项只有块大小与 multibuffer。num_warps 与 num_stages 没有对应的硬件概念,写进候选也不生效。
3.1 key 与缓存
key 是一组入参名。这些参数的值不变时,autotune 直接复用上次选出的配置,不再跑 benchmark;值一变就重选一轮。key=[] 表示只选一次,之后固定沿用。
选择原则是让 key 覆盖影响最优块大小的输入特征:逐元素算子用元素总数,矩阵乘用 M、N、K。矩阵乘如果 K 在网络里固定,写成 key=["M", "N"] 就少一轮重选。key 取得太细,形状每变一次就重选,首次调用延迟成倍上升;取得太粗,形状差异大时用的还是旧配置。
缓存在进程内,cache_results=False 是默认值。想跨进程复用,把它设成 True 让结果落盘。
3.2 参数注入
autotune 把候选配置的 kwargs 按名字注入 kernel 调用。host 侧如果再传一遍同名参数,就是重复赋值,报参数名冲突。
所以走 autotune 的 kernel,BLOCK 只出现在两处:Config 的字典里,和 grid 的 lambda 里(通过 meta["BLOCK"] 取)。调用处不写。没走 autotune 的 kernel 反过来,BLOCK= 必须在调用处传。
3.3 剪枝
候选一多,benchmark 的时间成本就上来了。prune_configs_by 在跑分之前先剔掉一批,三个字段分工:
| 字段 | 作用 |
|---|---|
early_config_prune | 按规则过滤候选:块大小撑爆 UB、不满足对齐要求的,直接出局 |
perf_model | 用代价模型估每个候选的耗时,按估值排序 |
top_k | 只留估值最好的前 k 个进 benchmark |
early_config_prune 的签名固定,收全量候选与入参,返回剩下的候选,至少留一个:
def prune_ub_overflow(configs, named_args, **kwargs):
"""剔除单块放不进 UB 的候选:双缓冲留一半,fp32 每元素 4 字节,进出各一份。"""
limit = 192 * 1024 // 2 // 4 // 2
return [c for c in configs if c.kwargs["BLOCK"] <= limit] or configs[:1]
192 KB 的 UB,双缓冲留一半,fp32 每元素 4 字节,输入输出各占一份,得到的上限是 12288 个元素。五个候选里 16384 与 32768 被剔掉,benchmark 次数从五次降到三次。
末尾的 or configs[:1] 是兜底。规则写错、把所有候选都剔光时,接口要求至少返回一个,否则调优直接中断。
3.4 两个保护参数
benchmark 会把 kernel 反复执行,副作用随之放大。两个参数按名字声明哪些入参需要保护:
reset_to_zero:每个候选跑之前把指定缓冲清零。kernel 用 atomic 累加时,不清零会让后一个候选在前一个的结果上继续加,耗时与结果都不对。restore_value:调优跑完后把指定入参恢复成原值。kernel 原地修改入参时,不恢复会把调用方传进来的张量改脏。
两者都只接受参数名列表,处理逻辑由 Triton 在 benchmark 前后插入。
三者接进同一个 kernel:
"""autotune 的三处进阶用法:key 缓存、候选剪枝、入参保护。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.backends.ascend.runtime
def prune_ub_overflow(configs, named_args, **kwargs):
"""剔除单块放不进 UB 的候选:双缓冲留一半,fp32 每元素 4 字节,进出各一份。"""
limit = 192 * 1024 // 2 // 4 // 2
return [c for c in configs if c.kwargs["BLOCK"] <= limit] or configs[:1]
@triton.autotune(
configs=[triton.Config({"BLOCK": b, "multibuffer": True})
for b in (2048, 4096, 8192, 16384, 32768)],
key=["n"],
prune_configs_by={"early_config_prune": prune_ub_overflow},
reset_to_zero=["out_ptr"],
)
@triton.jit
def sum_kernel(src_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
offs = pid * BLOCK + tl.arange(0, BLOCK)
vals = tl.load(src_ptr + offs, mask=offs < n, other=0.0)
tl.atomic_add(out_ptr, tl.sum(vals))
def total(x):
out = torch.zeros(1, device=x.device, dtype=torch.float32)
grid = lambda meta: (triton.cdiv(x.numel(), meta["BLOCK"]),)
sum_kernel[grid](x, out, x.numel())
return out
x = torch.randn(98432, device="npu")
assert torch.allclose(total(x), x.sum().reshape(1), rtol=1e-2, atol=1e-2)
print("PASSED")
sum_kernel 用 tl.atomic_add 把每块的和累加到 out,所以 reset_to_zero=["out_ptr"] 不能省:不清零的话,第二个候选跑起来时 out 里还留着第一个候选的结果。
3.5 调优日志
TRITON_PRINT_AUTOTUNING=1 打印调优耗时、最佳配置与每个候选的分位数耗时,被选中的那条标 [selected]:
Triton autotuning for function sum_kernel finished after 0.12s; best config selected: BLOCK: 8192, multibuffer: True;
Triton autotuning benchmark results for function sum_kernel:
config=BLOCK: 8192, multibuffer: True; p50=0.0100 ms, p20=0.0090 ms, p80=0.0110 ms [selected]
config=BLOCK: 4096, multibuffer: True; p50=0.0140 ms, p20=0.0130 ms, p80=0.0150 ms
上面的数值取自官方文档的示例格式,实际值随算子与硬件变化。
被剪掉的候选不出现在日志里;编译失败的候选单独一行 compile_failed 带原因,调优中断的标 not_evaluated。这两行比「最佳配置」更有用——它说明某个候选为什么没参评。
四、小结
- 迁移的改动在 host 侧:
import torch_npu、device="npu"、torch.npu.*;kernel 里的@triton.jit、tl.*与调用形式都不变。 - grid 最多 3 维,单维与总数都封顶 65535。按高维轴切、并行轴合并、开满物理核。
- UB 放不下时不要调小块,在 kernel 内二次切分:外层块与 grid 不动,行内按
SUB_N分段。 - 调试三件:
static_print看常量、device_print看张量(带前缀)、TRITON_INTERPRET=1插断点;精度对比按 dtype 定容差。 - autotune 的
key控制重选时机,prune_configs_by减少跑分次数,reset_to_zero与restore_value挡住反复执行带来的副作用。
参考
- Triton-Ascend 代码仓(
docs/zh/debug_guide调试指南、docs/zh/autotune_guide调优指南、docs/zh/examples精度对比示例) — https://gitcode.com/Ascend/triton-ascend - AscendNPU IR(内存层次、多缓冲 Pass 与 HIVM 方言) — https://gitcode.com/Ascend/AscendNPU-IR
- Triton 官方
triton.autotuneAPI(prune_configs_by、reset_to_zero、restore_value的语义) — https://triton-lang.org/main/python-api/generated/triton.autotune.html - 上一篇:昇腾 Triton 算子开发:分块抽象、编译链路与分核映射(同系列,讲编程模型、编译链路与算子开发接口)
接入昇腾知识图谱 https://gitcode.com/agent0/kg-tools
鲲鹏昇腾开发者社区是面向全社会开放的“联接全球计算开发者,聚合华为+生态”的社区,内容涵盖鲲鹏、昇腾资源,帮助开发者快速获取所需的知识、经验、软件、工具、算力,支撑开发者易学、好用、成功,成为核心开发者。
更多推荐



所有评论(0)