基于 PTO 的高性能 GEMM 算子实战:多核切分、L1 缓存与双缓冲流水线调优(Ascend A2/A3)

原创2026-09-17 23:27:251,837 阅读
文章标签:人工智能算子库CANNAscend

基于 PTO 的高性能 GEMM 算子实战:多核切分、L1 缓存与双缓冲流水线调优(Ascend A2/A3)

导读

本文以开源仓库 cann/pto-isa 中的 kernels/manual/a2a3/gemm_performance 示例为主线,完整讲解如何在 Ascend A2/A3 平台上使用 PTO(Parallel Tile Operation)虚拟指令集实现高性能 GEMM 算子:从多核切分(core partitioning)、base-block 选择、L1 stepK 缓存到 L1/L0A/L0B 双缓冲的流水线设计。读完本文,你将掌握 GEMM 类算子的标准四阶段流水线(TLOAD→TEXTRACT→TMATMUL→TSTORE)的源码级实现原理、tiling 参数的推导方法,以及如何借助 TMATMUL/TEXTRACT/TLOAD/TSTORE 占比指标定位端到端瓶颈并指导后续调优。

示例概览:一个以“可调优”为目的的 GEMM 参考实现

该示例的核心目标不是展示“最快的 GEMM”,而是围绕一个标准 GEMM 流水线,把每一类优化手段落成可读、可改、可验证的代码,让开发者能基于它复现性能调优的完整过程。

  • 计算目标:C = A × B,其中 A 为 m×k、B 为 k×n、C 为 m×n,默认参考配置 m = k = n = 6144;
  • 支持平台:A2/A3(示例默认以 24 核 A3 平台作为性能验证平台);
  • 算子规格:
项目 值
OpType GEMM
输入 a: m×k, float16, ND;b: n×k, float16, ND
输出 c: m×n, float, ND
Kernel 名称 GEMMPerformance

目录结构与关键文件

kernels/manual/a2a3/gemm_performance/
├── scripts/
│   └── gen_data.py                  # 生成输入与 golden 输出
├── CMakeLists.txt                   # 构建配置
├── gemm_performance_kernel.cpp      # Kernel 实现(核心)
├── main.cpp                         # Host 侧入口
└── run.sh                           # 便捷脚本
  • gemm_performance_kernel.cpp:设备侧 GEMM kernel 的全部实现,含 InitGMOffsets、ProcessKIteration、StoreResult、RunGemmE2E 等核心函数;
  • main.cpp:Host 侧入口,负责分配/拷贝内存、launch kernel、读取 golden 并与设备结果比对(误差阈值 0.001f),成功时打印 test success;
  • scripts/gen_data.py:用 np.random.seed(19) 固定随机种子生成 x1_gm.bin / x2_gm.bin(np.float16,均匀分布 [-5, 5))与 golden.bin(以 np.float32 计算 np.matmul 结果);
  • run.sh:解析 -r/--run-mode(npu 或 sim)与 -v/--soc-version,调用 CMake 构建并直接运行可执行文件;
  • CMakeLists.txt:定义 pto_example_cube 构建函数,kernel 侧以 --cce-pto-enable 启用 PTO 编译、--cce-aicore-arch=dav-c220-cube 指定 Cube 核架构,host 侧按 RUN_MODE 链接 runtime(npu)或 runtime_camodel(sim)。

四种核心优化手段的源码级解读

1)多核切分:把 m、n 摊到 24 个 Cube 核上

对于 m ≈ n 的方阵问题,单核内再切 k 会破坏数据复用,因此示例选择把 m 与 n 分摊到 24 核,每个核持有互不依赖的 C tile。在 InitGMOffsets 中:

constexpr uint32_t mIter = m / singleCoreM;
uint32_t mIterIdx = get_block_idx() % mIter; // 当前 launch 的核索引
uint32_t nIterIdx = get_block_idx() / mIter;
uint64_t gmOffsetA = mIterIdx * singleCoreM * k;
uint64_t gmOffsetB = nIterIdx * k * singleCoreN;
uint64_t gmOffsetC = mIterIdx * singleCoreM * n + nIterIdx * singleCoreN;
  • 采用 SPMD 式二维网格分解:核索引先按 m 方向、再按 n 方向映射;
  • 4 × 6 分组对应 mIter = 4、nIter = 6,得 singleCoreM = 1536、singleCoreN = 1024、singleCoreK = 6144(本示例选定);
  • 每个核读取连续的 A panel([singleCoreM, K])与 B panel([K, singleCoreN]),避免跨核访存竞争。

检查清单:确保 m % singleCoreM == 0 且 n % singleCoreN == 0;选择与 blockDim 匹配的 m-tiles × n-tiles 分解,使每个核拿到连续 panel。launch 配置在 LaunchGEMME2E 中:blockDim = 24,以 <<<blockDim, nullptr, stream>>> 拉起 kernel。

2)Base block 选择:抬高算术强度并满足 L0 容量

<a href="https://link.gitcode.com/i/f05f007f7649e54c08959ececb86a302" target="_blank">baseM, baseN, baseK] = [128, 256, 64] 相对 [128, 128, 128] 有两个优势:FP16 下单位搬运字节对应的 FMA 数更多(算术强度更高);baseN = 256 使 C 写回保持 512 字节对齐。在 [RunGemmE2E 中对应的 tile 类型为:

using LeftTile = TileLeft<U, baseM, baseK, baseM, baseK>;
using RightTile = TileRight<S, baseK, baseN, baseK, baseN>;
using ResTile = TileAcc<T, baseM, baseN, baseM, baseN>;

L0A/L0B 的双缓冲按 32 KiB ping/pang 划分(见代码中 L0_PINGPONG_BYTES = 32 * 1024),因此每个 buffer 的 tile footprint 必须 ≤ 32 KiB:

  • L0A tile bytes ≈ baseM * baseK * 2 = 128 * 64 * 2 = 16 KiB(空间充裕);
  • L0B tile bytes ≈ baseK * baseN * 2 = 64 * 256 * 2 = 32 KiB(恰好吃满预算)。

指导原则:优先让 tile 尺寸(尤其 B)充分利用 32 KiB 预算但不超过;baseK 保持对齐 Cube 偏好的 K 粒度(常见 32/64/128,取决于数据类型与布局)。TASSIGN 的具体地址分配见 RunGemmE2E:L1 的 aMatTile[0/1]、bMatTile[0/1] 顺序排布,L0A/L0B 各以 0x0 与 0x0 + 32768 划分 ping/pang 槽。

3)L1 stepK 缓存:一次 DMA 喂饱多次 extract

stepKa / stepKb 控制一次 TLOAD 搬入 L1 的 K 切片数。示例取 stepKa = stepKb = 4:一次 TLOAD 把 4 个 micro-panel(<a href="https://link.gitcode.com/i/8b56c3a7280ce3fa1ee04a8ab01af994" target="_blank">baseM, baseK*4] 与 [baseK*4, baseN])搬进 L1,之后由 TEXTRACT 逐 baseK 切片取用。对应 [ProcessKIteration 中的 GlobalTensor 形状定义:

using NDValidShapeA = TileShape2D<U, baseM, baseK * stepKa, Layout::ND>;
using NDValidShapeB = TileShape2D<U, baseK * stepKb, baseN, Layout::DN>;

kModstepKa = kIter % stepKa 为 0 时才触发新一轮 TLOAD,其余迭代只做 TEXTRACT,从而摊薄 DMA 启动开销、提升 burst 效率。L1 侧 tile 尺寸随之放大为 <a href="https://link.gitcode.com/i/2fcda475d698749b3cee7ea283d4c5e9" target="_blank">baseM, baseK*stepKa](A)与 [baseK*stepKb, baseN](B),见 [RunGemmE2E。

4)双缓冲:让搬运与计算在时间上交叠

流水线的性能核心是两组双缓冲标志 mte2DBFlag(TLOAD 侧)与 mte1DBFlag(TEXTRACT 侧)以及它们驱动的事件流(底层硬件 pipe 为 PIPE_MTE2、PIPE_MTE1、PIPE_M、PIPE_FIX,代码注释中对应高层 PTO 指令):

  • TLOAD 加载下一批 aMatTile[]/bMatTile[];
  • TEXTRACT 提取下一批 aTile[]/bTile[];
  • TMATMUL 计算当前批次的 TMATMUL[_ACC]。

关键同步点(见 ProcessKIteration):

  1. TLOAD 复用 L1 buffer 前:WaitFlag<PIPE_MTE1, PIPE_MTE2>(mte2DBFlag),确保上一次 TEXTRACT 已读完该槽;
  2. TEXTRACT 覆盖 L0 buffer 前:WaitFlag<PIPE_M, PIPE_MTE1>(mte1DBFlag),确保 Cube 已用完当前 L0A/L0B;
  3. TMATMUL 前:SetFlag<PIPE_MTE1, PIPE_M> + WaitFlag<PIPE_MTE1, PIPE_M>,确保 extract 结果就绪;
  4. 每个 k 迭代结束翻转 mte1DBFlag,stepKa 迭代结束用 SetFlag<PIPE_MTE1, PIPE_MTE2>(currMte2Idx) 释放 L1 槽。

TSTORE 阶段(StoreResult)通过 PIPE_M → PIPE_FIX → PIPE_M 的事件链确保 L0C 结果写完后再回写 GM,TSTORE 的 GlobalTensor 用全局 C<a href="https://link.gitcode.com/i/d68cbe9a71c81c080e421c5bf38a58e9" target="_blank">m,n] 作为 stride(BaseShape2D<T, m, n, Layout::ND>),保证任意 (i,j) 子块的写回位置正确。首末同步由 [InitSyncFlags / WaitSyncFlags 补齐——即 README 中强调的“首轮 warmup / 末轮 drain”处理,重构时务必保留。

Tiling 参数一览与逐项说明

以下为 main.cpp 中默认参考配置,也是 LaunchGEMME2E 的实例化参数:

参数 值 含义与推导
m / k / n 6144 全局问题规模,默认参考尺寸
singleCoreM 1536 单核负责的 M 片(6144 / 4,沿 m 切 4 份)
singleCoreK 6144 单核负责的 K 片(不切 k)
singleCoreN 1024 单核负责的 N 片(6144 / 6,沿 n 切 6 份)
baseM 128 base block 行数,决定 L0A 占用
baseK 64 base block K 粒度,对齐 Cube 偏好粒度
baseN 256 base block 列数,决定 L0B 占用与写回对齐
stepM 1 M 方向每次迭代的 block 数
stepKa 4 A 侧每次 TLOAD 缓存的 K 切片数(L1 复用)
stepKb 4 B 侧每次 TLOAD 缓存的 K 切片数(L1 复用)
stepN 1 N 方向每次迭代的 block 数

由此可推出循环次数(RunGemmE2E):mLoop = singleCoreM / baseM = 12、nLoop = singleCoreN / baseN = 4、kLoop = singleCoreK / baseK = 96。三层循环(i → j → kIter)即为每个核上的完整计算轨迹。

标准 GEMM 流水线与指令语义

示例围绕四条 PTO 指令组织流水线:

  1. TLOAD 阶段(GM → L1):TLOAD 写入 aMatTile<a href="https://link.gitcode.com/i/3c6dd1668be544a5e8912eb9c0006c23" target="_blank">] / bMatTile[]。TLOAD 从 GlobalTensor(GM)加载数据到 Tile,其语义、约束与 L2 cache hint 详见 [docs/isa/TLOAD.md;
  2. TEXTRACT 阶段(L1 → L0A/L0B):TEXTRACT 从大 tile 中按 (indexRow, indexCol) 切出 baseK 子块写入 aTile<a href="https://link.gitcode.com/i/6845e8c27f6cce56558f816fa837d462" target="_blank">] / bTile[]。注意 A 侧切分点在第 k 列(0, kModstepKa * baseK)、B 侧在第 k 行((kIter % stepKb) * baseK, 0),与各自的布局(A 为 ND、B 为 DN)对应。TEXTRACT 支持 TileType::Mat → TileType::Left/Right 等路径,详见 [docs/isa/TEXTRACT.md;
  3. TMATMUL 阶段(L0A/L0B → L0C):k == 0 时用 TMATMUL 初始化 cTile,之后每轮用 TMATMUL_ACC 累加(见 MatmulAcc),对应指令文档 docs/isa/TMATMUL.md 与 docs/isa/TMATMUL_ACC.md;
  4. TSTORE 阶段(L0C → GM):单个 kLoop 结束后把 <a href="https://link.gitcode.com/i/a29919a95aea0afe6f3c7383fe28925a" target="_blank">baseM, baseN] 的 cTile 写回 GM([docs/isa/TSTORE.md)。

底层同步仍使用 PIPE_MTE* 硬件事件(set_flag / wait_flag),但其语义与上层的 TLOAD/TEXTRACT/TMATMUL/TSTORE 一一对应,调优时以指令视角思考即可。所有 PTO 指令的 C++ intrinsic 声明位于 include/pto/common/pto_instr.hpp,TLOAD / TEXTRACT / TMATMUL 等均以 RecordEvent 形式返回事件对象,便于与事件同步机制衔接。

实测性能数据与瓶颈判读

以下数据在 Ascend A3(24 核) 上测得,覆盖多个 m=k=n 尺寸(fp16 输入 → fp32 输出):

参数 TMATMUL(Cube)占比 TEXTRACT 占比 TLOAD 占比 TSTORE 占比 执行时间(ms)
m=1536 k=1536 n=1536 54.5% 42.2% 72.2% 7.7% 0.0388
m=3072 k=3072 n=3072 79.0% 62.0% 90.9% 5.8% 0.2067
m=6144 k=6144 n=6144 86.7% 68.1% 95.2% 3.1% 1.5060
m=7680 k=7680 n=7680 80.6% 63.0% 98.4% 2.4% 3.1680

这些占比指标主要回答一个问题:端到端流水线到底被哪个引擎限制。要点如下:

  • 规模效应:执行时间随 m=k=n 超线性增长(符合 O(n^3) 计算量),吞吐通常从小尺寸提升到中等尺寸后趋于平缓;
  • TMATMUL 利用率先升后降:Cube 占比从 54.5% 升至 86.7%(更好的摊销与更稳定的流水),到 7680³ 回落至 80.6%,说明最大尺寸下计算已不再是唯一瓶颈;
  • TLOAD 接近饱和:7680³ 时 TLOAD 达 98.4%,GM 供给路径接近极限并开始反噬计算(TMATMUL 占比随之下滑);
  • TSTORE 很小且持续缩小:GEMM 输出写回占比本就小(一次写回对应大量 FMA),规模越大越不明显;
  • TEXTRACT 不可忽视:42%→68% 说明 L1→L0 的 extract/layout 成本不低,优化该阶段并与计算更好地重叠会直接影响整体性能。

经验法则:当 TLOAD 占比接近 ~100% 时,通常意味着被内存供给限制——即便 TMATMUL 看起来仍然“很忙”,进一步加速也应来自减少每 FLOP 的搬运字节数、提升复用(stepK)与改善重叠,而非微调计算本身。

性能优化指南:六步调优路径

1)优先做多核切分

检查 InitGMOffsets:确认 m % singleCoreM == 0、n % singleCoreN == 0;对方阵问题在 m、n 两个维度同时切分比只切一维更均衡。

2)选择能“干净”装进 L0A/L0B 的 base tile

L0A/L0B 双缓冲按 32 KiB ping/pang 划分,每个 buffer 的 footprint 必须 ≤ 32 KiB。FP16 下验证 baseM * baseK * 2 与 baseK * baseN * 2 是否超预算;B 侧尽量吃满预算,baseK 对齐 Cube 偏好的 K 粒度。

3)用 L1 stepK 缓存提升复用

增大 stepK 可减少 DMA 启动开销并提升 burst 效率,直到 L1 容量限制或阶段重叠开始恶化。当 TLOAD 接近 100% 且 TMATMUL 下滑时,可尝试:增大 stepK;在 L0 允许的前提下增大 baseN/baseM 提升计算强度;或改善重叠。

4)保持流水线重叠(避免气泡)

观察特征判断瓶颈方向:

  • TLOAD 高而 TMATMUL 低 → Cube “饿了”,要么重叠不足,要么 TLOAD 真正饱和;
  • TEXTRACT 高而 TMATMUL 低 → extract/layout 是瓶颈,需降低 TEXTRACT 成本或增大每次 extract 的计算量。

实操要点:确保首轮 warmup 与末轮 drain 不把稳态循环串行化(保留 InitSyncFlags / WaitSyncFlags 的补齐逻辑);将计算与搬运按 buffer index(ping/pang)分离,只在真实依赖边界上 wait_flag。

5)适配新形状时,先重新调 core tile

改动 m/k/n 时不要只改常量:重新计算 singleCoreM/singleCoreN 使各核工作量均衡;重新检查 mLoop、nLoop、kLoop(它们直接影响重叠效率)。常见失效模式:kLoop 很大但 stepK 不足 → TLOAD 主导;kLoop 很小 → 固定开销主导。

6)用占比指标决定“优化什么”

  • 7680³:TLOAD=98.4%、TMATMUL=80.6% → 应聚焦减少 GM 搬运(更高复用、更好缓存 staging)与重叠,而非单独微调 TMATMUL;
  • 中等尺寸(3072³、6144³):TMATMUL 与 TLOAD 同时较高 → 流水线接近平衡,进一步提升需要谨慎的端到端改动。

构建与运行

前置条件:已配置 Ascend CANN 环境(需安装与平台匹配的 CANN 工具链与驱动)。

# 1. 配置 Ascend CANN 环境
source ${ASCEND_INSTALL_PATH}/bin/setenv.bash

# 2. 生成输入 + golden 输出(在示例目录下执行)
cd ${git_clone_path}/kernels/manual/a2a3/gemm_performance
python3 scripts/gen_data.py

# 3. 运行示例(npu 模式,Ascend910B1 为例)
bash run.sh -r npu -v Ascend910B1

运行成功后输出:

test success

补充说明:

  • run.sh 支持 -r npu|sim 与 -v <SocVersion> 两个参数;sim 模式会在 LD_LIBRARY_PATH 中注入 ${ASCEND_HOME_PATH}/tools/simulator/${SOC_VERSION}/lib,并链接 runtime_camodel;
  • 脚本内部执行 cmake -DRUN_MODE=... -DSOC_VERSION=... -DCMAKE_LINK_DEPENDS_USE_LINKER=OFF .. && make -j16,随后直接运行 ./gemm_performance;CMAKE_LINK_DEPENDS_USE_LINKER=OFF 是为了规避 cce-ld 不接受 --dependency-file 的问题(CMake 3.27+ 默认开启);
  • gen_data.py 默认只生成 6144³ 一组数据(fp16 → fp32,无 bias),如需验证其他尺寸需同步修改 gen_data.py 与 main.cpp 中的 shape 常量;
  • Host 侧通过 ACL Runtime 接口(aclrtMalloc、aclrtMemcpy、aclrtSynchronizeStream 等)完成数据搬运,最终调用 ResultCmp 以 0.001 的容差比对设备输出与 golden,详见 main.cpp。

延伸阅读

变更记录:2025-12-15 调整示例目录并新增本 README(见 kernels/manual/a2a3/gemm_performance/README.md 的 Changelog 小节)。

登录后查看全文
pto-isa