From 4843053ad3f9a3fc382dfb39d817f84d2f1051d0 Mon Sep 17 00:00:00 2001 From: admin Date: Fri, 4 Sep 2026 11:43:23 +0800 Subject: [PATCH] =?UTF-8?q?Fix=20issues=20#23-#25=20(+#26=20=E6=A0=87?= =?UTF-8?q?=E6=B3=A8):=20GM=E8=AF=BB=E5=86=99=E5=85=B1=E4=BA=AB=E6=80=BB?= =?UTF-8?q?=E7=BA=BF=E7=B4=AF=E5=8A=A0=E8=AE=A1=E6=97=B6=20/=20ASW-?= =?UTF-8?q?=E5=88=87M/N=20=E5=85=B1=E4=BA=AB=E5=9D=97=20GM=E9=A6=96?= =?UTF-8?q?=E8=AF=BB1=E6=AC=A1+L2=E9=87=8D=E5=A4=8D=E8=AF=BB(n-1)=E6=AC=A1?= =?UTF-8?q?=E3=80=81=E5=9C=BA=E6=99=AF=E6=8C=89=E5=8D=95batch=E5=88=A4?= =?UTF-8?q?=E5=AE=9A=E3=80=81=E5=88=86=E7=BB=84=E9=A2=84=E7=AE=97=E4=B8=8D?= =?UTF-8?q?=E5=86=8D=E9=99=A4B=20/=20StreamK=20=E6=8C=89plan=E5=AE=9E?= =?UTF-8?q?=E9=99=85tile=E8=8A=AF=E7=89=87=E5=8F=A3=E5=BE=84=E8=AF=84?= =?UTF-8?q?=E4=BC=B0=20/=20=E9=99=8D=E6=A0=B8=E7=BA=BF=E6=80=A7=E5=B8=A6?= =?UTF-8?q?=E5=AE=BD=E5=81=87=E8=AE=BE=E6=96=87=E6=A1=A3=E6=A0=87=E6=B3=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- BMM/BMM_Theory/README.md | 9 +- .../bmm_theory/branches/asw_basic.py | 94 +++++++++++++------ .../bmm_theory/branches/stream_k.py | 63 ++++++++----- BMM/BMM_Theory/bmm_theory/evaluator.py | 9 +- .../bmm_theory/hardware/ascend950pr.py | 7 +- BMM/BMM_Theory/bmm_theory/timing.py | 25 +++-- BMM/BMM_Theory/examples/plans.csv | 44 ++++----- BMM/BMM_Theory/examples/result_evaluate.csv | 84 ++++++++--------- BMM/BMM_Theory/examples/result_recommend.csv | 84 ++++++++--------- BMM/BMM_Theory/tests/test_branches.py | 9 +- 10 files changed, 248 insertions(+), 180 deletions(-) diff --git a/BMM/BMM_Theory/README.md b/BMM/BMM_Theory/README.md index 2833a98..ba401db 100644 --- a/BMM/BMM_Theory/README.md +++ b/BMM/BMM_Theory/README.md @@ -49,10 +49,11 @@ python -m unittest discover -s tests -v ### 时延模型要点 (读结果前必看) -- **搬入 MTE2 分两段**: `t_mte2_gm` (GM→L1 直读, 按 GM 带宽 1.6TB/s; 无论是否随路驻留 L2 都不再累加 L2→L1) 与 `t_mte2_l2` (数据驻留 L2 后重复读命中, 按 L2 带宽 5.2TB/s); -- **Cube 计算** `t_mmad`: 单核算力 ≈15.2 TFLOPS, MergeBatch 的冗余计算计入; -- **Fixpipe 搬出** `t_fixpipe`: 数据量按 **C 矩阵 dtype** 计 (fp16/fp8 时随路转换、写出量减半); StreamK 中间部分和为防精度丢失按 4B (L0C dtype) 计; -- **总时延** `t_total = max(各级) + t_drain` (双缓冲稳态取最大 + 末级排空暴露); +- **GM 是读写共享总线 (1.6TB/s)**: MTE2 的 GM 读与 Fixpipe 直写 GM 并发时按 **(读+写)/1.6TB/s 累加**计入 MTE2 搬移链 (issue#23); +- **搬入 MTE2 分两段、同链相加**: `t_mte2_gm` (首读按 GM 带宽; 随路驻留 L2 不重复累加) + `t_mte2_l2` (共享块驻留 L2 后被其它核重复读, 按 L2 读口 5.2TB/s) + DMA 命令开销 (issue#24); +- **Cube 计算** `t_mmad`: 芯片算力 ≈486 TFLOPS (单核 ≈15.2 TFLOPS), MergeBatch 冗余计算计入; +- **Fixpipe 搬出**: 直写 GM 计入 GM 共享总线; 驻留 L2 走 5.2TB/s 写口 (独立计时); 数据量按 **C 矩阵 dtype** 计 (fp16/fp8 随路转换减半); StreamK 部分和按 4B (L0C dtype); +- **总时延** `t_total = max(MTE2搬移链, MMAD, Fixpipe-L2) + t_drain` (稳态取最大 + 末级排空暴露; REDUCE 串行追加); - **瓶颈交换**: 搬移瓶颈可牺牲算力换搬移效率 (MergeBatch), 计算瓶颈可牺牲搬移换计算效率 (ASW_Basic 切 M/N). ## 目录结构 diff --git a/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py b/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py index 6a555c6..72b2713 100644 --- a/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py +++ b/BMM/BMM_Theory/bmm_theory/branches/asw_basic.py @@ -80,21 +80,22 @@ class AswBasicBranch(Branch): # Step 4: swizzle 窗口 W = max{d | d|C, d <= floor(sqrt(C))} swizzle_w = self._swizzle_w() - # Step 5: L2 分组判断 - s_in = b * (m * k + k * n) * dt - s_out = b * m * n * case.dtype_out_bytes - if s_in + s_out <= s.l2_bytes: - l2_scene = "A_全驻留" + # Step 5: L2 分组判断 (issue#24: 按单 batch 工作集判定, 同一时刻单 batch 激活) + a_b = m * k * dt + bb_b = k * n * dt + out_batch = m * n * case.dtype_out_bytes + if a_b + bb_b + out_batch <= s.l2_bytes: + l2_scene = "A_单batch全驻留(输入+输出)" l2_out = "resident(输出驻留L2异步回写)" r_in = 1.0 - elif s_in <= s.l2_bytes: - l2_scene = "B_输入驻留输出直写GM" + elif a_b + bb_b <= s.l2_bytes: + l2_scene = "B_单batch输入驻留输出直写GM" l2_out = "direct_gm(输出直写GM不占L2)" r_in = 1.0 else: - l2_scene = "C_输入超L2分组执行" + l2_scene = "C_单batch输入超L2分组执行" l2_out = "direct_gm(输出直写GM不占L2)" - r_in = self._l2_group_r_in(case, single_m, single_n) + r_in = self._l2_group_r_gm(case, single_m, single_n) # Step 6: k_l1 (GM->L1 K 向粒度, 须 >= dValue 下限; K 小于下限时整 K 一次搬入不切) dv_min_elems = max(s.dvalue_hw_min // dt, 1) @@ -124,7 +125,7 @@ class AswBasicBranch(Branch): tail_block_cnt=tail["r"], tail_wave_num=tail["n_wave"], fixpipe_unitflag=True, out_dtype_bytes=case.dtype_out_bytes, - note=f"L2场景{l2_scene}, r_in={r_in:.2f}; 尾轮: {tail['reason']}", + note=f"L2场景{l2_scene}, GM首读倍率={r_in:.2f}; 尾轮: {tail['reason']}", ) # ------------------------------------------------------------------ @@ -189,12 +190,18 @@ class AswBasicBranch(Branch): w = d return w - def _l2_group_r_in(self, case, sm, sn) -> float: - """场景 C: L2 分组的重复读倍率 r_in = (n_grp*M + m_grp*N)/(M+N).""" + def _l2_group_r_gm(self, case, sm, sn) -> float: + """场景 C (单 batch 输入仍超 L2): 分组执行的 GM 重复读倍率. + + 每组 (m_grp x n_grp 个 tile) 输入工作集 <= L2; 组间共享块复用落空回 GM. + 预算 D 按**单 batch** 计 (issue#24: 线性映射同一时刻只激活 1 个 batch, + 不再除以总 batch 数). + r_gm = (ceil(n_cnt/n_grp)*M + ceil(m_cnt/m_grp)*N)/(M+N). + """ s = self.spec - m, n, k, b = case.m, case.n, case.k, case.batch_c + m, n, k = case.m, case.n, case.k dt = case.dtype_in_bytes - d = s.l2_bytes / (b * k * dt) + d = s.l2_bytes / (k * dt) m_grp = max(1, int(d / (2 * sm))) n_grp = max(1, int(d / (2 * sn))) m_cnt = ceil_div(m, sm) @@ -261,37 +268,64 @@ class AswBasicBranch(Branch): # ------------------------------------------------------------------ def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: + """MTE2 两段块级模型 (issue#24, 用户澄清): + + - 首读走 GM (按 GM 带宽, 不叠加 L2); 共享块 (A 行块被 n_cnt 个 tile 读、 + B 列块被 m_cnt 个 tile 读) 驻留 L2 后其余 (n_cnt-1)/(m_cnt-1) 次读走 + L2 读口 (5.2TB/s 独享) —— 场景 A/B (单 batch 工作集可驻留); + - 单 batch 输入超 L2 -> 场景 C 分组执行, GM 重复按组间落空计 (r_gm), 窗口内 + 复用未另计 (保守); + - 输出: 场景 A 驻留 L2 (5.2 写口) / 场景 B,C 直写 GM —— GM 读写共享总线 + 累加由 assemble 的 MTE2 链处理 (issue#23). + """ s = self.spec b = case.batch_c m, n, k = case.m, case.n, case.k dt = case.dtype_in_bytes out_b = case.dtype_out_bytes + used = max(plan.used_core_num, 1) flops = 2.0 * b * m * n * k - t_mmad = flops / (plan.used_core_num * s.q16) + t_mmad = flops / (used * s.q16) - in_bytes = b * (m * k + k * n) * dt - out_bytes = b * m * n * out_b - # r_in 从 note 里解析困难, 重新计算 - s_in = in_bytes - s_out = out_bytes - if s_in + s_out <= s.l2_bytes or s_in <= s.l2_bytes: - r_in = 1.0 + # ---- 字节量 (每 batch 口径) ---- + a_b = m * k * dt # 每 batch A 字节 + bb_b = k * n * dt # 每 batch B 字节 + out_all = b * m * n * out_b # 输出总字节 + m_cnt = max(plan.m_cnt, 1) + n_cnt = max(plan.n_cnt, 1) + + # ---- 场景判定: 按单 batch 工作集 (同一时刻单 batch 激活) ---- + if a_b + bb_b + m * n * out_b <= s.l2_bytes: + scene, to_l2, r_gm = "A_单batch全驻留(输入+输出)", True, 1.0 + elif a_b + bb_b <= s.l2_bytes: + scene, to_l2, r_gm = "B_单batch输入驻留,输出直写GM", False, 1.0 else: - r_in = self._l2_group_r_in(case, plan.single_core_m, plan.single_core_n) + scene, to_l2, r_gm = "C_单batch输入超L2分组执行", False, \ + self._l2_group_r_gm(case, plan.single_core_m, plan.single_core_n) - t_mte2 = r_in * in_bytes / (plan.used_core_num * s.bw_pc) - to_l2 = "resident" in plan.l2_policy_out - t_fix = out_bytes / (plan.used_core_num * (s.bw_l2_pc if to_l2 else s.bw_pc)) + # ---- MTE2: GM 段 (首读, 每字节一次) + L2 段 (共享块重复读) ---- + gm_read = r_gm * b * (a_b + bb_b) + if scene.startswith(("A_", "B_")): + # 驻留命中: A 行块被 n_cnt 个 tile 复用 -> 其余 (n_cnt-1) 次走 L2 读口 + l2_read = b * ((n_cnt - 1) * a_b + (m_cnt - 1) * bb_b) + else: + l2_read = 0.0 # 场景 C: 组间复用落空(已计 GM), 窗口内复用保守不计 + t_gm = gm_read / (used * s.bw_pc) + t_l2 = l2_read / (used * s.bw_l2_pc) + + # ---- Fixpipe ---- + t_fix = out_all / (used * (s.bw_l2_pc if to_l2 else s.bw_pc)) # drain: 尾轮暴露 (方案 B 已均匀重切, drain 小; A1b 尾轮凑满, drain 小; A0 尾轮 r 核空转) t_drain = 0.0 if plan.tail_strategy == "A0" and plan.tail_block_cnt > 0: - t_drain = max(t_mmad, t_mte2, t_fix) # 尾轮空转一个整块 + t_drain = max(t_mmad, t_gm + t_l2, t_fix) # 尾轮空转一个整块 return assemble_timing( - t_mte2_gm=t_mte2, t_mte2_l2=0.0, t_dma_cmd=0.0, + t_mte2_gm=t_gm, t_mte2_l2=t_l2, t_dma_cmd=0.0, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=0.0, t_drain=t_drain, - gm_read_bytes=r_in * in_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0, - cube_flops=flops, fixpipe_bytes=out_bytes, + gm_read_bytes=gm_read, l2_read_bytes=l2_read, dma_cmd_count=0.0, + cube_flops=flops, fixpipe_bytes=out_all, + fixpipe_to_gm=(not to_l2), ) diff --git a/BMM/BMM_Theory/bmm_theory/branches/stream_k.py b/BMM/BMM_Theory/bmm_theory/branches/stream_k.py index d8c0040..8816f18 100644 --- a/BMM/BMM_Theory/bmm_theory/branches/stream_k.py +++ b/BMM/BMM_Theory/bmm_theory/branches/stream_k.py @@ -129,40 +129,59 @@ class StreamKBranch(Branch): # ------------------------------------------------------------------ def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: + """芯片口径评估, 按 plan 实际 tile 布局 (issue#25). + + 切 K 组 (tile = single_m x single_n) 由 grid_k 核协作: 组内 K 段零重复读 + (GM 一次); 组间共享 (A 行块被 n_cnt 个 tile 用) 在单 batch 工作集可驻留时 + 走 L2 读口 (与 ASW 同规则). 全部 tile-组在 C 核上分波执行: + waves = ceil(b*m_cnt*n_cnt*grid_k / C). + - GM 读: 首读总量 = b*(m*k + k*n)*dt (组间共享命中 L2 时), 或按 r_gm 放大 + (工作集超 L2, 保守同 ASW 场景 C 公式); + - MMAD: 芯片总量 2*b*m*n*k / (C核) —— 全核忙稳态; + - 归约 (部分和 4B 写 L2/AIV 读回求和/最终写回): 每 tile-组一次、组间串行 + 追加为 drain: t_drain = waves * eval_streamk_reduce(tile, grid_k, out). + """ s = self.spec b = case.batch_c m, n, k = case.m, case.n, case.k dt = case.dtype_in_bytes out_b = case.dtype_out_bytes - grid_k = plan.grid_k + grid_k = max(plan.grid_k, 1) + m_cnt = max(plan.m_cnt, 1) + n_cnt = max(plan.n_cnt, 1) + tile_m = max(plan.single_core_m, 1) + tile_n = max(plan.single_core_n, 1) + tile = tile_m * tile_n # 每核实际 tile 元素数 - # 单 tile (L0C 满载基本块) - tile_elems = s.l0c_elems # 65536 - t_mmad_tile = 2.0 * k * s.l0c_bytes / 4 / s.q16 # 2K/Q16 * L0C/4B - t_mte2_tile = k * (2 * math.sqrt(tile_elems)) * dt / s.bw_pc # 近似方形 tile + # ---- MTE2: GM 段 + L2 段 (同 ASW 块级规则) ---- + a_b = m * k * dt + bb_b = k * n * dt + if a_b + bb_b <= s.l2_bytes: + gm_read = b * (a_b + bb_b) # 组间共享命中 L2: GM 每字节一次 + l2_read = b * ((n_cnt - 1) * a_b + (m_cnt - 1) * bb_b) + else: + gm_read = b * (a_b + bb_b) # 保守: 共享跨组回落 GM 未另计 + l2_read = 0.0 + t_gm = gm_read / s.bw_gm # 芯片口径 (全核并发) + t_l2 = l2_read / s.bw_l2 + t_mte2 = t_gm + t_l2 - # 切 K 后流水时延缩 grid_k 倍 - t_mmad = t_mmad_tile / grid_k - t_mte2 = t_mte2_tile / grid_k + # ---- MMAD: 芯片总量 ---- + flops = 2.0 * b * m * n * k + t_mmad = flops / (s.aic_num * s.q16) - # 归约: 部分和 4B 驻留 L2, AIV 归约 (含部分和写/读回/求和/最终按 C dtype 写回) - # 口径 (issue#11/#17): 归约整体为串行追加 (t_drain=t_reduce, reduce_serial=True), - # 部分和写出已计入 eval_streamk_reduce 的 t_write_partial —— 稳态 Fixpipe 不再 - # 重复计账. 若再按 grid_k*tile*4B/单核带宽份额另计一次, 既重复计账又把整组 - # 部分和串行压到单核写口, 高估 grid_k 倍 (streamk_demo 曾虚高到 55us/FIXPIPE; - # 第三轮曾回退该修复, issue#17 恢复). - t_reduce = eval_streamk_reduce(tile_elems, grid_k, out_b, s) + # ---- 归约: 每 tile-组一次, 组间分波串行追加 ---- + waves = ceil_div(b * m_cnt * n_cnt * grid_k, s.aic_num) + t_reduce_group = eval_streamk_reduce(tile, grid_k, out_b, s) + t_reduce = waves * t_reduce_group fix_bytes = 0.0 t_fix = 0.0 - flops_pc = 2.0 * tile_elems * k / grid_k - gm_bytes = k * (2 * math.sqrt(tile_elems)) * dt / grid_k - return assemble_timing( - t_mte2_gm=t_mte2, t_mte2_l2=0.0, t_dma_cmd=0.0, + t_mte2_gm=t_gm, t_mte2_l2=t_l2, t_dma_cmd=0.0, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=t_reduce, t_drain=t_reduce, # 归约串行追加 (reduce_serial 默认 True, 不进稳态 max) - gm_read_bytes=gm_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0, - cube_flops=flops_pc, fixpipe_bytes=fix_bytes, - reduce_serial=True, + gm_read_bytes=gm_read, l2_read_bytes=l2_read, dma_cmd_count=0.0, + cube_flops=flops, fixpipe_bytes=fix_bytes, + reduce_serial=True, fixpipe_to_gm=False, ) diff --git a/BMM/BMM_Theory/bmm_theory/evaluator.py b/BMM/BMM_Theory/bmm_theory/evaluator.py index 06f78df..c9fc058 100644 --- a/BMM/BMM_Theory/bmm_theory/evaluator.py +++ b/BMM/BMM_Theory/bmm_theory/evaluator.py @@ -66,11 +66,10 @@ class PlanEvaluator: if not res.feasible: tips.append("方案违反硬件约束, 需先修正: " + res.violations) bn = t.bottleneck - if bn == "MTE2_GM": - tips.append("瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, " - "或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)") - elif bn == "MTE2_L2": - tips.append("瓶颈在 L2 重复读: 优化核间分配/swizzle 窗口压低活跃工作集") + if bn == "MTE2": + tips.append("瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile " + "提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/" + "分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争") elif bn == "MMAD": tips.append("瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 " "(MergeBatch 交叉项) 可消除") diff --git a/BMM/BMM_Theory/bmm_theory/hardware/ascend950pr.py b/BMM/BMM_Theory/bmm_theory/hardware/ascend950pr.py index 5683c07..a008431 100644 --- a/BMM/BMM_Theory/bmm_theory/hardware/ascend950pr.py +++ b/BMM/BMM_Theory/bmm_theory/hardware/ascend950pr.py @@ -39,11 +39,16 @@ class NpuSpec: dvalue_hw_min: int = 256 # DMA 硬件突发下限 (Byte) —— 尾轮文档 §2.3 min_tile_size: int = 16 * 1024 # min_TileSize: 单块搬移最小量 16KB min_datamount_per_core: int = 480 * 1024 # min_DatamountPerCore: 单核搬移总量下限 480KB - min_core_num_ratio: float = 0.8 # minCoreNum ≈ 0.8 * C + min_core_num_ratio: float = 0.8 # minCoreNum ≈ 0.8 * C (经验: 约 3/4 核并发才达 90%+ 带宽利用率) # ---- DMA 固定开销 ---- t_cmd_ns: float = 50.0 # T_cmd: 单次 GM->L1 DMA 命令固定开销 (ns, 估计值, 需实测标定) + # ---- 带宽模型假设 (issue#26) ---- + # GM 1.6TB/s 为读写共享总线 (读+写累加计时); L2 带宽读写各自独享 5.2TB/s; + # active_cores < C 时按"每核份额线性配平"为模型假设 (如 1 核也给 50GB/s), + # 真实低核数带宽利用率低于线性, 需 msProf 实测曲线标定后替换该假设. + # ---- Cube 计算粒度 ---- fractal: int = 16 # 16x16x16 基本块 diff --git a/BMM/BMM_Theory/bmm_theory/timing.py b/BMM/BMM_Theory/bmm_theory/timing.py index 2c44f94..f87db6c 100644 --- a/BMM/BMM_Theory/bmm_theory/timing.py +++ b/BMM/BMM_Theory/bmm_theory/timing.py @@ -99,19 +99,31 @@ def assemble_timing(t_mte2_gm: float, t_mte2_l2: float, t_dma_cmd: float, gm_read_bytes: float, l2_read_bytes: float, dma_cmd_count: float, cube_flops: float, fixpipe_bytes: float, - reduce_serial: bool = True) -> HardwareTiming: + reduce_serial: bool = True, + fixpipe_to_gm: bool = True) -> HardwareTiming: """汇总各级时延, 判定瓶颈. + 带宽端口口径 (issue#23, 用户澄清 + KB): + - GM 1.6TB/s 为**读写共享总线**: MTE2 的 GM 读与 Fixpipe 直写 GM 并发时无法 + 拆分读写占用, 时延累加 (读+写)/1.6TB/s, 并入 MTE2 搬移链; + - L2 带宽读写各自独享 5.2TB/s: L2 重复读段(读口) 与 Fixpipe→L2 写(写口) + 互不竞争; MTE2 引擎顺序服务 GM/L2 装载, 两段相加 (官方 T≈HBM/1.6+L2/5.2); + - Fixpipe→L2 (resident) 写出独立为 FIXPIPE 级, 不进 GM 总线. + 归约计账约定 (issue#9): REDUCE 默认**串行追加** (reduce_serial=True, 归约不可 掩盖, 体现在 t_drain 中), 不进稳态 max(); 仅当调用方显式声明归约可流水掩盖 (reduce_serial=False) 时才进稳态 max(). 避免"既取最大又串行追加"的双倍计账. """ t_mte2 = t_mte2_gm + t_mte2_l2 + t_dma_cmd + fix_gm = t_fixpipe if fixpipe_to_gm else 0.0 # Fixpipe 直写 GM 的时延 + fix_l2 = 0.0 if fixpipe_to_gm else t_fixpipe # Fixpipe→L2 (5.2TB/s 写口) + # MTE2 搬移链 = GM 总线(读写共享, 读+直写累加) + L2 重复读段 + DMA 命令开销 + # (同一 MTE2 引擎顺序服务 GM/L2 两类装载; GM 写由 Fixpipe 并发发起, 共享 GM 总线) + mte2_chain = t_mte2_gm + t_dma_cmd + fix_gm + t_mte2_l2 stages = { - "MTE2_GM": t_mte2_gm + t_dma_cmd, - "MTE2_L2": t_mte2_l2, + "MTE2": mte2_chain, "MMAD": t_mmad, - "FIXPIPE": t_fixpipe, + "FIXPIPE": fix_l2, # 仅 Fixpipe→L2 (5.2 写口, 与 L2 读口互不竞争) } if not reduce_serial: stages["REDUCE"] = t_reduce @@ -135,8 +147,7 @@ def assemble_timing(t_mte2_gm: float, t_mte2_l2: float, t_dma_cmd: float, def bound_type_of(bottleneck: str) -> str: return { "MMAD": "计算Bound", - "MTE2_GM": "访存Bound(GM)", - "MTE2_L2": "访存Bound(L2)", - "FIXPIPE": "写出Bound", + "MTE2": "访存Bound(GM读写共享+L2重复读)", + "FIXPIPE": "写出Bound(L2写口)", "REDUCE": "归约Bound", }.get(bottleneck, "") diff --git a/BMM/BMM_Theory/examples/plans.csv b/BMM/BMM_Theory/examples/plans.csv index 29ed469..3872cfe 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1 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(输出仅写一次,直写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" 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_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06M->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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1 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),"direct_gm(输出仅写一次,直写GM不占L2)",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" 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1 -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场景C_输入超L2分组执行, r_in=1.09; 尾轮: r=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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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),"direct_gm(输出仅写一次,直写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" 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(输出仅写一次,直写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" -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场景C_输入超L2分组执行, r_in=12.00; 尾轮: 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场景C_输入超L2分组执行, r_in=10.56; 尾轮: r=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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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),"direct_gm(输出仅写一次,直写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" -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场景C_输入超L2分组执行, r_in=24.00; 尾轮: 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场景C_输入超L2分组执行, r_in=31.67; 尾轮: 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场景C_输入超L2分组执行, r_in=12.00; 尾轮: 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_输入驻留输出直写GM, r_in=1.00; 尾轮: 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场景C_输入超L2分组执行, r_in=6.00; 尾轮: 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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_全驻留, r_in=1.00; 尾轮: 面积型主导, 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场景C_输入超L2分组执行, r_in=1.24; 尾轮: 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场景C_输入超L2分组执行, r_in=1.00; 尾轮: 面积型主导, 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场景C_输入超L2分组执行, r_in=1.06; 尾轮: 面积型主导, 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场景C_输入超L2分组执行, r_in=75.00; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=1.14; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=2.88; 尾轮: 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场景C_输入超L2分组执行, r_in=75.00; 尾轮: 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分组执行, r_in=44.53; 尾轮: 周长型主导, 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,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 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场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, 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场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, 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场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 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_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)" 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场景C_输入超L2分组执行, r_in=10.38; 尾轮: 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场景C_输入超L2分组执行, r_in=47.00; 尾轮: 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_输入驻留输出直写GM, r_in=1.00; 尾轮: 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场景C_输入超L2分组执行, r_in=47.00; 尾轮: r=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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: 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 4056fd8..d720bea 100644 --- a/BMM/BMM_Theory/examples/result_evaluate.csv +++ b/BMM/BMM_Theory/examples/result_evaluate.csv @@ -1,45 +1,45 @@ case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,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, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.2743039999999997e-05,3.0192408230452674e-07,4.3044964082304525e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.0685759999999999e-05,4.400081646090535e-07,1.1125768164609053e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,5.4428799999999995e-06,3.0192408230452674e-07,5.744804082304526e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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(输出仅写一次,直写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",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.468608e-05,7.16176329218107e-07,8.540225632921811e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,6.5536e-06,3.4067453613053613e-06,9.960345361305361e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.44264e-06,7.548102057613169e-08,1.5181210205761316e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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),"direct_gm(输出仅写一次,直写GM不占L2)",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",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.5967200000000002e-05,2.932938271604938e-07,1.6260493827160496e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.392e-06,1.1322153086419754e-07,8.505221530864198e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=1.09; 尾轮: r=0 无尾轮",4103077888.0000005,0.0,0.0025644236800000005,0.0,0.0025644236800000005,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0025644236800000005,0.0,0.0025644236800000005,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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写最终",262144.0,0.0,5.24288e-06,0.0,5.24288e-06,0.0,0.0,33554432.0,2.209345316872428e-06,0.0,0.0,3.4067453613053613e-06,5.24288e-06,3.4067453613053613e-06,8.64962536130536e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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写最终",458752.0,0.0,9.17504e-06,0.0,9.17504e-06,0.0,0.0,58720256.0,3.866354304526749e-06,0.0,0.0,1.7159757575757577e-06,9.17504e-06,1.7159757575757577e-06,1.0891015757575759e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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),"direct_gm(输出仅写一次,直写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",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.705016e-05,7.16176329218107e-07,3.77663363292181e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" +special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,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, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.0567679999999999e-05,0.0,1.0567679999999999e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.5364479999999994e-05,3.0192408230452674e-07,4.566640408230452e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.1341119999999999e-05,4.400081646090535e-07,1.1781128164609052e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,6.09824e-06,3.0192408230452674e-07,6.400164082304526e-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(输出仅写一次,直写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",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.4836e-06,7.548102057613169e-08,1.5590810205761317e-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),"direct_gm(输出仅写一次,直写GM不占L2)",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",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.629488e-05,2.932938271604938e-07,1.6588173827160495e-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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.637760000000001e-06,1.1322153086419754e-07,8.7509815308642e-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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,1.6131938461538462e-06,0.0,0.0024183288123076924,0.0,0.0024183288123076924,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.7033726806526807e-06,0.00033558528,1.7033726806526807e-06,0.00033728865268065273,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.7159757575757577e-06,0.00058748928,1.7159757575757577e-06,0.0005892052557575758,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),"direct_gm(输出仅写一次,直写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",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.7214e-05,7.16176329218107e-07,3.7930176329218104e-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(输出仅写一次,直写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",58720256,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,30064771072.0,0.0019795734039176954,4194304,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场景C_输入超L2分组执行, r_in=12.00; 尾轮: r=0 无尾轮",19327352832.0,0.0,0.01207959552,0.0,0.01207959552,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.01207959552,0.0,0.01207959552,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=10.56; 尾轮: r=0 无尾轮",25501368320.0,0.0,0.0159383552,0.0,0.0159383552,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.0159383552,0.0,0.0159383552,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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),"direct_gm(输出仅写一次,直写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",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,7.06990501399177e-05,5.078042126748971e-05,0.0001214794714074074,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场景C_输入超L2分组执行, r_in=24.00; 尾轮: r=0 无尾轮",412316860416.0,0.0,0.25769803776,0.0,0.25769803776,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.25769803776,0.0,0.25769803776,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=31.67; 尾轮: r=0 无尾轮",178509578240.0,0.0,0.1115684864,0.0,0.1115684864,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.1115684864,0.0,0.1115684864,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=12.00; 尾轮: r=0 无尾轮",25769803776.0,0.0,0.01610612736,0.0,0.01610612736,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.01610612736,0.0,0.01610612736,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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_输入驻留输出直写GM, r_in=1.00; 尾轮: r=0 无尾轮",100663296.0,0.0,6.291456e-05,0.0,6.291456e-05,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.00067108864,0.0,0.00067108864,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -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场景C_输入超L2分组执行, r_in=6.00; 尾轮: r=0 无尾轮",3221225472.0,0.0,0.00201326592,0.0,0.00201326592,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00201326592,0.0,0.00201326592,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_全驻留, r_in=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,0.0,2.105344e-05,0.0,2.105344e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.105344e-05,0.0,2.105344e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=1.24; 尾轮: r=0 无尾轮",352321536.0,0.0,0.00022020096,0.0,0.00022020096,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0011311848022386832,0.0,0.0011311848022386832,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -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场景C_输入超L2分组执行, r_in=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134610944.0,0.0,8.413184e-05,0.0,8.413184e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,8.413184e-05,0.0,8.413184e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=1.06; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",574619648.0,0.0,0.00035913728,0.0,0.00035913728,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.00134217728,0.0,0.00134217728,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -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场景C_输入超L2分组执行, r_in=75.00; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=1.14; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=2.88; 尾轮: r=0 无尾轮",3288334336.0,0.0,0.00205520896,0.0,0.00205520896,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.04294967296,0.0,0.04294967296,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -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场景C_输入超L2分组执行, r_in=75.00; 尾轮: r=0 无尾轮",603979776000.0,0.0,0.37748736,0.0,0.37748736,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.37748736,0.0,0.37748736,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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分组执行, r_in=44.53; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",812822560768.0,0.0,0.50801410048,0.0,0.50801410048,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.50801410048,0.0,0.50801410048,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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写最终",786432.0,0.0,1.572864e-05,0.0,1.572864e-05,0.0,0.0,100663296.0,6.628035950617284e-06,0.0,0.0,2.3655235431235433e-07,1.572864e-05,2.3655235431235433e-07,1.5965192354312353e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=10.38; 尾轮: r=0 无尾轮",77980499968.0,0.0,0.04873781248,0.0,0.04873781248,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.04873781248,0.0,0.04873781248,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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场景C_输入超L2分组执行, r_in=47.00; 尾轮: r=0 无尾轮",353261060096.0,0.0,0.22078816256,0.0,0.22078816256,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.22078816256,0.0,0.22078816256,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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_输入驻留输出直写GM, r_in=1.00; 尾轮: r=0 无尾轮",16777216.0,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.00016777216,0.0,0.00016777216,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" -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场景C_输入超L2分组执行, r_in=47.00; 尾轮: r=0 无尾轮",1413044240384.0,0.0,0.88315265024,0.0,0.88315265024,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.88315265024,0.0,0.88315265024,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)" -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,1.985939393939394e-05,536870912,0.00033554432,0.0,0.00033554432,0.0,0.00033554432,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略" +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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.0002064888123076923,0.0,0.004413698363076923,0.0,0.004413698363076923,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.0002064888123076923,0.0,0.005949458904615385,0.0,0.005949458904615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +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),"direct_gm(输出仅写一次,直写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",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,8.428607999999999e-05,5.078042126748971e-05,0.00013506650126748969,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,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",17179869184.0,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场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮",7516192768.0,0.0,0.00469762048,0.0,0.00469762048,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,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,5.162220307692308e-05,0.0,0.005884931150769231,0.0,0.005884931150769231,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",100663296.0,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.0002064888123076923,0.0,0.0003532894523076923,0.0,0.0003532894523076923,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,6.452775384615385e-06,0.0,0.0008517663507692308,0.0,0.0008517663507692308,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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",285212672.0,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吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800.0,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,2.581110153846154e-05,0.0,0.00010272137846153847,0.0,0.00010272137846153847,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216.0,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场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, 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场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",1140850688.0,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",8053063680.0,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_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",86973087744.0,0.0,0.05435817984,0.0,0.05435817984,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.0698331002331e-07,0.00011042185846153846,2.0698331002331e-07,0.00011062884177156177,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00018067771076923076,0.0,0.018248448787692308,0.0,0.018248448787692308,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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮",15032385536.0,0.0,0.00939524096,0.0,0.00939524096,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,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",16777216.0,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,5.162220307692308e-05,0.0,8.469267692307693e-05,0.0,8.469267692307693e-05,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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮",60129542144.0,0.0,0.03758096384,0.0,0.03758096384,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,1.985939393939394e-05,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 10b6edb..8179138 100644 --- a/BMM/BMM_Theory/examples/result_recommend.csv +++ b/BMM/BMM_Theory/examples/result_recommend.csv @@ -1,45 +1,45 @@ case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"BatchA=1或BatchB=1, 折叠转普通Matmul" -special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,K=0纯写值 -special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,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, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"K=1逐元素乘, 走AIV向量通路" -merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.2743039999999997e-05,3.0192408230452674e-07,4.3044964082304525e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=43.04us vs T_IterBatch=45.22us -> MergeBatch更优; [裁决] MergeBatch" -merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.0685759999999999e-05,4.400081646090535e-07,1.1125768164609053e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=11.49us vs T_IterBatch=11.13us -> IterBatch更优; [裁决] IterBatch" -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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,5.4428799999999995e-06,3.0192408230452674e-07,5.744804082304526e-06,MTE2_GM,True,,访存Bound(GM),仅 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(输出仅写一次,直写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",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.468608e-05,7.16176329218107e-07,8.540225632921811e-05,MTE2_GM,True,,访存Bound(GM),仅 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写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,6.5536e-06,3.4067453613053613e-06,9.960345361305361e-06,MTE2_GM,True,,访存Bound(GM),"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_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06= 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,direct_gm,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,direct_gm,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,direct_gm,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) -b16_m4_n256_k192,16,16,4,256,192,bf16,bf16,bf16,False,False,False,True,0,b16_m4_n256_k192,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,4,256,192,192,1,标准核内流水,4,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.25= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) -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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.44264e-06,7.548102057613169e-08,1.5181210205761316e-06,MTE2_GM,True,,访存Bound(GM),仅 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),"direct_gm(输出仅写一次,直写GM不占L2)",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",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.5967200000000002e-05,2.932938271604938e-07,1.6260493827160496e-05,MTE2_GM,True,,访存Bound(GM),仅 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.392e-06,1.1322153086419754e-07,8.505221530864198e-06,MTE2_GM,True,,访存Bound(GM),仅 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场景C_输入超L2分组执行, r_in=1.09; 尾轮: r=0 无尾轮",4103077888.0000005,0.0,0.0025644236800000005,0.0,0.0025644236800000005,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0025644236800000005,0.0,0.0025644236800000005,MTE2_GM,True,,访存Bound(GM),"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写最终",262144.0,0.0,5.24288e-06,0.0,5.24288e-06,0.0,0.0,33554432.0,2.209345316872428e-06,0.0,0.0,3.4067453613053613e-06,5.24288e-06,3.4067453613053613e-06,8.64962536130536e-06,MTE2_GM,True,,访存Bound(GM),"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写最终",458752.0,0.0,9.17504e-06,0.0,9.17504e-06,0.0,0.0,58720256.0,3.866354304526749e-06,0.0,0.0,1.7159757575757577e-06,9.17504e-06,1.7159757575757577e-06,1.0891015757575759e-05,MTE2_GM,True,,访存Bound(GM),"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),"direct_gm(输出仅写一次,直写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",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.705016e-05,7.16176329218107e-07,3.77663363292181e-05,MTE2_GM,True,,访存Bound(GM),仅 IterBatch 条件满足 +special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),K=0纯写值 +special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,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, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.0567679999999999e-05,0.0,1.0567679999999999e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"K=1逐元素乘, 走AIV向量通路" +merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.5364479999999994e-05,3.0192408230452674e-07,4.566640408230452e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=45.67us vs T_IterBatch=47.84us -> MergeBatch更优; [裁决] MergeBatch" +merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.1341119999999999e-05,4.400081646090535e-07,1.1781128164609052e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=12.14us vs T_IterBatch=11.78us -> IterBatch更优; [裁决] IterBatch" +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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,6.09824e-06,3.0192408230452674e-07,6.400164082304526e-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(输出仅写一次,直写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",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06= 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,direct_gm,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,direct_gm,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,direct_gm,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) +b16_m4_n256_k192,16,16,4,256,192,bf16,bf16,bf16,False,False,False,True,0,b16_m4_n256_k192,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,4,256,192,192,1,标准核内流水,4,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.25= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) +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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.4836e-06,7.548102057613169e-08,1.5590810205761317e-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),"direct_gm(输出仅写一次,直写GM不占L2)",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",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.629488e-05,2.932938271604938e-07,1.6588173827160495e-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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.637760000000001e-06,1.1322153086419754e-07,8.7509815308642e-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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,1.6131938461538462e-06,0.0,0.0024183288123076924,0.0,0.0024183288123076924,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.7033726806526807e-06,0.00033558528,1.7033726806526807e-06,0.00033728865268065273,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.7159757575757577e-06,0.00058748928,1.7159757575757577e-06,0.0005892052557575758,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),"direct_gm(输出仅写一次,直写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",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.7214e-05,7.16176329218107e-07,3.7930176329218104e-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(输出仅写一次,直写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",58720256,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,30064771072.0,0.0019795734039176954,4194304,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场景C_输入超L2分组执行, r_in=12.00; 尾轮: r=0 无尾轮",19327352832.0,0.0,0.01207959552,0.0,0.01207959552,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.01207959552,0.0,0.01207959552,MTE2_GM,True,,访存Bound(GM),"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场景C_输入超L2分组执行, r_in=10.56; 尾轮: r=0 无尾轮",25501368320.0,0.0,0.0159383552,0.0,0.0159383552,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.0159383552,0.0,0.0159383552,MTE2_GM,True,,访存Bound(GM),"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),"direct_gm(输出仅写一次,直写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",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,7.06990501399177e-05,5.078042126748971e-05,0.0001214794714074074,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场景C_输入超L2分组执行, r_in=24.00; 尾轮: r=0 无尾轮",412316860416.0,0.0,0.25769803776,0.0,0.25769803776,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.25769803776,0.0,0.25769803776,MTE2_GM,True,,访存Bound(GM),"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场景C_输入超L2分组执行, r_in=31.67; 尾轮: r=0 无尾轮",178509578240.0,0.0,0.1115684864,0.0,0.1115684864,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.1115684864,0.0,0.1115684864,MTE2_GM,True,,访存Bound(GM),"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场景C_输入超L2分组执行, r_in=12.00; 尾轮: r=0 无尾轮",25769803776.0,0.0,0.01610612736,0.0,0.01610612736,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.01610612736,0.0,0.01610612736,MTE2_GM,True,,访存Bound(GM),"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_输入驻留输出直写GM, r_in=1.00; 尾轮: r=0 无尾轮",100663296.0,0.0,6.291456e-05,0.0,6.291456e-05,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.00067108864,0.0,0.00067108864,FIXPIPE,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" -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场景C_输入超L2分组执行, r_in=6.00; 尾轮: r=0 无尾轮",3221225472.0,0.0,0.00201326592,0.0,0.00201326592,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00201326592,0.0,0.00201326592,MTE2_GM,True,,访存Bound(GM),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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_全驻留, r_in=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,0.0,2.105344e-05,0.0,2.105344e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.105344e-05,0.0,2.105344e-05,MTE2_GM,True,,访存Bound(GM),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场景C_输入超L2分组执行, r_in=1.24; 尾轮: r=0 无尾轮",352321536.0,0.0,0.00022020096,0.0,0.00022020096,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0011311848022386832,0.0,0.0011311848022386832,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_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场景C_输入超L2分组执行, r_in=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134610944.0,0.0,8.413184e-05,0.0,8.413184e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,8.413184e-05,0.0,8.413184e-05,MTE2_GM,True,,访存Bound(GM),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场景C_输入超L2分组执行, r_in=1.06; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",574619648.0,0.0,0.00035913728,0.0,0.00035913728,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.00134217728,0.0,0.00134217728,FIXPIPE,True,,写出Bound,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场景C_输入超L2分组执行, r_in=75.00; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=1.14; 尾轮: 周长型主导, 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场景C_输入超L2分组执行, r_in=2.88; 尾轮: r=0 无尾轮",3288334336.0,0.0,0.00205520896,0.0,0.00205520896,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.04294967296,0.0,0.04294967296,FIXPIPE,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_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场景C_输入超L2分组执行, r_in=75.00; 尾轮: r=0 无尾轮",603979776000.0,0.0,0.37748736,0.0,0.37748736,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.37748736,0.0,0.37748736,MTE2_GM,True,,访存Bound(GM),"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分组执行, r_in=44.53; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",812822560768.0,0.0,0.50801410048,0.0,0.50801410048,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.50801410048,0.0,0.50801410048,MTE2_GM,True,,访存Bound(GM),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写最终",786432.0,0.0,1.572864e-05,0.0,1.572864e-05,0.0,0.0,100663296.0,6.628035950617284e-06,0.0,0.0,2.3655235431235433e-07,1.572864e-05,2.3655235431235433e-07,1.5965192354312353e-05,MTE2_GM,True,,访存Bound(GM),"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场景C_输入超L2分组执行, r_in=10.38; 尾轮: r=0 无尾轮",77980499968.0,0.0,0.04873781248,0.0,0.04873781248,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.04873781248,0.0,0.04873781248,MTE2_GM,True,,访存Bound(GM),"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场景C_输入超L2分组执行, r_in=47.00; 尾轮: r=0 无尾轮",353261060096.0,0.0,0.22078816256,0.0,0.22078816256,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.22078816256,0.0,0.22078816256,MTE2_GM,True,,访存Bound(GM),"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_输入驻留输出直写GM, r_in=1.00; 尾轮: r=0 无尾轮",16777216.0,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.00016777216,0.0,0.00016777216,FIXPIPE,True,,写出Bound,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场景C_输入超L2分组执行, r_in=47.00; 尾轮: r=0 无尾轮",1413044240384.0,0.0,0.88315265024,0.0,0.88315265024,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.88315265024,0.0,0.88315265024,MTE2_GM,True,,访存Bound(GM),"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,1.985939393939394e-05,536870912,0.00033554432,0.0,0.00033554432,0.0,0.00033554432,FIXPIPE,True,,写出Bound,"K=1逐元素乘, 走AIV向量通路" +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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.0002064888123076923,0.0,0.004413698363076923,0.0,0.004413698363076923,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.0002064888123076923,0.0,0.005949458904615385,0.0,0.005949458904615385,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_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),"direct_gm(输出仅写一次,直写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",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,8.428607999999999e-05,5.078042126748971e-05,0.00013506650126748969,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",17179869184.0,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场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮",7516192768.0,0.0,0.00469762048,0.0,0.00469762048,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,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,5.162220307692308e-05,0.0,0.005884931150769231,0.0,0.005884931150769231,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",100663296.0,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.0002064888123076923,0.0,0.0003532894523076923,0.0,0.0003532894523076923,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,6.452775384615385e-06,0.0,0.0008517663507692308,0.0,0.0008517663507692308,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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",285212672.0,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吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800.0,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,2.581110153846154e-05,0.0,0.00010272137846153847,0.0,0.00010272137846153847,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216.0,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场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, 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场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",1140850688.0,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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",8053063680.0,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_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",86973087744.0,0.0,0.05435817984,0.0,0.05435817984,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.0698331002331e-07,0.00011042185846153846,2.0698331002331e-07,0.00011062884177156177,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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00018067771076923076,0.0,0.018248448787692308,0.0,0.018248448787692308,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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮",15032385536.0,0.0,0.00939524096,0.0,0.00939524096,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,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",16777216.0,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,5.162220307692308e-05,0.0,8.469267692307693e-05,0.0,8.469267692307693e-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_归约代价可接受) +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场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮",60129542144.0,0.0,0.03758096384,0.0,0.03758096384,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,1.985939393939394e-05,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 d1eda2d..7c3bb81 100644 --- a/BMM/BMM_Theory/tests/test_branches.py +++ b/BMM/BMM_Theory/tests/test_branches.py @@ -134,7 +134,7 @@ class TestTimingSanity(unittest.TestCase): # MergeBatch case 必为访存 Bound (进入条件 5) case = mkcase(128, 64, 64, 512) mb = MergeBatchBranch().analyze(case) - self.assertIn(mb.timing.bottleneck, ("MTE2_GM", "MTE2_L2")) + self.assertIn(mb.timing.bottleneck, ("MTE2", "MMAD")) def test_fixpipe_dtype_conversion(self): # C 指定 fp16 输出时, 写出量按 2B 而非 L0C 的 4B @@ -224,10 +224,9 @@ class TestIssueRegression2(unittest.TestCase): t = sk.timing self.assertAlmostEqual(t.t_fixpipe, 0.0) # 归约串行口径下无稳态 fixpipe 账 self.assertAlmostEqual(t.fixpipe_bytes, 0.0) - # 端到端 = max(MTE2, MMAD) + 归约, 不再虚高到 55us/FIXPIPE - expect = max(t.t_mte2, t.t_mmad) + t.t_reduce - self.assertAlmostEqual(t.t_total, expect) - self.assertEqual(t.bottleneck, "MTE2_GM") + # 端到端 = 稳态(MTE2搬移链) + 归约, fixpipe 无重复账 + self.assertEqual(t.bottleneck, "MTE2") + self.assertAlmostEqual(t.t_total, t.t_steady + t.t_drain) def test_issue12_k1_pingpong_still_ok(self): # issue#12/#17: K=1 且 B>=128 仍走 UB 乒乓 (原行为不变)