From 18f59599e768c44b063a2a49f70e2354e98d8d1e Mon Sep 17 00:00:00 2001 From: admin Date: Fri, 4 Sep 2026 17:12:47 +0800 Subject: [PATCH] =?UTF-8?q?Fix=20#31/#32:=20=E5=88=87B=E7=B1=BBGM=E6=AF=8F?= =?UTF-8?q?=E5=AD=97=E8=8A=82=E6=81=B0=E4=B8=80=E6=AC=A1=3DV=5Fin(?= =?UTF-8?q?=E5=8E=BBK=E5=88=87=E5=88=86=E6=95=B4=E6=AE=B5=E4=B8=8A?= =?UTF-8?q?=E5=8F=96)=20/=20ASW=E5=9C=BA=E6=99=AF=E5=8D=87=E7=BA=A7(?= =?UTF-8?q?=E5=8D=95=E4=BE=A7=E5=85=A8=E9=A9=BB=E7=95=99+=E5=AF=B9?= =?UTF-8?q?=E4=BE=A7=E6=BB=91=E7=AA=97->S=5FB,=20S=5FC=E6=9C=80=E5=B0=8F?= =?UTF-8?q?=E6=9B=BF=E6=8D=A22D=E5=88=86=E7=BB=84+=E7=AA=97=E5=8F=A3L2?= =?UTF-8?q?=E8=AE=A1=E8=B4=A6)=20/=2006=E6=96=87=E6=A1=A3=C2=A73+Step5?= =?UTF-8?q?=E4=B8=8Edocs/05=E5=90=8C=E6=AD=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit #31 IterBatch/MergeBatch: K切分各(batch,K段)互不重叠+驻留侧每batch一次+末段按实际剩余 -> GM读取量=V_in(与L2容量无关), GM数据时延=V_in/W_GM; n_K仅决定DMA命令数(T_cmd) b64_m16_n256_k512 形态c: GM 25.07MB->17.83MB=V_in; 回归: 形态c/d非整除+L1绑定三类断言 #32 ASW: (1)S_B扩展单侧全驻留+对侧滑窗(a_b/b_b+2*对侧单块<=L2) -> GM=V_in, 6个场景C行回落S_B; (2)S_C在整L2容量约束下搜索最小GM=ceil(n_cnt/n_grp)a_b+ceil(m_cnt/m_grp)b_b(取代L2/2对半预算), 并计组内窗口L2流量((n_cnt-ceil)a_b+(m_cnt-ceil)b_b), 与S_B'驻留命中走L2'口径一致; b8_m131072_n8192_k8192 GM倍率4.76x->3.88x(物理下界~3.9x, 双侧均超L2) 大方形K行(如b128_m8192_n8192_k7168)由MMAD 253ms->MTE2(L2口)295ms: 共享块重复读1.38TB 经L2读口5.2TB/s, 如实计账(原C窗口流量零计低估) - docs/06 §3与Step5重写为S_A/S_B/S_C+两段链口径(旧r_in单段/除B/对半预算口径废弃) - docs/05 R5/R6/§3.1/§4.1/§4.3/§5与docs/01、02(01_MergeBatch/02_IterBatch GM口径附注)同步 - tests 54/54; 压力seed7/6000+seed2024/4000: 0违规/0占位/0NaN/0GM 输出驻留 L2 (R4, GM 写=0); - # S_B 整case超L2但单batch输入可驻留: batch 内共享块重复读命中 L2, 输出直写 GM; - # S_C 单batch输入超L2: 分组执行 (工作集), 组间共享块落空回 GM (r_gm). - scene = self._l2_scene(case, single_m, single_n) + # S_B 单batch可驻留 (全驻留或单侧全驻留+对侧滑窗): GM 每字节一次, + # 共享块重复读全部命中 L2 读口, 输出直写 GM; + # S_C 双侧超L2: 最小替换 2D 分组 (组间落空 GM, 窗口 L2). + scene = self._l2_scene(case, single_m, single_n, m_cnt, n_cnt) l2_out = ("resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)" if scene["to_l2"] else "direct_gm(输出直写GM, 输入优先驻留L2)") @@ -118,8 +119,10 @@ class AswBasicBranch(Branch): fixpipe_unitflag=True, out_dtype_bytes=case.dtype_out_bytes, note=(f"L2场景: {scene['label']} (V_in={case.input_bytes/1048576:.1f}MB, " - f"V_out={case.output_bytes/1048576:.1f}MB, L2={s.l2_bytes/1048576:.0f}MB), " - f"GM首读倍率={scene['r_gm']:.2f}; 尾轮: {tail['reason']}"), + f"V_out={case.output_bytes/1048576:.1f}MB, " + f"L2={s.l2_bytes/1048576:.0f}MB); " + + (scene["note_extra"] + "; " if scene["note_extra"] else "") + + f"尾轮: {tail['reason']}"), ) # ------------------------------------------------------------------ @@ -187,48 +190,88 @@ class AswBasicBranch(Branch): w = d return w - def _l2_scene(self, case: BmmCase, sm: int, sn: int) -> dict: - """L2 场景判定 (make_plan 与 evaluate 共用, 设计文档 docs/05 §4.1). + def _l2_scene(self, case: BmmCase, sm: int, sn: int, + m_cnt: int | None = None, n_cnt: int | None = None) -> dict: + """L2 场景判定 (make_plan 与 evaluate 共用, 设计文档 docs/05 §4.1, issue#32). - 判定顺序 S_A -> S_B -> S_C (L2 为整芯片 128MB): - S_A 整case全驻留: V_in + V_out <= L2 -> 输出驻留 L2 (R4); - S_B 单batch输入驻留: a_b + bb_b <= L2 -> 输入共享块重复读命中 L2; - S_C 单batch输入超L2: 分组执行, 组间落空回 GM (r_gm). + 判定顺序 S_A -> S_B -> S_C (L2 为整芯片 128MB; 返回"每 batch"流量): + S_A 整case全驻留: V_in + V_out <= L2 -> 输出驻留 L2 (R4, GM 写=0); + S_B 单batch可驻留: 单 batch 输入可全驻留 (a_b+bb_b<=L2) 或**单侧全驻留 + + 对侧滑窗** (驻留侧 <= L2 且 + 2x对侧单块 <= L2) -> GM 每字节恰读一次 + (V_in), 共享块重复读全部命中 L2 读口 (n_cnt-1)/(m_cnt-1) 次; + S_C 双侧均不可全驻留: 整 L2 容量约束下搜索**最小 GM** 的 2D 分组 + (力求最小 L2 替换), 组间共享块落空计 GM、组内窗口复用计 L2. """ s = self.spec m, n, k = case.m, case.n, case.k dt = case.dtype_in_bytes a_b = m * k * dt bb_b = k * n * dt + if m_cnt is None: + m_cnt = max(ceil_div(m, max(sm, 1)), 1) + if n_cnt is None: + n_cnt = max(ceil_div(n, max(sn, 1)), 1) + blk_a = a_b / max(m_cnt, 1) # A 行块字节 (tile 行宽 x K) + blk_b = bb_b / max(n_cnt, 1) # B 列块字节 (K x tile 列宽) if case.input_bytes + case.output_bytes <= s.l2_bytes: return {"code": "S_A", "label": "A_整case全驻留(输入+输出<=L2)", - "to_l2": True, "r_gm": 1.0} - if a_b + bb_b <= s.l2_bytes: + "to_l2": True, + "gm_batch": a_b + bb_b, + "l2_batch": (n_cnt - 1) * a_b + (m_cnt - 1) * bb_b, + "note_extra": ""} + if (a_b + bb_b <= s.l2_bytes or # 双侧全驻留 + bb_b + 2 * blk_a <= s.l2_bytes or # B 驻留 + A 行块滑窗 + a_b + 2 * blk_b <= s.l2_bytes): # A 驻留 + B 列块滑窗 return {"code": "S_B", - "label": "B_单batch输入驻留(整case超L2, 输出直写GM)", - "to_l2": False, "r_gm": 1.0} + "label": "B_单batch可驻留(全驻留或单侧驻留+对侧滑窗)", + "to_l2": False, + "gm_batch": a_b + bb_b, + "l2_batch": (n_cnt - 1) * a_b + (m_cnt - 1) * bb_b, + "note_extra": ""} + g = self._l2_group_min_gm(case, m_cnt, n_cnt, blk_a, blk_b) return {"code": "S_C", - "label": "C_单batch输入超L2分组执行(组间落空回GM)", - "to_l2": False, "r_gm": self._l2_group_r_gm(case, sm, sn)} + "label": "C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2)", + "to_l2": False, + "gm_batch": g["gm_batch"], + "l2_batch": g["l2_batch"], + "note_extra": g["note"]} - def _l2_group_r_gm(self, case, sm, sn) -> float: - """场景 C (单 batch 输入仍超 L2): 分组执行的 GM 重复读倍率. + def _l2_group_min_gm(self, case: BmmCase, m_cnt: int, n_cnt: int, + blk_a: float, blk_b: float) -> dict: + """场景 C: 整 L2 容量约束下的最小 GM 2D 分组 (issue#32, docs/05 §4.3b). - 每组 (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). + 容量约束: m_grp*blk_a + n_grp*blk_b <= L2 (组工作集占满整 L2, 不再对半); + 目标: GM = ceil(n_cnt/n_grp)*a_b + ceil(m_cnt/m_grp)*bb_b 最小 + (A 行块每列组一次 GM 首读; B 列块每行组一次 GM 首读); + 窗口 L2: (n_cnt - ceil(n_cnt/n_grp))*a_b + (m_cnt - ceil(m_cnt/m_grp))*bb_b + (组内共享块其余次复用走 L2 读口, 与 S_B 口径一致, issue#32 失真b); + 无可行分组 (单块对都超 L2) 时保守回落: 每共享块独立落 GM, 窗口不计. """ s = self.spec m, n, k = case.m, case.n, case.k dt = case.dtype_in_bytes - 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) - n_cnt = ceil_div(n, sn) - return (ceil_div(n_cnt, n_grp) * m + ceil_div(m_cnt, m_grp) * n) / (m + n) + a_b = m * k * dt + bb_b = k * n * dt + best = None + for mg in range(1, m_cnt + 1): + for ng in range(1, n_cnt + 1): + if mg * blk_a + ng * blk_b > s.l2_bytes: + continue + ga = ceil_div(n_cnt, ng) + gb = ceil_div(m_cnt, mg) + gm = ga * a_b + gb * bb_b + if best is None or gm < best[0]: + best = (gm, mg, ng, ga, gb) + if best is None: + return {"gm_batch": n_cnt * a_b + m_cnt * bb_b, "l2_batch": 0.0, + "note": "分组无可行解(单块对超L2): 保守每共享块独立落GM"} + gm, mg, ng, ga, gb = best + l2 = (n_cnt - ga) * a_b + (m_cnt - gb) * bb_b + r = gm / (a_b + bb_b) + return {"gm_batch": gm, "l2_batch": l2, + "note": f"最小替换分组 m_grp={mg}x n_grp={ng} (GM倍率{r:.2f}, " + f"窗口L2/batch={l2/1048576:.1f}MB)"} # ------------------------------------------------------------------ def _decide_tail(self, case, sm, sn, n_blk, k_l1) -> dict: @@ -291,13 +334,15 @@ class AswBasicBranch(Branch): # ------------------------------------------------------------------ def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: - """MTE2 两段块级模型 (issue#24 用户口径 + #28/#29/#30): + """MTE2 两段块级模型 (issue#24 用户口径 + #28/#29/#30/#32): - 首读走 GM (按 GM 带宽, 不叠加 L2); 共享块 (A 行块被 n_cnt 个 tile 读、 B 列块被 m_cnt 个 tile 读) 驻留 L2 后其余 (n_cnt-1)/(m_cnt-1) 次读走 - L2 读口 (5.2TB/s 独享) —— 场景 S_A/S_B (单 batch 工作集可驻留); - - 单 batch 输入超 L2 -> 场景 S_C 分组执行, GM 重复按组间落空计 (r_gm), - 窗口内复用未另计 (保守); + L2 读口 (5.2TB/s 独享); + - 场景 (与 make_plan 同源 _l2_scene, 返回每 batch GM/L2 流量): + S_A/S_B: GM = V_in 一次 (S_B 含单侧全驻留+对侧滑窗, issue#32); + S_C: 最小替换 2D 分组 (整 L2 容量约束下最小 GM), 组间落空计 GM、 + 组内窗口复用计 L2; - 输出落点 R4 (issue#30): 仅 S_A (整 case 输入+输出 <= L2) 驻留 L2 (5.2 写口, GM 写 = 0); S_B/S_C 直写 GM —— GM 读写共享总线累加由 assemble 的 MTE2 链处理 (issue#23); @@ -306,7 +351,6 @@ class AswBasicBranch(Branch): 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) qc = s.q_cube(case.dtype_a, case.dtype_b) @@ -315,23 +359,16 @@ class AswBasicBranch(Branch): t_mmad = flops / (used * qc) # ---- 字节量 (整芯片口径) ---- - 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) - # ---- L2 场景 (S_A/S_B/S_C, 与 make_plan 同源) ---- - scene = self._l2_scene(case, plan.single_core_m, plan.single_core_n) - to_l2, r_gm = scene["to_l2"], scene["r_gm"] - - # ---- MTE2: GM 段 (首读, 每字节一次) + L2 段 (共享块重复读) ---- - gm_read = r_gm * b * (a_b + bb_b) - if scene["code"] in ("S_A", "S_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 # 场景 S_C: 组间复用落空(已计 GM), 窗口内复用保守不计 + # ---- L2 场景 (S_A/S_B/S_C, 与 make_plan 同源; 每 batch 流量 x B) ---- + scene = self._l2_scene(case, plan.single_core_m, plan.single_core_n, + m_cnt, n_cnt) + to_l2 = scene["to_l2"] + gm_read = b * scene["gm_batch"] + l2_read = b * scene["l2_batch"] t_gm = gm_read / (used * s.bw_pc) t_l2 = l2_read / (used * s.bw_l2_pc) diff --git a/BMM/BMM_Theory/bmm_theory/branches/iter_batch.py b/BMM/BMM_Theory/bmm_theory/branches/iter_batch.py index 1436990..6eba4aa 100644 --- a/BMM/BMM_Theory/bmm_theory/branches/iter_batch.py +++ b/BMM/BMM_Theory/bmm_theory/branches/iter_batch.py @@ -197,8 +197,8 @@ class IterBatchBranch(Branch): # ------------------------------------------------------------------ # 时延评估 (v1.1 §4 端到端模型, IterBatch 侧) - # 口径: dtype 感知算力 (issue#28); 字节列整芯片 (issue#29); - # 输出落点 R4 (issue#30). + # 口径: dtype 感知算力 (issue#28); GM 每字节恰读一次 = V_in (issue#31); + # 字节列整芯片 (issue#29); 输出落点 R4 (issue#30). # ------------------------------------------------------------------ def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: s = self.spec @@ -214,14 +214,16 @@ class IterBatchBranch(Branch): k_truncated = k_l1 >= k n_k = 1 if k_truncated else -(-k // k_l1) - t_load = min(k_l1, k) * (m + n) * dt / s.bw_pc t_comp_chunk = 2.0 * m * n * min(k_l1, k) / qc t_write = m * n * out_b / w_fix - # 搬移: 每 batch n_K 次 GM->L1 (各 (batch,K段) 数据互不重叠, GM 每字节一次), - # 每次含 T_cmd; dma_cmds 为单核命令数 (各核并行, issue#29 口径) + # 搬移 (issue#31): 每 batch 的 K 段/驻留侧数据互不重叠, 每个输入字节恰好从 + # GM 读一次 (形态 c 驻留侧每 batch 只搬一次; 切 K 末段按实际剩余计) -> + # GM 数据量 = V_in, 数据时延 = V_in/芯片带宽 (全核并发); + # n_K/k_L1 只决定 DMA 命令次数 (T_cmd) 与双缓冲调度, 不放大数据量. + # dma_cmds 为单核命令数 (各核并行, issue#29 口径) dma_cmds = b_core * n_k - t_mte2_data = dma_cmds * t_load + t_mte2_data = case.input_bytes / s.bw_gm t_dma_cmd = dma_cmds * s.t_cmd t_mte2 = t_mte2_data + t_dma_cmd @@ -241,8 +243,7 @@ class IterBatchBranch(Branch): return assemble_timing( t_mte2_gm=t_mte2_data, t_mte2_l2=0.0, t_dma_cmd=t_dma_cmd, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=0.0, t_drain=t_drain, - gm_read_bytes=b * n_k * min(k_l1, k) * (m + n) * dt, - l2_read_bytes=0.0, + gm_read_bytes=case.input_bytes, l2_read_bytes=0.0, dma_cmd_count=dma_cmds, cube_flops=flops_chip, fixpipe_bytes=fix_bytes_chip, fixpipe_to_gm=(not out_l2), diff --git a/BMM/BMM_Theory/bmm_theory/branches/merge_batch.py b/BMM/BMM_Theory/bmm_theory/branches/merge_batch.py index 21648f7..e66276e 100644 --- a/BMM/BMM_Theory/bmm_theory/branches/merge_batch.py +++ b/BMM/BMM_Theory/bmm_theory/branches/merge_batch.py @@ -195,27 +195,23 @@ class MergeBatchBranch(Branch): w_fix = s.bw_l2_pc if out_l2 else s.bw_pc k_truncated = k_l1 >= k - # 每 K 分块搬移/计算时延 (未合并基准, v1.1 §4.1 符号) - t_load = k_l1 * (m + n) * dt / s.bw_pc + # 每 K 分块计算时延 (未合并基准, v1.1 §4.1 符号) / 单 batch 输出写回 (R4) t_comp_chunk = 2.0 * m * n * k_l1 / qc - t_write = m * n * out_b / w_fix # 单 batch 输出写回 (R4 落点带宽) + t_write = m * n * out_b / w_fix + # 搬移 (issue#31): 合并组/切 K 各 (组, K段) 数据互不重叠, 每个输入字节恰好 + # 从 GM 读一次 (K截断与 L1 绑定均如此; 切 K 末段按实际剩余计, 不再整段上取) + # -> GM 数据量 = V_in, 数据时延 = V_in/芯片带宽 (全核并发); + # 搬移命令数只决定 T_cmd (与 IterBatch 的同/少 b0 倍关系不变): + # K截断: 每核 b_core/b0 次合并搬入 (每次 b0 个 batch 全 K) + # L1绑定: k_L1^m = k_L1/b0, n_K^m = b0*n_K, 命令数与 IterBatch 相同 if k_truncated: - # K 截断: n_K=1, 每核 b_core/b0 次合并搬入, 每次搬 b0 个 batch 全 K - n_move = b_core / b0 - t_mte2_data = n_move * b0 * t_load - dma_cmds = n_move - gm_chip = b * (m + n) * k * dt # = V_in, GM 每字节一次 + dma_cmds = b_core / b0 else: - # L1 绑定: k_L1^m = k_L1/b0, n_K^m = b0*n_K, 搬移次数与 IterBatch 相同 - # (每 (合并组, K段) 数据互不重叠, GM 仍每字节一次, 末段含 padding 上取) n_k = -(-k // k_l1) - n_move = b_core * n_k - t_mte2_data = n_move * t_load - dma_cmds = n_move - gm_chip = b * (m + n) * n_k * k_l1 * dt # >= V_in (padding 上取) - + dma_cmds = b_core * n_k t_dma_cmd = dma_cmds * s.t_cmd + t_mte2_data = case.input_bytes / s.bw_gm t_mte2 = t_mte2_data + t_dma_cmd # Cube (每核口径): 合并计算含冗余 (b0^2 输出, 有效 b0), 每核 b_core/b0 步, @@ -235,7 +231,7 @@ class MergeBatchBranch(Branch): return assemble_timing( t_mte2_gm=t_mte2_data, t_mte2_l2=0.0, t_dma_cmd=t_dma_cmd, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=0.0, t_drain=t_drain, - gm_read_bytes=gm_chip, l2_read_bytes=0.0, + gm_read_bytes=case.input_bytes, l2_read_bytes=0.0, dma_cmd_count=dma_cmds, cube_flops=flops_chip, fixpipe_bytes=fix_bytes_chip, fixpipe_to_gm=(not out_l2), diff --git a/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md b/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md index 978af19..ab853ac 100644 --- a/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md +++ b/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md @@ -56,6 +56,11 @@ $$T_{mb} = \underbrace{\frac{b_{core}}{b_0}\cdot n_K^m\cdot(T_{load}^m + T_{cmd} L1 绑定情形搬移次数、单次搬移量都与 IterBatch 相同，只放大 drain——证明见 v1.1 §4.4。 +> **GM 数据量口径 (issue#31)**: 各 (合并组, K段) 的数据互不重叠, 每个输入字节恰好从 GM +> 读一次 —— K 截断与 L1 绑定两种情形的**芯片 GM 读取量都 = V_in** (末段按实际剩余计, +> 无 padding 上取)。上式的 T_load 级联只用于刻画命令/双缓冲调度结构: 数据时延按 +> V_in/W_GM 计, n_K 只放大 DMA 命令项 (b_core/b₀ 或 b_core·n_K) × T_cmd。 + ## 5. MergeBatch vs IterBatch 净收益 $$\text{净收益} = \underbrace{b_{core}\Big(1-\frac{1}{b_0}\Big)T_{cmd}}_{\text{搬移命令节省}} - \underbrace{(b_0-1)(T_{comp}+T_{write})}_{\text{drain 惩罚}}$$ diff --git a/BMM/BMM_Theory/docs/02_分支理论/02_IterBatch分支.md b/BMM/BMM_Theory/docs/02_分支理论/02_IterBatch分支.md index 3a49d59..18c93aa 100644 --- a/BMM/BMM_Theory/docs/02_分支理论/02_IterBatch分支.md +++ b/BMM/BMM_Theory/docs/02_分支理论/02_IterBatch分支.md @@ -40,6 +40,11 @@ $$T_{iter} = \underbrace{b_{core}\cdot n_K\cdot(T_{load} + T_{cmd})}_{\text{搬 每 batch 的 A[M,K]+B[K,N] 作为独立 DMA 操作搬入 L1（源码 `ndNum = curIterBatchL1`，多块独立寻址）。 +> **GM 数据量口径 (issue#31)**: 形态 a/b/c/d 的 K 段/驻留侧数据互不重叠、每个输入字节 +> 恰好从 GM 读一次 (形态 c 的驻留侧每 batch 只搬一次; 切 K 末段按实际剩余计, 无 padding +> 上取) —— **芯片 GM 读取量 = V_in**, 与 L2 容量无关 (IterBatch 无 L2 级重复读)。 +> n_K 只决定 DMA 命令数 (T_cmd 项) 与双缓冲调度, 不放大数据量; 数据时延按 V_in/W_GM 计。 + ## 6. 与 MergeBatch 的分界 见 [01_MergeBatch分支.md](01_MergeBatch分支.md) §4~5。IterBatch 在 **L1 绑定情形恒优**；MergeBatch 仅在 K 截断且 b_core 足够大时胜。 diff --git a/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md b/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md index 9019e6f..f9e0d98 100644 --- a/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md +++ b/BMM/BMM_Theory/docs/02_分支理论/06_ASW_Basic分支.md @@ -20,15 +20,29 @@ ASW_Basic 是 BMM 的**兜底分支**——核间切 M/N（或混合切），不 ## 3. 时延建模 -核间切 M/N（不切 K），每核处理若干 [singleCoreM, singleCoreN] 输出块： +核间切 M/N（不切 K），每核处理若干 [singleCoreM, singleCoreN] 输出块；单 batch 内 +A 行块被 n_cnt 个列 tile 共享、B 列块被 m_cnt 个行 tile 共享（issue#24 用户口径， +最新场景口径见 issue#32 与 docs/05 §4）： $$T = \max(T_{MTE2},\; T_{MMAD},\; T_{FIX}) + T_{drain}$$ -其中 `T_MMAD = 2BMNK/(C·Q16)`、`T_FIX = B·MN·outB/(C·W_pc)` 与分配策略无关——**分配策略只影响 T_MTE2**（通过 L2 命中率影响有效 GM 带宽）： +- `T_MMAD = 2BMNK / (used·Q16(dtype))` —— 与分配策略无关；Q16 按输入 dtype 分档 (issue#28)； +- **MTE2 两段搬移链**（issue#23/#31/#32，GM 为读写共享总线）: + - `t_gm = S_in^GM / W_GM`：GM 直读量（首读 + 落空重读；与输出直写 GM 并发时 + 读写累加，输出落点见 docs/05 §4.2 R4）； + - `t_l2 = S_in^L2 / W_L2`：L2 重复读量（共享块驻留后其余次读取，5.2TB/s 读口独享）； + - MTE2 链 = t_gm + t_l2 + DMA 命令开销。 +- `T_FIX`：R4 输出落点——整 case 输入+输出 ≤ L2 时写 L2 写口（异步回写不占算子时延）， + 否则直写 GM 计入共享总线（issue#30）。 -$$T_{MTE2} = \frac{S_{in}^{GM}}{C\cdot BW_{pc}},\qquad S_{in}^{GM} = r_{in}\cdot S_{in}$$ +**GM/L2 流量归属 —— L2 场景判定**（与代码 `_l2_scene` 同源，docs/05 §4.1/§4.3）: +S_A 整case全驻留 / S_B 单batch可驻留（全驻留**或单侧全驻留 + 对侧滑窗**）→ +GM = V_in 一次（r_in=1），共享块重复读全部命中 L2；S_C 双侧均超 L2 → 最小替换 2D 分组 +（整 L2 容量约束下最小 GM），组间共享块落空回 GM、组内窗口复用按 L2 计账。 -`r_in` = 重复读倍率（GM 输入流量/输入总量），r_in≥1，下界 1 表示每字节只从 GM 读一次（后续复用全命中 L2）。**分配策略的全部目标就是让 r_in 尽量接近 1**。 +`r_in` = GM 输入流量/输入总量，r_in≥1，下界 1 表示每字节只从 GM 读一次（后续复用 +全命中 L2）。**分配策略的全部目标就是让 r_in 尽量接近 1**：S_B 已识别"单侧可全驻留" +调度（不再把可驻留 case 错误地按分组放大 GM）；只有双侧都放不下 L2 时（S_C）r_in 才 > 1。 ## 4. 核间分配策略：B→M→N 线性映射 @@ -67,17 +81,19 @@ $$\text{BaseM}\times\text{BaseN} = \frac{L0C}{2\times 4B} = 32768\ \text{元素} 同一波 C 个核所需的 A 行块 + B 列块集合是"活跃工作集"，超 L2 就回 GM 读。swizzle 编排输出块执行顺序，把每一波的活跃工作集压到最小。窗口宽度 `W = max{d | d|C, d ≤ ⌊√C⌋}`（C=32 时 W=4）；窗口内先扫 M、扫满 W 行进下一列 N，奇数窗口行 N 向反向（蛇形）。 -**Step 5: L2 分组（工作集超 L2 时）** +**Step 5: L2 场景判定与分组（make_plan/evaluate 共用 `_l2_scene`，issue#24/#32）** -记 S_in = B(MK+KN)·dt，S_out = B·MN·outB。两个不变量：GM 流量下界 = S_in + S_out；L2 读入可用空间 L2_read = L2 − S_out^resident。 +记单 batch 输入 a_b = MK·dt、b_b = KN·dt，整 case V_in = S_in、V_out = S_out； +A 行块 block_a = a_b/m_cnt、B 列块 block_b = b_b/n_cnt。 -| 场景 | 条件 | 策略 | +| 场景 | 条件 | GM / L2 计账（每 batch） | |---|---|---| -| A 全驻留 | S_in + S_out ≤ L2 | 输入读一遍（r_in=1），输出驻留 L2 异步回写，无需切分 | -| B 输入能驻留，加输出超了 | S_in ≤ L2 < S_in+S_out | **输入驻留、输出直写 GM**，保住 r_in=1；校验总线 (S_in+S_out)/T_MMAD ≤ W_GM | -| C 输入本身超 | S_in > L2 | 分组执行，每组输入工作集 ≤ L2，输出直写 GM | +| S_A 整case全驻留 | V_in + V_out ≤ L2 | GM = a_b+b_b；重复读 (n_cnt−1)a_b+(m_cnt−1)b_b 走 L2；输出驻留 L2（GM 写=0） | +| S_B 单batch可驻留 | a_b+b_b ≤ L2，**或**单侧全驻留+对侧滑窗：b_b+2·block_a ≤ L2 或 a_b+2·block_b ≤ L2 | GM = a_b+b_b（r_in=1）；重复读 (n_cnt−1)a_b+(m_cnt−1)b_b 全部命中 L2；输出直写 GM | +| S_C 双侧超 L2 | 以上均不满足 | 容量 m_grp·block_a+n_grp·block_b ≤ L2 下最小化 GM = ⌈n_cnt/n_grp⌉·a_b + ⌈m_cnt/m_grp⌉·b_b；组间落空计 GM，窗口 (n_cnt−⌈n_cnt/n_grp⌉)a_b+(m_cnt−⌈m_cnt/m_grp⌉)b_b 计 L2 | -场景 C 分组：每组覆盖 M 向 m_grp、N 向 n_grp 个基本块，`m_grp = ⌊D/(2·sM)⌋`，`n_grp = ⌊D/(2·sN)⌋`，D = L2/(B·K·dt)；重复读倍率 `r_in = (n_grp·M + m_grp·N)/(M+N)`。块内错位分核（对角线分配）避免同地址并发读串行化。 +> 注：早期口径（预算 D = L2/(B·K·dt) 且对半切、组内窗口流量零计）已废弃 +> （issue#24 除总 B 的矛盾、issue#32 对半预算与窗口零计失真）；分组不再对半、窗口复用如实计 L2。 **Step 6: 核内 tiling**：BaseM×BaseN×4B×DB ≤ L0C；BaseM×k_L0×dt×2 ≤ L0A；k_L0×BaseN×dt×2 ≤ L0B；内轴按 dValue 256B/512B 对齐。 diff --git a/BMM/BMM_Theory/docs/05_L2驻留GM读写与dtype算力口径_设计分析.md b/BMM/BMM_Theory/docs/05_L2驻留GM读写与dtype算力口径_设计分析.md index 10f6e6a..190968c 100644 --- a/BMM/BMM_Theory/docs/05_L2驻留GM读写与dtype算力口径_设计分析.md +++ b/BMM/BMM_Theory/docs/05_L2驻留GM读写与dtype算力口径_设计分析.md @@ -83,41 +83,47 @@ StreamK 归约是对 **fp32 部分和**求和 → AIV 归约恒按 fp32 档 (因 - **R3 (整 case 全驻留边界)**: V_in + V_out (StreamK 另加部分和 workspace) ≤ L2 时, 全程零逐出: GM_read = V_in (每字节一次), 全部重复读走 L2, 输出驻留 L2 (见 §4.2)。 - **R4 (输出落点)**: 见 §4.2。 -- **R5 (输入工作集场景)**: 单 batch 输入 ≤ L2 → batch 内 tile 共享块重复读按 L2 计 - (A 行块被 n_cnt 个列 tile 复用 → (n_cnt−1) 次 L2; B 列块被 m_cnt 个行 tile 复用 → (m_cnt−1) 次 L2); - 单 batch 输入 > L2 → 分组执行 (工作集思想, §4.3)。 -- **R6 (已知简化, 文档标注)**: ① 组内窗口复用未另计 (保守); ② BatchA≠BatchB (均 ≥2, 如 2 vs 64) - 的广播/混合 batch 结构按"每 batch 独立矩阵"计 GM = b·(a_b+b_b), 是 V_in 的**保守放大** - (真实为 V_in + 共享矩阵跨 batch 重复读 ≤ 该值), 文档标注不做特殊建模; ③ K 切分 (k_L11) | S_A/S_B: b·[(n_cnt−1)·a_b + (m_cnt−1)·b_b]; S_C: 组内窗口计 L2 (issue#32) | ✓ GM≥V_in | | StreamK | 组内 K 段零重复读; 组间共享块同 ASW | V_in (命中时) | 组间共享块 (命中时) | ✓ | | 特殊分支 K=1 | AIV 通路, 每元素一次 | V_in | 0 | ✓ | | 转Matmul | 折叠单次 GEMM | V_in | 0 (Matmul 精切未展开) | ✓ | -→ **计算层面 GM 均 ≥ V_in**, 用户看到的 "GM < 输入" 来自**字节列每核/芯片口径混用** -(MergeBatch/IterBatch 记每核值 ×32 才是整芯片; ASW/StreamK 记整芯片值), 不是少算。 -统一为整芯片口径 (修正项 ①), 并加不变量测试 (修正项 ②), 补齐 R3 整 case 边界 (修正项 ③)。 +→ **整芯片口径统一后 (issue#29): GM 均 = V_in (无重复读结构) 或 ≥ V_in (S_C 双侧超 L2 的最小替换分组)**, 不变量 GM ≥ V_in 由测试锁死 (违反即 bug)。 --- -## 4. 场景模型 (输入侧) 与输出落点 (issue #30) +## 4. 场景模型 (输入侧) 与输出落点 (issue #30 / #32) ### 4.1 场景判定 (对切 M/N 及切 B 分支共用; L2 为整芯片 128MB) -- **S_A 整 case 全驻留**: V_in + V_out [+ workspace] ≤ L2 → 输出驻留 L2; -- **S_B 单 batch 输入可驻留**: 不满足 S_A, 但 a_b + b_b ≤ L2 → 输入 batch 内共享块重复读命中 L2; -- **S_C 单 batch 输入超 L2**: a_b + b_b > L2 → 分组执行 (输入工作集切分), 组间落空回 GM。 +- **S_A 整 case 全驻留**: V_in + V_out [+ workspace] ≤ L2 → 输出驻留 L2 (R4); +- **S_B 单 batch 可驻留**: 不满足 S_A, 但单 batch 输入可全驻留 (a_b + b_b ≤ L2) + **或单侧全驻留 + 对侧滑窗**: b_b + 2·block_a ≤ L2 或 a_b + 2·block_b ≤ L2 + (block_a = a_b/m_cnt = A 行块字节, block_b = b_b/n_cnt = B 列块字节) + → GM = V_in 一次, 共享块重复读全部命中 L2 读口; 输出直写 GM; +- **S_C 双侧均超 L2**: a_b、b_b 及其滑窗组合都放不下 → 最小替换 2D 分组 (§4.3)。 -判定顺序: S_A → S_B → S_C。(原 #24 场景 A 的"单 batch 输入+输出可驻留"判定被 S_A 取代: -整 case 输出跨 batch 累积时单 batch 判定不可靠, 见 #30。) +判定顺序 S_A → S_B → S_C。S_B 从原"双侧全驻留"扩展出"单侧全驻留+对侧滑窗"调度 +(issue#32): 大矩阵行块流式、小矩阵全驻留时, GM 仍 = V_in, 不再被分组模型成倍放大。 +(原 #24 场景 A 的"单 batch 输入+输出可驻留"判定被 S_A 取代: 整 case 输出跨 batch +累积时单 batch 判定不可靠, 见 #30。) ### 4.2 R4 输出落点规则 (取代一切"恒直写 GM / 单 batch 判定驻留") @@ -135,12 +141,19 @@ StreamK 归约是对 **fp32 部分和**求和 → AIV 归约恒按 fp32 档 (因 | ASW | 场景 A (单 batch in+out 驻留) 时 to_l2 | S_A (整 case) 时 to_l2; S_B/S_C 直写 GM | | StreamK | 归约内最终写回恒走 L2 | 最终写回按 S_A(+workspace); 不满足时写 GM (drain 内按 GM 带宽) | -### 4.3 场景 C 分组工作集 (沿用 #24 公式, 语义重申) +### 4.3 场景 C: 最小替换 2D 分组 (issue#32) -单 batch 输入超 L2 → 以 L2 为单 batch 活动窗口预算 D = L2 / (K·dt) (元素), -组 = m_grp × n_grp 个 tile, 组间共享块复用落空回 GM: -r_gm = (⌈n_cnt/n_grp⌉·M + ⌈m_cnt/m_grp⌉·N)/(M+N), GM = r_gm·V_in; -组内窗口复用未另计 (保守, R6①)。分组追求"最小 L2 替换": 一次只让一组的工作集占 L2。 +S_C (双侧均不可全驻留) 时, 在**整 L2 容量约束**下搜索最小 GM 的分组 +(取代旧版 "L2/2 对半预算 + 组内窗口流量零计" 口径; 每 batch 计算, 全 case ×b): + +- 容量约束: m_grp·block_a + n_grp·block_b ≤ L2 (组工作集可占满整 L2); +- 目标: GM = ⌈n_cnt/n_grp⌉·a_b + ⌈m_cnt/m_grp⌉·b_b **最小** + (A 行块在其列组内一次 GM 首读、B 列块在其行组内一次 GM 首读; GM ≥ V_in); +- 窗口 L2: (n_cnt − ⌈n_cnt/n_grp⌉)·a_b + (m_cnt − ⌈m_cnt/m_grp⌉)·b_b + (组内共享块其余次复用走 L2 读口, 与 S_B 口径一致); +- 无可行分组 (单块对都超 L2) 时保守回落: 每共享块独立落 GM (⌈·⌉ = n_cnt/m_cnt), 窗口不计。 + +分组追求"最小 L2 替换": 一次只让一组的工作集占 L2, 组间共享块落空回 GM。 ### 4.4 字节列与计数列语义 (修正 ①, 整芯片口径) @@ -157,9 +170,9 @@ dma_cmd_count 为**单核**命令数 (各核 DMA 引擎并行执行, 墙钟 T_cm | 分支 | GM 读 (芯片) | L2 读 (芯片) | 输出 | |---|---|---|---| -| MergeBatch | V_in (K截断); V_in·ceil(K/k_L1)·k_L1/K (L1绑定 padding, 模型按整段计) | 0 | S_A→L2 写口; else GM | -| IterBatch | V_in (a/b 形态); 同上 padding 式 (c/d) | 0 | 同 MergeBatch | -| ASW 切M/N | S_A/B: V_in; S_C: r_gm·V_in | S_A/B: b·[(n_cnt−1)·a_b + (m_cnt−1)·b_b] | S_A→L2; else GM | +| MergeBatch | V_in (每字节恰一次; K 截断/L1 绑定均无重复读, issue#31) | 0 | S_A→L2 写口; else GM | +| IterBatch | V_in (a/b/c/d 各形态均每字节恰一次, issue#31) | 0 | 同 MergeBatch | +| ASW 切M/N | S_A/S_B: V_in; S_C: b·[⌈n_cnt/n_grp⌉·a_b + ⌈m_cnt/m_grp⌉·b_b] (最小替换分组) | S_A/S_B: b·[(n_cnt−1)·a_b + (m_cnt−1)·b_b]; S_C: b·[(n_cnt−⌈n_cnt/n_grp⌉)·a_b + (m_cnt−⌈m_cnt/m_grp⌉)·b_b] | S_A→L2; else GM | | StreamK | V_in (组间共享命中) | b·[(n_cnt−1)·a_b + (m_cnt−1)·b_b] (命中时) | 最终写回: S_A(+ws)→L2; else GM | | 特殊分支 | K=1: V_in; K=0: 0 | 0 | S_A→L2 写口; else GM (K=0 只有输出) | | 转Matmul | V_in (折叠后) | 0 | S_A→L2; else GM | diff --git a/BMM/BMM_Theory/examples/plans.csv b/BMM/BMM_Theory/examples/plans.csv index 293db8b..5c49856 100644 --- a/BMM/BMM_Theory/examples/plans.csv +++ b/BMM/BMM_Theory/examples/plans.csv @@ -7,7 +7,7 @@ merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮 iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留 iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM" streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" -asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=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可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留 b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留" b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留 -b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=3591.0MB, V_out=8.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮" b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留" b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM" -b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留" -b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB), 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) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2048.0MB, V_out=256.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=96.0MB, V_out=1024.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=512.0MB, V_out=32.0MB, L2=128MB), 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(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=272.0MB, V_out=1024.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=128.1MB, V_out=128.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=516.0MB, V_out=2048.0MB, L2=128MB), 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) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), 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) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB), 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) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB), GM首读倍率=4.76; 尾轮: 周长型主导, 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可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)" +b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)" +b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)" +b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)" b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" -b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=7168.0MB, V_out=896.0MB, L2=128MB), 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) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16.0MB, V_out=256.0MB, L2=128MB), 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) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB), GM首读倍率=2.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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮" +b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮" 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 cab5597..fcbe85e 100644 --- a/BMM/BMM_Theory/examples/result_evaluate.csv +++ b/BMM/BMM_Theory/examples/result_evaluate.csv @@ -7,39 +7,39 @@ merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,m iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=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可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留,2228224,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,16777216.0,3.452102057613169e-08,65536,1.2603076923076923e-08,0.0,1.44264e-06,4.712409749920861e-08,1.4897640974992086e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",25067520,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.5967200000000002e-05,1.798661348528015e-07,1.6147066134852802e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",17825792,0.0,1.114112e-05,0.0,1.1441120000000001e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.1441120000000001e-05,1.798661348528015e-07,1.1620986134852803e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留,13107200,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,100663296.0,2.0712612345679012e-07,393216,7.561846153846153e-08,0.0,8.392e-06,7.068614624881291e-08,8.462686146248813e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=3591.0MB, V_out=8.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.731729603729604e-06,0.00033558528,1.731729603729604e-06,0.0003373170096037296,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b16_m2_n4096_k7168,16,16,2,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",939982848,0,0.00058748928,0.0,0.00058748928,0.0,0.0,1879048192.0,3.866354304526749e-06,0.0,0.0,1.7726896037296038e-06,0.00058748928,1.7726896037296038e-06,0.0005892619696037297,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.705016e-05,6.027486369104147e-07,3.7652908636910414e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.670016e-05,0.0,3.7050160000000004e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.7050160000000004e-05,6.027486369104147e-07,3.765290863691042e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.00117440512,0.0,0.0011856051200000001,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" +b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b32_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留",67108864,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,34359738368.0,7.06990501399177e-05,67108864,1.290555076923077e-05,0.0,7.06990501399177e-05,2.1742932036720483e-05,9.244198217663819e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" -b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB), 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) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2048.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=96.0MB, V_out=1024.0MB, L2=128MB), 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.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=512.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=272.0MB, V_out=1024.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=128.1MB, V_out=128.0MB, L2=128MB), 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,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=516.0MB, V_out=2048.0MB, L2=128MB), 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) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), 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) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB), 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) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB), 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 交叉项) 可消除" +b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,172872433664,0.00352321536,0.03324469878153846,0.03676791414153846,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.03811009142153846,0.0,0.03811009142153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",70866960384,1536524550144,0.04429185024,0.2954854904123077,0.3397773406523077,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.3505147588923077,0.0,0.3505147588923077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.566079254079254e-07,0.00011042185846153846,2.566079254079254e-07,0.00011067846638694638,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=7168.0MB, V_out=896.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16.0MB, V_out=256.0MB, L2=128MB), 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,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" -b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB), 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 交叉项) 可消除" +b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,345744867328,0.00469762048,0.06648939756307692,0.07118701804307692,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.07387137260307693,0.0,0.07387137260307693,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" +b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,1382979469312,0.01879048192,0.2659575902523077,0.2847480721723077,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.2954854904123077,0.0,0.2954854904123077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,9.92969696969697e-06,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" diff --git a/BMM/BMM_Theory/examples/result_recommend.csv b/BMM/BMM_Theory/examples/result_recommend.csv index 9553e45..93a3616 100644 --- a/BMM/BMM_Theory/examples/result_recommend.csv +++ b/BMM/BMM_Theory/examples/result_recommend.csv @@ -7,39 +7,39 @@ merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,m iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" -asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), 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,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00= 256B/dtype 且 grid_K>=2) -b4_m1_n128_k256,4,4,1,128,256,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) -b8_m2_n192_k128,8,8,2,192,128,bf16,bf16,bf16,False,False,False,True,0,b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) -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,resident(整case全驻留S_A),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) +asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=64.0MB, V_out=256.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.06= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00= 256B/dtype 且 grid_K>=2) +b4_m1_n128_k256,4,4,1,128,256,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) +b8_m2_n192_k128,8,8,2,192,128,bf16,bf16,bf16,False,False,False,True,0,b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,resident(整case全驻留S_A),0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) +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,resident(整case全驻留S_A),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),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留,2228224,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,16777216.0,3.452102057613169e-08,65536,1.2603076923076923e-08,0.0,1.44264e-06,4.712409749920861e-08,1.4897640974992086e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 -b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",25067520,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.5967200000000002e-05,1.798661348528015e-07,1.6147066134852802e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 +b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留",17825792,0.0,1.114112e-05,0.0,1.1441120000000001e-05,6,3.0000000000000004e-07,268435456.0,5.52336329218107e-07,524288,1.0082461538461538e-07,0.0,1.1441120000000001e-05,1.798661348528015e-07,1.1620986134852803e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留,13107200,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,100663296.0,2.0712612345679012e-07,393216,7.561846153846153e-08,0.0,8.392e-06,7.068614624881291e-08,8.462686146248813e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 -b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=3591.0MB, V_out=8.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B" +b32_m16_n8192_k7168,32,32,16,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m16_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,1,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=3591.0MB, V_out=8.0MB, L2=128MB); 尾轮: r=0 无尾轮",3765436416,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,5.24288e-06,0.0,0.0024235716923076923,0.0,0.0024235716923076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B" b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.731729603729604e-06,0.00033558528,1.731729603729604e-06,0.0003373170096037296,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" b16_m2_n4096_k7168,16,16,2,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",939982848,0,0.00058748928,0.0,0.00058748928,0.0,0.0,1879048192.0,3.866354304526749e-06,0.0,0.0,1.7726896037296038e-06,0.00058748928,1.7726896037296038e-06,0.0005892619696037297,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=16)" -b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.705016e-05,6.027486369104147e-07,3.7652908636910414e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 -b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,仅 IterBatch 条件满足 -b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m64_n64_k7168,32,32,64,64,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留",58720256,0.0,3.670016e-05,0.0,3.7050160000000004e-05,7,3.5000000000000004e-07,1879048192.0,3.866354304526749e-06,262144,5.041230769230769e-08,0.0,3.7050160000000004e-05,6.027486369104147e-07,3.765290863691042e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 +b64_m1024_n1024_k7168,64,64,1024,1024,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n1024_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,1024,1024,7168,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM",1879048192,0.0,0.00117440512,0.0,0.0011856051200000001,224,1.1200000000000001e-05,962072674304.0,0.0019795734039176954,134217728,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,仅 IterBatch 条件满足 +b128_m2048_n2048_k1536,128,128,2048,2048,1536,bf16,bf16,bf16,False,False,False,True,0,b128_m2048_n2048_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",1610612736,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.00067108864,0.0,0.005084787003076923,0.0,0.005084787003076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m1024_n8192_k2048,64,64,1024,8192,2048,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",2415919104,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.00067108864,0.0,0.006620547544615385,0.0,0.006620547544615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" b32_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留",67108864,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,34359738368.0,7.06990501399177e-05,67108864,1.290555076923077e-05,0.0,7.06990501399177e-05,2.1742932036720483e-05,9.244198217663819e-05,MMAD,True,,计算Bound,仅 IterBatch 条件满足 -b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB), 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) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2048.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=96.0MB, V_out=1024.0MB, L2=128MB), 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.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=512.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=272.0MB, V_out=1024.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=128.1MB, V_out=128.0MB, L2=128MB), 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,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=516.0MB, V_out=2048.0MB, L2=128MB), 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) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), 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) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB), 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输入驻留(整case超L2, 输出直写GM) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB), 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) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB), 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_归约代价可接受) +b128_m4096_n4096_k8192,128,128,4096,4096,8192,bf16,bf16,bf16,False,False,False,True,0,b128_m4096_n4096_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2304,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",17179869184,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m8192_n4096_k7168,32,32,8192,4096,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB); 尾轮: r=0 无尾轮",5637144576,172872433664,0.00352321536,0.03324469878153846,0.03676791414153846,0.0,0.0,15393162788864.0,0.031673174462683126,2147483648,0.00134217728,0.0,0.03811009142153846,0.0,0.03811009142153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m2048_n2048_k8192,32,32,2048,2048,8192,bf16,bf16,bf16,False,False,False,True,0,b32_m2048_n2048_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,12,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2048.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",2147483648,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,0.00016777216,0.0,0.006052703310769231,0.0,0.006052703310769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m4096_n2048_k128,64,64,4096,2048,128,bf16,bf16,bf16,False,False,False,True,0,b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=96.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",100663296,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.00067108864,0.0,0.0010243780923076921,0.0,0.0010243780923076921,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b16_m1024_n1024_k8192,16,16,1024,1024,8192,bf16,bf16,bf16,False,False,False,True,0,b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=512.0MB, V_out=32.0MB, L2=128MB); 尾轮: r=0 无尾轮",536870912,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.0008727378707692308,0.0,0.0008727378707692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m32768_n128_k128,4,4,32768,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b8_m32768_n2048_k512,8,8,32768,2048,512,bf16,bf16,bf16,False,False,False,True,0,b8_m32768_n2048_k512,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,512,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,561,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=272.0MB, V_out=1024.0MB, L2=128MB); 尾轮: r=0 无尾轮",285212672,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m131072_n128_k128,4,4,131072,128,128,bf16,bf16,bf16,False,False,False,True,0,b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=128.1MB, V_out=128.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,8.388608e-05,0.0,0.00018660745846153846,0.0,0.00018660745846153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b8_m131072_n1024_k256,8,8,131072,1024,256,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n1024_k256,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,256,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,820,7,1,820,7,16,1118,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=516.0MB, V_out=2048.0MB, L2=128MB); 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b16_m32768_n8192_k7168,16,16,32768,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b16_m32768_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,52,1,205,52,16,4395,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.50= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=2056.0MB, V_out=32.0MB, L2=128MB); 尾轮: 周长型主导, rho=0.38= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB); 尾轮: r=0 无尾轮",1140850688,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB); 尾轮: r=0 无尾轮",8053063680,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b8_m131072_n8192_k8192,8,8,131072,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b8_m131072_n8192_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A1b,2,2,1,2,2,24,8754,True,2,"L2场景: C_双侧超L2: 最小替换2D分组(组间落空GM, 窗口L2) (V_in=17408.0MB, V_out=16384.0MB, L2=128MB); 最小替换分组 m_grp=22x n_grp=24 (GM倍率3.88, 窗口L2/batch=183168.0MB); 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",70866960384,1536524550144,0.04429185024,0.2954854904123077,0.3397773406523077,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.3505147588923077,0.0,0.3505147588923077,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.566079254079254e-07,0.00011042185846153846,2.566079254079254e-07,0.00011067846638694638,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=2)" -b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=7168.0MB, V_out=896.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" -b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB), 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吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16.0MB, V_out=256.0MB, L2=128MB), 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,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) -b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB), 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" +b64_m1024_n7168_k7168,64,64,1024,7168,7168,bf16,bf16,bf16,False,False,False,True,0,b64_m1024_n7168_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,41,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=896.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00058720256,0.0,0.018835651347692307,0.0,0.018835651347692307,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b32_m8192_n8192_k7168,32,32,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b32_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,2209,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB); 尾轮: r=0 无尾轮",7516192768,345744867328,0.00469762048,0.06648939756307692,0.07118701804307692,0.0,0.0,30786325577728.0,0.06334634892536625,4294967296,0.00268435456,0.0,0.07387137260307693,0.0,0.07387137260307693,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" +b8_m4096_n4096_k128,8,8,4096,4096,128,bf16,bf16,bf16,False,False,False,True,0,b8_m4096_n4096_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=16.0MB, V_out=256.0MB, L2=128MB); 尾轮: r=0 无尾轮",16777216,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,0.00016777216,0.0,0.0002524648369230769,0.0,0.0002524648369230769,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) +b128_m8192_n8192_k7168,128,128,8192,8192,7168,bf16,bf16,bf16,False,False,False,True,0,b128_m8192_n8192_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"direct_gm(输出直写GM, 输入优先驻留L2)",4,0,A0,1,1,1,0,0,0,8836,True,2,"L2场景: B_单batch可驻留(全驻留或单侧驻留+对侧滑窗) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB); 尾轮: r=0 无尾轮",30064771072,1382979469312,0.01879048192,0.2659575902523077,0.2847480721723077,0.0,0.0,123145302310912.0,0.253385395701465,17179869184,0.01073741824,0.0,0.2954854904123077,0.0,0.2954854904123077,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,9.92969696969697e-06,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"K=1逐元素乘, 走AIV向量通路" diff --git a/BMM/BMM_Theory/tests/test_branches.py b/BMM/BMM_Theory/tests/test_branches.py index e910228..6a4c45b 100644 --- a/BMM/BMM_Theory/tests/test_branches.py +++ b/BMM/BMM_Theory/tests/test_branches.py @@ -250,9 +250,23 @@ class TestIssueRegression2(unittest.TestCase): def test_issue13_router_fallback_when_winner_infeasible(self): # issue#13: 仲裁胜出的 MergeBatch 自检违规时, 回退到可行候选 IterBatch + # (issue#31 后该样例 MergeBatch 时延已不再胜出, 用 mock 压低其时延以固定 + # "胜者违规 -> 回退" 机制路径; MergeBatch 方案 dValue=112B<128 仍违规) + from unittest import mock + from bmm_theory.branches.merge_batch import MergeBatchBranch from bmm_theory.constraints import check_plan_constraints - case = mkcase(256, 1, 256, 4096, dtype_a="int8", dtype_b="int8") # 原 0.2% 违规样例 - r = self.router.route(case) + case = mkcase(256, 1, 256, 4096, dtype_a="int8", dtype_b="int8") + mb_plan = MergeBatchBranch().analyze(case).plan + self.assertTrue(check_plan_constraints(case, mb_plan), + "该样例 MergeBatch 方案应仍自检违规 (dValue)") + real_eval = MergeBatchBranch.evaluate + + def fake_win(self, c, p): + t = real_eval(self, c, p) + t.t_total = 1e-9 # 强制 MergeBatch 时延胜出 -> 仲裁选它 -> 走自检/回退 + return t + with mock.patch.object(MergeBatchBranch, "evaluate", fake_win): + r = self.router.route(case) self.assertEqual(r["branch"], "IterBatch") # 回退 self.assertIn("自检违规", r["arbitration"]) self.assertIn("回退", r["arbitration"]) @@ -592,5 +606,96 @@ class TestIssue27to30(unittest.TestCase): big.output_bytes / self.s.bw_gm) +class TestIssue31to32(unittest.TestCase): + """第五轮评审: #31 切B类 GM 每字节恰读一次 = V_in; #32 ASW 场景升级 + (单侧全驻留 -> S_B 使 GM=V_in; 双侧超 L2 -> S_C 最小替换 2D 分组 + 窗口 L2 计账).""" + + def setUp(self): + from bmm_theory.hardware import ASCEND950PR + self.s = ASCEND950PR + self.router = BranchRouter() + + # ---------------- #31 ---------------- + def test_issue31_iter_form_c_gm_equals_vin(self): + # b64_m16_n256_k512: 形态 c, K=512 切 n_K=3 (k_L1=240) 非整除 -> GM 仍 = V_in + from bmm_theory.branches.iter_batch import IterBatchBranch + case = mkcase(64, 16, 256, 512) + ib = IterBatchBranch().analyze(case) + self.assertIn("c_", ib.plan.l1_form) + self.assertLess(ib.plan.k_l1, case.k) + t = ib.timing + self.assertAlmostEqual(t.gm_read_bytes, case.input_bytes) + self.assertAlmostEqual(t.l2_read_bytes, 0.0) + self.assertAlmostEqual(t.t_mte2_gm, case.input_bytes / self.s.bw_gm) + + def test_issue31_iter_form_d_gm_equals_vin(self): + # K=5000 非整除切段 (k_L1=1024, n_K=5, 末段剩 904): GM 仍恰一次 = V_in + from bmm_theory.branches.iter_batch import IterBatchBranch + case = mkcase(128, 64, 64, 5000) + ib = IterBatchBranch().analyze(case) + self.assertIn("d_", ib.plan.l1_form) + self.assertLess(ib.plan.k_l1, case.k) + self.assertAlmostEqual(ib.timing.gm_read_bytes, case.input_bytes) + self.assertAlmostEqual(ib.timing.t_mte2_gm, + case.input_bytes / self.s.bw_gm) + + def test_issue31_merge_l1_bound_gm_equals_vin(self): + # MergeBatch L1 绑定 (k_L1 L2, 但 B=58.7MB 可全驻留 + # + A 行块滑窗 (58.7+2x2.5 <= 128) -> S_B: GM = V_in, 重复读全命中 L2 + case = mkcase(32, 8192, 4096, 7168) + r = self.router.route(case) + self.assertEqual(r["branch"], "ASW_Basic") + p, t = r["plan"], r["timing"] + a_b = case.m * case.k * case.dtype_in_bytes + bb_b = case.k * case.n * case.dtype_in_bytes + m_cnt, n_cnt = p.m_cnt, p.n_cnt + self.assertGreater(a_b + bb_b, self.s.l2_bytes) # 单 batch 确实超 L2 + self.assertLessEqual(bb_b + 2 * (a_b / m_cnt), + self.s.l2_bytes) # 单侧全驻留成立 + self.assertAlmostEqual(t.gm_read_bytes, case.input_bytes) + exp_l2 = case.batch_c * ((n_cnt - 1) * a_b + (m_cnt - 1) * bb_b) + self.assertAlmostEqual(t.l2_read_bytes, exp_l2) + + def test_issue32_asw_scene_c_min_gm(self): + # b8_m131072_n8192_k8192: 双侧均不可全驻留 -> S_C 最小替换分组; + # gm == 容量约束最小解 (测试内复算), 且 >= V_in + case = mkcase(8, 131072, 8192, 8192) + r = self.router.route(case) + self.assertEqual(r["branch"], "ASW_Basic") + p, t = r["plan"], r["timing"] + self.assertIn("C_", p.note) + m_cnt, n_cnt = p.m_cnt, p.n_cnt + dt = case.dtype_in_bytes + a_b = case.m * case.k * dt + bb_b = case.k * case.n * dt + blk_a = a_b / m_cnt + blk_b = bb_b / n_cnt + best = None + for mg in range(1, m_cnt + 1): + for ng in range(1, n_cnt + 1): + if mg * blk_a + ng * blk_b > self.s.l2_bytes: + continue + gm = (n_cnt + ng - 1) // ng * a_b + (m_cnt + mg - 1) // mg * bb_b + if best is None or gm < best: + best = gm + self.assertIsNotNone(best) + self.assertAlmostEqual(t.gm_read_bytes, case.batch_c * best) + self.assertGreaterEqual(t.gm_read_bytes, case.input_bytes) + # 最小替换解应严格优于"每块独立落 GM"的保守上界 + self.assertLessEqual(t.gm_read_bytes, + case.batch_c * (n_cnt * a_b + m_cnt * bb_b)) + + if __name__ == "__main__": unittest.main()