个人主页：ujainu

前言

昇腾NPU 跑同一个 Transformer 模型，PTO 指令调度策略换一换，吞吐能差 3 倍。CANN 的 pto-isa 仓库定义了虚拟指令集规范，让同一套算子描述在不同硬件上映射成最优机器码。本文拆解这条从 PTO 指令到 NPU 执行的全链路。

PTO 为什么存在

昇腾 NPU 的达芬奇架构和 x86、GPU 的指令集完全不同。直接拿 LLVM IR 去跑——跑不起来。早期做法：给每个硬件写一套算子，Ascend 910 写一套，换家厂商又重写，维护成本爆炸。

PTO（Portable Tile Operator）的解法：定义一套虚拟指令集，让算子开发者只写一次，就能在不同硬件上跑。pto-isa 仓库就是这套规范的唯一定义，包含 90+ 标准 Tile 级操作，在 CANN 五层架构第 3 层（编译层）和 Graph Compiler 配合。

为什么 AI 编译需要虚拟 ISA

直接生成硬件机器码行，但代价大。AI 编译器输入是计算图，几百个算子，每个在不同硬件上的最优指令序列都不同。让编译器直接面对硬件——每加一款芯片，重写一遍指令生成逻辑。

虚拟 ISA 的作用：解耦。没有虚拟 ISA：Graph Compiler → 直接生成 NPU 机器码（换芯片？重写）。有虚拟 ISA：Graph Compiler → 生成 PTO 指令 → 后端映射（换芯片？只改映射层）。

pto-isa 选 Tile 级抽象——大到够描述计算模式，小到硬件一个调度周期内完成。

# PTO 指令生成示例（Python 伪代码）
import pto
def matmul_tile(M, N, K):
    A = pto.dma_load("HBM", "A", M, K)
    B = pto.dma_load("HBM", "B", K, N)
    C = pto.cube_matmul(A, B)
    C = pto.vector_add(C, "Bias")
    pto.dma_store(C, "HBM", "C", M, N)
    return pto.get_instruction_sequence()
print(f"PTO 指令数: {len(matmul_tile(128, 128, 128))}")

同样逻辑，Ascend 910 映射成 Cube 指令，Ascend 950 映射成更新后的 Cube 指令，上层代码一行不用改。

Graph Compiler 如何生成 PTO

Graph Compiler 拿到计算图，生成 PTO 指令分三步：融合决策 → Tile 切分 → PTO 指令生成。

融合规则：Conv2D → BatchNorm → ReLU 可融合（同一 Tensor 操作），MatMul → Softmax 可融合（不写回 HBM）。目的：减少数据搬运。

Tile 切分：融合后的大算子，切成能放进 SRAM 的 Tile，大小直接影响性能。

// Graph Compiler Tile 切分（C++ 伪代码）
TilePlan compute(Operator op, DeviceInfo dev) {
    int64_t sram = dev.sram_size;
    int64_t T = sqrt(sram * 0.6 / 3 / 4);
    return TilePlan{align_to(T, 16),};
}

PTO 指令生成：每个 Tile 翻译成 PTO 指令序列（pto-isa 的 90+ 标准操作）。

PTO 指令序列（真实格式）：
LOAD    D_SRAM[0], HBM[A], 128*128*4
LOAD    D_SRAM[1], HBM[B], 128*128*4
CUBE    D_OUT, D_SRAM[0], D_SRAM[1]
VECTOR  D_OUT, "ReLU"
STORE   HBM[C], D_OUT, 128*128*4
SYNC

指令调度：性能优化的核心

不做调度优化，指令按顺序执行——LOAD 等 CUBE，CUBE 等 VECTOR，硬件利用率低。调度优化：让无依赖的指令并行。

# 流水线调度后的 PTO 指令（Python 伪代码）
def pipeline(M, N, K, tiles=4):
    seq = pto.InstructionSequence()
    for t in range(tiles):
        if t < tiles - 1:
            seq.append(pto.LOAD("A", t + 1))
        seq.append(pto.CUBE(f"A_{t}", f"B_{t}"))
        seq.append(pto.VECTOR("ReLU"))
        seq.append(pto.STORE(f"C_{t}", "HBM"))
    return seq

指令重排：把无依赖的指令插到 RAW（Read After Write）等待周期里。

# 查看调度效果
python -m pto_compiler --input model.onnx --output model.pto
python -m pto_compiler --input model.pto --target ascend910 --report-cycles
# Naive=182,000 | Pipeline=67,000 | 2.72x

昇腾 NPU 如何执行底层指令

PTO 指令是虚拟的，真正跑在昇腾 NPU 上的是达芬奇架构的机器码。中间映射由 CANN 编译层后端完成：pto.dma_load(A) → 01 0A…（DMA）；pto.cube_matmul() → 02 01…（Cube）；pto.vector_relu() → 03 20…（Vector）。

一条 PTO 指令可能映射成多条机器码。硬件特化：同样 pto.cube_matmul()，在 Ascend 910 和 Ascend 950 上的最优映射不同——两款芯片的 Cube 吞吐、SRAM 大小、DMA 带宽不同，pto-isa 的 90+ 操作中有一部分是可特化的。

Transformer 推理中的编译链路

输入 → PyTorch 前向 → TorchAir 图捕获 → Graph Compiler 收计算图
→ [融合] FlashAttention + KVRMSNormRoPECache
→ [Tile] 按 SRAM 切 128x128x128
→ [PTO生成] pto-isa 规范
→ [调度] 流水线 + 指令重排
→ [映射] PTO → NPU 机器码
→ [执行] DaVinci 架构
→ 输出 token

和 pto-isa 直接相关的是 [PTO 生成] 和 [调度]，决定指令序列质量——直接影响推理延迟。

# 性能分析：找 PTO 指令瓶颈
import pto, profiler
model = load_model("DeepSeek-V3")
with profiler.profile() as prof:
    output = model.generate("解释量子纠缠")
for instr, cycles in sorted(prof.stats.items(), reverse=True)[:3]:
    print(f"{instr}: {cycles} cycles")

调试技巧

开发 PTO 算子时，最常见 bug 是指令序列里漏了同步屏障，导致数据没搬完就开始算。

void debug(PTOInstructionSequence& seq) {
    for (int i = 0; i < seq.size(); i++) {
        if (seq[i].opcode == PTO_OPCODE_LOAD) {
            bool sync = any_of(seq.begin()+i+1,
                seq.begin()+min(i+5,(int)seq.size()),
                [](auto& x){ return x.opcode == PTO_OPCODE_SYNC; });
            if (!sync) std::cerr << "⚠ LOAD 后缺少 SYNC" << std::endl;
        }
    }
}

编译配置

target: { device: "ascend910", sram_size: 1048576 }
schedule: { enable_pipeline: true, enable_instr_reorder: true }
tile: { strategy: "heuristic", tile_m: 128, tile_n: 128, tile_k: 128 }

python -m pto_compiler --input model.onnx --config pto_config.yaml \
    --output model_opt.pto --target ascend910
# Naive=45.2ms | Optimized=16.8ms | 2.69x

进阶学习

pto-isa 定义虚拟指令集，真正用起来配合：ge（Graph Compiler，核心协作组件）、pypto（Python PTO 框架）、asc-devkit（Ascend C，手写算子）。建议下一步直接看 Graph Compiler 实现——理解它怎么生成 PTO 指令，对整条编译链路就通了。

pto-isa 仓库：https://atomgit.com/cann/pto-isa

Graph Compiler 仓库：https://atomgit.com/cann/ge