昇腾 Triton 算子开发:分块抽象、编译链路与分核映射
一句话让Agent变成昇腾专家,昇腾任务轻松搞定。评测入口:请按这个开源仓接入昇腾图谱 https://gitcode.com/agent0/kg-tools
适用:熟悉 Python,需要在昇腾 NPU 上编写并跑通 Triton 算子
前置:Ubuntu 机器 + 昇腾卡(Atlas A2 / A3 或 950 系列),具备 sudo 权限
口径:命令、接口与版本差异核对自 Triton-Ascend 与 AscendNPU IR 官方文档,2026-11 核对
昇腾算子开发有两种方式,差别在抽象层次。高效开发描述一块数据如何计算,分核、片上内存分配、搬运与计算的重叠交给编译器。深度调优描述指令与流水,UB 与 L1 怎么分、双缓冲开几份、Cube 与 Vector 如何交替,逐项由开发者指定。
Triton 属于前者。它在昇腾上的落地路径可以拆成三层映射:块到核、Python 到 MLIR、MLIR 到二进制。
一、两种开发方式
同一段计算,在不同硬件上的最优写法不一样:数据放哪一级存储、开多少路并行、搬运与计算重叠多少,答案随硬件变化。硬件种类越多,逐个手写的成本越高,抽象层次就成了绕不开的选择。
高效开发只要求写出「一块数据做什么运算」:
- 代码形态:以块(Block / Tile)为单位描述运算,不写线程,不写指令。
- 编译器接管:分核与任务划分、片上内存分配与复用、搬运与计算的重叠、循环展开。
- 首版周期:以天计,改一个块大小就能重跑。
- 性能:取编译器通用优化的结果,接近手写,通常超不过;换代硬件时随编译器一起受益。
- 适用场景:原型验证、算子库没有覆盖的算子、模型迁移时补的算子。
深度调优要求写出「指令与流水怎么排」:
- 代码形态:逐项指定 UB / L1 的分配、双缓冲的份数、Cube 与 Vector 的交替顺序、同步插入的位置。
- 开发者接管:上面每一项,加上 Tiling 的切分方式。
- 首版周期:以周计,调优按「改一版、量一版」推进。
- 性能:上限取决于调优深度,能压到编译器给不出的水平;换代硬件要重调。
- 适用场景:端到端耗时里占大头的少数几个算子。
两种方式的差别最终落在控制权上。同一步操作,一边由编译器决定,一边由开发者决定:
| 决定项 | 高效开发 | 深度调优 |
|---|---|---|
| 分核与任务划分 | 编译器按块推导 | 开发者写 Tiling |
| 片上内存 | 编译器推断容量与复用 | 开发者指定地址与容量 |
| 搬运与计算重叠 | 编译器插流水、自动多缓冲 | 开发者开双缓冲、插同步 |
| 调优手段 | 改块大小、调编译参数 | 改 Tiling、改指令序列、改流水深度 |
| 一次改动的代价 | 改一行参数 | 重写一段流水 |
抽象层次升高,开发效率与性能上限朝相反方向走。

开发效率单调上升,性能上限单调下降。上限下降不是因为编译器写得差,而是因为通用优化必须对一类形状都成立,无法针对某一次调用做取舍:块大小、流水深度、片上内存的复用方式,都被压成一个对多数情况安全的值。
编译参数能把上限抬一点,抬不过手写的天花板。所以「用哪种方式」等价于「这个算子值不值得付手写的成本」,判据是它在端到端耗时里的占比。
两种方式在同一个算子上前后衔接,不是二选一:
- 用高效开发写通算子,与参考实现对齐精度。
- 在单算子或整网层面测一遍,看它是否落在热点上。
- 只有热点算子才下沉到深度调优;下沉时保留高效开发那一版,作为对拍基准。
- 调优版本回到整网再测一遍,确认收益没有被别处吃掉。
多数算子停在第一步。算子库已经覆盖的、形状规整的、占比小的,下沉的收益抵不上维护成本:一份手写 kernel 要跟着硬件代际、CANN 版本、Tiling 约束一起改。
二、Triton 的编程模型
Triton 由 OpenAI 开源,是一套 Python 内嵌 DSL。被 @triton.jit 装饰的函数不经过 Python 解释器执行,由 Triton 编译器解析函数体,生成面向目标硬件的 kernel。
核心抽象是块(Block / Tile)。CUDA 要求开发者指定每个线程处理哪个元素、线程如何组成 warp、共享内存如何声明;Triton 只要求声明一次处理长度为 BLOCK 的一段数据。
offs = tl.arange(0, 1024) # 一整块的索引,不是循环变量
x = tl.load(x_ptr + offs) # 一次搬 1024 个元素
tl.arange 返回张量,长度在编译期确定,可以整体参与运算。上面两行在生成的 IR 中对应一次批量搬运,不是 1024 次标量访问。
前端与后端解耦是 Triton 能跨硬件的前提。同一份 Python 代码换一个后端,编译目标随之改变,算子源码不动。
这种取舍在 Triton 里落到编译参数上。片上内存排布、搬运与计算的重叠比例、Cube 与 Vector 的配比无法逐条指定,只能通过 multibuffer、enable_flatten 间接影响。需要指令级控制时,回到 AscendC。
三、昇腾编译链路
昇腾上的 Triton kernel 不经过 AscendC。适配组件叫 Triton-Ascend,它在 Triton 外层接入昇腾后端,kernel 经 @triton.jit 解析后进入昇腾自己的编译路径。

- Python AST。 编译器读取函数源码,提取参数签名与运算结构。这一步决定后续所有优化的起点,也决定 kernel 内为什么不能调用任意 Python 库函数。
- TTIR。 Triton 张量 IR,落在
tt方言上。这一层与硬件无关,描述「对一块张量做什么」。 - Ascend Passes。 昇腾的转换与优化 Pass 集合,入口是
ttir_to_linalg。AutoBlockify 把大块切成编译器能处理的粒度,TritonToStructured 把非结构化访存整理成循环,TritonToAnnotation 打上硬件提示,再交给 TritonToHIVM 与 TritonToLinalg,降到目标方言。 - Linalg IR。 落在 MLIR 线性代数方言上,由
linalg、memref、arith、scf组成。调试时可在缓存目录看到kernel.ttadapter.mlir。到这一步,Triton 的痕迹已经消失。 - 毕昇编译器。 入口是
bishengir-compile,输入输出都是 MLIR。它先把 Linalg 提升到自定义方言上做优化,再由hivmc转成 LLVM IR,完成指令选择与调度。 - NPU Binary。 产出
kernel.o,由运行时下发到 AI Core 执行。
第 5 步由 AscendNPU IR 承担。它基于 MLIR 构建,自定义了五个方言:
| 方言 | 职责 |
|---|---|
| HFusion | 基于 Linalg 扩展,做硬件相对无关的优化:算子融合、数据类型合法化、张量表达式化简 |
| HIVM | 面向昇腾硬件的 Tile 级 Operation,管 CV 核映射、片上内存分配、处理单元映射 |
| HACC | 异构硬件抽象表达 |
| Annotation / Scope | 给特定 Operand 或 Operation 打编译提示、约束作用域 |
性能差距主要产生在 HIVM 这一层,它做三件事:
- 拆核。 一个 kernel 里同时存在 Cube 与 Vector 操作时,自动插入数据搬运与核间同步,把 kernel 拆成 AIC、AIV 两个核函数。
- 算内存。 推断片上内存占用、对齐方式与地址分配。
- 排流水。 识别多级流水,插入同步并让相邻阶段并行。
同一个 kernel 调整块大小后性能变化明显,原因通常在这里:块大小改变了片上内存占用与流水填充。
不同代际芯片的路径不同:
| 平台 | 编译路径 |
|---|---|
| Atlas A2 / A3(910B 等) | Linalg → HFusion + HIVM → 二进制,默认开自动多缓冲 |
| 910_95 | Linalg → HFusion → 二进制,不启用 hivm-compile 开关 |
任意平台,compile_mode="simt_only" | TTIR → TTGIR → LLVM → 二进制 |
950PR / 950DT 增加了寄存器层、Cube 与 Vector 之间的数据通路,并引入 SIMT。AscendNPU IR 在这一代把社区的 TritonGPU 方言直接对接 HIVM,支持纯 SIMD、纯 SIMT 与两者混合三种模式。
四、开发环境
五个步骤,后一步依赖前一步的产物。前提是新装的 Ubuntu,/usr/local/Ascend 可写。
4.1 安装 CANN
CANN 是底座,Triton-Ascend 编译出的二进制通过它下发到硬件。需要 Toolkit 包与对应硬件的 ops 包,两个都要装。
chmod +x Ascend-cann-{version}_linux-x86_64.run
chmod +x Ascend-cann-A3-ops_{version}_linux-x86_64.run
./Ascend-cann-{version}_linux-x86_64.run --full --install-path=${PATH-TO-CANN}
./Ascend-cann-A3-ops_{version}_linux-x86_64.run --install --install-path=${PATH-TO-CANN}
{version} 换成实际版本号,A3 换成对应产品系列。装完不设环境变量,npu-smi info 能列出卡信息,说明驱动与固件正常。
4.2 设置环境变量
脚本路径在版本之间改过一次:
# CANN 8.5.0 及更早
source ${PATH-TO-CANN}/ascend-toolkit/set_env.sh
# CANN 8.5.0 之后
source ${PATH-TO-CANN}/cann/set_env.sh
路径写错不会立即报错,症状是 import torch_npu 失败,或编译时找不到 bishengir-compile。判据是 echo $ASCEND_HOME_PATH 能打印安装目录(老版本为 $ASCEND_TOOLKIT_HOME)。这行建议写进 ~/.bashrc。
4.3 安装 Python 依赖与 torch_npu
pip install attrs==24.2.0 numpy==1.26.4 scipy==1.13.1 decorator==5.1.1 psutil==6.0.0 pyyaml
pip install torch=={torch 版本} torch_npu=={配套的 torch_npu 版本}
torch、torch_npu、CANN 三者的版本必须互相对应。不匹配时的表现是 import torch_npu 报符号未定义,或跑算子时崩在运行时。版本对照查官方兼容矩阵,不要按最新版装。
4.4 安装 Triton-Ascend
在线安装:
pip install triton-ascend --extra-index-url=https://mirrors.huaweicloud.com/ascend/repos/pypi
离线环境用官方 wheel 包,本地 pip install 安装,包名中的平台标签要与机器架构一致。
需要修改编译器行为时走源码构建,依赖 clang 与 lld:
apt install zlib1g-dev clang-15 lld-15
update-alternatives --install /usr/bin/clang clang /usr/bin/clang-15 100
update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-15 100
pip install ninja cmake wheel pybind11
git clone https://github.com/triton-lang/triton-ascend.git && cd triton-ascend
pip install -e .
这条路径会下载预编译的 LLVM。自行编译 LLVM 时,需要检出指定 commit,打上 third_party/ascend/patch 中的补丁。cmake 时打开 mlir;llvm;lld,再用 LLVM_SYSPATH 指回自建目录。
社区 Triton 与 Triton-Ascend 安装到同一个目录。3.2.0 及以下的版本必须先卸载社区 Triton;3.2.1 起 Triton 被声明为依赖,先装 Triton,再由 Triton-Ascend 覆盖同名目录。装完 Triton-Ascend 之后再安装依赖 Triton 的其他包,会覆盖该目录。症状是 import 正常,一运行就报 NPU 后端错误。处理方式是两个都卸载重装。
4.5 验证后端
python -c "from triton.runtime import driver; print(driver.active.get_current_target())"
输出中的 backend 为 npu 即通过。为 cuda 说明装的是社区版 Triton;报文件缺失则回到 4.2 检查环境变量。
cd triton-ascend
python third_party/ascend/tutorials/01_vector_add.py
末行打印精度对比通过,说明从 TTIR 到二进制的整条链路已经打通。编译失败时设 TRITON_DEBUG=1,在 ~/.triton/cache 查看中间产物。kernel.ttir.mlir 与 kernel.ttadapter.mlir 分别对应降级前后的状态。
五、算子开发
一个 Triton 算子由两部分组成:被 @triton.jit 装饰的 kernel 函数,以及负责校验、分核与调用的 host 代码。kernel 内部只用 triton.language 的原语,host 侧只用 grid 与参数传递,两套接口不通用。
5.1 四个装饰器
| 接口 | 作用 | 关键参数 |
|---|---|---|
@triton.jit | 把函数交给 Triton 编译器,生成 kernel | 无 |
@triton.autotune | 列一批配置,实跑选出最快的一个 | configs、key |
triton.Config | 一组候选参数 | 块大小等 kwargs、multibuffer |
@triton.heuristics | 按输入形状算出参数值,不做搜索 | values |
@triton.jit 是整条流程的入口。被装饰的函数不再是普通 Python 函数,调用时执行的是编译后的 kernel。
@triton.autotune 的 key 决定重新选配置的时机。写成 key=["n"],只有元素总数变化才重新跑分;写成 key=[],只选一次后一直沿用。triton.Config 中的 multibuffer 是昇腾特有的可调项,控制 ping-pong 多缓冲,A2 / A3 默认开,910_95 默认关。
昇腾上的 autotune 只支持块大小与 multibuffer,num_warps 与 num_stages 写进候选也不生效。这两个参数在 GPU 上是主要调优项,在 NPU 上因为执行模型不同没有对应含义,num_stages 保持 1。
@triton.heuristics 走另一条路:不测性能,直接按输入算出参数值。块大小规则明确时用它,省掉搜索开销。
def pick_block(args):
return 8192 if args["n"] > 8192 else triton.next_power_of_2(args["n"])
@triton.heuristics(values={"BLOCK": pick_block})
@triton.jit
def kernel(x_ptr, n, BLOCK: tl.constexpr):
...
它的函数收到 kernel 全部入参组成的字典,按名字取值。装饰顺序与 autotune 一致,都放在 @triton.jit 外层。
5.2 triton.language 常用接口
| 接口 | 语义 |
|---|---|
tl.program_id(axis) | 当前 program 在指定轴上的编号 |
tl.num_programs(axis) | 指定轴上启动的 program 总数 |
tl.arange(start, end) | 连续整数序列,用作偏移 |
tl.full(shape, value, dtype) | 用指定值填满的张量 |
tl.load(ptr, mask, other) | 从全局内存搬到片上,mask 为假的位置取 other |
tl.store(ptr, value, mask) | 从片上写回全局内存 |
program_id 与 num_programs 是分核的基础:前者是当前核的编号,后者是本次启动的核数。arange 配上块起点构成一整块的地址:
offs = pid * BLOCK + tl.arange(0, BLOCK) # 每个核各自的一段下标
load 与 store 都接受 mask。尾块不满一块时,mask 挡掉越界位置,读入时取 other,写回时跳过。不加 mask 会在最后一个块上读写越界。
5.3 分核模型

一次 kernel 启动会发射 grid 指定数量的 program。NPU 上一个 AI Core 同时接一个 program,核数只有几十个。运行时接口允许下发最多 65535 个并发任务,超出物理核数的部分靠多轮下发完成,每一轮都有核启动与初始化开销。
通行写法是 grid 等于物理核数,剩余工作由核内循环分掉:
pid = tl.program_id(0)
stride = tl.num_programs(0)
for blk in range(pid, tl.cdiv(n, BLOCK), stride):
... # 这个核处理第 pid、pid+stride、pid+2*stride 块
跨步分配比手工划区间更均匀。块数除不尽核数时,多出的块落在前几个核上,不会集中到最后一个。
核数在 host 侧读取:
import triton.runtime.driver as driver
props = driver.active.utils.get_device_properties(device)
props["num_vectorcore"] # Vector 核数,逐元素算子用它
props["num_aicore"] # Cube 核数,CV 融合算子用它
一个 AI Core 包含 1 个 Cube 核与 2 个 Vector 核,num_vectorcore 通常是 num_aicore 的两倍。逐元素算子按 Vector 核数分核,含矩阵乘的融合算子按 Cube 核数分核,运行时再按 1:2 调度 Vector 核。
5.4 kernel 的五步结构

- 取核号。
pid = tl.program_id(0)。多维任务先展平成一维,再用整除与取余还原各维下标。 - 算偏移。 用
pid、块大小与 stride 算出本核负责的数据在内存中的偏移。算术要与 host 侧传入的 stride 对齐,否则读到错位的数据。 - 搬到片上。
tl.load把数据从全局内存搬进 UB,mask处理尾块。 - 计算。 中间结果留在片上,不再读写全局内存。同一个张量在一个 kernel 内反复
load/store,性能下降明显。 - 写回。
tl.store把结果搬回全局内存。
五步里容易漏掉的是第 4 步的「留在片上」与第 2 步的偏移计算:前者决定访存次数,后者决定结果是否正确。
5.5 三段示例
从最小 kernel 到按核数分核,再到自动调优。每个文件都包含 kernel、host 调用与一行自检。
最小 kernel。 两个向量相加,一个 program 处理一块数据,grid 按块数开。
"""最简 Triton kernel:两个向量相加,一个 program 处理一块数据。"""
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):
out = torch.empty_like(x)
n = out.numel()
grid = (triton.cdiv(n, 1024),) # 块数 = 元素数 / 块大小
add_kernel[grid](x, y, out, n, BLOCK=1024)
return out
x = torch.randn(98432, device="npu")
y = torch.randn(98432, device="npu")
out = add(x, y)
assert torch.allclose(out, x + y), "结果与 PyTorch 不一致"
print("PASSED")
n 按值传入,不标 constexpr:每次调用的元素数可能不同,标成编译期常量会触发重编译。BLOCK 反过来必须标 constexpr,它参与形状推导。grid 是一维元组,元组长度决定 program_id 的轴数。
98432 除以 1024 余 128,最后一个块只填满 128 个位置,mask 处理的就是这一段。
按核数分核。 grid 固定为 Vector 核数,核内跨步领块,适合大数据量。
"""按物理核数分核,核内跨步领任务,避免 grid 远大于核数带来的启动开销。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.runtime.driver as driver
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid = tl.program_id(0)
stride = tl.num_programs(0) # 这次启动的核数
for blk in range(pid, tl.cdiv(n, BLOCK), stride): # 每个核隔 stride 领一块
offs = blk * 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)
props = driver.active.utils.get_device_properties(torch_npu.npu.current_device())
grid = (props["num_vectorcore"],) # grid 等于 Vector 核数
add_kernel[grid](x, y, out, out.numel(), BLOCK=8192)
return out
x = torch.randn(4 * 1024 * 1024, device="npu")
y = torch.randn(4 * 1024 * 1024, device="npu")
out = add(x, y)
assert torch.allclose(out, x + y, atol=1e-5), "结果与 PyTorch 不一致"
print("PASSED")
块大小从 1024 提到 8192,是因为数据量放大到四百万个元素后,每个核要串行处理几十个块。块太小会让循环次数上百,循环本身的开销盖过计算。上限受片上内存容量与数据类型约束,超过时报 UB Overflow。
自动调优。 把块大小与多缓冲开关列成候选,由 Triton 实跑选优。
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, "multibuffer": True}),
triton.Config({"BLOCK": 8192, "multibuffer": True}),
triton.Config({"BLOCK": 8192, "multibuffer": False}),
], key=["n"]) # 只有 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())
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")
与前面相比有三处差异。import triton.backends.ascend.runtime 不能省,它把 autotune 切到昇腾的扩展路径。grid 由固定元组改成函数,因为块大小要等配置选出来才确定。multibuffer 写在 Config 的字典里,不是 kernel 参数,编译器读到它才决定多缓冲的开关。
首次运行会编译并实测每个候选,速度较慢。结果按 key 缓存,n 不变时不再重选。configs=[] 是另一种写法,表示不由调用方列候选,交给后端按 kernel 语义自动生成。
5.6 调用侧封装
生产代码里 kernel 本身只占几行,其余部分是校验、grid 计算与缓冲管理。一个可复用的封装需要处理三件事:形状校验、核数封顶、输出缓冲复用。
"""host 侧调用封装:形状校验、核数封顶、输出缓冲复用。"""
import torch
import torch_npu
import triton
import triton.language as tl
import triton.runtime.driver as driver
BLOCK = 8192
@triton.jit
def add_kernel(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
pid, stride = tl.program_id(0), tl.num_programs(0)
for blk in range(pid, tl.cdiv(n, BLOCK), stride):
offs = blk * 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 triton_add(x, y, out=None):
if x.shape != y.shape:
raise ValueError(f"shape 不一致: {tuple(x.shape)} vs {tuple(y.shape)}")
if not (x.is_contiguous() and y.is_contiguous()):
raise ValueError("输入需连续,非连续张量先调 .contiguous()")
n = x.numel()
out = torch.empty_like(x) if out is None else out
props = driver.active.utils.get_device_properties(x.device.index or 0)
grid = (min(triton.cdiv(n, BLOCK), props["num_vectorcore"]),) # 核数封顶
add_kernel[grid](x, y, out, n, BLOCK=BLOCK)
return out
if __name__ == "__main__":
x = torch.randn(8_000_000, device="npu", dtype=torch.float16)
y = torch.randn_like(x)
out = torch.empty_like(x)
triton_add(x, y, out) # out 已存在,不再分配
triton_add(x, y, out) # 第二次调用只走 kernel
assert torch.allclose(out, x + y, atol=1e-2), "结果与 PyTorch 不一致"
print("PASSED")
add_kernel[grid](x, y, out, n, BLOCK=BLOCK) 这一行的三条规定:
- 方括号里是 grid,圆括号里是 kernel 入参。
- 位置参数依次对应指针与标量,
constexpr参数按关键字传。 - 张量直接传入,Triton 取它的
data_ptr;grid 元组的长度决定program_id的轴数,一维任务传单元素元组。
grid 的三种写法对应三种场景:
| 写法 | 形式 | 适用 |
|---|---|---|
| 固定元组 | (triton.cdiv(n, 1024),) | 块大小写死 |
| 等于核数 | (props["num_vectorcore"],) | 核内跨步分块 |
| 函数 | lambda meta: (triton.cdiv(n, meta["BLOCK"]),) | 块大小由 autotune 决定 |
min(triton.cdiv(n, BLOCK), props["num_vectorcore"]) 是核数封顶。数据量小时按实际块数开核,避免启动几十个只领到空任务的核;数据量大时按物理核数开核,避免多轮下发。
复用 out 的意义在于跳过分配。输入形状固定时,torch.empty_like 的分配与释放会进入总耗时,循环调用时尤其明显。
六、小结
- 昇腾算子开发有两种方式:高效开发(Triton)首版快、性能由编译器决定;深度调优(AscendC)首版慢、性能上限更高。先写通,量完再决定是否下沉。
- Triton 在昇腾上不经过 AscendC,路径是 TTIR → Linalg IR → 毕昇编译器 → 二进制。性能差异多出在 HIVM 的片上内存推导与流水调度。
- 分核是 NPU 与 GPU 差别最大的地方。grid 对齐物理核数、核内跨步领块,比把 grid 开到几千个更省。
参考
- Triton-Ascend 代码仓(
docs/zh下有安装指南、编程指南、Autotune 指南) — https://gitcode.com/Ascend/triton-ascend - Triton-Ascend 镜像仓 — https://github.com/triton-lang/triton-ascend
- AscendNPU IR(方言分工、编译流程、950 上的 SIMT 支持) — https://gitcode.com/Ascend/AscendNPU-IR
- Triton 官方文档(
triton.jit、autotune、heuristics的语义) — https://triton-lang.org/main/index.html - CANN 下载与快速安装 — https://www.hiascend.com/cann/download
接入昇腾知识图谱 https://gitcode.com/agent0/kg-tools
更多推荐



所有评论(0)