mat_mul_v3 算子源码分析 —— 分支决策与 tiling/swizzle 实现

0. 源码结构总览

mat_mul_v3 采用 Host Tiling（CPU）+ Device Kernel（NPU） 两层结构，中间以 tiling key（位域编码）+ tiling data（参数结构体） 传递决策：

┌─────────────────────────── Host（CPU 侧，算子启动前执行一次）───────────────────────────┐
│  MatMulV3Tiling::DoTiling()                                                             │
│    └─ MMTilingRegistry::DoTilingImpl()  按 priority 依次尝试各 tiling 类（策略模式）    │
│         ├─ MatMulV3KEqZeroTiling        (priority 0)                                    │
│         ├─ MatMulV3ToMulTiling          (priority 1)                                    │
│         ├─ MatMulV3ToVectorTiling       (priority 2)                                    │
│         ├─ MatMulV3BasicStreamKTiling   (priority 3)                                    │
│         ├─ MatMulV3BasicAswtTiling      (priority 4)                                    │
│         └─ MatMulV3AswTiling            (priority 999, 兜底)                            │
│    每个类：IsCapable() 判条件 → DoOpTiling() 算参数 → 编码 tiling key + tiling data     │
└─────────────────────────────────────────────────────────────────────────────────────────┘
                                    │ tiling key（分支选择结果）+ tiling data（参数）
                                    ▼
┌─────────────────────────── Device（NPU 侧，每个核独立执行）────────────────────────────┐
│  mat_mul_v3() 入口：if constexpr 按 (ApiLevel, FullLoad, Model, L0C2Out) 四元组分发    │
│    ├─ MatMulInputKEqZeroClearOutput          K==0 清零                                 │
│    ├─ MatMulToMulActKernel / MatMulToVectorActKernel   退化向量乘                       │
│    ├─ MatMulStreamKKernel / MatMulStreamKSplitKKernel   StreamK 切 K                   │
│    ├─ MatMulBasicKernel / MatMulBasicSplitKKernel       ASWT 基础模板                  │
│    ├─ MatMulAL1FullLoadKernel / MatMulBL1FullLoadKernel A/B 全载                      │
│    └─ MatMulFixpipeOptiTensorKernel           Fixpipe 随路搬出优化                     │
└─────────────────────────────────────────────────────────────────────────────────────────┘

关键枚举（mat_mul_v3_tiling_key_public.h）：

贯穿全文的符号约定（维度标注）：

关键硬件规格（原理性推导的输入，来自 950PR 架构解读）：

1. 分支决策总表（DAV_3510 = 950PR）

策略优先级定义在 matmul_v3_tiling_strategy.h：

{ NpuArch::DAV_3510, {K_EQUAL_ZERO, TO_MUL, TO_MULTI_MUL, BASIC_STREAM_K, BASIC_ASWT} }

MMTilingRegistry::DoTilingImpl 按 priority 顺序逐个 IsCapable() + DoTiling()，第一个成功者胜出（每个 tiling 类的 DoTiling 返回失败则尝试下一优先级）。

2. 各分支详细分析

2.1 K_EQUAL_ZERO（priority 0）

触发条件：!hasBias && K == 0。

原理：K=0 时 C[i,j] = 0，输出恒为全零矩阵。若走 Cube，MMAD 对空 K 做无效计算；而 64 个 AIV 是天然的并行批量写单元，直接对 C 的 M×N 个元素清零即可。

实现（matmul_v3_k_equal_zero_tiling.cpp + mat_mul_input_k_eq_zero_clear_output.h）：

totalDataAmount = M · N            // 需清零的元素总数（元素个数）
usedCoreNum = aivNum               // 64 个 AIV 并行

Device 侧 MatMulInputKEqZeroClearOutput(biasGM, cGM, tilingData)：每个 AIV 负责一段连续的 C 地址，一次搬移清零。数据流极简：

AIV ──(写0)──► GM(C)     // 无 GM 读、无 Cube 参与

评价：正确且高效（不浪费 Cube、不产生 GM 读流量）。适用面窄（仅 K==0 且无 bias）。

2.2 TO_MUL（priority 1）—— M==1 或 N==1 的 FP32 退化向量乘

触发条件：isForceGrpAccForFp32（op_impl_mode_enum==0x4 高精度 FP32）∧ 非 slice ∧ (M==1 ∨ N==1) ∧ dtypeA==dtypeB==FP32。

原理（结合硬件）：Cube 的 MMAD 指令最小分形是 16×16×16。当 M==1 时，MMAD 的 M 维 16 个 lane 只能用 1 个 → Cube 算力利用率仅 1/16 ≈ 6%。此时 [1,K]·[K,N] 本质是一个 K 维向量与 N 个 K 维向量的点积，用 AIV 的向量乘加（Mul+ReduceSum）天然适合，且 64 个 AIV 的 FP32 算力 27 TFLOPS 足够覆盖。

实现（matmul_v3_to_mul_tiling.cpp + mat_mul_to_mul_cmct.h）：数据流为「GM→UB→AIV 向量乘→UB→GM」，全程不走 Cube：

GM(A[M=1,K]) ──MTE2──► UB ──AIV向量乘加──► UB ──MTE3──► GM(C[N])
GM(B[K,N])   ──MTE2──► UB

tiling 参数由 UB 容量（ubSize/4 个 float）反推：

tmpMN  = ⌈(M·N) / aivNum⌉                        // 每核摊到的 MN 元素数（元素个数）
baseMN = min(Align(tmpMN, 对齐), BASE_MN)        // MN 方向分块（元素个数）
baseK  = (ubCount - baseMN - biasCount)/5/baseMN // K 方向分块，受 UB 容量约束（元素个数）
loopK  = ⌈K / baseK⌉                             // K 循环次数（无量纲）
usedCoreNum = min(⌈M·N/baseMN⌉, aivNum)          // 实际核数

dataCopyMode 区分「K 内轴连续（(K,N)/(K,M) 布局）」还是「MN 内轴连续」，决定 baseK/baseMN 的取舍顺序。

评价：对退化场景绕开 Cube 走 AIV 正确。局限：① 仅覆盖高精度 FP32，FP16/BF16 的 M==1/N==1 无退化分支、仍走 Cube（§6 改进点）；② TO_MULTI_MUL 不支持 bias。

2.3 TO_MULTI_MUL（priority 2）—— 特定转置组合的 FP32 退化向量乘

触发条件：高精度FP32 ∧ 非slice ∧ !ATrans ∧ BTrans ∧ 无bias ∧ FP32。

原理：与 TO_MUL 同（退化向量乘），但锁定 !ATrans∧BTrans：A 行主序（K 连续）、B 列主序（K 连续），内积方向 K 两侧都连续，向量乘访存顺序、无需 gather。

实现（matmul_v3_to_multi_mul_tiling.cpp + mat_mul_to_multi_mul_cmct.h）：同样「GM→UB→AIV 向量乘→UB→GM」。核数分配用 CalcBasicBlock() 启发式均衡：

mCore = ⌈M/baseM⌉, nCore = ⌈N/baseN⌉
if (mCore·nCore < aivNum)  CalcBasicBlock()    // 块数不足分满核时重调 baseM/baseN
while (baseN ≥ 2·baseM ∧ nCore < aivNum/2):    // N 侧块太多 → nCore·=2, baseN=⌈N/nCore⌉
while (baseM ≥ 2·baseN ∧ mCore < aivNum/2):    // M 侧块太多 → mCore·=2, baseM=⌈M/mCore⌉
usedCoreNum = min(mCore·nCore, aivNum)

评价：与 TO_MUL 同族但更窄（限转置、无 bias）。共同原则：矩阵乘退化到 M==1 或 N==1 时，绕开 Cube 走 AIV，规避 Cube 16 对齐分形浪费。

2.4 BASIC_STREAM_K（priority 3）—— 切 K 满核

2.4.0 解决的问题（硬件原理）

核心矛盾：baseM=baseN=256 时，若 M、N 较小（如 M=N=256），则 mCnt·nCnt = 1×1 = 1 个 MN 块，但 aicNum=32 → 只有 1 个核工作、31 核空闲，算力利用率 1/32。950PR「算力/带宽比极高」架构下，大 K 瘦高形状（如 [256, 8192]×[8192, 256]）是典型 case：MN 方向分不满核，但 K 很大、总计算量足够喂饱 32 核。

解法：把 K 轴切成 kCnt 份分给多个核，每个核算 M×N×singleCoreK 的部分和，最后跨核累加。有效并行度变为 mCnt·nCnt·kCnt。

普通 ASWT（M=N=256, K=8192，kCnt=1）:
  ┌────────────────────────────────────────────┐
  │ 核0: [256×256] × [256×8192]   (算完整 K)    │ ← 只有 1 核，31 核空闲
  └────────────────────────────────────────────┘

StreamK（切 K，kCnt=32）:
  ┌───────────────┐  ┌───────────────┐        ┌───────────────┐
  │ 核0: K[0:256]  │  │ 核1: K[256:512]│  ...   │ 核31: K[...]   │  ← 32 核各算一段 K
  └───────┬───────┘  └───────┬───────┘        └───────┬───────┘
          └──────────────────┴──────────────────────────┘
                          ▼ 核间累加（workspace，AIV 顺序累加）
                    C[M,N] = Σ_k 部分和

2.4.1 分支结构（含 3 个子模式）

IsCapable 前置条件（MatMulV3BasicStreamKTiling::IsCapable）：

deterministicLevel ≤ 1        // 切 K 核间累加顺序不确定，强一致性场景禁用整分支
∧ aFormat == ND               // 左矩阵必须 ND
∧ 非 slice                    // 不支持非连续视图
∧ aivNum == 2·aicNum          // 必须 AIC:AIV = 1:2
∧ (CheckStreamKSKTiling() ∨ CheckStreamKDPSKTiling())

子模式 ①：SK（纯切 K） —— CheckStreamKSKTilingDav3510：

align(K, 256) >= max(8192, aicNum·256B) / dtypeA      // K 足够大
mCnt · nCnt <= aicNum / 2                              // MN 块数不超过核数一半

语义：M/N 小到「MN 块数 ≤ 核数一半」，K 大 → 全 K 切分，每核算一段 K。

注：FP32 且非 hf32 时，alignValue 从 256 退化为 32（BLOCK_BYTE_SIZE）。

子模式 ②：DPSK（数据并行 StreamK） —— CheckStreamKDPSKTilingDav3510：

M % 256 == 0 且 N % 256 == 0                           // MN 严格 256 对齐
K >= max(8192, aicNum·128B) / dtypeA                   // K 足够大
totalMNCnt >= aicNum                                   // MN 块数能分满核（主轮）
totalMNCnt % aicNum != 0                               // 但有尾轮余数
(totalMNCnt % aicNum) <= aicNum/2                      // 余数不超过核数一半

语义：主轮 MN 块数 ≥ 核数（DP 满核、K 不分片），尾轮剩余 MN 块 < 核数 → 尾轮把 K 切开分给空闲核，且提前执行让 AIV 累加与 AIC 下一轮计算重叠（数据并行）。

子模式 ③：SK_SPLIT_K：SK/DPSK 基础上，若 FP32 ∧ singleCoreK ≥ FP32_SPLIT_K_THRESHOLD，则单核内再切 K（splitSingleK，保 FP32 累加精度），model 由 STREAM_K 升级为 SK_SPLIT_K。

2.4.2 tiling 参数推导（DoOpTiling）

baseM, baseN        // 由 ResetBase + 后续逻辑给出（§3.2），通常 256
mCnt = ⌈M/baseM⌉, nCnt = ⌈N/baseN⌉
totalMNCnt = mCnt · nCnt

if (totalMNCnt <= aicNum/2):                        // 纯 SK 模式
    调整 mCnt/nCnt 到 [aicNum/3, aicNum/2] 区间     // 避免切得过碎
    baseM = Align(⌈M/mCnt⌉, 16); baseN = Align(⌈N/nCnt⌉, 16)
    kCnt = ⌊aicNum / totalMNCnt⌋                     // 每个 MN 块分配多少核切 K
    singleCoreK = ⌈K / kCnt⌉                         // 单核 K 分片（元素个数）
else:                                               // DPSK 模式（尾轮切 K）
    kCnt = aicNum / (totalMNCnt % aicNum)
    singleCoreK = ⌈K / kCnt⌉
    kCnt = ⌈K / singleCoreK⌉                         // 回算实际切分数

// baseK：受 L0A 容量约束（§3.3）
kValueMax = ⌊L0A/DB/dtypeA / max(baseM, baseN)⌋   （按 128B/dtype 或 16 对齐）
baseK = min(singleCoreK, kValueMax)

CalL1Tiling(...)                                     // 复用 §3.4 计算 stepKa/stepKb
workspace = aicNum·256·256·4B + 20·MB               // 核间累加工作区（字节）

L0C2Out：N 大且 N 不对齐（N>64 ∧ N%16≠0 ∧ M>2 ∧ M·N≥256）→ ND_FIXPIPE_1_2，否则 ON_THE_FLY（同 §2.5.4 的 fixpipe 逻辑）。

2.4.3 Device 数据流（block_scheduler_streamk.h + StreamK kernel）

StreamK 的 L1 只装一个 base 块（mL1=baseM, nL1=baseN），核间通过 workspace 累加：

DP 主轮（每核一个 MN 块，算完整 K）:
  GM(A块) ─MTE2─► L1 ─MTE1─► L0A ─┐
                                   ├─MMAD─► L0C ─Fixpipe─► GM(C块)   // 直接写结果
  GM(B块) ─MTE2─► L1 ─MTE1─► L0B ─┘

SK 尾轮（每核一个 MN 块的一段 K）:
  GM(A块) ─► L1 ─► L0A ─┐
                        ├─MMAD─► L0C ─Fixpipe─► workspace(部分和)     // 写部分和
  GM(B块) ─► L1 ─► L0B ─┘
  然后 AIV 从 workspace 顺序累加（Atomic/确定性累加）─► GM(C块)

CheckIsSkScene(tileIdx) 判定当前核索引属于 DP 轮还是 SK 轮：ceil((tileIdx+1)/usedCoreNum) == ceil(tileNum/usedCoreNum)（最后一轮是 SK）。

2.4.4 评价

• 优点：① 解决"MN 块数不足分满核、但 K 大"的场景，大 K 瘦高形状算力利用率可从 1/32 提升到接近满核；② DPSK 让尾轮 SK 与 AIC 计算重叠，减少核空闲。
• 缺点：① workspace 核间累加带来额外 GM 写+读流量（部分和写出 + AIV 读回），950PR 带宽紧张下成本不低；② 累加顺序不确定 → deterministicLevel>1 整分支禁用；③ 仅 A 为 ND；④ DPSK 要求 M/N 严格 256 对齐；⑤ FP32 切 K 需额外 splitSingleK 保精度，复杂度高。

2.5 BASIC_ASWT（priority 4）—— 主分支（含 4 个子分支）

IsCapable：无条件返回 true（除命中 StreamK 场景外的绝大多数 case 都落在这里）。

DoOpTiling 先调用父类 MatMulV3AswTiling::DoOpTiling() 完成基础 tiling（ResetBase→GetRebalanceBlock→CalcTailBasicBlock→CalL1Tiling，即 §3 的完整流程），得到 baseM/baseN/baseK 后，再按顺序做子分支决策：

DoOpTiling():
  isSlice_ = IsSelfNonContiguous()                  // 子分支④：非连续 3D slice
  l0C2Out_ = GetL0C2Out()                           // 子分支③：fixpipe 优化判定
  if (!isSlice_ && CheckAL1FullLoad())  → DoAL1FullLoad()   // 子分支①：A 全载
  elif (!isSlice_ && CheckBL1FullLoad()) → DoBL1FullLoad()  // 子分支②：B 全载
  elif (l0C2Out_ == ON_THE_FLY)         → 普通场景，L1 剩余容量均分 stepK
  else                                  → fixpipe 优化场景
  CheckFp32SplitK()                                 // FP32 大 K → BASIC_SPLIT_K
  CheckApiLevelAndModel()                           // BASIC / TENSOR api

ASWT 的标准数据流（所有子分支共享的骨架，mat_mul_asw_kernel.h 的 mm_.Iterate()）：

GM(A块) ─MTE2─► L1(A) ─MTE1─► L0A ─┐
                                    ├─ MMAD(16×16×16) ─► L0C ─Fixpipe─► GM(C块)
GM(B块) ─MTE2─► L1(B) ─MTE1─► L0B ─┘
   （MTE2 重复读可命中 L2，5.2TB/s；L1 用 Double Buffer 掩盖搬移延迟）

2.5.1 子分支①：A 全载 L1（A_FULL_LOAD）

触发条件（CheckAL1FullLoad）：

l0C2Out == ON_THE_FLY                 // 不与 fixpipe 叠加
∧ cubeBoundParam > cubeBoundEdge      // 非 CubeBound（MTE2 是瓶颈，重复读代价高）
∧ nCnt > aicNum                       // N 方向块数多于核数 → 同一 A 块被跨 N 的核重复读
∧ !(K <= 128 && mCnt != 1)            // 排除 Fixp Bound 多轮
∧ (M·K·dtypeA + bias) <= 3/4·L1       // 整个 A + bias 能装进 3/4 L1（384KB）

原理（结合硬件）：当 nCnt > aicNum，同一列（固定 m）的 A 块会被 nCnt 个核重复读。若 A 的 M×K 整个能装进 L1，则把它常驻 L1，只流式搬 B → A 的重复读从 GM/L2 级别降为 0，只剩 B 的单次读 + A 的单次读。对 950PR 的 1.6TB/s 带宽是直接省流。

A 全载数据流（A 常驻 L1，B 按 baseN 流式）:
  GM(A[M×K]) ─MTE2─► L1(A, 常驻, 不再搬出)
                     │每次只搬 B 块：
  GM(B[K×baseN]) ─MTE2─► L1(B) ─MTE1─► L0B ─┐
  L1(A) ─MTE1─► L0A ────────────────────────┼─MMAD─► L0C ─Fixpipe─► GM(C)

tiling（DoAL1FullLoad）：

singleCoreM = M                       // M 不再分核（A 常驻，M 方向一块）
singleCoreN = baseN                   // N 方向按 baseN 分
aL1Size = M·K·dtypeA                 // A 全载字节数
remainL1 = L1 - (aL1Size + bias)      // L1 剩余容量
maxBaseN = min(remainL1/(baseK·dtypeB·DB),  L0C/(baseM·4B·DB))   // 受 L1 剩余 + L0C 双缓冲约束
baseN = min(baseN, maxBaseN, ⌈N/aicNum⌉对齐16)                    // 三者取小
stepKa = ⌈K/baseK⌉, stepM = ⌈M/baseM⌉    // K、M 方向 L1 分片
stepKb = 由 B 的 L1 搬移量 + 256B 对齐确定  // B 侧 K 分片
l1BufferNum = (4·B搬移量 + aL1Size + bias > L1) ? 2 : 4    // 能否 4-buffer
dbL0C = (baseM·baseN·4B·2 <= L0C) ? 2 : 1                 // L0C 双缓冲
usedCoreNum = min(nCore·batchNum, aicNum)

2.5.2 子分支②：B 全载 L1（B_FULL_LOAD）

与 A 全载完全对称：!CubeBound ∧ mCnt > aicNum ∧ (K·N·dtypeB + bias) <= 3/4·L1 时，整个 B 常驻 L1，A 按 baseM 流式。

B 全载数据流（B 常驻 L1，A 按 baseM 流式）:
  GM(B[K×N]) ─MTE2─► L1(B, 常驻)
  GM(A[baseM×K]) ─MTE2─► L1(A) ─MTE1─► L0A ─┐
  L1(B) ─MTE1─► L0B ────────────────────────┼─MMAD─► L0C ─Fixpipe─► GM(C)

tiling 对称：singleCoreN=N、singleCoreM=baseM，baseM = min(baseM, 剩余容量上限, L0C上限, ⌈M/aicNum⌉)。

2.5.3 子分支③：Fixpipe 随路搬出优化（ND_FIXPIPE_1_1 / 1_2）

触发条件（GetL0C2OutDav3510）：

isValidMKN   = (K <= 256) ∧ (M >= 256)                // 计算量小、M 大
isMultiRound = (mCnt·nCnt > aicNum)                   // 多轮（搬出流水与计算重叠才有意义）
isUnalignedN = (N·cDtypeSize % 128 != 0) ∧ (N·cDtypeSize > 256)   // N 不对齐 128B
fixpipeBound = isValidMKN ∧ isMultiRound ∧ isUnalignedN
→ 满足且 aivNum == 2·aicNum：
    FP16/BF16 → ND_FIXPIPE_1_1      FP32 → ND_FIXPIPE_1_2

原理（结合硬件）：小 K 大 M 场景，MMAD 计算时间短，T_FIXPIPE = M·N·dtypeC / BW_fixp 可能超过 T_MMAD，成为 Fixpipe Bound。950PR 的 Fixpipe 随路硬化（L0C→GM 直接量化/排布转换）但对 N 不对齐（非 128B 对齐）的搬出效率低。ND_FIXPIPE_1_1/1_2 用 AIV 辅助做搬出对齐（1V1 或 1V2 的 AIC:AIV 配比），配合 SetMMLayoutTransform(true)（fixp 用 N 搬出）+ UnitFlag（512B 粒度同步），让 Fixpipe 与 Cube 并行、搬出对齐。

普通（ON_THE_FLY）:   MMAD ──────► 等算完 ──Fixpipe──► GM    (串行)
Fixpipe 优化:         MMAD(512B) ─► 立即随路 Fixpipe ─► GM   (并行，粒度 512B)

2.5.4 子分支④：非连续 Slice（SLICE model）

触发条件：IsSelfNonContiguous(context) —— self 是 view 且 storageShape 为 1D、self 3D / mat2 2D（createView with TensorV2 场景）。此时 model=SLICE，MatMulBasicKernel 用 sliceM/srcNdStride 做非连续搬移（NDDMA 多维重排），GetBlockShape 对 sliceM 对齐。

2.5.5 评价

• 优点：① 通用性强，覆盖绝大多数 shape；② SWAT 提升 L2 命中（§4）；③ A/B 全载在"一侧重复读多、另一侧能装进 L1"时显著减少 GM→L1 流量；④ fixpipe 优化在特定小 K 大 M 场景让搬出与计算并行；⑤ 尾轮负载均衡（§3.5）减少尾轮算力浪费。
• 缺点：① baseM/baseN 是启发式搜索（§3.2 的 cubeBoundParam/balanceRate 权衡），非严格最优；② A/B 全载只支持"整个矩阵常驻 L1"一种粒度，A/B 稍大于 3/4 L1 时直接放弃（存在优化断档，§6）；③ fixpipe 条件苛刻（K≤256 ∧ M≥256 ∧ N 不对齐），覆盖面窄；④ GM 带宽未区分读写（§6）。

2.6 BASE（priority 999）—— 老 Cmct 接口兜底

实现（matmul_v3_asw_tiling.cpp + mat_mul_asw_kernel.h / mat_mul_asw_block.h）：

• DoOpTiling: ResetBase → GetRebalanceBlock → CalcTailBasicBlock → CalL1Tiling（与 BASIC_ASWT 基础 tiling 完全相同的引擎，§3）；
• Device 走 MatMulActKernel（老 Cmct 接口），核内 mm_.Iterate() 执行标准 GM→L1→L0A/L0B→Cube→L0C→Fixpipe 流水；SetMMLayoutTransform(true) 让 Fixpipe 用 N 搬出实现 Cube 与 Fixpipe 并行；
• 块索引（MatmulAswBlock::UpdateBasicIndex）同样实现 SWAT 窗口 + 蛇形扫描 + 尾轮重切（§4）。

与 BASIC_ASWT 的区别：两者共用同一套 tiling 引擎和 swizzle，区别只在 Device 接口代际——BASE 走老 Cmct 接口（无全载/fixpipe/StreamK 的 kernel 模板），BASIC_ASWT 走新 Blaze 接口（支持全载/fixpipe/SplitK）。实际运行时 BASIC_ASWT（priority 4）几乎总是先命中，BASE 仅在注册表异常时兜底。

评价：保证正确性；性能上限低于主分支（缺全载/fixpipe/SplitK 等新优化）。

3. 核心 tiling 算法（ASW 系分支共用的参数计算引擎）

3.1 ResetBase（初始值）

// ResetBaseDav3510（950PR）
usedCoreNum = aicNum = 32
baseM = 256;  baseN = 256                // 950PR 的 base 块（上代为 128）
baseK = 128B / dtypeA                    // FP16/BF16=64 元素，FP32=32 元素
iterateOrder = ITER_COL_FIRST            // 列优先遍历
singleCoreK = K; singleCoreM/N = baseM/N

为什么 baseM=baseN=256：L0C=256KB，FP32 累加 256×256×4B = 256KB 恰好填满 L0C。baseM=baseN=256 是"L0C 能容纳的最大方块"，也是重复读最少的配置（重复读 ∝ 1/baseM + 1/baseN，见 §3.2 的 cubeBoundParam）。950PR 的 L0C 比上代（128KB）大一倍，所以 baseM 从 128 升到 256。

为什么 baseK = 128B/dtype：GM→L1 高效搬移要求单次 dValue ≥ 128B（连续列数据量）。K 方向对齐 128B 保证 MTE2 搬移效率。

3.2 GetRebalanceBlock（baseM/baseN 最优搜索，核心）

分两步：

① Roofline 判 CubeBound（cubeBoundEdge 计算）：

hbmBW = freq · 32核 · 31B/拍 / 1024            ≈ 1.6 TB/s
l2BW  = freq · 32核 · 100B/拍 / 1024           ≈ 5.2 TB/s
singleCoreComputePower = freq · 8              ≈ 13.2 TFLOPS（单核 BF16）
computePower = singleCoreComputePower · aicNum

cmr = (M+N) / (M·N)                            // 临界算术强度相关量（1/元素）
l2CacheUsage = max(batch·(M+N)·K·dtypeA / L2, 1)   // L2 占用倍率（无量纲）
cubeBoundEdge = (l2BW/computePower)
              + l2CacheUsage·(1 - l2BW/hbmBW)·cmr
              - (1 + l2BW/hbmBW)/K
cubeBoundParam = 1/baseM + 1/baseN             // 重复读因子（1/元素）
// Cube Bound 条件：cubeBoundParam <= cubeBoundEdge

物理含义：cubeBoundParam 是当前 tiling 的 MTE2 重复搬移强度，cubeBoundEdge 是"恰好 Cube Bound"的临界强度。cubeBoundParam ≤ cubeBoundEdge ⇔ MTE2 不成为瓶颈。这与官方 matmul_performance.md 的 MTE2 Bound 条件 BW_mte2 ≥ (1/baseN + 1/baseM)·dtype·16·16·16·核数·频率 等价。

② 搜索最优 (baseM, baseN)：在 maxBaseM × maxBaseN 解空间双重循环，每个候选算：

curCubeBoundParam = 1/curBaseM + 1/curBaseN
curBalanceRate     = GetBalanceRateWithTail(...)   // 尾轮负载均衡率（无量纲 0~1）
目标：优先满足 CubeBound 且 balanceRate 更高；
     否则综合 (curCubeBoundParam/curBalanceRate) 评选（值小者优）

maxBaseM/maxBaseN 由 GetMaxBaseWithLimit 计算，受 L0A/L0C/L1/bias table/K 对齐多重约束。搜索步长 baseMAlignUnit/baseNAlignUnit 与转置、fixp bound 相关（16 / 32 / 64 / 128B 对齐）。

3.3 GetBaseK（baseK 约束）

maxBaseK = L0A_SIZE/DB_SIZE/dtypeA / max(baseM, baseN)   // 受 L0A 容量约束（元素个数）
// K 能全载进 L0A 则取 K 对齐值；否则按 256B 对齐；再退候选 {128,64,32,16}

3.4 CalL1Tiling（K 方向 L1 分片）

isKInner = !ATrans || BTrans                  // K 是否内轴
maxStepK = min(⌈K/baseK⌉, 8)                 // K 方向 L1 分片数上限 8
遍历 stepK（1..maxStepK）:
    满足 (aL1+bL1)·DB <= L1 且 K 256B 对齐 且 单次搬移量约束
stepKa = stepKb = resKL1 / baseK              // K 方向 L1 分片步数（无量纲）
depthA1 = stepKa·DB;  depthB1 = stepKb·DB     // L1 流水深度（tile 层数）
singleCoreM = baseM;  singleCoreN = baseN

3.5 CalcTailBasicBlock（尾轮重切）

tailCnt = (mCnt·nCnt > aicNum) ? (mCnt·nCnt % aicNum) : 0
// 尾轮把 base 块在 M/N 方向重切 mTailCnt×nTailCnt 份，
// 使尾轮也尽量填满核，且保持 128B 搬移对齐
while ((mTailCnt+1)·nTailCnt·tailCnt <= aicNum ∧ 搬移对齐)  mTailCnt++

4. Swizzle 编排（SWAT 窗口 + 蛇形扫描）

4.1 ASWT 的 SWAT 蛇形滑动（UpdateMNTileIdx）

mainWindow = min(4, mCnt)                 // 固定窗口 4 个 base 块（WINDOW_LEN=4）
mainRow    = mCnt / mainWindow - 1
tailWindow = mCnt - mainRow·mainWindow

rowIdx = tileIdx / nCnt / mainWindow
if (rowIdx < mainRow):                    // 主窗口区
    mTileIdx = rowIdx·mainWindow + tileIdx % mainWindow   // 窗口内 M 小步滑动
    nTileIdx = (tileIdx / mainWindow) % nCnt              // N 方向连续滑动
else:                                     // 尾窗口区（M 剩余不足一窗）
    mTileIdx = mainRow·mainWindow + tailIndex % tailWindow
    nTileIdx = (tailIndex / tailWindow) % nCnt
if (rowIdx % 2 != 0):                     // 蛇形：奇数行 N 反向扫描
    nTileIdx = nCnt - 1 - nTileIdx

物理含义（结合硬件）：把 M 轴按窗口（4 个 base 块）分组，窗口内沿 N 连续滑动、M 小步滑动，使相邻核访问的数据在 GM 地址上空间邻近 → 最大化 L2 命中（重复读走 5.2TB/s 的 L2 而非 1.6TB/s 的 GM）。奇数行 N 反向（蛇形）让相邻两轮的首尾块空间相邻，进一步复用 L2。示意图：

M方向 base 块（窗口=4）
┌──────────────────────────────────────────┐
│ 窗口0: 核0→N0, 核1→N1, 核2→N2, 核3→N3  (N 连续)      │
│ 窗口1: 核4→N3, 核5→N2, 核6→N1, 核7→N0  (蛇形反向)      │
│ ...                                       │
└──────────────────────────────────────────┘
   （每行窗口内 N 方向连续滑动 → 相邻核读相邻 A 块 → L2 命中）

4.2 尾轮重切（GetBlockShape）

最后一轮把单个 base 块在 M/N 方向再切 mTailCnt × nTailCnt 份分给更多核，blockIdx % tailCnt 决定每核拿哪个子块，消除尾轮"核数远大于剩余块数"的算力浪费（配合 §3.5）。

4.3 StreamK 的 DP/SK 编排（block_scheduler_streamk.h）

在 SWAT 蛇形基础上叠加 DP 主轮 + SK 尾轮 判定：

tileNum = (mCnt·nCnt - tailMNTileNum)  +  tailMNTileNum·skKTileNum·batch
          └──────── DP 部分(每核一个MN块) ┘  └───── SK 尾轮(每MN块切K) ─────┘
CheckIsSkScene(tileIdx) = (⌈(tileIdx+1)/usedCoreNum⌉ == ⌈tileNum/usedCoreNum⌉)
// DP 轮：kTileNum=1（K 不分片）；SK 轮：kTileNum=skKTileNum（K 分片）

DP 主轮每核一个 MN 块算完整 K（数据并行），SK 尾轮把剩余 MN 块切 K 分给空闲核（提前执行，AIV 累加与 AIC 下一轮重叠）。

5. 各分支优缺点对比

6. 初步观察到的可改进点（衔接任务 3.2）

在通读源码过程中浮现的改进线索，留待后续用性能模型严格论证：

1. baseM/baseN 搜索是启发式的：GetRebalanceBlock 用 cubeBoundParam/balanceRate 复合指标剪枝，而非直接代入 T_total = max(T_MMAD, T_MTE2, T_MTE1, T_FIXPIPE) 精确评估。理论上可用性能模型对候选解精确打分。
2. SWAT 窗口固定为 4（WINDOW_LEN=4）：未根据 L2 容量、shape、核数自适应调窗。窗口大小直接影响 L2 命中率与重复读量的权衡。
3. A/B 全载只有"整个矩阵常驻"一种粒度：没有"部分驻留"（多个 base 块驻留 L1 的中间态），A/B 稍大于 3/4 L1 时直接放弃，存在优化断档。
4. fixpipe 优化覆盖窄：仅 K≤256 ∧ M≥256 ∧ N 不对齐 触发，其它 Fixpipe Bound 场景未覆盖。
5. GM 带宽未区分读写：GetHbmBW 统一按 32核·31B/拍 换算，未区分读/写共享 1.6TB/s 的竞争，可能高估有效带宽。
6. M==1/N==1 的 FP16/BF16 无退化分支：TO_MUL/TO_MULTI_MUL 仅覆盖 FP32 高精度，FP16/BF16 的退化场景仍走 Cube（1/16 利用率）。

附录：关键源码文件索引