PTO 实现 GEMM+AllReduce 融合算子:A2/A3 双流重叠实战指南

原创2026-09-17 23:20:152,131 阅读
文章标签:人工智能算子库CANNAscend

PTO 实现 GEMM+AllReduce 融合算子:A2/A3 双流重叠实战指南

导读

本指南以 CANN pto-isa 仓库中的 kernels/manual/a2a3/gemm_ar 示例为主线,讲解如何在 A2/A3 芯片上使用 PTO(Parallel Tile Operation)指令集实现多卡 GEMM + AllReduce 融合算子。该示例通过"计算流 + 通信流"双流设计与逐 tile 级别的信号量握手,让 GEMM 计算与跨卡 AllReduce 通信并发执行,在参考平台上获得约 1.443x 端到端加速。读完本文,你将掌握该算子的整体架构、计算/通信内核的关键实现、无锁就绪队列与 RDMA 窗口编程模型,以及构建、运行、调参与性能解读的完整实战方法。

功能概述与算子规格

示例实现的多卡融合语义为:

Cfinal=∑i=0nranks−1Ai×BC_{final} = \sum_{i=0}^{nranks-1} A_i \times B

其中 A_i 为各 rank 私有的 M x K 矩阵,B 为所有 rank 共享的 K x N 矩阵,C_i 是本地 GEMM 结果,C_final 是 AllReduce 之后的最终 M x N 输出。默认矩阵配置定义在 gemm_ar_config.h 中:M=5416、K=6144、N=1408。

算子规格如下:

Item Value
OpType GEMM + AllReduce
Input A_i: M x K, float16, ND(每 rank 私有);B: K x N, float16, DN(共享)
Output C_final: M x N, float16, ND(AllReduce 结果)
Compute kernel name GemmComputeKernel(Cube 架构,dav-c220-cube)
Comm kernel name GemmCommAllKernel(Vector 架构,dav-c220-vec)

目录布局

kernels/manual/a2a3/gemm_ar/
├── CMakeLists.txt              # 构建配置(3 个 target:cube 内核、vec 内核、host 可执行程序)
├── run.sh                      # 一键构建+运行脚本(自动计算 HCCL_BUFFSIZE 并定位 MPI)
├── gemm_ar_config.h            # 全局配置(矩阵形状、tile 尺寸、block 数量)
├── main.cpp                    # 入口:MPI 初始化、数据生成、HCCL 初始化、窗口分配、性能测量、验证
├── gemm_compute_kernel.cpp     # GEMM 计算内核(Cube 侧,L0C FP32 -> GM FP16 自动转换)
├── comm_kernel.cpp             # 通信内核(Vector 侧,单内核内重叠 RS/AG 的 AllReduce)
├── kernel_launchers.h          # host 侧内核 launcher 声明
├── common.hpp                  # 设备侧 HcclRemotePtr 封装(RDMA 窗口地址转换)
├── comm_context.h              # HcclDeviceContext 结构(每个 rank 的 RDMA 窗口地址)
├── ready_queue.hpp             # 多 block 无锁 tile 队列(计算 -> 通信信令)
└── comm_mpi.h                  # MPI 动态加载封装(dlopen/dlsym,无硬链接依赖)

说明:README 目录清单中标注的 hccl_context.h 在当前仓库中实际命名为 comm_context.h,其中定义了 CommDeviceContext,内含 rankId、rankNum、winSize 以及每个 rank 的 windowsIn[HCCL_MAX_RANK_NUM] / windowsOut[] RDMA 窗口地址数组。

总体架构:双流通信-计算重叠

示例采用双流设计:Compute Stream 上运行 GemmComputeKernel(24 个 AIC 块),Comm Stream 上运行 GemmCommAllKernel(24 个 AIV 块)。PTO 通信指令直接操作 HCCL RDMA 窗口完成 AllReduce,计算与通信之间通过逐 tile 信号量进行流水线交接,而非设备级全局屏障。

┌──────────────────────────────────────────────────────────────────────────────┐
│  Compute Stream (24 AIC)                Comm Stream (24 AIV)                │
│                                                                              │
│  GemmComputeKernel:                     GemmCommAllKernel:                   │
│  ┌─────────────────────────┐            ┌──────────────────────────────┐     │
│  │ for each tile:          │            │ RS/AG overlap loop           │     │
│  │   K-loop (L1 -> L0 -> Cube)          │   poll Ready Queue           │     │
│  │   TSTORE -> gemm_output │──Ready──→ │   TLOAD tile from gemm_output│     │
│  │   pipe_barrier(ALL)     │  Queue    │   TSTORE<AtomicAdd> -> owner │     │
│  │   Enqueue tile_idx      │            │   subtile-ready / summary++  │     │
│  └─────────────────────────┘            │   drain ready subtiles for AG│     │
│                                          │   TLOAD -> TSTORE to remote │     │
│                                          │   ready-driven AG handoff    │     │
│                                          │   subtile-level overlap      │     │
│                                          │                              │     │
│                                          └──────────────────────────────┘     │
└──────────────────────────────────────────────────────────────────────────────┘

从源码角度看,main.cpp 中分别通过 aclrtCreateStream 创建 computeStream 与 commStream,host 侧 LaunchCompute 调用 launchGemmCompute(见 gemm_compute_kernel.cpp 底部),LaunchComm 调用 launchGemmCommAll(见 comm_kernel.cpp 底部),launcher 声明统一放在 kernel_launchers.h 中。

计算内核实现细节

计算内核的时间流水线可概括为:

Time ->
L1 (MTE2):  [TLOAD A0,B0]                [TLOAD A1,B1]              ...
L0 (MTE1):       [TEXTRACT k0] [k1] [k2] [k3] [TEXTRACT k0'] ...
Cube (M):             [TMATMUL k0] [ACC k1] [ACC k2] [ACC k3] [TMATMUL k0'] ...
                      ^ full three-stage overlap ^

每个 AIC 按 block_idx x tiles_per_block 方式领取 tile 子集,对每个 tile 依次执行:

  1. Block Swizzle 映射:SwizzleTileIndex() 把线性 tile 索引映射为"之字形"遍历顺序(奇数行反转),使相邻 tile 在 L1 中复用矩阵 B 的列;
  2. K 循环:每 stepKa=4 次迭代做一次批量 TLOAD 将 4 个 K 片拉入 L1,之后每次用 TEXTRACT 取出一个 K 片到 L0,再做 TMATMUL / TMATMUL_ACC 累加(见 ProcessKIteration());
  3. TSTORE:L0C 中的 FP32 结果经 FixPipe 自动转成 FP16 后写回 gemm_output;
  4. pipe_barrier(PIPE_ALL):确保 GM 写完成;
  5. MultiBlockEnqueueFast:将 tile_idx 入队通知通信内核。

源码中相关常量与断言位于 gemm_compute_kernel.cpp 的 G_K_LOOP、G_STEP_KA/G_STEP_KB = 4 处:static_assert 强制 G_K_LOOP 可被 stepK 整除、stepKa == stepKb,且 G_BASE_K 固定为 64。tile 类型别名 TileMatAData、TileMatBData、ResTileT 分别对应 L1 面板、L0 切片与 L0C 累加器。

通信内核实现细节

通信内核 GemmCommAllImpl()(见 comm_kernel.cpp)把 RS(ReduceScatter)生产与 AG(AllGather)消费交织在同一个循环里,同步点是"逐 subtile 计数器"而不是设备级屏障。

RS 生产者路径

每个通信 block 认领的队列子集为:

queues(block b) = { b, b + num_comm_blocks, b + 2*num_comm_blocks, ... }

默认 COMPUTE_BLOCK_NUM = COMM_BLOCK_NUM = 24 时退化为 1:1;通信 block 更少时,一个 block 通过 RsPollQueues() / RsWaitOnQueue() 轮询多个计算队列。对每个出队的 tile:

  1. 沿 M 方向把 tile 拆成 G_COMM_SUBTILES_PER_TILE = G_BASE_M / G_COMM_SUB_M 个定高 subtile;
  2. RsPipelineStep() 使用 ping/pong 两块 UB tile,使当前 subtile 的 TLOAD 与上一 subtile 的 TSTORE<AtomicAdd> 重叠;
  3. RS 目的地是 owner rank:owner = tile_idx % nranks,归约直接写进该 rank 的 reduced_output。

RS/AG 重叠同步

重叠协议使用 owner rank 的 signal_matrix 中的两类计数器:

  1. subtile-ready[local_subtile_id]:统计有多少 rank 已对某个 owner-local subtile 完成 RS;
  2. ag-summary[summary_block]:面向负责该 subtile 的 AG block 的粗粒度唤醒门铃。

发布侧遵循 RsPublishSubtileReady():先 pipe_barrier(PIPE_ALL) 冲刷本地流水线,再 dsb(DSB_DDR) 保证 reduced_output 写全局可见,随后 RsNotifySubtileReady() 递增 owner-local 就绪计数、RsNotifyAgSummary() 递增由 AgSummaryBlockForSubtile() 选出的 AG 唤醒计数(两者底层均为 pto::comm::TNOTIFY(..., NotifyOp::AtomicAdd))。

消费侧遵循 AgDrainReadyAssignedSubtiles():

  1. 用 TTEST(..., nranks, GE) 探测本 block 认领的 subtile-ready 计数;
  2. 一次 drain pass 首次命中时,只执行一次 acquire fence(pipe_barrier + dsb)即可消费该批全部就绪 subtile;
  3. 将每个就绪 subtile 搬运到所有远端 rank;
  4. 若无法推进,则 AgWaitAssignedSummary() 阻塞在 summary_ack_count + 1,等待下一次分配的唤醒。

AgSummaryBlockForSubtile() 采用反转条带(reversed-stripe)映射,让 AG 重的 block 落在 RS 轻的 block 上,从而拉平 rs_work + ag_work 的组合负载。

AG 执行器路径

AG 工作在 owner-local subtile 空间分配:

total_local_subtiles = my_tile_count * G_COMM_SUBTILES_PER_TILE
assigned_ids(block b) = { num_comm_blocks - 1 - b + k*num_comm_blocks }

对每个就绪的 assigned subtile:

  1. AgDecodeLocalSubtile() 把 owner-local subtile id 映射回 reduced_output 的全局行偏移;
  2. AgTransferSubtileToAll() 恰好向每个远端 rank 广播 G_COMM_SUB_M 行;
  3. 首个远端 peer 按 local_subtile_id % (nranks - 1) 轮转,避免所有 block 同时锤击同一目的地。

该设计使 AG 可以在某个 owner-local subtile 被所有 rank 完全归约后立即开始,无需等待整卡 RS 结束。

就绪队列机制

┌─────────────┐         ┌─────────────┐
│  AIC 0      │         │  AIV 0      │
│  (Compute)  │──Queue──│  (Comm)     │
│  block_idx=0│   0     │  block_idx=0│
└─────────────┘         └─────────────┘
┌─────────────┐         ┌─────────────┐
│  AIC 1      │         │  AIV 1      │
│  (Compute)  │──Queue──│  (Comm)     │
│  block_idx=1│   1     │  block_idx=1│
└─────────────┘         └─────────────┘
      ...                     ...
┌─────────────┐         ┌─────────────┐
│  AIC 23     │         │  AIV 23     │
│  (Compute)  │──Queue──│  (Comm)     │
│  block_idx=23│  23    │  block_idx=23│
└─────────────┘         └─────────────┘

实现位于 ready_queue.hpp:

  • 每个队列是 64 字节对齐的 PerBlockQueue,含 count(生产者侧单调递增计数)与 data[](tile 索引数组);槽位通过 GetQueueSlot() 辅助函数寻址,不依赖隐式的 data[idx] 布局假设;
  • 生产者(AIC):PerBlockQueueEnqueueFast 通过 GetQueueSlot() 写目标槽,再递增 count,并用 dcci 刷新缓存状态使条目对 AIV 可见(由调用方跟踪槽位,可将 dcci 次数从 5 次降到 2 次);
  • 消费者(AIV):PerBlockQueueTryDequeue 用硬件 TTEST 检查 count >= head+1,经 GetQueueSlot() 刷新目标槽后返回 tile id;无就绪数据返回 -1,长时间空闲后退化为硬件 TWAIT;
  • 当 COMM_BLOCK_NUM < COMPUTE_BLOCK_NUM 时,一个通信 block 按轮询顺序排空多个队列;队列分配是静态的,因此无需跨 block 原子仲裁;
  • 设计为单生产者-单消费者,队列内部无需任何原子操作。

内存布局与 HCCL 窗口

只有被远端 TPUT 或 TNOTIFY 写入的缓冲区才必须放在 HCCL RDMA 窗口内;仅本地读写使用的缓冲区可用普通 aclrtMalloc 分配:

Buffer Size Location Why
reduced_output M x N x 2B HCCL window RS AtomicAdd 与 AG 远端 TPUT 写入(FP16)
signal_matrix G_SIGNAL_TOTAL_SLOTS x 4B,按 64B 对齐 HCCL window subtile-ready 与 AG-summary 计数(外加保留的旧版 barrier 槽位)
gemm_output M x N x 2B aclrtMalloc 仅本地读写(FP16)
src0_dev, src1_dev 输入矩阵(FP16) aclrtMalloc 仅本地读写

main.cpp 中 AllocDeviceBuffers 通过 WindowAlloc(windowBase, ...) 从 hostCtx.windowsIn[rankId] 起步分配 reduced_output 与 signal_matrix,并校验 winOffset <= winSize,否则报 "HCCL window too small"。

窗口大小由环境变量 HCCL_BUFFSIZE 控制,run.sh 按 padded 后的 reduced_output 占用自动计算并附加较大余量:

pad(M, G_BASE_M) x pad(N, G_BASE_N) x 2 / 1MB + 64MB

signal_matrix 位于同一窗口内,相对 64MB 余量可忽略。

关于跨 rank 寻址:common.hpp 的 CommRemotePtr(ctx, localPtr, pe) 以本 rank 窗口基址计算偏移,再叠加到目标 rank 的 windowsIn[pe] 上得到远端地址;设备上下文由 comm_context.h 的 CommDeviceContext 承载。拓扑适配方面,main.cpp 在 MESH 拓扑(A2)下直接复用 HCCL 返回的上下文结构,在 RING 拓扑(A3)下通过 hccl_compat 兼容结构从 CommOpResParam 的 remoteRes 提取远端 RDMA 地址并手工组装 host 上下文。

性能数据(参考值)

以下数据来自当前 subtile-ready / AG-summary overlap 实现,采集环境为 8 卡 Ascend 910B,M=5416, K=6144, N=1408(pad 为 5504 x 1536),258 tiles (43 x 6),compute_blocks=24、comm_blocks=24。每个 rank 计算完整 GEMM C_i = A_i x B,AllReduce 对 8 个 C_i 求和。

Metric Value
Compute-only 368.1 us(254546 GFLOPS)
Sequential 808.9 us(compute 371.6 us + comm 437.3 us @ 63.6 GB/s)
Pipelined 560.6 us(compute done 367.2 us,comm done 560.6 us @ 49.7 GB/s)
Speedup 1.443x
Time saved 248.4 us(30.7%)
Overlap eff 66.8%
Throughput 1337307 GFLOPS(total)

main.cpp 中 PrintTimingDetails 给出了上述指标的完整计算口径:Speedup = Sequential / Pipelined;Time saved = seq_avg - pipe_avg;Overlap eff = (seq_comp + seq_comm - pipe) / min(seq_comp, seq_comm)。

指标解读

  • Compute-only:纯 GEMM 无通信的执行时间,反映单卡 Cube 利用率上限;
  • Sequential:先计算后通信、无重叠的路径(808.9 us = 371.6 us 计算 + 437.3 us 通信);
  • Pipelined:双流并发路径(560.6 us),相对 Sequential 为 1.443x 加速,重叠效率 66.8%;
  • Overlap efficiency:较短阶段被重叠隐藏的比例,66.8% 表示约三分之二的短阶段被隐藏。

优化历史

下表为历史优化检查点;最后一行是当前 subtile-ready / AG-summary overlap 路径的最新端到端结果。较早行应视为背景参考,而非当前路径的字面分解。

Optimization Pipelined (us) Gain Conclusion
Baseline 808 - -
Block Swizzle 793 -1.8% Kept
RS AtomicAdd 移除独立 Reduce 阶段 736 -6.6% Kept
AG 行级扁平化调度 623 -15.4% 历史检查点
48 AIV(RS skip + AG participate) 639 RS 仅 24 AIV,AG 48 AIV Reverted(AIC 干扰)
48 AIV 双队列(1 AIC : 2 AIV) 667 RS 与 AG 均在 48 AIV Reverted(AIC 干扰)
当前 subtile-ready / AG-summary overlap 路径 560.6 较 623 us 历史检查点约 -10.0% 当前结果

性能调优指南

1. 优先做多核划分

每个 AIC 按 block_idx x tiles_per_block 领取 tile 子集,块间互不干扰。

检查清单:

  • 调节 COMPUTE_BLOCK_NUM,使每个 block 分到相近数量的 tile;
  • 不同矩阵形状下,按 G_NUM_TILES = (M_padded/128) x (N_padded/256) 重算总 tile 数。

配套源码:gemm_ar_config.h 中的 GEMM_AR_BLOCK_TILE_COUNT / GEMM_AR_BLOCK_START_TILE 宏实现了"余数摊给前 remainder 个 block"的均衡划分,避免经典 ceil 划分产生"1 个矮块 + N-1 个满块"的负载不均。

2. 选择合适的 base tile

L0A 与 L0B 采用 ping/pong 双缓冲,每个缓冲限制为 32 KiB。

对于 FP16 输入(2 bytes/elem):

  • L0A tile 字节 ~= baseM x baseK x 2 = 128 x 64 x 2 = 16 KiB
  • L0B tile 字节 ~= baseK x baseN x 2 = 64 x 256 x 2 = 32 KiB

通信 tile 尺寸为:

baseM x baseN x sizeof(FP16) = 128 x 256 x 2 = 64 KB

3. 用 L1 stepK 缓存提升复用

stepKa=stepKb=4 时,一次 TLOAD 将 4 个 K 片带入 L1,之后逐个 TEXTRACT 拉入 L0。

L1 占用:

2 x 64KB (A) + 2 x 128KB (B) = 384KB <= 1024KB

增大 stepK 可减少 DMA 启动开销,但总量必须仍能装进 L1。

4. 保住流水线重叠

性能关键来自两件事的组合:

  • 计算内核内部双缓冲(L1 / L0A / L0B);
  • 计算与通信之间的双流重叠。

当观察到:

  • communication time >> compute time:计算侧已高效,应聚焦改善通信或提升重叠度;
  • compute time >> communication time:通信已被完全隐藏,应聚焦计算侧。

5. 调节通信 block 数量

COMM_BLOCK_NUM 控制通信内核的 AIV 并行度,可通过 --comm-blocks 调整。在 Ascend 910B 上,将 COMM_BLOCK_NUM 从 24 提升到 48 会使 AIC 计算时间显著增加(约 +24%),原因是 HBM 带宽争用与 TSCH 调度开销,因此默认稳定取 24。

6. 约束条件

  • K 必须能被 G_BASE_K x G_STEP_KA 整除(默认 64 x 4 = 256);
  • M 自动 pad 到 128 的倍数,N 自动 pad 到 256 的倍数;
  • 所有 HCCL 窗口缓冲区必须在每个 rank 上以相同偏移分配;
  • 每次迭代前必须用 aclrtMemset 重置 signal_matrix(见 main.cpp 中 ResetDeviceState)。

构建与运行

  1. 配置 Ascend CANN 环境:
export ASCEND_CANN_PATH=/usr/local/Ascend/cann-<version>/set_env.sh
source "${ASCEND_CANN_PATH}"
  1. 激活提供 Python 与 NumPy 的 conda 环境:
conda activate <your-conda-env>
  1. 以 8 rank 运行示例:
cd ${git_clone_path}/kernels/manual/a2a3/gemm_ar
./run.sh --nranks 8 --soc-version Ascend910B1
  1. 指定起始设备编号:
FIRST_DEVICE=0 ./run.sh --nranks 8 --soc-version Ascend910B1
  1. 使用自定义计算/通信 block 数量:
./run.sh --nranks 8 --compute-blocks 20 --comm-blocks 4

运行成功时程序打印:

GEMM AllReduce demo completed successfully.

脚本 run.sh 内部会按 getopt 解析 -r/--run-mode、-v/--soc-version、-n/--nranks、-d/--ndevices、--compute-blocks、--comm-blocks 等参数;先清理遗留 HCCL 共享内存状态(rm -rf /dev/shm/sem.hccl*; ipcrm -a),按 PAD_M * PAD_N * 2 / 1024 / 1024 + 64(MB)自动抬升 HCCL_BUFFSIZE,再调用 cmake 与 make,最后执行 mpirun -n ${NRANKS} ./gemm_allreduce --first-device ${FIRST_DEVICE}。

环境变量

Environment Variable Purpose Default Behavior
ASCEND_CANN_PATH CANN set_env.sh 脚本的完整路径 自动 glob /usr/local/Ascend/cann-*/set_env.sh 并取最新
MPI_SEARCH_DIRS MPI bin/ 目录搜索路径(空格分隔) 搜索 /usr/local/mpich/bin、/home/mpich/bin 等常见位置
ASCEND_DRIVER_PATH CMake 使用的 Ascend 驱动路径 默认 /usr/local/Ascend/driver
MPI_LIB_PATH 运行时动态加载的 libmpi.so 绝对路径 由 run.sh 按发现的 MPI 安装自动设置
HCCL_BUFFSIZE HCCL RDMA 窗口大小(MB) 由 run.sh 根据 padded M/N 占用自动计算
FIRST_DEVICE 起始 NPU 设备编号 默认 0

修改矩阵维度

更新 gemm_ar_config.h 中的 CONFIG_G_M、CONFIG_G_K、CONFIG_G_N(注意宏带 #ifndef 保护,源码通过 include 共享配置)。也可以直接从 CMake 传入:

cmake -DCONFIG_G_M=8192 -DCONFIG_G_K=8192 -DCONFIG_G_N=2048 ..

约束:K 必须能被 G_BASE_K x G_STEP_KA 整除(默认 64 x 4 = 256);HCCL_BUFFSIZE 由 run.sh 自动计算。此外 gemm_ar_config.h 还支持 CONFIG_G_BASE_M、CONFIG_G_BASE_K、CONFIG_G_BASE_N、CONFIG_COMPUTE_BLOCK_NUM、CONFIG_COMM_BLOCK_NUM、CONFIG_COMM_SUB_M 等编译期参数,并带有 static_assert(如 G_COMM_SUB_M 必须整除 G_BASE_M、AG summary 槽至少占一个 cache line 等)作为配置安全网。

FAQ

Problem Cause and Fix
HCCL window too small 窗口必须覆盖 padded reduced_output 占用加上 signal_matrix。检查是否手动覆盖了 HCCL_BUFFSIZE;run.sh 会自动按 pad(M) x pad(N) x 2 / 1MB + 64MB 抬升
HcclGetRootInfo failed: 7 上次运行的遗留脏状态。执行 rm -rf /dev/shm/sem.hccl*; ipcrm -a 或等待约 30 秒重试
HCCL 初始化后挂起 通常是 rank 同步问题。检查所有 rank 是否都到达了 CommMpiBarrier
通信内核段错误 通常是窗口地址非法。验证 windowsIn[] 条目非零
信号等待死锁或 AG 停滞 signal_matrix 未在迭代间清零,或 subtile-ready / AG-summary 归属映射错误。检查 resetState 是否对 signal_matrix 调用了 memset
校验时 max_diff 过大 FP16 精度有限。校验容差为 atol=1.0, rtol=0.01(见 main.cpp 的 VerifyOutput)。若 diff 异常大,检查 subtile-ready / AG-summary 同步与 owner 映射
aclInit repeat init(100002) 无害。代码已对单进程重复 aclInit 做了防护
--allow-run-as-root 失败 本项目使用 MPICH,该选项是 OpenMPI 专有

构建系统

CMakeLists.txt 定义了三个 target:

  • Compiler:bisheng(CANN 内置 clang 15.0.5);
  • Cube 内核 flags:--cce-aicore-arch=dav-c220-cube -DMEMORY_BASE(gemm_compute_kernel,链接 runtime,--cce-fatobj-link);
  • Vector 内核 flags:--cce-aicore-arch=dav-c220-vec -DMEMORY_BASE(comm_kernel);
  • Host 可执行程序:标准 -xc++ 编译(gemm_allreduce,链接 gemm_compute_kernel、comm_kernel、runtime/ascendcl/hcomm/m/tiling_api 等);
  • pto-comm-isa 的 include 路径必须放在最前,以覆盖 CANN 自带的 pto_tile.hpp(include_directories 中 ${PROJECT_SOURCE_DIR}/../../../../include 即仓库根 include/ 目录);
  • CMAKE_CCE_COMPILE_OPTIONS 中开启 --cce-pto-enable,并设置了 aicore 栈大小、溢出记录、地址变换等 LLVM 选项;RUN_MODE 为 sim 时链接 runtime_camodel 以支持模拟器。

变更日志

Date Change
2025-12-15 初始版本,双流 GEMM + AllReduce 融合
2026-04-01 适配 CANN 9.0.0(移除废弃的 hccl/hccl.h 依赖)
2026-04-02 RS AtomicAdd 移除独立 Reduce 阶段;AG 扁平化改善负载均衡
2026-04-21 通信模式由 RS -> DeviceBarrier -> AG 改为 subtile-ready / AG-summary overlap

延伸阅读

登录后查看全文
pto-isa