From 05ca91e291d326283d4e24b22d3fbc53dc98557d Mon Sep 17 00:00:00 2001 From: admin Date: Mon, 7 Sep 2026 15:49:24 +0800 Subject: [PATCH] =?UTF-8?q?Fix=20#33:=20ASW=5FBasic=20tile=20=E9=80=89?= =?UTF-8?q?=E6=8B=A9=E9=87=8D=E5=86=99=20(v1.91=20=C2=A75.1/=C2=A75.2=20+?= =?UTF-8?q?=20=E5=B0=BE=E8=BD=AE=20v1.5=20=C2=A72.1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - BaseM/BaseN: UnitFlag 单缓冲方形 256x256 (L0C/4B=65536 元素用满, 替代双缓冲 176x176); M/N < 256 被迫跟随 M/N (另一侧按 L0C 余量放大, 且收敛 L0A/L0B baseK>=16 单边上限); baseK = min(L0A/(2*BaseM*dt), L0B/(2*BaseN*dt)) 向下16对齐 (64KB 两侧双缓冲) - SingleCoreM/N: 有界枚举取代旧"仅 sqrt(P)+2 范围按面积取最大"(恒退回176兜底): P=1 (B>=C) 先试不切分 tile 跟随 M/N; 否则枚举 mCnt<=ceil(M/BaseM) x nCnt<=ceil(N/BaseN) 且 B*mCnt*nCnt>=C, sM/sN 为 Base 整数倍, 约束2 L1 双缓冲反推 k_L1, 约束3 dValue>=256B 转置感知 + minTile 16KB; 目标 = 每batch搬入 K*dt*(nCnt*M+mCnt*N) 最小 (v1.5 修正: 稳态下 k_L1 约掉, 只进约束); 并列取 r 最大 - 兜底: 约束4无解时放开到 16 对齐网格按硬下限(dValue>=128B)再搜; 极端形状 (如 N=8 int8 大K)仍无解时退回 Base tile 并自检标注违规 (不静默产伪方案) - constraints: ASW 双分支 L0C 口径改 UnitFlag 单缓冲 (factor 1) - docs/06 Step0/Step1/Step6 重写为 v1.91 口径, 头部标注 2026-09 更新与 issue#33 - 回归: v1.91 §5.2 完整实例 (B=8 M=N=2048 K=1024 -> (4,4) 512x512, k_l1=128, r=0); 方形例外 (M=128 -> 128x512); 单缓冲约束通过; 极端形状违规标注; 60->61 测试全过; 压力 seed7/6000 + seed2024/4000: 0 崩溃/0 NaN/0 GM451GB) --- .../bmm_theory/branches/asw_basic.py | 185 ++++++++++++++---- BMM/BMM_Theory/bmm_theory/constraints.py | 5 +- .../docs/02_分支理论/06_ASW_Basic分支.md | 44 +++-- BMM/BMM_Theory/examples/plans.csv | 44 ++--- BMM/BMM_Theory/examples/result_evaluate.csv | 44 ++--- BMM/BMM_Theory/examples/result_recommend.csv | 44 ++--- BMM/BMM_Theory/tests/test_branches.py | 78 ++++++++ 7 files changed, 321 insertions(+), 123 deletions(-) diff --git a/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py b/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py index 876fe7d..05eb2f8 100644 --- a/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py +++ b/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py @@ -1,8 +1,10 @@ """ASW_Basic 分支: 核间切 M/N (或混合切) 的兜底分支, 含尾轮处理. 理论依据: - - 《BMM算子优化分析 v0.98》§八 + docs/02_分支理论/06_ASW_Basic分支.md - - 《BMM尾轮处理策略对比分析 v1.5》+ docs/02_分支理论/07_尾轮处理策略.md + - 《ASW_Basic分支分析 v1.91》(L0C 单缓冲方形 Base tile §5.1 + SingleCoreM/N 有界 + 枚举 §5.2) + docs/02_分支理论/06_ASW_Basic分支.md + - 《BMM尾轮处理策略对比分析 v1.5》(单块搬入稳态口径 K(sM+sN)·dt/BW, k_L1 约掉) + + docs/02_分支理论/07_尾轮处理策略.md 核心: 兜底分支, 核间切 M/N, 重复读交给 L2 + swizzle. 尾轮处理是必要组成环节: 默认方案 B (工程简洁, 主流场景与 A1b 严格打平), 周长型且 rho>=rho_dv 时 A1b. @@ -13,7 +15,7 @@ from __future__ import annotations import math from ..hardware import NpuSpec, ASCEND950PR -from ..models import BmmCase, ImplPlan, HardwareTiming, ceil_div, align_down +from ..models import BmmCase, ImplPlan, HardwareTiming, ceil_div, align_down, align_up from ..timing import assemble_timing from .base import Branch, ConditionCheck @@ -60,22 +62,31 @@ class AswBasicBranch(Branch): return self._plan_reduced_core(case, p) # ---- 正常模式: Step 0~6 ---- - # Step 0: BaseM/BaseN 用满 L0C (32768 元素双缓冲) - base_mn = int(math.sqrt(s.l0c_bytes // 8)) # L0C/(2*4B) - base_m = align_down(base_mn, s.fractal) - base_n = align_down(base_mn, s.fractal) - base_k = align_down(int(min( - s.l0a_bytes / (2 * base_m * dt), - s.l0b_bytes / (2 * base_n * dt), - )), s.fractal) + # Step 0: BaseM/BaseN (v1.91 §5.1): UnitFlag 单缓冲 (tile 内 16x16x16 细粒度 + # 流水替代 tile 间粗粒度双缓冲), BaseM*BaseN = L0C/4B = 65536 元素, 方形 + # 优先 (256x256, L0A/L0B 同时装满、baseK 加倍); 仅当 M/N < 方形边长时被迫 + # 跟随 M/N (另一侧按 L0C 面积余量放大); BaseK 由 L0A/L0B (双缓冲) 反推. + from ..constraints import clamp_base_k + cap_l0c = s.l0c_bytes // 4 # 65536 元素 (单缓冲) + sq = align_down(int(math.sqrt(cap_l0c)), s.fractal) # 256 + # L0A/L0B 在 base_k>=16 (fractal) 下的单边上限 (v1.91 §5.7 核内约束; + # 防止例外路径 (如 M=16 -> BaseN=4096) 超 L0B) + side_cap = s.l0a_bytes // (2 * s.fractal * dt) # L0A=L0B=64KB + if m >= sq and n >= sq: + base_m = base_n = sq + elif m < sq: + base_m = max(align_down(m, s.fractal), s.fractal) + base_n = max(align_down(min(cap_l0c // base_m, n, side_cap), + s.fractal), s.fractal) + else: # n < sq + base_n = max(align_down(n, s.fractal), s.fractal) + base_m = max(align_down(min(cap_l0c // base_n, m, side_cap), + s.fractal), s.fractal) + base_k = clamp_base_k(base_m, base_n, dt, case.k, s) # v1.91 §5.7 - # Step 1: SingleCoreM/N 尽量大 (满足并行度下限) - min_blocks = ceil_div(s.aic_num, b) - single_m, single_n = self._pick_single_core(m, n, min_blocks, base_m, base_n, dt) - - # Step 2: mCnt/nCnt - m_cnt = ceil_div(m, single_m) - n_cnt = ceil_div(n, single_n) + # Step 1+2+6: SingleCoreM/N + k_L1 + mCnt/nCnt 有界枚举 (v1.91 §5.2): + (single_m, single_n, k_l1, m_cnt, n_cnt, pick_note) = \ + self._pick_single_core(case, base_m, base_n) # Step 4: swizzle 窗口 W = max{d | d|C, d <= floor(sqrt(C))} swizzle_w = self._swizzle_w() @@ -90,12 +101,6 @@ class AswBasicBranch(Branch): if scene["to_l2"] else "direct_gm(输出直写GM, 输入优先驻留L2)") - # Step 6: k_l1 (GM->L1 K 向粒度, 须 >= dValue 下限; K 小于下限时整 K 一次搬入不切) - dv_min_elems = max(s.dvalue_hw_min // dt, 1) - k_l1 = min(k, s.dvalue_recommend // dt) - if k_l1 < dv_min_elems: - k_l1 = k # K 本身小于 dValue 下限: 不切 K, 整段搬入 (K 非连续维, dValue 由 M/N 保证) - # ---- 尾轮决策 (必要组成环节) ---- n_blk = b * m_cnt * n_cnt tail = self._decide_tail(case, single_m, single_n, n_blk, k_l1) @@ -116,9 +121,11 @@ class AswBasicBranch(Branch): tail_m_cnt=tail["tail_m_cnt"], tail_n_cnt=tail["tail_n_cnt"], tail_k_cnt=1, tail_m_main=tail["tail_m_main"], tail_n_main=tail["tail_n_main"], tail_block_cnt=tail["r"], tail_wave_num=tail["n_wave"], - fixpipe_unitflag=True, + fixpipe_unitflag=True, # UnitFlag 单缓冲: tile 内 16x16x16 细粒度流水 out_dtype_bytes=case.dtype_out_bytes, - note=(f"L2场景: {scene['label']} (V_in={case.input_bytes/1048576:.1f}MB, " + note=(f"tile枚举: {pick_note}; Base tile {base_m}x{base_n} " + f"(L0C 单缓冲方形用满); " + f"L2场景: {scene['label']} (V_in={case.input_bytes/1048576:.1f}MB, " f"V_out={case.output_bytes/1048576:.1f}MB, " f"L2={s.l2_bytes/1048576:.0f}MB); " + (scene["note_extra"] + "; " if scene["note_extra"] else "") @@ -163,24 +170,116 @@ class AswBasicBranch(Branch): ) # ------------------------------------------------------------------ - def _pick_single_core(self, m, n, min_blocks, base_m, base_n, dt): - """Step 1: 满足并行度下限前提下 SingleCoreM/N 尽量大, 长宽比跟随 M/N.""" + def _pick_single_core(self, case: BmmCase, base_m: int, base_n: int) -> tuple: + """SingleCoreM/N + k_L1 + mCnt/nCnt 有界枚举 (v1.91 §5.2 + v1.5 §2.1 修正口径). + + - P = ⌈C/B⌉; P=1 (B>=C): 先试不切分 (mCnt=nCnt=1, tile 跟随 M/N, 情形1), + 约束不满足则进入枚举强制切分; + - 枚举空间: mCnt ∈ [1, ⌈M/BaseM⌉], nCnt ∈ [1, ⌈N/BaseN⌉] (约束4 上界: + SingleCore 为 Base 整数倍), 且 B·mCnt·nCnt >= C (约束1 并行度); + - 约束 2 (L1 双缓冲): k_L1 = min(K, ⌊L1/(2(sM+sN)·dt)⌋16), 须 ≥ 一个 + fractal 且满足 dValue 下限; + - 约束 3 (搬移效率, 转置感知): A 非转置 dValue = k_L1·dt / A 转置 = sM·dt; + B 非转置 dValue = sN·dt / B 转置 = k_L1·dt; 均须 ≥ 256B (dValue 硬件 + 突发下限); 且 sM·k_L1·dt 与 k_L1·sN·dt ≥ min_TileSize (16KB); + - 目标 (v1.5 §2.1 修正: 稳态流水下单块搬入 = K·(sM+sN)·dt, 与分次粒度 + k_L1 无关, k_L1 只进约束): 每 batch 搬入量 K·dt·(nCnt·M + mCnt·N) 最小 + (共享块重复读最少 = tile 尽可能大/少); 并列取 r = B·mCnt·nCnt mod C 最大 + (尾轮块越多, 重切收益越大, v1.91 §5.2.d); + 返回 (single_m, single_n, k_l1, m_cnt, n_cnt, note). + """ s = self.spec - # 从大到小枚举 (m_cnt*n_cnt >= min_blocks), 取最大 tile - best = (base_m, base_n) - for m_cnt in range(1, int(math.sqrt(min_blocks)) + 2): - n_cnt = ceil_div(min_blocks, m_cnt) - if m_cnt * n_cnt < min_blocks: - continue - sm = align_down(ceil_div(m, m_cnt), base_m) or base_m - sn = align_down(ceil_div(n, n_cnt), base_n) or base_n - # 约束 2: L1 容量 2(sM+sN)*k_l1*dt <= L1, k_l1 取 256B/dt - k_l1_min = s.dvalue_hw_min // dt - if 2 * (sm + sn) * k_l1_min * dt > s.l1_bytes: - continue - if sm * sn > best[0] * best[1]: - best = (sm, sn) - return best + b = case.batch_c + m, n, k = case.m, case.n, case.k + dt = case.dtype_in_bytes + c = s.aic_num + p_min = ceil_div(c, b) # 最少切分块数 (约束1) + dv_min = s.dvalue_hw_min # 256B + min_tile = s.min_tile_size # 16KB + + def eval_tile(sm: int, sn: int): + """约束 2/3 + 目标值; 返回 (ok, k_l1, traffic_per_batch).""" + k_cap = int(s.l1_bytes / (2 * (sm + sn) * dt)) + k_l1 = align_down(min(k, k_cap), s.fractal) + if k_l1 < s.fractal: + return False, 0, None + # dValue 下限 (转置感知连续维, 同 issue#19 口径) + dv_a = sm * dt if case.trans_a else k_l1 * dt + dv_b = k_l1 * dt if case.trans_b else sn * dt + if dv_a < dv_min or dv_b < dv_min: + return False, 0, None + # 单次搬移量下限 + if sm * k_l1 * dt < min_tile or k_l1 * sn * dt < min_tile: + return False, 0, None + mc = ceil_div(m, sm) + nc = ceil_div(n, sn) + traffic = k * dt * (nc * m + mc * n) # 每 batch 总搬入字节 + return True, k_l1, traffic + + # 情形 1: P=1 (B >= C) 先试不切分, tile 跟随 M/N + if p_min == 1: + sm = max(align_up(m, s.fractal), s.fractal) + sn = max(align_up(n, s.fractal), s.fractal) + ok, k_l1, traffic = eval_tile(sm, sn) + if ok: + return (sm, sn, k_l1, 1, 1, + "P=1(B>=C) 不切分, tile 跟随 M/N (v1.91 §5.2 情形1)") + + # 情形 2: 有界枚举 + best = None + m_max = ceil_div(m, base_m) + n_max = ceil_div(n, base_n) + for mc in range(1, m_max + 1): + sm = align_up(ceil_div(m, mc), base_m) + for nc in range(1, n_max + 1): + sn = align_up(ceil_div(n, nc), base_n) + ok, k_l1, traffic = eval_tile(sm, sn) + if not ok: + continue + mc_r = ceil_div(m, sm) + nc_r = ceil_div(n, sn) + # 约束 1: 并行度 (真实块数, 考虑 align 上取后的收缩) + if b * mc_r * nc_r < c: + continue + r = (b * mc_r * nc_r) % c + key = (traffic, -r) # 主键搬入量最小; 并列 r 最大 + if best is None or key < best[0]: + best = (key, sm, sn, k_l1, mc_r, nc_r, traffic, r) + if best is None: + # 兜底: 放开约束 4 (Base 整数倍), 在 16 对齐网格上按硬下限 (dValue>=128B + # 硬底 / L1 容量) 找最优可行 —— 极端形状 (如 M=2 与大 N/K 组合) 下 + # Base 粒度可能无可行解; 若仍无解则退回 Base tile 由自检标注违规 + dv_hard = s.dvalue_min # 128B 硬下限 + for sm in range(s.fractal, align_up(min(m, 1024), s.fractal) + 1, s.fractal): + for sn in range(s.fractal, align_up(min(n, 1024), s.fractal) + 1, s.fractal): + k_cap = int(s.l1_bytes / (2 * (sm + sn) * dt)) + k_l1 = align_down(min(k, k_cap), s.fractal) + if k_l1 < s.fractal: + continue + dv_a = sm * dt if case.trans_a else k_l1 * dt + dv_b = k_l1 * dt if case.trans_b else sn * dt + if dv_a < dv_hard or dv_b < dv_hard: + continue + mc_r = ceil_div(m, sm) + nc_r = ceil_div(n, sn) + if b * mc_r * nc_r < c: + continue + traffic = k * dt * (nc_r * m + mc_r * n) + r = (b * mc_r * nc_r) % c + key = (traffic, -r) + if best is None or key < best[0]: + best = (key, sm, sn, k_l1, mc_r, nc_r, traffic, r) + if best is None: + # 极端兜底: 退回 Base tile (约束校验会标注违规, 方案不可行可人工处置) + k_l1 = max(align_down(min(k, int(s.l1_bytes / + (2 * (base_m + base_n) * dt))), + s.fractal), s.fractal) + return (base_m, base_n, k_l1, ceil_div(m, base_m), ceil_div(n, base_n), + "枚举无可行候选, 退回 Base tile (自检会标注)") + _, sm, sn, k_l1, mc_r, nc_r, traffic, r = best + return (sm, sn, k_l1, mc_r, nc_r, + f"P={p_min}, 有界枚举最优 mCnt={mc_r} x nCnt={nc_r} " + f"(tile {sm}x{sn}, 每batch搬入{traffic/1048576:.1f}MB, r={r})") def _swizzle_w(self) -> int: s = self.spec diff --git a/BMM/BMM_Theory/bmm_theory/constraints.py b/BMM/BMM_Theory/bmm_theory/constraints.py index e8f920e..0e33644 100644 --- a/BMM/BMM_Theory/bmm_theory/constraints.py +++ b/BMM/BMM_Theory/bmm_theory/constraints.py @@ -57,8 +57,9 @@ def check_plan_constraints(case: BmmCase, plan: ImplPlan, if plan.used_core_num > s.aic_num: v.append(f"used_core_num={plan.used_core_num} 超 AIC 核数 {s.aic_num}") - # --- L0C --- (ASW 降核每核单份, 其他分支双缓冲) - l0c_factor = 1 if plan.branch == "ASW_Basic_降核" else 2 + # --- L0C --- (ASW 两分支 UnitFlag 单缓冲: tile 内 16x16x16 细粒度流水 + # (ASW_Basic分支分析 v1.91 §5.1); IterBatch/MergeBatch 双缓冲) + l0c_factor = 1 if plan.branch in ("ASW_Basic", "ASW_Basic_降核") else 2 l0c_need = plan.base_m * plan.base_n * 4 * l0c_factor if l0c_need > s.l0c_bytes: v.append(f"L0C tile 超容量: BaseM*BaseN*4B*{l0c_factor}={l0c_need}B > {s.l0c_bytes}B") diff --git a/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md b/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md index f9e0d98..2784dea 100644 --- a/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md +++ b/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md @@ -1,8 +1,9 @@ # ASW_Basic 分支理论（含尾轮处理） -> 整理自《BMM算子优化分析 v0.98》§八 + 《BMM尾轮处理策略对比分析 v1.5》. +> 整理自《BMM算子优化分析 v0.98》§八 + 《ASW_Basic分支分析 v1.91》 + 《BMM尾轮处理策略对比分析 v1.5》. > 尾轮策略的完整推导见 [07_尾轮处理策略.md](07_尾轮处理策略.md), 本文将其结论**内化为 ASW_Basic 最优实现的必要环节**. > 对应软件实现: `bmm_theory/branches/asw_basic.py`. +> 2026-09 更新: Step0/Step1 按 v1.91 §5.1/§5.2 重写为"UnitFlag 单缓冲方形 256 + 有界枚举最小搬入" (issue#33)。 ## 1. 定位：兜底分支，实践中最常命中 @@ -56,22 +57,41 @@ GM = V_in 一次（r_in=1），共享块重复读全部命中 L2；S_C 双侧均 ## 5. 实现方案 -**Step 0: BaseM/BaseN**（L0 级 tile，先把 L0C 用满） +**Step 0: BaseM/BaseN**（L0 级 tile, 先按 UnitFlag 单缓冲把 L0C 用满——v1.91 §5.1） -$$\text{BaseM}\times\text{BaseN} = \frac{L0C}{2\times 4B} = 32768\ \text{元素}$$ +Fixpipe 的 UnitFlag 提供 **tile 内部 16×16×16 细粒度流水**, 取代 tile 间粗粒度双缓冲 → +L0C 只需一份 buffer: -双缓冲两份、FP32 4B/元素。长宽比跟随 SingleCoreM/N，对齐 16。baseK = min(L0A/(2·BaseM·dt), L0B/(2·BaseN·dt)) 向下 16 对齐（L1→L0 无 dValue 要求）。 +$$\text{BaseM}\times\text{BaseN} = \frac{L0C}{4\text{B}} = 65536\ \text{元素（UnitFlag 单缓冲）}$$ -**Step 1: SingleCoreM/N**（每核输出 tile，≥ BaseM/N） +长宽比**方形优先**（而非跟随 M/N——跟随不会改善 GM→L1 搬移, 只会使 L0A/L0B 容量利用率 +失衡、baseK 减半）: 默认 BaseM = BaseN = 256（L0A/L0B 同时装满）; **例外**: M 或 N 小于 +方形边长时被迫跟随: BaseM = min(256, ⌊M⌋₁₆), 另一维 = min(65536/BaseM, N) 向下 16 对齐 +（例：M=128, N=4096 → BaseM=128, BaseN=512）。 -不受 L0 容量直接约束（内部由若干 BaseM×BaseN L0 tile 组成）。核心影响 **GM→L1 搬移效率和 L2 重复读率**： +$$\text{baseK} = \min\Big(\frac{L0A}{2 \cdot \text{BaseM} \cdot dtype},\; \frac{L0B}{2 \cdot \text{BaseN} \cdot dtype}\Big) \text{ 向下 16 对齐}$$ -- 约束 1 并行度：`mCnt×nCnt ≥ ⌈C/B⌉`； -- 约束 2 L1 容量：`2(sM+sN)·k_L1·dt ≤ L1`，`k_L1·dt ≥ 256B`； -- 约束 3 搬移效率：`sM·k_L1·dt ≥ 16KB`，`k_L1·sN·dt ≥ 16KB`； -- 约束 4：SingleCoreM/N 是 BaseM/N 的整数倍。 +（L0A/L0B 仍开双缓冲; 16 对齐是 Cube K 向粒度要求, L1→L0 搬移无 dValue 要求。） -选取策略：满足约束 1 前提下 SingleCoreM/N 尽量大，长宽比跟随 M/N。 +**Step 1: SingleCoreM/N + k_L1 + mCnt/nCnt**（有界枚举——v1.91 §5.2, 与尾轮 v1.5 §2.1 +修正口径一致） + +SingleCoreM/N **不受 L0 容量直接约束**（内部由若干 BaseM×BaseN L0 tile 组成）, 核心影响 +GM→L1 搬移效率与 L2 重复读率: + +- **P = ⌈C/B⌉**（最少切分块数）; +- **P=1 (B ≥ C)**: 先试不切分 (mCnt=nCnt=1, tile 跟随 M/N); 约束不满足则强制切分, 进入枚举; +- **枚举空间**（有界, host 端遍历）: mCnt ∈ [1, ⌈M/BaseM⌉], nCnt ∈ [1, ⌈N/BaseN⌉], + 且 B·mCnt·nCnt ≥ C（约束 1 并行度）; +- 每候选: sM = align_up(⌈M/mCnt⌉, BaseM)（约束 4: BaseM 整数倍）, sN 同理; +- **约束 2**（L1 双缓冲）: k_L1 = min(K, ⌊L1/(2(sM+sN)·dtype)⌋₁₆)（k_L1 与形状耦合）; +- **约束 3**（搬移效率, 转置感知）: dValue ≥ 256B——A 非转置 k_L1·dt / A 转置 sM·dt; + B 非转置 sN·dt / B 转置 k_L1·dt; 且单次搬移量 sM·k_L1·dt 与 k_L1·sN·dt ≥ 16KB; +- **目标**: 每 batch 总搬入 `K·dt·(nCnt·M + mCnt·N)` 最小（v1.5 §2.1 修正: 稳态流水下 + k_L1 约掉——单块搬入 = K(sM+sN)·dt 与分次粒度无关, k_L1 只进约束）; + **并列时取 r = B·mCnt·nCnt mod C 最大**（尾轮块越多, 重切越省）。 + +mCnt = ⌈M/singleCoreM⌉, nCnt = ⌈N/singleCoreN⌉（按实际 tile 反推）。 **Step 2: mCnt/nCnt 与核间分配**：`mCnt=⌈M/sM⌉`，`nCnt=⌈N/sN⌉`，总块数 B·mCnt·nCnt，B→M→N 线性映射。 @@ -95,7 +115,7 @@ A 行块 block_a = a_b/m_cnt、B 列块 block_b = b_b/n_cnt。 > 注：早期口径（预算 D = L2/(B·K·dt) 且对半切、组内窗口流量零计）已废弃 > （issue#24 除总 B 的矛盾、issue#32 对半预算与窗口零计失真）；分组不再对半、窗口复用如实计 L2。 -**Step 6: 核内 tiling**：BaseM×BaseN×4B×DB ≤ L0C；BaseM×k_L0×dt×2 ≤ L0A；k_L0×BaseN×dt×2 ≤ L0B；内轴按 dValue 256B/512B 对齐。 +**Step 6: 核内 tiling**：BaseM×BaseN×4B ≤ L0C（UnitFlag 单缓冲, 见 Step 0）；BaseM×k_L0×dt×2 ≤ L0A；k_L0×BaseN×dt×2 ≤ L0B；内轴按 dValue 256B/512B 对齐。 **Step 7: 内部特化**：单边无 batch 且该侧矩阵小时小侧整个常驻 L1 只搬一次。 diff --git a/BMM/BMM_Theory/examples/plans.csv b/BMM/BMM_Theory/examples/plans.csv index 5c49856..488901c 100644 --- a/BMM/BMM_Theory/examples/plans.csv +++ b/BMM/BMM_Theory/examples/plans.csv @@ -7,7 +7,7 @@ merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮 iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留 iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM" streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" -asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1024,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=16, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入512.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留 b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留" b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留 -b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,16,1024,7168,112,1,双缓冲驻留当前tile输入,16,1024,16,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=1 x nCnt=8 (tile 16x1024, 每batch搬入113.8MB, r=0); Base tile 16x1024 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮" b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留" b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM" -b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入48.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,2048,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=16 (tile 512x512, 每batch搬入128.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留" -b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)" -b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)" -b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)" -b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)" +b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=8 (tile 512x512, 每batch搬入1792.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=4 (tile 512x512, 每batch搬入8.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=2 x nCnt=2 (tile 512x512, 每batch搬入64.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入10.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,512,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=64 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,32,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=256 x nCnt=1 (tile 512x128, 每batch搬入40.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,256,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=2 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,512,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入14336.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,8192,192,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入640.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,4096,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2048,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入3072.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入65536.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=8x n_grp=8 (GM倍率3.76, 窗口L2/batch=57344.0MB); 尾轮: r=0 无尾轮" b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" -b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" -b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,14,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,56,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=14 (tile 512x512, 每batch搬入392.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入16.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮" special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)" diff --git a/BMM/BMM_Theory/examples/result_evaluate.csv b/BMM/BMM_Theory/examples/result_evaluate.csv index fcbe85e..9199c82 100644 --- a/BMM/BMM_Theory/examples/result_evaluate.csv +++ b/BMM/BMM_Theory/examples/result_evaluate.csv @@ -7,7 +7,7 @@ merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,m iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1024,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=16, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入512.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",67108864,1006632960,4.194304e-05,0.00019358326153846154,0.00023552630153846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留,2228224,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,16777216.0,3.452102057613169e-08,65536,1.2603076923076923e-08,0.0,1.44264e-06,4.712409749920861e-08,1.4897640974992086e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",17825792,0.0,1.114112e-05,0.0,1.1441120000000001e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.1441120000000001e-05,1.798661348528015e-07,1.1620986134852803e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留,13107200,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,100663296.0,2.0712612345679012e-07,393216,7.561846153846153e-08,0.0,8.392e-06,7.068614624881291e-08,8.462686146248813e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,16,1024,7168,112,1,双缓冲驻留当前tile输入,16,1024,16,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=1 x nCnt=8 (tile 16x1024, 每batch搬入113.8MB, r=0); Base tile 16x1024 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,51380224,0.00235339776,9.880812307692307e-06,0.0023632785723076925,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0023685214523076923,0.0,0.0023685214523076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.731729603729604e-06,0.00033558528,1.731729603729604e-06,0.0003373170096037296,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b16_m2_n4096_k7168,16,16,2,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",939982848,0,0.00058748928,0.0,0.00058748928,0.0,0.0,1879048192.0,3.866354304526749e-06,0.0,0.0,1.7726896037296038e-06,0.00058748928,1.7726896037296038e-06,0.0005892619696037297,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.670016e-05,0.0,3.7050160000000004e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.7050160000000004e-05,6.027486369104147e-07,3.765290863691042e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.00117440512,0.0,0.0011856051200000001,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入48.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,4831838208,0.00100663296,0.0009291996553846154,0.0019358326153846154,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.0033935544067160493,0.0,0.0033935544067160493,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,2048,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=16 (tile 512x512, 每batch搬入128.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,6174015488,0.00150994944,0.0011873106707692308,0.0026972601107692305,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.004524739208954733,0.0,0.004524739208954733,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" b32_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留",67108864,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,34359738368.0,7.06990501399177e-05,67108864,1.290555076923077e-05,0.0,7.06990501399177e-05,2.1742932036720483e-05,9.244198217663819e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,172872433664,0.00352321536,0.03324469878153846,0.03676791414153846,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.03811009142153846,0.0,0.03811009142153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",70866960384,1536524550144,0.04429185024,0.2954854904123077,0.3397773406523077,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.3505147588923077,0.0,0.3505147588923077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,120259084288,0.01073741824,0.023126746978461538,0.033864165218461535,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.07239582734327572,0.0,0.07239582734327572,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=8 (tile 512x512, 每batch搬入1792.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,54492397568,0.00352321536,0.010479307224615384,0.014002522584615384,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.031673174462683126,0.0,0.031673174462683126,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,6442450944,0.00134217728,0.0012389328738461537,0.002581110153846154,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.004524739208954733,0.0,0.004524739208954733,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=4 (tile 512x512, 每batch搬入8.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,436207616,6.291456e-05,8.388608e-05,0.00014680063999999998,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.00081788928,0.0,0.00081788928,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=2 x nCnt=2 (tile 512x512, 每batch搬入64.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,536870912,0.00033554432,0.00010324440615384615,0.0004387887261538461,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入10.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",33685504,8257536,2.105344e-05,1.5879876923076922e-06,2.2641427692307692e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.2641427692307692e-05,0.0,2.2641427692307692e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,512,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=64 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,1862270976,0.00017825792,0.00035812903384615385,0.0005363869538461539,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0012074755938461538,0.0,0.0012074755938461538,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,32,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=256 x nCnt=1 (tile 512x128, 每batch搬入40.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: r=0 无尾轮",134348800,33423360,8.3968e-05,6.427569230769231e-06,9.039556923076924e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00017428164923076922,0.0,0.00017428164923076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,256,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=2 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",541065216,1606418432,0.00033816576,0.00030892662153846154,0.0006470923815384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0019892696615384617,0.0,0.0019892696615384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,512,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入14336.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: r=0 无尾轮",9395240960,231122927616,0.0058720256,0.044446716849230766,0.05031874244923076,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,8192,192,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入640.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",2155872256,528482304,0.00134742016,0.0001016312123076923,0.0014490513723076923,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0014700228923076922,0.0,0.0014700228923076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,4096,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,33218887680,0.00071303168,0.006388247630769231,0.007101279310769231,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.05005095227076922,0.0,0.05005095227076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2048,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入3072.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,198105366528,0.0050331648,0.03809718587076923,0.04313035067076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.10859374101491358,0.0,0.10859374101491358,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入65536.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=8x n_grp=8 (GM倍率3.76, 窗口L2/batch=57344.0MB); 尾轮: r=0 无尾轮",68719476736,481036337152,0.04294967296,0.09250698791384615,0.13545666087384614,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.2895833093731029,0.0,0.2895833093731029,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.566079254079254e-07,0.00011042185846153846,2.566079254079254e-07,0.00011067846638694638,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,345744867328,0.00469762048,0.06648939756307692,0.07118701804307692,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.07387137260307693,0.0,0.07387137260307693,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,1382979469312,0.01879048192,0.2659575902523077,0.2847480721723077,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.2954854904123077,0.0,0.2954854904123077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,14,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,56,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=14 (tile 512x512, 每batch搬入392.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,18790481920,0.00469762048,0.0036135542153846152,0.008311174695384616,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.013857013827423869,0.0,0.013857013827423869,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,112742891520,0.00469762048,0.021681325292307693,0.026378945772307694,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.06334634892536625,0.0,0.06334634892536625,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入16.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,117440512,1.048576e-05,2.2584713846153845e-05,3.307047384615384e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.00020084263384615383,0.0,0.00020084263384615383,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,450971566080,0.01879048192,0.08672530116923077,0.10551578308923078,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.253385395701465,0.0,0.253385395701465,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,9.92969696969697e-06,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" diff --git a/BMM/BMM_Theory/examples/result_recommend.csv b/BMM/BMM_Theory/examples/result_recommend.csv index 93a3616..90288b4 100644 --- a/BMM/BMM_Theory/examples/result_recommend.csv +++ b/BMM/BMM_Theory/examples/result_recommend.csv @@ -7,7 +7,7 @@ merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,m iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" -asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1024,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=16, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入512.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",67108864,1006632960,4.194304e-05,0.00019358326153846154,0.00023552630153846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00= 256B/dtype 且 grid_K>=2) b4_m1_n128_k256,4,4,1,128,256,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) b8_m2_n192_k128,8,8,2,192,128,bf16,bf16,bf16,False,False,False,True,0,b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) @@ -15,31 +15,31 @@ b16_m4_n256_k192,16,16,4,256,192,bf16,bf16,bf16,False,False,False,True,0,b16_m4_ b32_m8_n128_k256,32,32,8,128,256,bf16,bf16,bf16,False,False,False,True,0,b32_m8_n128_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,8,128,256,256,1,a_单batch全驻留,8,128,128,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留,2228224,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,16777216.0,3.452102057613169e-08,65536,1.2603076923076923e-08,0.0,1.44264e-06,4.712409749920861e-08,1.4897640974992086e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",17825792,0.0,1.114112e-05,0.0,1.1441120000000001e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.1441120000000001e-05,1.798661348528015e-07,1.1620986134852803e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留,13107200,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,100663296.0,2.0712612345679012e-07,393216,7.561846153846153e-08,0.0,8.392e-06,7.068614624881291e-08,8.462686146248813e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 -b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B" +b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,16,1024,7168,112,1,双缓冲驻留当前tile输入,16,1024,16,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=1 x nCnt=8 (tile 16x1024, 每batch搬入113.8MB, r=0); Base tile 16x1024 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,51380224,0.00235339776,9.880812307692307e-06,0.0023632785723076925,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0023685214523076923,0.0,0.0023685214523076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B" b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.731729603729604e-06,0.00033558528,1.731729603729604e-06,0.0003373170096037296,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" b16_m2_n4096_k7168,16,16,2,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",939982848,0,0.00058748928,0.0,0.00058748928,0.0,0.0,1879048192.0,3.866354304526749e-06,0.0,0.0,1.7726896037296038e-06,0.00058748928,1.7726896037296038e-06,0.0005892619696037297,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=16)" b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.670016e-05,0.0,3.7050160000000004e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.7050160000000004e-05,6.027486369104147e-07,3.765290863691042e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.00117440512,0.0,0.0011856051200000001,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,仅 IterBatch 条件满足 -b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入48.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,4831838208,0.00100663296,0.0009291996553846154,0.0019358326153846154,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.0033935544067160493,0.0,0.0033935544067160493,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,2048,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=16 (tile 512x512, 每batch搬入128.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,6174015488,0.00150994944,0.0011873106707692308,0.0026972601107692305,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.004524739208954733,0.0,0.004524739208954733,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" b32_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留",67108864,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,34359738368.0,7.06990501399177e-05,67108864,1.290555076923077e-05,0.0,7.06990501399177e-05,2.1742932036720483e-05,9.244198217663819e-05,MMAD,True,,计算Bound,仅 IterBatch 条件满足 -b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,172872433664,0.00352321536,0.03324469878153846,0.03676791414153846,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.03811009142153846,0.0,0.03811009142153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",70866960384,1536524550144,0.04429185024,0.2954854904123077,0.3397773406523077,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.3505147588923077,0.0,0.3505147588923077,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,120259084288,0.01073741824,0.023126746978461538,0.033864165218461535,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.07239582734327572,0.0,0.07239582734327572,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=8 (tile 512x512, 每batch搬入1792.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,54492397568,0.00352321536,0.010479307224615384,0.014002522584615384,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.031673174462683126,0.0,0.031673174462683126,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,4,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=4 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,6442450944,0.00134217728,0.0012389328738461537,0.002581110153846154,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.004524739208954733,0.0,0.004524739208954733,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=8 x nCnt=4 (tile 512x512, 每batch搬入8.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,436207616,6.291456e-05,8.388608e-05,0.00014680063999999998,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.00081788928,0.0,0.00081788928,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=2 x nCnt=2 (tile 512x512, 每batch搬入64.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,536870912,0.00033554432,0.00010324440615384615,0.0004387887261538461,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入10.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",33685504,8257536,2.105344e-05,1.5879876923076922e-06,2.2641427692307692e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.2641427692307692e-05,0.0,2.2641427692307692e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,4,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,512,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,64,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=64 x nCnt=4 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,1862270976,0.00017825792,0.00035812903384615385,0.0005363869538461539,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0012074755938461538,0.0,0.0012074755938461538,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,128,128,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,32,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=256 x nCnt=1 (tile 512x128, 每batch搬入40.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: r=0 无尾轮",134348800,33423360,8.3968e-05,6.427569230769231e-06,9.039556923076924e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00017428164923076922,0.0,0.00017428164923076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,2,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,256,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,128,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=2 (tile 512x512, 每batch搬入256.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",541065216,1606418432,0.00033816576,0.00030892662153846154,0.0006470923815384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0019892696615384617,0.0,0.0019892696615384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,512,True,2,"tile枚举: P=2, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入14336.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: r=0 无尾轮",9395240960,231122927616,0.0058720256,0.044446716849230766,0.05031874244923076,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,128,8192,192,1,双缓冲驻留当前tile输入,512,128,32,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8,True,2,"tile枚举: P=8, 有界枚举最优 mCnt=64 x nCnt=1 (tile 512x128, 每batch搬入640.0MB, r=0); Base tile 512x128 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",2155872256,528482304,0.00134742016,0.0001016312123076923,0.0014490513723076923,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0014700228923076922,0.0,0.0014700228923076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,4096,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入1024.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,33218887680,0.00071303168,0.006388247630769231,0.007101279310769231,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.05005095227076922,0.0,0.05005095227076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,64,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,1536,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2048,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=64 x nCnt=16 (tile 512x512, 每batch搬入3072.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,198105366528,0.0050331648,0.03809718587076923,0.04313035067076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.10859374101491358,0.0,0.10859374101491358,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,256,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,8192,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=256 x nCnt=16 (tile 512x512, 每batch搬入65536.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=8x n_grp=8 (GM倍率3.76, 窗口L2/batch=57344.0MB); 尾轮: r=0 无尾轮",68719476736,481036337152,0.04294967296,0.09250698791384615,0.13545666087384614,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.2895833093731029,0.0,0.2895833093731029,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.566079254079254e-07,0.00011042185846153846,2.566079254079254e-07,0.00011067846638694638,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=2)" -b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,345744867328,0.00469762048,0.06648939756307692,0.07118701804307692,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.07387137260307693,0.0,0.07387137260307693,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,1382979469312,0.01879048192,0.2659575902523077,0.2847480721723077,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.2954854904123077,0.0,0.2954854904123077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,2,14,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,56,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=2 x nCnt=14 (tile 512x512, 每batch搬入392.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,18790481920,0.00469762048,0.0036135542153846152,0.008311174695384616,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.013857013827423869,0.0,0.013857013827423869,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,256,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,112742891520,0.00469762048,0.021681325292307693,0.026378945772307694,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.06334634892536625,0.0,0.06334634892536625,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,8,8,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,128,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,16,True,2,"tile枚举: P=4, 有界枚举最优 mCnt=8 x nCnt=8 (tile 512x512, 每batch搬入16.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,117440512,1.048576e-05,2.2584713846153845e-05,3.307047384615384e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.00020084263384615383,0.0,0.00020084263384615383,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,16,16,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,512,512,7168,128,1,双缓冲驻留当前tile输入,256,256,64,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1024,True,2,"tile枚举: P=1, 有界枚举最优 mCnt=16 x nCnt=16 (tile 512x512, 每batch搬入3584.0MB, r=0); Base tile 256x256 (L0C 单缓冲方形用满); L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,450971566080,0.01879048192,0.08672530116923077,0.10551578308923078,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.253385395701465,0.0,0.253385395701465,MMAD,True,,计算Bound,"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,9.92969696969697e-06,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"K=1逐元素乘, 走AIV向量通路" diff --git a/BMM/BMM_Theory/tests/test_branches.py b/BMM/BMM_Theory/tests/test_branches.py index 6a4c45b..048d9e0 100644 --- a/BMM/BMM_Theory/tests/test_branches.py +++ b/BMM/BMM_Theory/tests/test_branches.py @@ -697,5 +697,83 @@ class TestIssue31to32(unittest.TestCase): case.batch_c * (n_cnt * a_b + m_cnt * bb_b)) +class TestIssue33(unittest.TestCase): + """ASW_Basic tile 选择 (issue#33, v1.91 §5.1/§5.2 + 尾轮 v1.5 §2.1 修正口径): + BaseM/N = 256 方形 (UnitFlag 单缓冲 L0C 用满 65536 元素), SingleCoreM/N 有界枚举.""" + + def setUp(self): + from bmm_theory.hardware import ASCEND950PR + self.s = ASCEND950PR + self.router = BranchRouter() + + def test_base_tile_square_single_buffer(self): + # 默认 BaseM=BaseN=256 (非 176 双缓冲口径), L0C 恰用满 (256*256*4=256KB) + from bmm_theory.branches.asw_basic import AswBasicBranch + p = AswBasicBranch().make_plan(mkcase(32, 4096, 4096, 4096)) + self.assertEqual((p.base_m, p.base_n), (256, 256)) + self.assertEqual(p.base_m * p.base_n * 4, self.s.l0c_bytes) + self.assertEqual(p.base_k, 64) # 64KB/(2*256*2) = 64 + self.assertTrue(p.fixpipe_unitflag) # UnitFlag 单缓冲 + + def test_base_tile_exception_small_m(self): + # M=128 < 256: BaseM=128 (被迫跟随), BaseN = min(65536/128=512, N)=512 + from bmm_theory.branches.asw_basic import AswBasicBranch + p = AswBasicBranch().make_plan(mkcase(64, 128, 4096, 1024)) + self.assertEqual((p.base_m, p.base_n), (128, 512)) + self.assertEqual(p.base_k, 32) # min(64K/(2*128*2)=128, 64K/(2*512*2)=32) + + def test_v191_example_singlecore(self): + # v1.91 §5.2 完整实例: B=8 M=N=2048 K=1024 bf16 -> (4,4) 512x512, k_l1=128, r=0 + case = mkcase(8, 2048, 2048, 1024) + r = self.router.route(case) + self.assertEqual(r["branch"], "ASW_Basic") + p = r["plan"] + self.assertEqual((p.single_core_m, p.single_core_n), (512, 512)) + self.assertEqual((p.m_cnt, p.n_cnt), (4, 4)) + self.assertEqual(p.k_l1, 128) + self.assertEqual(p.tail_block_cnt, 0) # 8*4*4=128 % 32 = 0 完美整除 + + def test_singlecore_not_constant_176(self): + # 回归原 bug: SingleCoreM/N 恒为 176 (双缓冲 Base 兜底); 现在自适应 + from bmm_theory.branches.asw_basic import AswBasicBranch + p = AswBasicBranch().make_plan(mkcase(8, 4096, 4096, 1024)) + self.assertNotEqual((p.single_core_m, p.single_core_n), (176, 176)) + self.assertEqual((p.single_core_m, p.single_core_n), (512, 512)) + # 且为 Base 的整数倍 (约束 4) + self.assertEqual(p.single_core_m % p.base_m, 0) + self.assertEqual(p.single_core_n % p.base_n, 0) + + def test_l0c_single_buffer_constraint_pass(self): + # ASW 单缓冲: base 256x256 通过约束 (无违规) + from bmm_theory.constraints import check_plan_constraints + from bmm_theory.branches.asw_basic import AswBasicBranch + case = mkcase(8, 4096, 4096, 1024) + p = AswBasicBranch().make_plan(case) + self.assertEqual(check_plan_constraints(case, p), []) + + def test_p1_fallback_to_enum_when_no_split_infeasible(self): + # B>=C 时不切分 k_l1 过 dValue 下限失败 -> 强制切分枚举 -> 512x512 (8,8) + case = mkcase(128, 4096, 4096, 8192) + r = self.router.route(case) + self.assertEqual(r["branch"], "ASW_Basic") + p = r["plan"] + self.assertEqual((p.single_core_m, p.single_core_n), (512, 512)) + self.assertEqual((p.m_cnt, p.n_cnt), (8, 8)) + + def test_pathological_shape_flagged_infeasible(self): + # 极端形状 (N=8 int8, 大 K): B 侧 dValue = sN*dt = 8B 物理上不可能满足 + # 256B/128B 下限 -> 方案必须被自检标注违规 (不再静默产出伪可行方案) + from bmm_theory.constraints import check_plan_constraints + from bmm_theory.branches.asw_basic import AswBasicBranch + case = mkcase(4096, 2048, 8, 1024, dtype_a="int8", dtype_b="int8") + r = self.router.route(case) + self.assertEqual(r["branch"], "ASW_Basic") + v = check_plan_constraints(case, r["plan"]) + self.assertTrue(v, "极端形状应被自检标注违规 (搬移效率崩塌)") + self.assertIn("自检违规", r["arbitration"]) + # 时延仍应给出 (供人工评估), 但不为 0 / NaN + self.assertGreater(r["timing"].t_total, 0.0) + + if __name__ == "__main__": unittest.main()