一句话让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、改指令序列、改流水深度
一次改动的代价改一行参数重写一段流水

抽象层次升高,开发效率与性能上限朝相反方向走。

在这里插入图片描述

开发效率单调上升,性能上限单调下降。上限下降不是因为编译器写得差,而是因为通用优化必须对一类形状都成立,无法针对某一次调用做取舍:块大小、流水深度、片上内存的复用方式,都被压成一个对多数情况安全的值。

编译参数能把上限抬一点,抬不过手写的天花板。所以「用哪种方式」等价于「这个算子值不值得付手写的成本」,判据是它在端到端耗时里的占比。

两种方式在同一个算子上前后衔接,不是二选一:

  1. 用高效开发写通算子,与参考实现对齐精度。
  2. 在单算子或整网层面测一遍,看它是否落在热点上。
  3. 只有热点算子才下沉到深度调优;下沉时保留高效开发那一版,作为对拍基准。
  4. 调优版本回到整网再测一遍,确认收益没有被别处吃掉。

多数算子停在第一步。算子库已经覆盖的、形状规整的、占比小的,下沉的收益抵不上维护成本:一份手写 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 解析后进入昇腾自己的编译路径。

在这里插入图片描述

  1. Python AST。 编译器读取函数源码,提取参数签名与运算结构。这一步决定后续所有优化的起点,也决定 kernel 内为什么不能调用任意 Python 库函数。
  2. TTIR。 Triton 张量 IR,落在 tt 方言上。这一层与硬件无关,描述「对一块张量做什么」。
  3. Ascend Passes。 昇腾的转换与优化 Pass 集合,入口是 ttir_to_linalg。AutoBlockify 把大块切成编译器能处理的粒度,TritonToStructured 把非结构化访存整理成循环,TritonToAnnotation 打上硬件提示,再交给 TritonToHIVM 与 TritonToLinalg,降到目标方言。
  4. Linalg IR。 落在 MLIR 线性代数方言上,由 linalg、memref、arith、scf 组成。调试时可在缓存目录看到 kernel.ttadapter.mlir。到这一步,Triton 的痕迹已经消失。
  5. 毕昇编译器。 入口是 bishengir-compile,输入输出都是 MLIR。它先把 Linalg 提升到自定义方言上做优化,再由 hivmc 转成 LLVM IR,完成指令选择与调度。
  6. 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_95Linalg → 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 的五步结构

在这里插入图片描述

  1. 取核号。 pid = tl.program_id(0)。多维任务先展平成一维,再用整除与取余还原各维下标。
  2. 算偏移。 用 pid、块大小与 stride 算出本核负责的数据在内存中的偏移。算术要与 host 侧传入的 stride 对齐,否则读到错位的数据。
  3. 搬到片上。 tl.load 把数据从全局内存搬进 UB,mask 处理尾块。
  4. 计算。 中间结果留在片上,不再读写全局内存。同一个张量在一个 kernel 内反复 load / store,性能下降明显。
  5. 写回。 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 开到几千个更省。

参考

接入昇腾知识图谱 https://gitcode.com/agent0/kg-tools

Logo

作为“人工智能6S店”的官方数字引擎,为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐