admin/matmul-analysis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix #27-#30: dtype感知算力(Cube/AIV速率表) / GM首读下限与整芯片字节列口径+设计文档 / Fixpipe输出落点R4(整case驻留L2否则直写GM) / MergeBatch Cube公式复核注释

Browse Source 
- docs/05_L2驻留GM读写与dtype算力口径_设计分析.md: R1-R6公理、S_A/S_B/S_C场景、输出落点R4、dtype速率表(白皮书出处+待标定假设)、逐分支GM/L2归属表 (issue#29/#30 先文档后代码)
- hardware: CUBE_DTYPE_FACTOR(f16/bf16=1, fp8=2x, fp4=4x, fp32=1/2假设) + AIV_DTYPE_FACTOR + q_cube/aiv_elem_rate (issue#28)
- 全分支 t_mmad/t_comp/drain/尾轮主导项/θ_c/R16 语义按输入dtype取算力; 混精度取慢侧; StreamK归约保持fp32(AIV fp32部分和)
- Fixpipe输出落点R4: to_l2 <=> V_in+V_out(+workspace)<=L2; 否则直写GM计入共享总线; ASW场景改S_A整case全驻留(原单batch驻留判定漏计整case输出累积逐出)
- 字节列统一整芯片口径(gm/l2/fix/cube_flops), dma_cmd_count注明单核; GM>=V_in不变量入测试; MergeBatch每步flops=2(b0M)(b0N)K公式注释显式化(#27复核与CSV一致无数值改动)
- tests 39->49 全过; 双压力seed7/6000+seed2024/4000: 0违规/0占位/0NaN/0GM<输入; examples三件套重生成且可复现0diff
This commit is contained in:
admin
2026-09-04 16:26:10 +08:00
parent 4843053ad3
commit b9e07edc1d
15 changed files with 793 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
BMM/BMM_Theory/README.md
View File

@@ -54,6 +54,9 @@ python -m unittest discover -s tests -v
- **Cube 计算** `t_mmad`: 芯片算力 ≈486 TFLOPS (单核 ≈15.2 TFLOPS), MergeBatch 冗余计算计入; - **Cube 计算** `t_mmad`: 芯片算力 ≈486 TFLOPS (单核 ≈15.2 TFLOPS), MergeBatch 冗余计算计入;
- **Fixpipe 搬出**: 直写 GM 计入 GM 共享总线; 驻留 L2 走 5.2TB/s 写口 (独立计时); 数据量按 **C 矩阵 dtype** 计 (fp16/fp8 随路转换减半); StreamK 部分和按 4B (L0C dtype); - **Fixpipe 搬出**: 直写 GM 计入 GM 共享总线; 驻留 L2 走 5.2TB/s 写口 (独立计时); 数据量按 **C 矩阵 dtype** 计 (fp16/fp8 随路转换减半); StreamK 部分和按 4B (L0C dtype);
- **总时延** `t_total = max(MTE2搬移链, MMAD, Fixpipe-L2) + t_drain` (稳态取最大 + 末级排空暴露; REDUCE 串行追加); - **总时延** `t_total = max(MTE2搬移链, MMAD, Fixpipe-L2) + t_drain` (稳态取最大 + 末级排空暴露; REDUCE 串行追加);
- **GM 读取下限**: 每输入字节至少从 GM 读一次 (R1); L2 只吸收"驻留后的再次读取"; 整 case 输入+输出 ≤ L2 时 GM 恰读一次、输出全驻留 L2 (issue#29 设计文档 docs/05);
- **Fixpipe 输出落点**: 整 case (输入+输出+workspace) 可驻留 L2 → 输出写 L2 写口 5.2TB/s、GM 写流量 0; 否则输入优先保 L2, 输出直写 GM 计入共享总线 (issue#30);
- **算力按输入 dtype**: Cube BF16/FP16 486TFLOPS 为基准, fp8=2x/fp4=4x (白皮书), fp32=1/2 (假设待标定); AIV 逐元素通量同理 (issue#28);
- **瓶颈交换**: 搬移瓶颈可牺牲算力换搬移效率 (MergeBatch), 计算瓶颈可牺牲搬移换计算效率 (ASW_Basic 切 M/N). - **瓶颈交换**: 搬移瓶颈可牺牲算力换搬移效率 (MergeBatch), 计算瓶颈可牺牲搬移换计算效率 (ASW_Basic 切 M/N).
## 目录结构 ## 目录结构
@@ -89,6 +92,7 @@ BMM_Theory/
│ │ ├── 06_ASW_Basic分支.md # 尾轮策略已内化为其必要环节 │ │ ├── 06_ASW_Basic分支.md # 尾轮策略已内化为其必要环节
│ │ └── 07_尾轮处理策略.md # 尾轮完整推导 (参考) │ │ └── 07_尾轮处理策略.md # 尾轮完整推导 (参考)
│ └── 03_测评报告/ # 外部测评报告 (v1.0/v2.0 及后续复评) │ └── 03_测评报告/ # 外部测评报告 (v1.0/v2.0 及后续复评)
│ └── 05_L2驻留GM读写与dtype算力口径_设计分析.md # GM/L2/输出落点/dtype算力统一口径 (issue#27-#30)
├── examples/ # 示例输入输出 ├── examples/ # 示例输入输出
└── tests/ # 单元测试 (固化文档边界 case + issue 回归) └── tests/ # 单元测试 (固化文档边界 case + issue 回归)
``` ```

101
BMM/BMM_Theory/bmm_theory/branches/asw_basic.py
View File

@@ -80,22 +80,14 @@ class AswBasicBranch(Branch):
# Step 4: swizzle 窗口 W = max{d | d|C, d <= floor(sqrt(C))} # Step 4: swizzle 窗口 W = max{d | d|C, d <= floor(sqrt(C))}
swizzle_w = self._swizzle_w() swizzle_w = self._swizzle_w()
# Step 5: L2 分组判断 (issue#24: 按单 batch 工作集判定, 同一时刻单 batch 激活) # Step 5: L2 场景判定 (issue#24/#30, 设计文档 docs/05 §4, 芯片 L2 128MB)
a_b = m * k * dt # S_A 整case全驻留: V_in+V_out <= L2 -> 输出驻留 L2 (R4, GM 写=0);
bb_b = k * n * dt # S_B 整case超L2但单batch输入可驻留: batch 内共享块重复读命中 L2, 输出直写 GM;
out_batch = m * n * case.dtype_out_bytes # S_C 单batch输入超L2: 分组执行 (工作集), 组间共享块落空回 GM (r_gm).
if a_b + bb_b + out_batch <= s.l2_bytes: scene = self._l2_scene(case, single_m, single_n)
l2_scene = "A_单batch全驻留(输入+输出)" l2_out = ("resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0)"
l2_out = "resident(输出驻留L2异步回写)" if scene["to_l2"] else
r_in = 1.0 "direct_gm(输出直写GM, 输入优先驻留L2)")
elif a_b + bb_b <= s.l2_bytes:
l2_scene = "B_单batch输入驻留输出直写GM"
l2_out = "direct_gm(输出直写GM不占L2)"
r_in = 1.0
else:
l2_scene = "C_单batch输入超L2分组执行"
l2_out = "direct_gm(输出直写GM不占L2)"
r_in = self._l2_group_r_gm(case, single_m, single_n)
# Step 6: k_l1 (GM->L1 K 向粒度, 须 >= dValue 下限; K 小于下限时整 K 一次搬入不切) # Step 6: k_l1 (GM->L1 K 向粒度, 须 >= dValue 下限; K 小于下限时整 K 一次搬入不切)
dv_min_elems = max(s.dvalue_hw_min // dt, 1) dv_min_elems = max(s.dvalue_hw_min // dt, 1)
@@ -125,7 +117,9 @@ class AswBasicBranch(Branch):
tail_block_cnt=tail["r"], tail_wave_num=tail["n_wave"], tail_block_cnt=tail["r"], tail_wave_num=tail["n_wave"],
fixpipe_unitflag=True, fixpipe_unitflag=True,
out_dtype_bytes=case.dtype_out_bytes, out_dtype_bytes=case.dtype_out_bytes,
note=f"L2场景{l2_scene}, GM首读倍率={r_in:.2f}; 尾轮: {tail['reason']}", 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']}"),
) )
# ------------------------------------------------------------------ # ------------------------------------------------------------------
@@ -143,6 +137,7 @@ class AswBasicBranch(Branch):
single_m, single_n = clamp_base_mn_l0c(single_m, single_n, False, s) single_m, single_n = clamp_base_mn_l0c(single_m, single_n, False, s)
# base_k 由 L0A/L0B 容量按 dtype 反推 (issue#5: 原硬编码 min(K,64) 在 fp32 下溢出) # base_k 由 L0A/L0B 容量按 dtype 反推 (issue#5: 原硬编码 min(K,64) 在 fp32 下溢出)
base_k = clamp_base_k(single_m, single_n, dt, case.k, s) base_k = clamp_base_k(single_m, single_n, dt, case.k, s)
out_l2 = case.input_bytes + case.output_bytes <= s.l2_bytes # R4 (issue#30)
return ImplPlan( return ImplPlan(
case_id=case.case_id, branch=self.name + "_降核", case_id=case.case_id, branch=self.name + "_降核",
used_core_num=used, used_core_num=used,
@@ -155,7 +150,9 @@ class AswBasicBranch(Branch):
l1_form="标准核内流水", l1_form="标准核内流水",
base_m=single_m, base_n=single_n, base_m=single_m, base_n=single_n,
base_k=base_k, base_k=base_k,
l2_policy_in="allocate", l2_policy_out="direct_gm", l2_policy_in="allocate",
l2_policy_out=("resident(整case全驻留S_A)"
if out_l2 else "direct_gm(输出直写GM)"),
swizzle_w=0, workspace_bytes=0, swizzle_w=0, workspace_bytes=0,
tail_strategy="不涉及(每核一块无尾轮)", tail_strategy="不涉及(每核一块无尾轮)",
fixpipe_unitflag=True, out_dtype_bytes=case.dtype_out_bytes, fixpipe_unitflag=True, out_dtype_bytes=case.dtype_out_bytes,
@@ -190,6 +187,31 @@ class AswBasicBranch(Branch):
w = d w = d
return w return w
def _l2_scene(self, case: BmmCase, sm: int, sn: int) -> dict:
"""L2 场景判定 (make_plan 与 evaluate 共用, 设计文档 docs/05 §4.1).
判定顺序 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 = 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 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:
return {"code": "S_B",
"label": "B_单batch输入驻留(整case超L2, 输出直写GM)",
"to_l2": False, "r_gm": 1.0}
return {"code": "S_C",
"label": "C_单batch输入超L2分组执行(组间落空回GM)",
"to_l2": False, "r_gm": self._l2_group_r_gm(case, sm, sn)}
def _l2_group_r_gm(self, case, sm, sn) -> float: def _l2_group_r_gm(self, case, sm, sn) -> float:
"""场景 C (单 batch 输入仍超 L2): 分组执行的 GM 重复读倍率. """场景 C (单 batch 输入仍超 L2): 分组执行的 GM 重复读倍率.
@@ -227,7 +249,8 @@ class AswBasicBranch(Branch):
# 主导项判定 # 主导项判定
bw_eff = s.bw_l2_pc # L2 命中 bw_eff = s.bw_l2_pc # L2 命中
t_mmad = 2 * sm * sn * case.k / s.q16 qc = s.q_cube(case.dtype_a, case.dtype_b) # issue#28
t_mmad = 2 * sm * sn * case.k / qc
t_mte2 = case.k * (sm + sn) * dt / bw_eff t_mte2 = case.k * (sm + sn) * dt / bw_eff
t_fix = sm * sn * out_b / s.bw_pc t_fix = sm * sn * out_b / s.bw_pc
t_block = max(t_mmad, t_mte2, t_fix) t_block = max(t_mmad, t_mte2, t_fix)
@@ -268,15 +291,17 @@ class AswBasicBranch(Branch):
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming:
"""MTE2 两段块级模型 (issue#24, 用户澄清): """MTE2 两段块级模型 (issue#24 用户口径 + #28/#29/#30):
- 首读走 GM (按 GM 带宽, 不叠加 L2); 共享块 (A 行块被 n_cnt 个 tile 读、 - 首读走 GM (按 GM 带宽, 不叠加 L2); 共享块 (A 行块被 n_cnt 个 tile 读、
B 列块被 m_cnt 个 tile 读) 驻留 L2 后其余 (n_cnt-1)/(m_cnt-1) 次读走 B 列块被 m_cnt 个 tile 读) 驻留 L2 后其余 (n_cnt-1)/(m_cnt-1) 次读走
L2 读口 (5.2TB/s 独享) —— 场景 A/B (单 batch 工作集可驻留); L2 读口 (5.2TB/s 独享) —— 场景 S_A/S_B (单 batch 工作集可驻留);
- 单 batch 输入超 L2 -> 场景 C 分组执行, GM 重复按组间落空计 (r_gm), 窗口内 - 单 batch 输入超 L2 -> 场景 S_C 分组执行, GM 重复按组间落空计 (r_gm),
复用未另计 (保守); 窗口内复用未另计 (保守);
- 输出: 场景 A 驻留 L2 (5.2 写口) / 场景 B,C 直写 GM —— GM 读写共享总线 - 输出落点 R4 (issue#30): 仅 S_A (整 case 输入+输出 <= L2) 驻留 L2
累加由 assemble 的 MTE2 链处理 (issue#23). (5.2 写口, GM 写 = 0); S_B/S_C 直写 GM —— GM 读写共享总线累加由
assemble 的 MTE2 链处理 (issue#23);
- 字节列整芯片口径 (issue#29); Cube 算力按输入 dtype (issue#28).
""" """
s = self.spec s = self.spec
b = case.batch_c b = case.batch_c
@@ -284,37 +309,33 @@ class AswBasicBranch(Branch):
dt = case.dtype_in_bytes dt = case.dtype_in_bytes
out_b = case.dtype_out_bytes out_b = case.dtype_out_bytes
used = max(plan.used_core_num, 1) used = max(plan.used_core_num, 1)
qc = s.q_cube(case.dtype_a, case.dtype_b)
flops = 2.0 * b * m * n * k flops = 2.0 * b * m * n * k
t_mmad = flops / (used * s.q16) t_mmad = flops / (used * qc)
# ---- 字节量 (每 batch 口径) ---- # ---- 字节量 (整芯片口径) ----
a_b = m * k * dt # 每 batch A 字节 a_b = m * k * dt # 单 batch A 字节
bb_b = k * n * dt # 每 batch B 字节 bb_b = k * n * dt # 单 batch B 字节
out_all = b * m * n * out_b # 输出总字节 out_all = b * m * n * out_b # 输出总字节
m_cnt = max(plan.m_cnt, 1) m_cnt = max(plan.m_cnt, 1)
n_cnt = max(plan.n_cnt, 1) n_cnt = max(plan.n_cnt, 1)
# ---- 场景判定: 按单 batch 工作集 (同一时刻单 batch 激活) ---- # ---- L2 场景 (S_A/S_B/S_C, 与 make_plan 同源) ----
if a_b + bb_b + m * n * out_b <= s.l2_bytes: scene = self._l2_scene(case, plan.single_core_m, plan.single_core_n)
scene, to_l2, r_gm = "A_单batch全驻留(输入+输出)", True, 1.0 to_l2, r_gm = scene["to_l2"], scene["r_gm"]
elif a_b + bb_b <= s.l2_bytes:
scene, to_l2, r_gm = "B_单batch输入驻留,输出直写GM", False, 1.0
else:
scene, to_l2, r_gm = "C_单batch输入超L2分组执行", False, \
self._l2_group_r_gm(case, plan.single_core_m, plan.single_core_n)
# ---- MTE2: GM 段 (首读, 每字节一次) + L2 段 (共享块重复读) ---- # ---- MTE2: GM 段 (首读, 每字节一次) + L2 段 (共享块重复读) ----
gm_read = r_gm * b * (a_b + bb_b) gm_read = r_gm * b * (a_b + bb_b)
if scene.startswith(("A_", "B_")): if scene["code"] in ("S_A", "S_B"):
# 驻留命中: A 行块被 n_cnt 个 tile 复用 -> 其余 (n_cnt-1) 次走 L2 读口 # 驻留命中: A 行块被 n_cnt 个 tile 复用 -> 其余 (n_cnt-1) 次走 L2 读口
l2_read = b * ((n_cnt - 1) * a_b + (m_cnt - 1) * bb_b) l2_read = b * ((n_cnt - 1) * a_b + (m_cnt - 1) * bb_b)
else: else:
l2_read = 0.0 # 场景 C: 组间复用落空(已计 GM), 窗口内复用保守不计 l2_read = 0.0 # 场景 S_C: 组间复用落空(已计 GM), 窗口内复用保守不计
t_gm = gm_read / (used * s.bw_pc) t_gm = gm_read / (used * s.bw_pc)
t_l2 = l2_read / (used * s.bw_l2_pc) t_l2 = l2_read / (used * s.bw_l2_pc)
# ---- Fixpipe ---- # ---- Fixpipe (R4) ----
t_fix = out_all / (used * (s.bw_l2_pc if to_l2 else s.bw_pc)) t_fix = out_all / (used * (s.bw_l2_pc if to_l2 else s.bw_pc))
# drain: 尾轮暴露 (方案 B 已均匀重切, drain 小; A1b 尾轮凑满, drain 小; A0 尾轮 r 核空转) # drain: 尾轮暴露 (方案 B 已均匀重切, drain 小; A1b 尾轮凑满, drain 小; A0 尾轮 r 核空转)

45
BMM/BMM_Theory/bmm_theory/branches/iter_batch.py
View File

@@ -13,7 +13,7 @@ from __future__ import annotations
from ..hardware import NpuSpec, ASCEND950PR from ..hardware import NpuSpec, ASCEND950PR
from ..models import BmmCase, ImplPlan, HardwareTiming, align_down from ..models import BmmCase, ImplPlan, HardwareTiming, align_down
from ..timing import assemble_timing from ..timing import assemble_timing, output_to_l2
from .base import Branch, BranchResult, ConditionCheck from .base import Branch, BranchResult, ConditionCheck
@@ -171,6 +171,12 @@ class IterBatchBranch(Branch):
form_name = {"a": "a_单batch全驻留", "b": "b_双batch乒乓", form_name = {"a": "a_单batch全驻留", "b": "b_双batch乒乓",
"c": "c_一侧驻留+对侧切K", "d": "d_两侧都切K"}[form] "c": "c_一侧驻留+对侧切K", "d": "d_两侧都切K"}[form]
# 输出落点 (issue#30, R4): 整 case 输入+输出 <= L2 才驻留 L2
out_l2 = output_to_l2(case, s)
l2_out = ("resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)"
if out_l2 else
"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)")
return ImplPlan( return ImplPlan(
case_id=case.case_id, branch=self.name, case_id=case.case_id, branch=self.name,
used_core_num=s.aic_num, used_core_num=s.aic_num,
@@ -181,54 +187,63 @@ class IterBatchBranch(Branch):
k_l1=k_l1, b_l1=2 if form == "b" else 1, l1_form=form_name, k_l1=k_l1, b_l1=2 if form == "b" else 1, l1_form=form_name,
base_m=base_m, base_n=base_n, base_k=base_k, base_m=base_m, base_n=base_n, base_k=base_k,
l2_policy_in="allocate(GM->L1随路驻留L2)", l2_policy_in="allocate(GM->L1随路驻留L2)",
l2_policy_out="direct_gm(输出仅写一次,直写GM不占L2)", l2_policy_out=l2_out,
swizzle_w=0, workspace_bytes=0, swizzle_w=0, workspace_bytes=0,
tail_strategy="不涉及(核内不切M/N)", tail_strategy="不涉及(核内不切M/N)",
fixpipe_unitflag=True, fixpipe_unitflag=True,
out_dtype_bytes=case.dtype_out_bytes, out_dtype_bytes=case.dtype_out_bytes,
note=form_desc, note=form_desc + f"; 输出落点: {'L2驻留' if out_l2 else '直写GM'}",
) )
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# 时延评估 (v1.1 §4 端到端模型, IterBatch 侧) # 时延评估 (v1.1 §4 端到端模型, IterBatch 侧)
# 口径: dtype 感知算力 (issue#28); 字节列整芯片 (issue#29);
# 输出落点 R4 (issue#30).
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming:
s = self.spec s = self.spec
m, n, k = case.m, case.n, case.k m, n, k = case.m, case.n, case.k
dt = case.dtype_in_bytes dt = case.dtype_in_bytes
out_b = case.dtype_out_bytes out_b = case.dtype_out_bytes
b = case.batch_c
b_core, k_l1 = plan.b_core, plan.k_l1 b_core, k_l1 = plan.b_core, plan.k_l1
qc = s.q_cube(case.dtype_a, case.dtype_b)
out_l2 = output_to_l2(case, s)
w_fix = s.bw_l2_pc if out_l2 else s.bw_pc
k_truncated = k_l1 >= k k_truncated = k_l1 >= k
n_k = 1 if k_truncated else -(-k // k_l1) n_k = 1 if k_truncated else -(-k // k_l1)
t_load = min(k_l1, k) * (m + n) * dt / s.bw_pc t_load = min(k_l1, k) * (m + n) * dt / s.bw_pc
t_comp_chunk = 2.0 * m * n * min(k_l1, k) / s.q16 t_comp_chunk = 2.0 * m * n * min(k_l1, k) / qc
t_write = m * n * out_b / s.bw_pc t_write = m * n * out_b / w_fix
# 搬移: 每 batch n_K 次 GM->L1, 每次含 T_cmd # 搬移: 每 batch n_K 次 GM->L1 (各 (batch,K段) 数据互不重叠, GM 每字节一次),
# 每次含 T_cmd; dma_cmds 为单核命令数 (各核并行, issue#29 口径)
dma_cmds = b_core * n_k dma_cmds = b_core * n_k
t_mte2_data = dma_cmds * t_load t_mte2_data = dma_cmds * t_load
t_dma_cmd = dma_cmds * s.t_cmd t_dma_cmd = dma_cmds * s.t_cmd
t_mte2 = t_mte2_data + t_dma_cmd t_mte2 = t_mte2_data + t_dma_cmd
# Cube: 无冗余 # Cube: 无冗余; 每核 flops = b_core*2MNK (整芯片列 = b*2MNK)
flops_pc = b_core * 2.0 * m * n * k flops_pc = b_core * 2.0 * m * n * k
t_mmad = flops_pc / s.q16 flops_chip = b * 2.0 * m * n * k
t_mmad = flops_pc / qc
# Fixpipe: b_core 个 batch 输出, 按 C dtype # Fixpipe (R4): b_core 个 batch 输出, 按 C dtype
fix_bytes_pc = b_core * m * n * out_b fix_bytes_pc = b_core * m * n * out_b
t_fix = fix_bytes_pc / s.bw_pc fix_bytes_chip = b * m * n * out_b
t_fix = fix_bytes_pc / w_fix
# drain: 末 batch 排空 = T_comp + T_write # drain: 末 batch 排空 = T_comp + T_write
t_drain = t_comp_chunk + t_write t_drain = t_comp_chunk + t_write
gm_bytes_pc = b_core * (m * k + k * n) * dt
return assemble_timing( return assemble_timing(
t_mte2_gm=t_mte2_data, t_mte2_l2=0.0, t_dma_cmd=t_dma_cmd, 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, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=0.0, t_drain=t_drain,
gm_read_bytes=gm_bytes_pc, l2_read_bytes=0.0, gm_read_bytes=b * n_k * min(k_l1, k) * (m + n) * dt,
dma_cmd_count=dma_cmds, cube_flops=flops_pc, l2_read_bytes=0.0,
fixpipe_bytes=fix_bytes_pc, dma_cmd_count=dma_cmds, cube_flops=flops_chip,
fixpipe_bytes=fix_bytes_chip,
fixpipe_to_gm=(not out_l2),
) )

60
BMM/BMM_Theory/bmm_theory/branches/merge_batch.py
View File

@@ -18,7 +18,7 @@ import math
from ..hardware import NpuSpec, ASCEND950PR from ..hardware import NpuSpec, ASCEND950PR
from ..models import BmmCase, ImplPlan, HardwareTiming, align_down from ..models import BmmCase, ImplPlan, HardwareTiming, align_down
from ..timing import MoveInPlan, assemble_timing from ..timing import assemble_timing, output_to_l2
from .base import Branch, BranchResult, ConditionCheck from .base import Branch, BranchResult, ConditionCheck
MIN_B0 = 2 # b0: 合并搬移有收益的最小合并数 MIN_B0 = 2 # b0: 合并搬移有收益的最小合并数
@@ -142,9 +142,17 @@ class MergeBatchBranch(Branch):
)) ))
b_l1 = max(b_l1, b0) b_l1 = max(b_l1, b0)
# Step 5: 输出落点 (issue#30): 整 case 输入+输出可驻留 L2 才写 L2 (R4)
out_l2 = output_to_l2(case, s)
l2_out = ("resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)"
if out_l2 else
"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)")
note = (f"b0={b0} (L0C上限{b0_l0c:.1f}/算存比上限{b0_ai:.1f}/b_core={b_core}); " note = (f"b0={b0} (L0C上限{b0_l0c:.1f}/算存比上限{b0_ai:.1f}/b_core={b_core}); "
f"{'K截断' if k_truncated else 'L1绑定'}; " f"{'K截断' if k_truncated else 'L1绑定'}; "
f"合并后单次DMA搬入 A'[{b0*m},{k_l1}]+B'[{k_l1},{b0*n}]") f"合并后单次DMA搬入 A'[{b0*m},{k_l1}]+B'[{k_l1},{b0*n}]; "
f"输出落点: {'L2驻留' if out_l2 else '直写GM'} (整case V_in+V_out"
f"={case.input_bytes/1048576:.1f}MB vs L2={s.l2_bytes/1048576:.0f}MB)")
return ImplPlan( return ImplPlan(
case_id=case.case_id, branch=self.name, case_id=case.case_id, branch=self.name,
@@ -157,7 +165,7 @@ class MergeBatchBranch(Branch):
# L0C 双缓冲约束已由进入条件 2 保证 (2*(b0*M)*(b0*N)*4B <= L0C) # L0C 双缓冲约束已由进入条件 2 保证 (2*(b0*M)*(b0*N)*4B <= L0C)
base_m=b0 * m, base_n=b0 * n, base_k=max(min(k_l0, k_l1, k), s.fractal), base_m=b0 * m, base_n=b0 * n, base_k=max(min(k_l0, k_l1, k), s.fractal),
l2_policy_in="allocate(GM->L1随路驻留L2)", l2_policy_in="allocate(GM->L1随路驻留L2)",
l2_policy_out="direct_gm(输出仅写一次,直写GM不占L2)" if not case.out_nd else "direct_gm", l2_policy_out=l2_out,
swizzle_w=0, workspace_bytes=0, swizzle_w=0, workspace_bytes=0,
tail_strategy="不涉及(核内不切M/N)", tail_strategy="不涉及(核内不切M/N)",
fixpipe_unitflag=True, fixpipe_unitflag=True,
@@ -166,55 +174,71 @@ class MergeBatchBranch(Branch):
) )
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# 时延评估 (v1.1 §4 端到端模型) # 时延评估 (v1.1 §4 端到端模型; issue#27/#28/#29/#30 口径)
# - Cube flops (issue#27 复核): 每合并步计算全网格 (b0*M)x(b0*N)xK
# 含交叉项冗余, flops_step = 2*(b0M)*(b0N)*K, 每核步数 = b_core/b0
# -> 每核 flops = b_core*b0*2MNK (与 CSV 及文档公式一致, 无修改);
# - 算力按输入 dtype (issue#28): q_cube(dtype_a, dtype_b);
# - 字节列 = 整芯片口径 (issue#29); GM 首读 = V_in 一次 (合并按组搬入
# 各 (batch,K段) 数据互不重叠, 无 L2 重复读);
# - 输出落点按整 case 驻留判定 (issue#30, R4).
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming:
s = self.spec s = self.spec
m, n, k = case.m, case.n, case.k m, n, k = case.m, case.n, case.k
dt = case.dtype_in_bytes dt = case.dtype_in_bytes
out_b = case.dtype_out_bytes out_b = case.dtype_out_bytes
b = case.batch_c
b_core, b0, k_l1 = plan.b_core, plan.merge_b0, plan.k_l1 b_core, b0, k_l1 = plan.b_core, plan.merge_b0, plan.k_l1
qc = s.q_cube(case.dtype_a, case.dtype_b)
out_l2 = output_to_l2(case, s, 0.0)
w_fix = s.bw_l2_pc if out_l2 else s.bw_pc
k_truncated = k_l1 >= k k_truncated = k_l1 >= k
# 每 K 分块搬移/计算时延 (未合并基准, v1.1 §4.1 符号) # 每 K 分块搬移/计算时延 (未合并基准, v1.1 §4.1 符号)
t_load = k_l1 * (m + n) * dt / s.bw_pc t_load = k_l1 * (m + n) * dt / s.bw_pc
t_comp_chunk = 2.0 * m * n * k_l1 / s.q16 t_comp_chunk = 2.0 * m * n * k_l1 / qc
t_write = m * n * out_b / s.bw_pc # 单 batch 输出写回 (单核带宽份额) t_write = m * n * out_b / w_fix # 单 batch 输出写回 (R4 落点带宽)
if k_truncated: if k_truncated:
# K 截断: n_K=1, 合并后单次搬移量 b0 倍 # K 截断: n_K=1, 每核 b_core/b0 次合并搬入, 每次搬 b0 个 batch 全 K
n_move = b_core / b0 n_move = b_core / b0
t_mte2_data = n_move * b0 * t_load t_mte2_data = n_move * b0 * t_load
dma_cmds = n_move dma_cmds = n_move
gm_chip = b * (m + n) * k * dt # = V_in, GM 每字节一次
else: else:
# L1 绑定: k_L1^m = k_L1/b0, n_K^m = b0*n_K, 搬移次数与 IterBatch 相同 # L1 绑定: k_L1^m = k_L1/b0, n_K^m = b0*n_K, 搬移次数与 IterBatch 相同
# (每 (合并组, K段) 数据互不重叠, GM 仍每字节一次, 末段含 padding 上取)
n_k = -(-k // k_l1) n_k = -(-k // k_l1)
n_move = b_core * n_k n_move = b_core * n_k
t_mte2_data = n_move * t_load t_mte2_data = n_move * t_load
dma_cmds = n_move dma_cmds = n_move
gm_chip = b * (m + n) * n_k * k_l1 * dt # >= V_in (padding 上取)
t_dma_cmd = dma_cmds * s.t_cmd t_dma_cmd = dma_cmds * s.t_cmd
t_mte2 = t_mte2_data + t_dma_cmd t_mte2 = t_mte2_data + t_dma_cmd
# Cube: 合并计算含冗余 (b0^2 输出, 有效 b0) -> 计算量 = b_core*b0*2MNK # Cube (每核口径): 合并计算含冗余 (b0^2 输出, 有效 b0), 每核 b_core/b0 步,
# 每步 flops = 2*(b0*M)*(b0*N)*K -> 每核 = b_core*b0*2MNK (issue#27 复核一致)
flops_pc = b_core * b0 * 2.0 * m * n * k flops_pc = b_core * b0 * 2.0 * m * n * k
t_mmad = flops_pc / s.q16 flops_chip = b * b0 * 2.0 * m * n * k # 整芯片口径列
t_mmad = flops_pc / qc
# Fixpipe: 只写对角块, 写出量 = b_core*MN*outB (C 矩阵 dtype, 随路转换) # Fixpipe (R4): 只写对角块, 写出量 = b_core*MN*outB (C 矩阵 dtype, 随路转换)
fix_bytes_pc = b_core * m * n * out_b fix_bytes_pc = b_core * m * n * out_b
t_fix = fix_bytes_pc / s.bw_pc fix_bytes_chip = b * m * n * out_b
t_fix = fix_bytes_pc / w_fix
# drain: 末合并 batch 排空 = b0*(T_comp + T_write) # drain: 末合并 batch 排空 = b0*(T_comp + T_write)
t_drain = b0 * (t_comp_chunk + t_write) t_drain = b0 * (t_comp_chunk + t_write)
gm_bytes_pc = b_core * (m * k + k * n) * dt
return assemble_timing( return assemble_timing(
t_mte2_gm=t_mte2_data, t_mte2_l2=0.0, t_dma_cmd=t_dma_cmd, 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, t_mmad=t_mmad, t_fixpipe=t_fix, t_reduce=0.0, t_drain=t_drain,
gm_read_bytes=gm_bytes_pc, l2_read_bytes=0.0, gm_read_bytes=gm_chip, l2_read_bytes=0.0,
dma_cmd_count=dma_cmds, cube_flops=flops_pc, dma_cmd_count=dma_cmds, cube_flops=flops_chip,
fixpipe_bytes=fix_bytes_pc, fixpipe_bytes=fix_bytes_chip,
fixpipe_to_gm=(not out_l2),
) )
# ------------------------------------------------------------------ # ------------------------------------------------------------------
@@ -243,7 +267,9 @@ class MergeBatchBranch(Branch):
plan = self.make_plan(case) plan = self.make_plan(case)
b0 = plan.merge_b0 b0 = plan.merge_b0
t_comp = 2.0 * m * n * min(k_l1_iter, k) / s.q16 # T_comp 按输入 dtype 算力 (issue#28); T_write 保持 v1.1 直写 GM 语义
qc = s.q_cube(case.dtype_a, case.dtype_b)
t_comp = 2.0 * m * n * min(k_l1_iter, k) / qc
t_write = m * n * out_b / s.bw_pc t_write = m * n * out_b / s.bw_pc
drain_pen = (b0 - 1) * (t_comp + t_write) drain_pen = (b0 - 1) * (t_comp + t_write)

30
BMM/BMM_Theory/bmm_theory/branches/special.py
View File

@@ -10,7 +10,7 @@ from __future__ import annotations
from ..hardware import NpuSpec, ASCEND950PR from ..hardware import NpuSpec, ASCEND950PR
from ..models import BmmCase, ImplPlan, HardwareTiming from ..models import BmmCase, ImplPlan, HardwareTiming
from ..timing import assemble_timing from ..timing import assemble_timing, output_to_l2
from .base import Branch, ConditionCheck from .base import Branch, ConditionCheck
@@ -68,32 +68,42 @@ class SpecialBranch(Branch):
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming:
"""AIV 通路时延: 瓶颈在搬移 (AIV 算力远剩).""" """AIV 通路时延: 瓶颈在搬移 (AIV 算力远剩).
口径: AIV 逐元素通量按输入 dtype (issue#28); 输出落点 R4 (issue#30):
整 case 输入+输出 <= L2 -> 输出写 L2 (异步回写不占算子时延), 否则直写
GM 与读共享总线 (assemble 的 MTE2 链累加, issue#23).
"""
s = self.spec s = self.spec
b = case.batch_c b = case.batch_c
m, n, k = case.m, case.n, case.k m, n, k = case.m, case.n, case.k
dt = case.dtype_in_bytes dt = case.dtype_in_bytes
out_b = case.dtype_out_bytes out_b = case.dtype_out_bytes
out_l2 = output_to_l2(case, s)
w_fix = s.bw_l2 if out_l2 else s.bw_gm
cube_flops = 0.0
t_compute = 0.0
if k == 0: if k == 0:
# 纯写值: 仅写出 # 纯写值: 仅写出 (R1 下 GM 读 = 0, 输入本身为空)
t_in, t_compute, t_out = 0.0, 0.0, b * m * n * out_b / s.bw_gm t_in = 0.0
in_bytes, cube_flops = 0.0, 0.0 t_out = b * m * n * out_b / w_fix
in_bytes = 0.0
else: else:
# 逐元素乘: 搬入 A+B, 搬出 C, AIV 算力远剩 # 逐元素乘: 搬入 A+B (GM 每字节一次), 搬出 C
in_bytes = b * (m * k + k * n) * dt in_bytes = b * (m * k + k * n) * dt
out_bytes = b * m * n * out_b out_bytes = b * m * n * out_b
t_in = in_bytes / s.bw_gm t_in = in_bytes / s.bw_gm
t_out = out_bytes / s.bw_gm t_out = out_bytes / w_fix
# AIV 求积吞吐 (近似按 Q_AIV) # AIV 逐元素吞吐按输入 dtype 取通量 (issue#28: bf16/fp16 x2, int8 x4...)
t_compute = b * m * n / s.q_aiv t_compute = b * m * n / s.aiv_elem_rate(case.dtype_in)
cube_flops = float(b * m * n) cube_flops = float(b * m * n)
t_total = max(t_in, t_out, t_compute)
return assemble_timing( return assemble_timing(
t_mte2_gm=t_in, t_mte2_l2=0.0, t_dma_cmd=0.0, t_mte2_gm=t_in, t_mte2_l2=0.0, t_dma_cmd=0.0,
t_mmad=t_compute, t_fixpipe=t_out, t_reduce=0.0, t_drain=0.0, t_mmad=t_compute, t_fixpipe=t_out, t_reduce=0.0, t_drain=0.0,
gm_read_bytes=in_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0, gm_read_bytes=in_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0,
cube_flops=cube_flops, cube_flops=cube_flops,
fixpipe_bytes=b * m * n * out_b, fixpipe_bytes=b * m * n * out_b,
fixpipe_to_gm=(not out_l2),
) )

27
BMM/BMM_Theory/bmm_theory/branches/stream_k.py
View File

@@ -12,7 +12,7 @@ import math
from ..hardware import NpuSpec, ASCEND950PR from ..hardware import NpuSpec, ASCEND950PR
from ..models import BmmCase, ImplPlan, HardwareTiming, ceil_div from ..models import BmmCase, ImplPlan, HardwareTiming, ceil_div
from ..timing import assemble_timing, eval_streamk_reduce from ..timing import assemble_timing, eval_streamk_reduce, output_to_l2
from .base import Branch, ConditionCheck from .base import Branch, ConditionCheck
@@ -32,10 +32,14 @@ class StreamKBranch(Branch):
p = self._p_value(case) p = self._p_value(case)
return int(self.spec.aic_num // max(1, math.ceil(p))) return int(self.spec.aic_num // max(1, math.ceil(p)))
def _theta_c(self) -> float: def _theta_c(self, case: BmmCase) -> float:
"""归约代价系数 theta_c = Q16/2 * (8B/W_L2 + 1/Q_AIV) ≈ 12.""" """归约代价系数 theta_c = Q_cube(dtype)/2 * (8B/W_L2 + 1/Q_AIV_fp32).
Q_AIV 用 fp32 档 (部分和为 fp32, issue#28); Cube 侧按输入 dtype.
"""
s = self.spec s = self.spec
return s.q16 / 2 * (8 / s.bw_l2 + 1 / s.q_aiv) qc = s.q_cube(case.dtype_a, case.dtype_b)
return qc / 2 * (8 / s.bw_l2 + 1 / s.q_aiv)
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def check_conditions(self, case: BmmCase) -> list: def check_conditions(self, case: BmmCase) -> list:
@@ -61,7 +65,7 @@ class StreamKBranch(Branch):
# 条件 3: K > grid_K^2/(grid_K-1) * theta_c (归约代价可接受) # 条件 3: K > grid_K^2/(grid_K-1) * theta_c (归约代价可接受)
if grid_k >= 2: if grid_k >= 2:
theta_c = self._theta_c() theta_c = self._theta_c(case)
k_thresh = grid_k * grid_k / (grid_k - 1) * theta_c k_thresh = grid_k * grid_k / (grid_k - 1) * theta_c
c3 = case.k > k_thresh c3 = case.k > k_thresh
checks.append(ConditionCheck( checks.append(ConditionCheck(
@@ -139,7 +143,9 @@ class StreamKBranch(Branch):
(工作集超 L2, 保守同 ASW 场景 C 公式); (工作集超 L2, 保守同 ASW 场景 C 公式);
- MMAD: 芯片总量 2*b*m*n*k / (C核) —— 全核忙稳态; - MMAD: 芯片总量 2*b*m*n*k / (C核) —— 全核忙稳态;
- 归约 (部分和 4B 写 L2/AIV 读回求和/最终写回): 每 tile-组一次、组间串行 - 归约 (部分和 4B 写 L2/AIV 读回求和/最终写回): 每 tile-组一次、组间串行
追加为 drain: t_drain = waves * eval_streamk_reduce(tile, grid_k, out). 追加为 drain: t_drain = waves * eval_streamk_reduce(tile, grid_k, out);
最终输出写回落点按 R4 (issue#30): 整 case 输入+输出+workspace <= L2
时写 L2, 否则直写 GM (drain 内按 GM 带宽).
""" """
s = self.spec s = self.spec
b = case.batch_c b = case.batch_c
@@ -152,6 +158,8 @@ class StreamKBranch(Branch):
tile_m = max(plan.single_core_m, 1) tile_m = max(plan.single_core_m, 1)
tile_n = max(plan.single_core_n, 1) tile_n = max(plan.single_core_n, 1)
tile = tile_m * tile_n # 每核实际 tile 元素数 tile = tile_m * tile_n # 每核实际 tile 元素数
qc = s.q_cube(case.dtype_a, case.dtype_b)
out_l2 = output_to_l2(case, s, float(plan.workspace_bytes))
# ---- MTE2: GM 段 + L2 段 (同 ASW 块级规则) ---- # ---- MTE2: GM 段 + L2 段 (同 ASW 块级规则) ----
a_b = m * k * dt a_b = m * k * dt
@@ -166,13 +174,14 @@ class StreamKBranch(Branch):
t_l2 = l2_read / s.bw_l2 t_l2 = l2_read / s.bw_l2
t_mte2 = t_gm + t_l2 t_mte2 = t_gm + t_l2
# ---- MMAD: 芯片总量 ---- # ---- MMAD: 芯片总量, dtype 感知算力 (issue#28) ----
flops = 2.0 * b * m * n * k flops = 2.0 * b * m * n * k
t_mmad = flops / (s.aic_num * s.q16) t_mmad = flops / (s.aic_num * qc)
# ---- 归约: 每 tile-组一次, 组间分波串行追加 ---- # ---- 归约: 每 tile-组一次, 组间分波串行追加 ----
waves = ceil_div(b * m_cnt * n_cnt * grid_k, s.aic_num) waves = ceil_div(b * m_cnt * n_cnt * grid_k, s.aic_num)
t_reduce_group = eval_streamk_reduce(tile, grid_k, out_b, s) t_reduce_group = eval_streamk_reduce(tile, grid_k, out_b, s,
out_to_gm=not out_l2)
t_reduce = waves * t_reduce_group t_reduce = waves * t_reduce_group
fix_bytes = 0.0 fix_bytes = 0.0
t_fix = 0.0 t_fix = 0.0

16
BMM/BMM_Theory/bmm_theory/branches/to_matmul.py
View File

@@ -12,7 +12,7 @@ from __future__ import annotations
from ..hardware import NpuSpec, ASCEND950PR from ..hardware import NpuSpec, ASCEND950PR
from ..models import BmmCase, ImplPlan, HardwareTiming from ..models import BmmCase, ImplPlan, HardwareTiming
from ..timing import assemble_timing from ..timing import assemble_timing, output_to_l2
from .base import Branch, ConditionCheck from .base import Branch, ConditionCheck
@@ -71,7 +71,12 @@ class ToMatmulBranch(Branch):
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming: def evaluate(self, case: BmmCase, plan: ImplPlan) -> HardwareTiming:
"""折叠后按 Matmul 粗估 (详细切分待 MM 理论体系打通后接入).""" """折叠后按 Matmul 粗估 (详细切分待 MM 理论体系打通后接入).
口径: Cube 算力按输入 dtype (issue#28); GM 首读 = V_in 一次 (R1);
输出落点 R4 (issue#30): 整 case 输入+输出 <= L2 时写 L2 写口, 否则
直写 GM 与读共享总线 (assemble 累加).
"""
s = self.spec s = self.spec
if case.batch_b == 1: if case.batch_b == 1:
fold_m, fold_n, kk = case.batch_a * case.m, case.n, case.k fold_m, fold_n, kk = case.batch_a * case.m, case.n, case.k
@@ -79,13 +84,15 @@ class ToMatmulBranch(Branch):
fold_m, fold_n, kk = case.m, case.batch_b * case.n, case.k fold_m, fold_n, kk = case.m, case.batch_b * case.n, case.k
dt = case.dtype_in_bytes dt = case.dtype_in_bytes
out_b = case.dtype_out_bytes out_b = case.dtype_out_bytes
qc = s.q_cube(case.dtype_a, case.dtype_b)
out_l2 = output_to_l2(case, s)
flops = 2.0 * fold_m * fold_n * kk flops = 2.0 * fold_m * fold_n * kk
t_mmad = flops / (s.aic_num * s.q16) t_mmad = flops / (s.aic_num * qc)
in_bytes = (fold_m * kk + kk * fold_n) * dt in_bytes = (fold_m * kk + kk * fold_n) * dt
out_bytes = fold_m * fold_n * out_b out_bytes = fold_m * fold_n * out_b
t_mte2 = in_bytes / s.bw_gm t_mte2 = in_bytes / s.bw_gm
t_fix = out_bytes / s.bw_gm t_fix = out_bytes / (s.bw_l2 if out_l2 else s.bw_gm)
return assemble_timing( return assemble_timing(
t_mte2_gm=t_mte2, t_mte2_l2=0.0, t_dma_cmd=0.0, t_mte2_gm=t_mte2, t_mte2_l2=0.0, t_dma_cmd=0.0,
@@ -93,4 +100,5 @@ class ToMatmulBranch(Branch):
t_drain=0.0, t_drain=0.0,
gm_read_bytes=in_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0, gm_read_bytes=in_bytes, l2_read_bytes=0.0, dma_cmd_count=0.0,
cube_flops=flops, fixpipe_bytes=out_bytes, cube_flops=flops, fixpipe_bytes=out_bytes,
fixpipe_to_gm=(not out_l2),
) )

73
BMM/BMM_Theory/bmm_theory/hardware/ascend950pr.py
View File

@@ -4,12 +4,36 @@
换芯片时逻辑结构不变, 只需新增一份同结构参数表. 换芯片时逻辑结构不变, 只需新增一份同结构参数表.
单位约定: 算力 FLOP/s, 带宽 Byte/s, 容量 Byte, 时延 秒. 单位约定: 算力 FLOP/s, 带宽 Byte/s, 容量 Byte, 时延 秒.
dtype 感知算力 (issue#28, 设计文档 docs/05 §2):
Cube 算力按输入 dtype 分档, 基准 = BF16 (fp16 同速); 白皮书: FP8/MXFP8/HiF8
提供 2x FP16 张量 TFLOPS, MXFP4 提供 4x FP16; FP32/TF32 同代比值为假设值
(按 DaVinci 惯例 = 1/2, 白皮书未给同代比值), int8 假设同 FP8, 均待实测标定.
AIV 逐元素通量按 lane 位宽等比假设 (16bit x2 / 8bit x4 / 4bit x8, 待标定).
""" """
from __future__ import annotations from __future__ import annotations
from dataclasses import dataclass from dataclasses import dataclass
# Cube 精度因子 (相对 BF16/FP16 基准档; A/B 不一致时取较慢一侧 = min 因子)
CUBE_DTYPE_FACTOR = {
"fp32": 0.5, "f32": 0.5, "tf32": 0.5, # 假设 = 1/2, 待实测标定
"fp16": 1.0, "f16": 1.0, "bf16": 1.0,
"fp8": 2.0, "fp8_e4m3": 2.0, "fp8_e5m2": 2.0, "int8": 2.0, # 白皮书 FP8=2xFP16; int8 假设同 FP8
"fp4": 4.0, "fp4_e2m1": 4.0, # 白皮书 MXFP4=4xFP16; 普通 fp4 假设同 MXFP4
}
# AIV 逐元素通量因子 (相对 fp32 128 lane/拍/核; 位宽等比假设, 待实测标定)
AIV_DTYPE_FACTOR = {
"fp32": 1.0, "f32": 1.0, "tf32": 1.0,
"fp16": 2.0, "f16": 2.0, "bf16": 2.0,
"fp8": 4.0, "fp8_e4m3": 4.0, "fp8_e5m2": 4.0, "int8": 4.0,
"fp4": 8.0, "fp4_e2m1": 8.0,
}
_RATE_FALLBACK = 1.0 # 未知 dtype 按基准档 (models.dtype_bytes 已先行校验, 正常不会到达)
@dataclass(frozen=True) @dataclass(frozen=True)
class NpuSpec: class NpuSpec:
@@ -55,13 +79,50 @@ class NpuSpec:
# ---- 派生量 (属性) ---- # ---- 派生量 (属性) ----
@property @property
def q16(self) -> float: def q16(self) -> float:
"""单核 Cube BF16 峰值算力 (FLOP/s).""" """单核 Cube BF16/FP16 峰值算力 (FLOP/s) = 15.1875T."""
return self.cube_peak_tflops * 1e12 / self.aic_num return self.cube_peak_tflops * 1e12 / self.aic_num
@staticmethod
def _dtype_key(dtype) -> str:
return str(dtype).strip().lower()
def cube_factor(self, dtype_a, dtype_b=None) -> float:
"""按输入 dtype 取 Cube 精度因子 (issue#28).
A/B 不一致时取**较慢一侧** (因子较小者, 等价字节较大者);
Cube 乘法两侧的实际吞吐受较慢精度限制.
"""
keys = [self._dtype_key(dtype_a)]
if dtype_b is not None:
keys.append(self._dtype_key(dtype_b))
factors = [CUBE_DTYPE_FACTOR.get(k, _RATE_FALLBACK) for k in keys]
return min(factors)
def q_cube(self, dtype_a, dtype_b=None) -> float:
"""单核 Cube 峰值算力 (FLOP/s), 按输入 dtype 分档 (issue#28)."""
return self.q16 * self.cube_factor(dtype_a, dtype_b)
def aiv_elem_factor(self, dtype) -> float:
"""按 dtype 取 AIV 逐元素通量因子 (相对 fp32 基准)."""
return AIV_DTYPE_FACTOR.get(self._dtype_key(dtype), _RATE_FALLBACK)
@property
def aiv_elem_rate_fp32(self) -> float:
"""AIV fp32 逐元素吞吐 (元素/s), 64 核合计."""
return self.aiv_num * self.aiv_fp32_per_cycle * self.aiv_freq_ghz * 1e9
def aiv_elem_rate(self, dtype) -> float:
"""AIV 逐元素吞吐 (元素/s, 64 核合计), 按 dtype 分档 (issue#28)."""
return self.aiv_elem_rate_fp32 * self.aiv_elem_factor(dtype)
@property @property
def q_aiv(self) -> float: def q_aiv(self) -> float:
"""AIV 向量求和吞吐 (元素/s), 64 核合计.""" """AIV fp32 逐元素吞吐 (元素/s, 64 核合计) = aiv_elem_rate_fp32.
return self.aiv_num * self.aiv_fp32_per_cycle * self.aiv_freq_ghz * 1e9
注意: 该值只适用于 fp32 数据 (如 StreamK 对 fp32 部分和求和);
逐元素运算按输入 dtype 用 aiv_elem_rate(dtype) (issue#28).
"""
return self.aiv_elem_rate_fp32
@property @property
def bw_pc(self) -> float: def bw_pc(self) -> float:
@@ -75,7 +136,11 @@ class NpuSpec:
@property @property
def r16(self) -> float: def r16(self) -> float:
"""16bit 位宽平衡点算存比 R_16 = Cube峰值 / (GM带宽/2B) ≈ 607.5 FLOP/元素.""" """16bit 位宽平衡点算存比 R_16 = Cube峰值 / (GM带宽/2B) ≈ 607.5 FLOP/元素.
按 issue#28 速率表该比值对全 dtype 不变 (Cube 因子与元素字节数互成反比),
故入口条件沿用单一 R_16.
"""
return self.cube_peak_tflops * 1e12 / (self.bw_gm / 2) return self.cube_peak_tflops * 1e12 / (self.bw_gm / 2)
@property @property

27
BMM/BMM_Theory/bmm_theory/models.py
View File

@@ -133,6 +133,12 @@ class BmmCase:
# 返回 float 以兼容 fp4 (0.5B) # 返回 float 以兼容 fp4 (0.5B)
return max(dtype_bytes(self.dtype_a), dtype_bytes(self.dtype_b)) return max(dtype_bytes(self.dtype_a), dtype_bytes(self.dtype_b))
@property
def dtype_in(self) -> str:
"""输入侧"较慢"dtype (元素字节较大者) — Cube/AIV 速率取慢侧 (issue#28)."""
return (self.dtype_a if dtype_bytes(self.dtype_a) >= dtype_bytes(self.dtype_b)
else self.dtype_b)
@property @property
def dtype_out_bytes(self) -> float: def dtype_out_bytes(self) -> float:
return dtype_bytes(self.dtype_c) return dtype_bytes(self.dtype_c)
@@ -261,23 +267,30 @@ class ImplPlan:
@dataclass @dataclass
class HardwareTiming: class HardwareTiming:
"""各硬件流水级时延 (秒) 与数据量明细.""" """各硬件流水级时延 (秒) 与数据量明细.
数据量列口径 (issue#29, 设计文档 docs/05 §4.4):
gm_read_bytes / l2_read_bytes / fixpipe_bytes / cube_flops = **整芯片**总量
(跨分支可比, GM 首读下限断言: gm_read_bytes >= case.input_bytes);
dma_cmd_count = **单核** GM->L1 DMA 命令数 (各核引擎并行, 墙钟 T_cmd =
单核命令数 x T_cmd), 与字节列口径不同属.
"""
# 搬入 (MTE2) # 搬入 (MTE2)
gm_read_bytes: float = 0.0 # GM->L1 直读数据量 (不驻留/未命中 L2 的部分) gm_read_bytes: float = 0.0 # GM->L1 直读数据量 (整芯片, 首读/落空重读)
l2_read_bytes: float = 0.0 # L2->L1 数据量 (驻留 L2 后重复读命中部分) l2_read_bytes: float = 0.0 # L2->L1 数据量 (整芯片, 驻留 L2 后重复读命中部分)
t_mte2_gm: float = 0.0 # GM->L1 时延 (按 GM 带宽, 不累加 L2->L1) t_mte2_gm: float = 0.0 # GM->L1 时延 (按 GM 带宽, 不累加 L2->L1)
t_mte2_l2: float = 0.0 # L2->L1 时延 (按 L2 带宽) t_mte2_l2: float = 0.0 # L2->L1 时延 (按 L2 带宽)
t_mte2: float = 0.0 # 搬入合计 = t_mte2_gm + t_mte2_l2 (两者发生在不同数据上) t_mte2: float = 0.0 # 搬入合计 = t_mte2_gm + t_mte2_l2 (两者发生在不同数据上)
dma_cmd_count: float = 0.0 # GM->L1 DMA 命令次数 (T_cmd 分析用) dma_cmd_count: float = 0.0 # 单核 GM->L1 DMA 命令次数 (T_cmd 分析用)
t_dma_cmd: float = 0.0 # DMA 命令固定开销合计 t_dma_cmd: float = 0.0 # DMA 命令固定开销合计 (墙钟)
# 计算 (Cube MMAD) # 计算 (Cube MMAD)
cube_flops: float = 0.0 # Cube 实际计算量 (MergeBatch 含冗余) cube_flops: float = 0.0 # Cube 实际计算量 (整芯片, MergeBatch 含冗余)
t_mmad: float = 0.0 t_mmad: float = 0.0
# 搬出 (Fixpipe) # 搬出 (Fixpipe)
fixpipe_bytes: float = 0.0 # 写出数据量 (按 C 矩阵 dtype / StreamK 临时矩阵按 4B) fixpipe_bytes: float = 0.0 # 写出数据量 (整芯片, 按 C 矩阵 dtype / StreamK 临时矩阵按 4B)
t_fixpipe: float = 0.0 t_fixpipe: float = 0.0
# 归约 (StreamK 专用) # 归约 (StreamK 专用)

35
BMM/BMM_Theory/bmm_theory/timing.py
View File

@@ -24,7 +24,19 @@ from __future__ import annotations
from dataclasses import dataclass from dataclasses import dataclass
from .hardware import NpuSpec, ASCEND950PR from .hardware import NpuSpec, ASCEND950PR
from .models import HardwareTiming from .models import BmmCase, HardwareTiming
def output_to_l2(case: BmmCase, spec: NpuSpec = ASCEND950PR,
workspace_bytes: float = 0.0) -> bool:
"""Fixpipe 输出落点决策 (issue#30, 设计文档 docs/05 §4.2 R4).
to_l2 (输出写 L2 写口 5.2TB/s, GM 写流量 = 0, 异步回写不占算子时延)
⟺ 整 case 输入 V_in + 输出 V_out [+ StreamK workspace] ≤ L2
否则输出**直写 GM**: 输入优先驻留 L2 (输入存在重复读), 输出计入 GM
读写共享总线 (与读累加, issue#23).
"""
return (case.input_bytes + case.output_bytes + workspace_bytes) <= spec.l2_bytes
@dataclass @dataclass
@@ -56,9 +68,11 @@ def eval_mte2(move: MoveInPlan, spec: NpuSpec = ASCEND950PR,
return t_gm, t_l2, t_gm + t_l2 + t_cmd, t_cmd return t_gm, t_l2, t_gm + t_l2 + t_cmd, t_cmd
def eval_mmad(flops_per_core: float, spec: NpuSpec = ASCEND950PR) -> float: def eval_mmad(flops_per_core: float, spec: NpuSpec = ASCEND950PR,
"""Cube 计算时延: 单核计算量 / 单核算力.""" dtype_a=None, dtype_b=None) -> float:
return flops_per_core / spec.q16 if flops_per_core > 0 else 0.0 """Cube 计算时延: 单核计算量 / 单核 dtype 感知算力 (issue#28)."""
rate = spec.q_cube(dtype_a, dtype_b)
return flops_per_core / rate if flops_per_core > 0 else 0.0
def eval_fixpipe(bytes_per_core: float, to_l2: bool, def eval_fixpipe(bytes_per_core: float, to_l2: bool,
@@ -75,21 +89,24 @@ def eval_fixpipe(bytes_per_core: float, to_l2: bool,
def eval_streamk_reduce(tile_elems: float, grid_k: int, out_dtype_bytes: int, def eval_streamk_reduce(tile_elems: float, grid_k: int, out_dtype_bytes: int,
spec: NpuSpec = ASCEND950PR) -> float: spec: NpuSpec = ASCEND950PR, out_to_gm: bool = False) -> float:
"""StreamK 单 tile 归约时延 (v0.98 §七). """StreamK 单 tile 归约时延 (v0.98 §七).
部分和 dtype = L0C dtype (4B, 防精度丢失), 驻留 L2, AIV 归约: 部分和 dtype = L0C dtype (4B, 防精度丢失), 驻留 L2, AIV 归约 (fp32 求和,
AIV 按 fp32 通量, 不随输入 dtype 变 — issue#28):
AIC 写部分和 grid_k x tile x 4B / W_L2 AIC 写部分和 grid_k x tile x 4B / W_L2
AIV 读回 grid_k x tile x 4B / W_L2 AIV 读回 grid_k x tile x 4B / W_L2
AIV 求和 grid_k x tile / Q_AIV AIV 求和 grid_k x tile / Q_AIV(fp32)
写回 tile x outB / W_L2 写回 tile x outB / W (最终输出落点, issue#30):
整 case 可驻留 (S_A) 时 W = W_L2; 否则直写 GM (W = W_GM)
""" """
b4 = 4 b4 = 4
w_l2 = spec.bw_l2 w_l2 = spec.bw_l2
w_out = spec.bw_gm if out_to_gm else w_l2
t_write_partial = grid_k * tile_elems * b4 / w_l2 t_write_partial = grid_k * tile_elems * b4 / w_l2
t_read_back = grid_k * tile_elems * b4 / w_l2 t_read_back = grid_k * tile_elems * b4 / w_l2
t_sum = grid_k * tile_elems / spec.q_aiv t_sum = grid_k * tile_elems / spec.q_aiv
t_write_out = tile_elems * out_dtype_bytes / w_l2 t_write_out = tile_elems * out_dtype_bytes / w_out
return t_write_partial + t_read_back + t_sum + t_write_out return t_write_partial + t_read_back + t_sum + t_write_out

197
BMM/BMM_Theory/docs/05_L2驻留GM读写与dtype算力口径_设计分析.md Normal file
View File

@@ -0,0 +1,197 @@
# 05 L2 驻留、GM 读写与 dtype 算力口径 — 设计分析
> 关联 issue: #27 (MergeBatch Cube 复核) / #28 (dtype 感知算力) /
> #29 (GM 读取量下限 + L2 驻留工作集) / #30 (Fixpipe 输出落点)
>
> 状态: 设计文档先行, 代码按本文档落地 (2026-06 评审轮)。
> 本文档是 GM/L2/输出计账与算力口径的**单一语义来源**; 各分支 evaluate/生成注释以本文档为准。
---
## 0. 本轮的四个问题与结论摘要
| # | 问题 | 结论 | 落地 |
|---|---|---|---|
| #27 | MergeBatch Cube 时延 "每次 b0 个 batch, flops=2·b0M·b0N·K, 共 b_core/b0 次" | **公式与代码一致** (总 flops = b_core·b0·2MNK, 证明见 §6); 无计算改动 | 注释显式化; 暴露的"字节列每核/芯片口径混用"随 #29 统一 |
| #28 | 估算时延恒用 BF16 Cube / fp32 AIV 算力 | **确认错误** | §2 dtype 感知速率表 + 全链路替换 |
| #29 | GM 读取量"小于输入数据量" | 计算层面各分支 GM ≥ 输入一次 (逐分支表见 §5); **真问题**: ① 字节列每核/芯片口径混用导致比对失真; ② 缺整 case 驻留边界与统一驻留判定 | §3 公理化 + §4 场景模型 + 芯片口径列统一 + GM≥输入不变量测试 |
| #30 | Fixpipe 输出落点 (默认写 L2, 容量不足才写 GM) | **确认错误** (Iter/Merge/特殊恒直写 GM; ASW 场景 A 按单 batch 判定, 整 case 输出累积必逐出) | §4.2 输出落点规则 |
---
## 1. 硬件事实 (Ascend950PR, 与 hardware/ascend950pr.py 对应)
- GM (HBM): **1.6TB/s, 读写共享总线** —— 同一时刻读与写累加计时 (issue#23 已落地)。
- L2: 128MB, **5.2TB/s, 读口/写口各自独享** —— L2 重复读(读口)与 Fixpipe→L2 写(写口)互不竞争 (issue#23 已落地)。
- 输入首访一律走 GM 带宽计一次, 不叠加 L2 (issue#24 已落地); L2 只吸收"驻留后的再次读取"。
- Cube 算力分精度 (白皮书: FP8/MXFP8/HiF8 = 2×FP16, MXFP4 = 4×FP16; 16bit 档 = 基准):
BF16 486 TFLOPS/芯片 (=15.1875 TFLOPS/核)。FP32/TF32 同代比值白皮书未给 → **假设 ½, 待实测标定** (见 §2 假设表)。
- AIV (Vector): 64 核 × 128 fp32 lane/拍 × 1.65GHz = 13.5T 元素/s (fp32 档)。
---
## 2. dtype 感知算力 (issue #28)
### 2.1 速率表 (因子, 相对基准档)
Cube 因子 (相对 BF16, 同倍率作用于整芯片与单核):
| dtype | 因子 | 依据 |
|---|---|---|
| bf16 / fp16 | 1.0 | 基准档 (950 同速) |
| fp32 / tf32 | 0.5 | **假设**: 白皮书仅述 FP16/FP32 单核较上代均 +100%, 未给同代比值; 按 DaVinci 惯例 FP32 累加通量减半。待 msProf 实测标定 |
| fp8 / fp8_e4m3 / fp8_e5m2 | 2.0 | 白皮书: FP8 = 2×FP16 |
| int8 | 2.0 | **假设** 同 FP8 (8bit 整数张量档), 待实测 |
| fp4 / fp4_e2m1 | 4.0 | 白皮书: MXFP4 = 4×FP16; 普通 fp4 按 MXFP4 假设, 待实测 |
AIV (Vector) 逐元素通量因子 (相对 fp32 lane 基准):
| dtype | 因子 | 依据 |
|---|---|---|
| fp32 / tf32 | 1.0 | 基准 (128 lane/拍/核) |
| fp16 / bf16 | 2.0 | **假设** 16bit 双元素/lane, 待实测 |
| fp8 / int8 | 4.0 | **假设** 8bit 四元素/lane, 待实测 |
| fp4 | 8.0 | **假设** 待实测 |
A/B dtype 不一致 (混精度): Cube 取**较慢一侧**的因子 (max(字节数) 侧, 即 min(因子))。
StreamK 归约是对 **fp32 部分和**求和 → AIV 归约恒按 fp32 档 (因子 1.0), 不随输入 dtype 变。
### 2.2 替换点 (全部时延估算)
| 位置 | 现状 | 改为 |
|---|---|---|
| 各分支 t_mmad / t_comp_chunk / drain / 尾轮决策主导项 | flops / spec.q16 | flops / spec.q_cube(dtype_a, dtype_b) |
| MergeBatch beats_iterbatch 阈值中的 T_comp | q16 | 同上 (该分支 A/B 同 dtype, 简化为 dtype_a) |
| special K=1 t_compute (逐元素乘) | b·m·n / spec.q_aiv (fp32) | b·m·n / spec.aiv_elem_rate(dtype_in) |
| StreamK θ_c (归约代价系数) | q16(bf16) | q_cube(输入 dtype) (AIV 侧仍 fp32) |
| R16 平衡点 (MergeBatch 进入条件 5 / b0 算存比上限) | r16(bf16 基准) | r16_for(dtype) |
| 入口条件/生成侧 | — | 同步按 §2.1 因子 (dtype 只影响时延, 不改变分支结构) |
---
## 3. 存储口径公理 (issue #29)
记号:
- V_in = 输入存储总量 = batch_a·M·K·dt + batch_b·K·N·dt (广播前实际存储), V_out = batch_c·M·N·out_dt;
- a_b = M·K·dt (单 batch A 字节), b_b = K·N·dt (单 batch B 字节)。
- **R1 (GM 首读下限)**: 每个输入字节最初在 GM, 至少从 GM 读一次 → **GM_read ≥ V_in**。
违反即模型 bug (统一用测试锁死)。
- **R2 (L2 只吸收驻留后的重复读)**: 同一字节的第 2..n 次访问, 仅当两次访问之间该字节仍驻留 L2
(所在"复用窗口"的工作集 ≤ L2 减去其它占用) 才按 L2 读口计时; 否则按 GM 重读计时。
- **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_L1<K) 的
chunk 搬运按整段 k_L1 计 (含末段 padding 上取), GM ≥ V_in 恒成立。
### 3.1 逐分支 GM/L2 流量归属表 (现行模型正确性核查结果)
| 分支 | 结构 | GM 直读 | L2 重复读 | 核查 |
|---|---|---|---|---|
| IterBatch (切 B) | 逐 batch 整驻留/切 K; 每 (batch, K段) 数据互不重叠 | V_in (+K padding) | 0 (L1 形态吸收核内复用) | ✓ GM≥V_in |
| MergeBatch | 合并组 (b0 batch) 一次搬入; K 段/整 K 均不跨段重读同一字节 | V_in (+K padding) | 0 | ✓ GM≥V_in |
| ASW (切 M/N) | batch 内 tile 共享行/列块 | 场景 B: V_in; 场景 C: r_gm·V_in | (n_cnt−1)·a_b·b + (m_cnt−1)·b_b·b (场景 A/B) | ✓ GM≥V_in (场景 C 只放大) |
| 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 边界 (修正项 ③)。
---
## 4. 场景模型 (输入侧) 与输出落点 (issue #30)
### 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 → S_B → S_C。(原 #24 场景 A 的"单 batch 输入+输出可驻留"判定被 S_A 取代:
整 case 输出跨 batch 累积时单 batch 判定不可靠, 见 #30。)
### 4.2 R4 输出落点规则 (取代一切"恒直写 GM / 单 batch 判定驻留")
> to_l2(输出写 L2 写口 5.2TB/s, GM 写流量=0, 异步回写不占算子时延 — #23 口径延续)
> ⟺ **V_in + V_out [+ StreamK workspace] ≤ L2** (整 case 判定)
> 否则输出**直写 GM**: 计入 GM 读写共享总线, 与读累加进 MTE2 搬移链 (#23 口径)。
理由: 输出字节只写一次无复用价值, L2 应优先保输入工作集 (输入存在重复读);
只有当"整 case 输入+输出"可同时全驻留时才值得让输出占 L2 (省掉整条 GM 写时延)。
各分支应用:
| 分支 | 原行为 | 新行为 |
|---|---|---|
| IterBatch / MergeBatch / 特殊分支 / 转Matmul | 恒 direct_gm | S_A 时 to_l2; 否则直写 GM |
| 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 公式, 语义重申)
单 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。
### 4.4 字节列与计数列语义 (修正 ①, 整芯片口径)
输出 CSV 中数据量列一律为**整芯片**口径: gm_read_bytes / l2_read_bytes /
fixpipe_bytes / cube_flops = 整芯片量; 时延列 t_* 为墙钟时延 (已含核数折算);
dma_cmd_count 为**单核**命令数 (各核 DMA 引擎并行执行, 墙钟 T_cmd = 单核命令数 × t_cmd),
与字节列口径不同属, 单独标注。
---
## 5. 各分支 GM/输出计账公式落地 (与代码对应)
统一由 case 属性提供 V_in / V_out; 输出落点判断函数 `output_to_l2(case, spec, workspace)` (S_A)。
| 分支 | 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 |
| 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 |
时延计算: 全核并发时 t = 芯片字节 / 芯片带宽; 降核 (used < C) 时按 used×单核份额
(线性假设, issue#26 标注), Cube t = 芯片 flops / (used × q_cube(dtype))。
---
## 6. MergeBatch Cube 复核 (issue #27) — 证明
合并语义: A'[b0·M, K] @ B'[K, b0·N] 作为单次 GEMM, Cube 硬件计算**全网格**
(b0·M)×(b0·N) 输出 (含交叉项, 冗余比例 (b0²−b0)/b0² = (b0−1)/b0), 只保留 b0 个对角块。
- 每次合并计算 (步): flops_step = 2·(b0·M)·(b0·N)·K;
- 每核合并组数: b_core/b0;
- 总: flops = (b_core/b0)·2·(b0·M)·(b0·N)·K = **b_core·b0·2MNK** —— 与现行代码
`flops_pc = b_core·b0·2·m·n·k` 逐项相等, t_mmad = flops/Q16 不变。
CSV 证据 (merge_demo_k_trunc, B=2048 M=N=32 K=256, b0=4, b_core=64):
flops_step = 2·128·128·256 = 8,388,608; 步数 16; 合计 134,217,728 = 代码值 = CSV cube_flops 列;
t_mmad = 134,217,728 / 15.1875e12 = 8.837us = CSV t_mmad。**结论: 无需数值修改**;
若意图是"只算对角块"则与全网格 GEMM 语义冲突 (冗余消失, v0.98 §五 理论前提需另行裁决)。
---
## 7. 变更影响与验证口径
1. 字节列整芯片化 (IterBatch/MergeBatch/special 数值 ×C 或按 b 直接计算);
2. S_A 判定下输出写 L2: 小 case (整 case 可全驻留) GM 写流量清零、输出时延降为 L2 写口;
3. S_A 之外输出 GM 写流量如实计入共享总线 → 修正单 batch 驻留判定导致的漏计;
4. dtype 感知算力: bf16 案例数值零回退; fp32/fp8/fp4/… 案例时延按 §2.1 表修正;
5. 新增回归: GM≥V_in 不变量 (全分支随机集)、S_A 输出落点开关、dtype 速率比例、
fp32 Cube 时延 = bf16 的 2 倍、字节列整芯片口径等;
6. examples 三件套重生成, 与模型改动前 diff 隔离后入库; 压力回归 0 违规/0 NaN。

72
BMM/BMM_Theory/examples/plans.csv
View File

@@ -2,44 +2,44 @@
to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split" to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split"
special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核" special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核"
special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)" special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)"
merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]" merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB)"
merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1 merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留
iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1 iter_demo_form_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(输出仅写一次,直写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" 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写最终" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超" 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超"
asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)"
b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)"
b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)"
b16_m4_n256_k192,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,4,256,192,192,1,标准核内流水,4,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)"
b32_m8_n128_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,8,128,256,256,1,a_单batch全驻留,8,128,128,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1 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驻留
b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B" 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), 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输入驻留(整case超L2, 输出直写GM) (V_in=3591.0MB, V_out=8.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮"
b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终" 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写最终" b16_m2_n4096_k7168,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,16,"B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16))",1,1,2,4096,448,256,1,K段标准分块流水,2,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=16路切K+归约,1,1,16,0,0,0,0,True,4,"P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终"
b32_m64_n64_k7168,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,64,64,7168,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B" 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(输出仅写一次,直写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" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), 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输入驻留(整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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮" b64_m1024_n8192_k2048,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,2048,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"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 无尾轮"
b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=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 无尾轮"
b32_m8192_n4096_k7168,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,24,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,7168,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,1128,True,2,"L2场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮" b32_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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮" b64_m4096_n2048_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,24,12,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮" b16_m1024_n1024_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,6,6,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),"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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=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 无尾轮"
b4_m131072_n128_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案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首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超" 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超"
b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超" 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超"
b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮" 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 无尾轮"
b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮" 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首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)" 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倍凑满核)"
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写最终" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.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输入驻留(整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首读倍率=2.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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.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首读倍率=2.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 无尾轮"
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单缓冲串行)" 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单缓冲串行)"
1 case_id branch npu op used_core_num split_b m_cnt n_cnt grid_k core_map b_core merge_b0 single_core_m single_core_n single_core_k k_l1 b_l1 l1_form base_m base_n base_k l2_policy_in l2_policy_out swizzle_w workspace_bytes tail_strategy tail_m_cnt tail_n_cnt tail_k_cnt tail_m_main tail_n_main tail_block_cnt tail_wave_num fixpipe_unitflag out_dtype_bytes note
2 to_matmul_demo 转Matmul Ascend950PR batch_mat_mul_v3 32 1 0 0 1 折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系 0 1 0 0 2048 0 1 0 0 0 0 0 转Matmul后由 Matmul 体系决定 1 1 1 0 0 0 0 True 2 BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split
3 special_k0_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 0 0 1 UB驻留(AIV) 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核
4 special_k1_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 1 0 1 UB驻留(AIV) UB乒乓 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)
5 merge_demo_k_trunc MergeBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B均分(核间零重复读零依赖) 64 4 128 128 256 256 8 合并驻留 128 128 128 allocate(GM->L1随路驻留L2) direct_gm resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128] b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB)
6 merge_iter_arbitrate IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 512 512 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留
7 iter_demo_form_b IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 256 256 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留
8 iter_demo_form_d IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 64 64 8192 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM
9 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写最终
10 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 52 52 1 52 52 2 139 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超
11 asw_demo_reduce_core ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 16 1 1 1 1 降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置 0 1 256 256 128 128 1 标准核内流水 256 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)
12 b4_m1_n128_k256 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 1 128 256 256 1 标准核内流水 1 128 128 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)
13 b8_m2_n192_k128 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 2 192 128 128 1 标准核内流水 2 192 80 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)
14 b16_m4_n256_k192 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 4 256 192 192 1 标准核内流水 4 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)
15 b32_m8_n128_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 8 128 256 256 1 a_单batch全驻留 8 128 128 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留
16 b64_m16_n256_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 16 256 512 240 1 c_一侧驻留+对侧切K 16 256 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留
17 b128_m8_n192_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 8 192 256 256 2 b_双batch乒乓 8 192 80 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留
18 b32_m16_n8192_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 1 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 47 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=3591.0MB, V_out=8.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
19 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写最终
20 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写最终
21 b32_m64_n64_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 64 64 7168 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留
22 b64_m1024_n1024_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 1024 1024 7168 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM
23 b128_m2048_n2048_k1536 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 1536 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=1536.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
24 b64_m1024_n8192_k2048 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 2048 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 564 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2304.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
25 b32_m1024_n1024_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 1024 1024 512 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留
26 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2304 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16384.0MB, V_out=4096.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
27 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 1128 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=5376.0MB, V_out=2048.0MB, L2=128MB), GM首读倍率=1.33; 尾轮: r=0 无尾轮
28 b32_m2048_n2048_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=2048.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
29 b64_m4096_n2048_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=96.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
30 b16_m1024_n1024_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 6 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 18 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=512.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
31 b4_m32768_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 187 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile) L2场景: A_整case全驻留(输入+输出<=L2) (V_in=32.1MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)
32 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 561 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=272.0MB, V_out=1024.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
33 b4_m131072_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 745 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 1 1 820 1 4 94 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile) 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)
34 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 7 1 820 7 16 1118 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile) 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)
35 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 52 1 205 52 16 4395 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超
36 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超
37 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 35015 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=1088.0MB, V_out=65536.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
38 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 17578 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=7680.0MB, V_out=32768.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
39 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A1b 2 2 1 2 2 24 8754 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核) 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倍凑满核)
40 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写最终
41 b64_m1024_n7168_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 41 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 492 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=7168.0MB, V_out=896.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
42 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2209 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=7168.0MB, V_out=4096.0MB, L2=128MB), GM首读倍率=2.00; 尾轮: r=0 无尾轮
43 b8_m4096_n4096_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 24 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=16.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: r=0 无尾轮
44 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 8836 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=28672.0MB, V_out=16384.0MB, L2=128MB), GM首读倍率=2.00; 尾轮: r=0 无尾轮
45 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单缓冲串行)

86
BMM/BMM_Theory/examples/result_evaluate.csv
View File

@@ -1,45 +1,45 @@
case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice
to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,1.6131938461538462e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除"
special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,3.2263876923076923e-06,0.0,3.2263876923076923e-06,0.0,3.2263876923076923e-06,FIXPIPE,True,,写出Bound(L2写口),"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.0567679999999999e-05,0.0,1.0567679999999999e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,3.103030303030303e-07,16777216,3.2263876923076923e-06,0.0,3.2263876923076923e-06,0.0,3.2263876923076923e-06,FIXPIPE,True,,写出Bound(L2写口),"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.5364479999999994e-05,3.0192408230452674e-07,4.566640408230452e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB)",67108864,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,4194304,8.065969230769231e-07,0.0,4.2743039999999997e-05,1.8849638999683443e-07,4.293153638999683e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.1341119999999999e-05,4.400081646090535e-07,1.1781128164609052e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留,16777216,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,536870912.0,1.104672658436214e-06,1048576,2.0164923076923077e-07,0.0,1.0685759999999999e-05,3.265804723013612e-07,1.101234047230136e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,6.09824e-06,3.0192408230452674e-07,6.400164082304526e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" iter_demo_form_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(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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 直写与读竞争" streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,3087007744,4.194304e-05,0.0005936553353846154,0.0006355983753846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0008033705353846154,0.0,0.0008033705353846154,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.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,3087007744,4.194304e-05,0.0005936553353846154,0.0006355983753846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0008033705353846154,0.0,0.0008033705353846154,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,8.065969230769231e-07,0.0,2.62144e-06,0.0,2.62144e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,8.065969230769231e-07,0.0,2.62144e-06,0.0,2.62144e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b4_m1_n128_k256,4,4,1,128,256,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",264192.0,0,5.28384e-06,0.0,5.28384e-06,0.0,0.0,262144.0,1.7260510288065844e-08,1024,6.3015384615384615e-09,0.0,5.28384e-06,0.0,5.28384e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",264192.0,0,5.28384e-06,0.0,5.28384e-06,0.0,0.0,262144.0,1.7260510288065844e-08,1024,6.3015384615384615e-09,0.0,5.28384e-06,0.0,5.28384e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b8_m2_n192_k128,8,8,2,192,128,bf16,bf16,bf16,False,False,False,True,0,b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",397312.0,0,7.94624e-06,0.0,7.94624e-06,0.0,0.0,786432.0,5.178153086419753e-08,6144,3.7809230769230766e-08,0.0,7.94624e-06,0.0,7.94624e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",397312.0,0,7.94624e-06,0.0,7.94624e-06,0.0,0.0,786432.0,5.178153086419753e-08,6144,3.7809230769230766e-08,0.0,7.94624e-06,0.0,7.94624e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b16_m4_n256_k192,16,16,4,256,192,bf16,bf16,bf16,False,False,False,True,0,b16_m4_n256_k192,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,4,256,192,192,1,标准核内流水,4,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",1597440.0,0,3.19488e-05,0.0,3.19488e-05,0.0,0.0,6291456.0,4.1425224691358024e-07,32768,2.0164923076923077e-07,0.0,3.19488e-05,0.0,3.19488e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",1597440.0,0,3.19488e-05,0.0,3.19488e-05,0.0,0.0,6291456.0,4.1425224691358024e-07,32768,2.0164923076923077e-07,0.0,3.19488e-05,0.0,3.19488e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b32_m8_n128_k256,32,32,8,128,256,bf16,bf16,bf16,False,False,False,True,0,b32_m8_n128_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,8,128,256,256,1,a_单batch全驻留,8,128,128,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.4836e-06,7.548102057613169e-08,1.5590810205761317e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b64_m16_n256_k512,64,64,16,256,512,bf16,bf16,bf16,False,False,False,True,0,b64_m16_n256_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,16,256,512,240,1,c_一侧驻留+对侧切K,16,256,64,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.629488e-05,2.932938271604938e-07,1.6588173827160495e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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 直写与读竞争"
b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.637760000000001e-06,1.1322153086419754e-07,8.7509815308642e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,1.6131938461538462e-06,0.0,0.0024183288123076924,0.0,0.0024183288123076924,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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 直写与读竞争"
b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.7033726806526807e-06,0.00033558528,1.7033726806526807e-06,0.00033728865268065273,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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.7159757575757577e-06,0.00058748928,1.7159757575757577e-06,0.0005892052557575758,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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.7214e-05,7.16176329218107e-07,3.7930176329218104e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B",58720256,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,30064771072.0,0.0019795734039176954,4194304,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.0002064888123076923,0.0,0.004413698363076923,0.0,0.004413698363076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.0002064888123076923,0.0,0.005949458904615385,0.0,0.005949458904615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,8.428607999999999e-05,5.078042126748971e-05,0.00013506650126748969,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",17179869184.0,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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首读倍率=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_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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,5.162220307692308e-05,0.0,0.005884931150769231,0.0,0.005884931150769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",100663296.0,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.0002064888123076923,0.0,0.0003532894523076923,0.0,0.0003532894523076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,6.452775384615385e-06,0.0,0.0008517663507692308,0.0,0.0008517663507692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",285212672.0,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800.0,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,2.581110153846154e-05,0.0,0.00010272137846153847,0.0,0.00010272137846153847,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216.0,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超",30064771072.0,0.0,0.01879048192,0.0,0.01879048192,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超",30064771072.0,0.0,0.01879048192,0.0,0.01879048192,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除"
b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超",2222981120.0,0.0,0.0013893632,0.0,0.0013893632,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00141033472,0.0,0.00141033472,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超",2222981120.0,0.0,0.0013893632,0.0,0.0013893632,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00141033472,0.0,0.00141033472,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",1140850688.0,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,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重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争"
b64_m32768_n8192_k1536,64,64,32768,8192,1536,bf16,bf16,bf16,False,False,False,True,0,b64_m32768_n8192_k1536,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1536,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,17578,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",8053063680.0,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",86973087744.0,0.0,0.05435817984,0.0,0.05435817984,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.2895833093731029,0.0,0.2895833093731029,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除" b8_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 交叉项) 可消除"
b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.0698331002331e-07,0.00011042185846153846,2.0698331002331e-07,0.00011062884177156177,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00018067771076923076,0.0,0.018248448787692308,0.0,0.018248448787692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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首读倍率=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 交叉项) 可消除" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",16777216.0,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,5.162220307692308e-05,0.0,8.469267692307693e-05,0.0,8.469267692307693e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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首读倍率=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 交叉项) 可消除" 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 交叉项) 可消除"
special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,1.985939393939394e-05,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" 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 直写与读竞争"
1 case_id batch_a batch_b m n k dtype_a dtype_b dtype_c trans_a trans_b has_bias out_nd deterministic_level plan_case_id plan_branch plan_npu plan_op plan_used_core_num plan_split_b plan_m_cnt plan_n_cnt plan_grid_k plan_core_map plan_b_core plan_merge_b0 plan_single_core_m plan_single_core_n plan_single_core_k plan_k_l1 plan_b_l1 plan_l1_form plan_base_m plan_base_n plan_base_k plan_l2_policy_in plan_l2_policy_out plan_swizzle_w plan_workspace_bytes plan_tail_strategy plan_tail_m_cnt plan_tail_n_cnt plan_tail_k_cnt plan_tail_m_main plan_tail_n_main plan_tail_block_cnt plan_tail_wave_num plan_fixpipe_unitflag plan_out_dtype_bytes plan_note gm_read_bytes l2_read_bytes t_mte2_gm t_mte2_l2 t_mte2 dma_cmd_count t_dma_cmd cube_flops t_mmad fixpipe_bytes t_fixpipe t_reduce t_steady t_drain t_total bottleneck feasible violations bound_type advice
2 to_matmul_demo 1 1 2048 2048 2048 bf16 bf16 bf16 False False False True 0 to_matmul_demo 转Matmul Ascend950PR batch_mat_mul_v3 32 1 0 0 1 折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系 0 1 0 0 2048 0 1 0 0 0 0 0 转Matmul后由 Matmul 体系决定 1 1 1 0 0 0 0 True 2 BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split 16777216 0.0 1.048576e-05 0.0 1.048576e-05 0.0 0.0 17179869184.0 3.534952506995885e-05 8388608 5.24288e-06 1.6131938461538462e-06 0.0 3.534952506995885e-05 0.0 3.534952506995885e-05 MMAD True 计算Bound 瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除
3 special_k0_demo 128 128 256 256 0 bf16 bf16 bf16 False False False True 0 special_k0_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 0 0 1 UB驻留(AIV) 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 16777216 1.048576e-05 3.2263876923076923e-06 0.0 1.048576e-05 3.2263876923076923e-06 0.0 1.048576e-05 3.2263876923076923e-06 MTE2 FIXPIPE True 访存Bound(GM读写共享+L2重复读) 写出Bound(L2写口) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争 瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略
4 special_k1_demo 128 128 256 256 1 bf16 bf16 bf16 False False False True 0 special_k1_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 1 0 1 UB驻留(AIV) UB乒乓 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水) 131072 0.0 8.192e-08 0.0 8.192e-08 0.0 0.0 8388608.0 6.206060606060606e-07 3.103030303030303e-07 16777216 1.048576e-05 3.2263876923076923e-06 0.0 1.0567679999999999e-05 3.2263876923076923e-06 0.0 1.0567679999999999e-05 3.2263876923076923e-06 MTE2 FIXPIPE True 访存Bound(GM读写共享+L2重复读) 写出Bound(L2写口) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争 瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略
5 merge_demo_k_trunc 2048 2048 32 32 256 bf16 bf16 bf16 False False False True 0 merge_demo_k_trunc MergeBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B均分(核间零重复读零依赖) 64 4 128 128 256 256 8 合并驻留 128 128 128 allocate(GM->L1随路驻留L2) direct_gm resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128] b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB) 2097152 67108864 0.0 4.194304e-05 0.0 4.2743039999999997e-05 16.0 8.000000000000001e-07 134217728.0 4294967296.0 8.837381267489712e-06 131072 4194304 2.62144e-06 8.065969230769231e-07 0.0 4.5364479999999994e-05 4.2743039999999997e-05 3.0192408230452674e-07 1.8849638999683443e-07 4.566640408230452e-05 4.293153638999683e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
6 merge_iter_arbitrate 128 128 64 64 512 bf16 bf16 bf16 False False False True 0 merge_iter_arbitrate IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 512 512 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留 524288 16777216 0.0 1.048576e-05 0.0 1.0685759999999999e-05 4 2.0000000000000002e-07 16777216.0 536870912.0 1.104672658436214e-06 32768 1048576 6.5536e-07 2.0164923076923077e-07 0.0 1.1341119999999999e-05 1.0685759999999999e-05 4.400081646090535e-07 3.265804723013612e-07 1.1781128164609052e-05 1.101234047230136e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
7 iter_demo_form_b 128 128 64 64 256 bf16 bf16 bf16 False False False True 0 iter_demo_form_b IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 256 256 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留 262144 8388608 0.0 5.24288e-06 0.0 5.4428799999999995e-06 4 2.0000000000000002e-07 8388608.0 268435456.0 5.52336329218107e-07 32768 1048576 6.5536e-07 2.0164923076923077e-07 0.0 6.09824e-06 5.4428799999999995e-06 3.0192408230452674e-07 1.8849638999683443e-07 6.400164082304526e-06 5.631376389996834e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
8 iter_demo_form_d 64 64 64 64 8192 bf16 bf16 bf16 False False False True 0 iter_demo_form_d IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 64 64 8192 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM 4194304 134217728 0.0 8.388608e-05 0.0 8.468608e-05 16 8.000000000000001e-07 134217728.0 4294967296.0 8.837381267489712e-06 16384 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 直写与读竞争
9 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 直写与读竞争
10 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 52 52 1 52 52 2 139 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超 67108864.0 3087007744 4.194304e-05 0.0005936553353846154 0.0006355983753846153 0.0 0.0 274877906944.0 0.0005655924011193416 268435456 0.00016777216 0.0 0.0008033705353846154 0.0 0.0008033705353846154 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
11 asw_demo_reduce_core 16 16 256 256 128 bf16 bf16 bf16 False False False True 0 asw_demo_reduce_core ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 16 1 1 1 1 降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置 0 1 256 256 128 128 1 标准核内流水 256 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 2097152.0 0 2.62144e-06 0.0 2.62144e-06 0.0 0.0 268435456.0 1.104672658436214e-06 2097152 8.065969230769231e-07 0.0 2.62144e-06 0.0 2.62144e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
12 b4_m1_n128_k256 4 4 1 128 256 bf16 bf16 bf16 False False False True 0 b4_m1_n128_k256 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 1 128 256 256 1 标准核内流水 1 128 128 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 264192.0 0 5.28384e-06 0.0 5.28384e-06 0.0 0.0 262144.0 1.7260510288065844e-08 1024 6.3015384615384615e-09 0.0 5.28384e-06 0.0 5.28384e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
13 b8_m2_n192_k128 8 8 2 192 128 bf16 bf16 bf16 False False False True 0 b8_m2_n192_k128 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 2 192 128 128 1 标准核内流水 2 192 80 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 397312.0 0 7.94624e-06 0.0 7.94624e-06 0.0 0.0 786432.0 5.178153086419753e-08 6144 3.7809230769230766e-08 0.0 7.94624e-06 0.0 7.94624e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
14 b16_m4_n256_k192 16 16 4 256 192 bf16 bf16 bf16 False False False True 0 b16_m4_n256_k192 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 4 256 192 192 1 标准核内流水 4 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 1597440.0 0 3.19488e-05 0.0 3.19488e-05 0.0 0.0 6291456.0 4.1425224691358024e-07 32768 2.0164923076923077e-07 0.0 3.19488e-05 0.0 3.19488e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
15 b32_m8_n128_k256 32 32 8 128 256 bf16 bf16 bf16 False False False True 0 b32_m8_n128_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 8 128 256 256 1 a_单batch全驻留 8 128 128 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留 69632 2228224 0.0 1.39264e-06 0.0 1.44264e-06 1 5.0000000000000004e-08 524288.0 16777216.0 3.452102057613169e-08 2048 65536 4.096e-08 1.2603076923076923e-08 0.0 1.4836e-06 1.44264e-06 7.548102057613169e-08 4.712409749920861e-08 1.5590810205761317e-06 1.4897640974992086e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
16 b64_m16_n256_k512 64 64 16 256 512 bf16 bf16 bf16 False False False True 0 b64_m16_n256_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 16 256 512 240 1 c_一侧驻留+对侧切K 16 256 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留 557056 25067520 0.0 1.56672e-05 0.0 1.5967200000000002e-05 6 3.0000000000000004e-07 8388608.0 268435456.0 5.52336329218107e-07 16384 524288 3.2768e-07 1.0082461538461538e-07 0.0 1.629488e-05 1.5967200000000002e-05 2.932938271604938e-07 1.798661348528015e-07 1.6588173827160495e-05 1.6147066134852802e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
17 b128_m8_n192_k256 128 128 8 192 256 bf16 bf16 bf16 False False False True 0 b128_m8_n192_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 8 192 256 256 2 b_双batch乒乓 8 192 80 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留 409600 13107200 0.0 8.192e-06 0.0 8.392e-06 4 2.0000000000000002e-07 3145728.0 100663296.0 2.0712612345679012e-07 12288 393216 2.4576e-07 7.561846153846153e-08 0.0 8.637760000000001e-06 8.392e-06 1.1322153086419754e-07 7.068614624881291e-08 8.7509815308642e-06 8.462686146248813e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
18 b32_m16_n8192_k7168 32 32 16 8192 7168 bf16 bf16 bf16 False False False True 0 b32_m16_n8192_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 1 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 47 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 1.6131938461538462e-06 5.24288e-06 0.0 0.0024183288123076924 0.0024235716923076923 0.0 0.0024183288123076924 0.0024235716923076923 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
19 b4_m1_n8192_k8192 4 4 1 8192 8192 bf16 bf16 bf16 False False False True 0 b4_m1_n8192_k8192 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 1 32 B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32)) 1 1 1 8192 256 256 1 K段标准分块流水 1 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 4194304 grid_K=32路切K+归约 1 1 32 0 0 0 0 True 4 P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 536936448 0.0 0.00033558528 0.0 0.00033558528 0.0 0.0 536870912.0 1.104672658436214e-06 0.0 0.0 1.7033726806526807e-06 1.731729603729604e-06 0.00033558528 1.7033726806526807e-06 1.731729603729604e-06 0.00033728865268065273 0.0003373170096037296 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
20 b16_m2_n4096_k7168 16 16 2 4096 7168 bf16 bf16 bf16 False False False True 0 b16_m2_n4096_k7168 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 1 16 B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16)) 1 1 2 4096 448 256 1 K段标准分块流水 2 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 8388608 grid_K=16路切K+归约 1 1 16 0 0 0 0 True 4 P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 939982848 0 0.00058748928 0.0 0.00058748928 0.0 0.0 1879048192.0 3.866354304526749e-06 0.0 0.0 1.7159757575757577e-06 1.7726896037296038e-06 0.00058748928 1.7159757575757577e-06 1.7726896037296038e-06 0.0005892052557575758 0.0005892619696037297 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
21 b32_m64_n64_k7168 32 32 64 64 7168 bf16 bf16 bf16 False False False True 0 b32_m64_n64_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 64 64 7168 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留 1835008 58720256 0.0 3.6700159999999995e-05 0.0 3.705016e-05 7 3.5000000000000004e-07 58720256.0 1879048192.0 3.866354304526749e-06 8192 262144 1.6384e-07 5.041230769230769e-08 0.0 3.7214e-05 3.705016e-05 7.16176329218107e-07 6.027486369104147e-07 3.7930176329218104e-05 3.7652908636910414e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
22 b64_m1024_n1024_k7168 64 64 1024 1024 7168 bf16 bf16 bf16 False False False True 0 b64_m1024_n1024_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 1024 1024 7168 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM 58720256 1879048192 0.0 0.0011744051199999998 0.0 0.00118560512 224 1.1200000000000001e-05 30064771072.0 962072674304.0 0.0019795734039176954 4194304 134217728 8.388608e-05 0.0 0.0019795734039176954 5.078042126748971e-05 0.0020303538251851853 MMAD True 计算Bound 瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除
23 b128_m2048_n2048_k1536 128 128 2048 2048 1536 bf16 bf16 bf16 False False False True 0 b128_m2048_n2048_k1536 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 1536 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.004413698363076923 0.005084787003076923 0.0 0.004413698363076923 0.005084787003076923 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
24 b64_m1024_n8192_k2048 64 64 1024 8192 2048 bf16 bf16 bf16 False False False True 0 b64_m1024_n8192_k2048 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 2048 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 564 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.005949458904615385 0.006620547544615385 0.0 0.005949458904615385 0.006620547544615385 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
25 b32_m1024_n1024_k512 32 32 1024 1024 512 bf16 bf16 bf16 False False False True 0 b32_m1024_n1024_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 1024 1024 512 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留 2097152 67108864 0.0 4.194304e-05 0.0 4.234304e-05 8 4.0000000000000003e-07 1073741824.0 34359738368.0 7.06990501399177e-05 2097152 67108864 4.194304e-05 1.290555076923077e-05 0.0 8.428607999999999e-05 7.06990501399177e-05 5.078042126748971e-05 2.1742932036720483e-05 0.00013506650126748969 9.244198217663819e-05 MTE2 MMAD True 访存Bound(GM读写共享+L2重复读) 计算Bound 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争 瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除
26 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2304 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 直写与读竞争
27 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 1128 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮 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 交叉项) 可消除
28 b32_m2048_n2048_k8192 32 32 2048 2048 8192 bf16 bf16 bf16 False False False True 0 b32_m2048_n2048_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 5.162220307692308e-05 0.00016777216 0.0 0.005884931150769231 0.006052703310769231 0.0 0.005884931150769231 0.006052703310769231 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
29 b64_m4096_n2048_k128 64 64 4096 2048 128 bf16 bf16 bf16 False False False True 0 b64_m4096_n2048_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.0003532894523076923 0.0010243780923076921 0.0 0.0003532894523076923 0.0010243780923076921 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
30 b16_m1024_n1024_k8192 16 16 1024 1024 8192 bf16 bf16 bf16 False False False True 0 b16_m1024_n1024_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 6 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 18 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 6.452775384615385e-06 2.097152e-05 0.0 0.0008517663507692308 0.0008727378707692308 0.0 0.0008517663507692308 0.0008727378707692308 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
31 b4_m32768_n128_k128 4 4 32768 128 128 bf16 bf16 bf16 False False False True 0 b4_m32768_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 187 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile) 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 直写与读竞争
32 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 561 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 直写与读竞争
33 b4_m131072_n128_k128 4 4 131072 128 128 bf16 bf16 bf16 False False False True 0 b4_m131072_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 745 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 1 1 820 1 4 94 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile) 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 2.581110153846154e-05 8.388608e-05 0.0 0.00010272137846153847 0.00018660745846153846 0.0 0.00010272137846153847 0.00018660745846153846 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
34 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 7 1 820 7 16 1118 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile) 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 直写与读竞争
35 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 52 1 205 52 16 4395 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超 30064771072.0 0.0 0.01879048192 0.0 0.01879048192 0.0 0.0 61572651155456.0 0.1266926978507325 8589934592 0.00536870912 0.0 0.1266926978507325 0.0 0.1266926978507325 MMAD True 计算Bound 瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除
36 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超 2222981120.0 0.0 0.0013893632 0.0 0.0013893632 0.0 0.0 274877906944.0 0.0005655924011193416 33554432 2.097152e-05 0.0 0.00141033472 0.0 0.00141033472 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
37 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 35015 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 直写与读竞争
38 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 17578 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 直写与读竞争
39 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A1b 2 2 1 2 2 24 8754 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核) 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 交叉项) 可消除
40 b8_m16_n7168_k1536 8 8 16 7168 1536 bf16 bf16 bf16 False False False True 0 b8_m16_n7168_k1536 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 2 2 B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2)) 1 1 16 3584 768 256 1 K段标准分块流水 16 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 3670016 grid_K=2路切K+归约 1 1 2 0 0 0 0 True 4 P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 176553984 393216 0.00011034624 7.561846153846153e-08 0.00011042185846153846 0.0 0.0 2818572288.0 5.799531456790123e-06 0.0 0.0 2.0698331002331e-07 2.566079254079254e-07 0.00011042185846153846 2.0698331002331e-07 2.566079254079254e-07 0.00011062884177156177 0.00011067846638694638 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
41 b64_m1024_n7168_k7168 64 64 1024 7168 7168 bf16 bf16 bf16 False False False True 0 b64_m1024_n7168_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 41 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 492 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.00018067771076923076 0.00058720256 0.0 0.018248448787692308 0.018835651347692307 0.0 0.018248448787692308 0.018835651347692307 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
42 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2209 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 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 交叉项) 可消除
43 b8_m4096_n4096_k128 8 8 4096 4096 128 bf16 bf16 bf16 False False False True 0 b8_m4096_n4096_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 24 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 5.162220307692308e-05 0.00016777216 0.0 8.469267692307693e-05 0.0002524648369230769 0.0 8.469267692307693e-05 0.0002524648369230769 MTE2 True 访存Bound(GM读写共享+L2重复读) 瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争
44 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 8836 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 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 交叉项) 可消除
45 special_k1_b64 64 64 8192 512 1 bf16 bf16 bf16 False False False True 0 special_k1_b64 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 1 0 1 UB驻留(AIV) AIV单缓冲 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行) 1114112 0.0 6.9632e-07 0.0 6.9632e-07 0.0 0.0 268435456.0 1.985939393939394e-05 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 直写与读竞争

86
BMM/BMM_Theory/examples/result_recommend.csv
View File

@@ -1,45 +1,45 @@
case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice
to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"BatchA=1或BatchB=1, 折叠转普通Matmul" to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,1.6131938461538462e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"BatchA=1或BatchB=1, 折叠转普通Matmul"
special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),K=0纯写值 special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,3.2263876923076923e-06,0.0,3.2263876923076923e-06,0.0,3.2263876923076923e-06,FIXPIPE,True,,写出Bound(L2写口),K=0纯写值
special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.0567679999999999e-05,0.0,1.0567679999999999e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"K=1逐元素乘, 走AIV向量通路" special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,3.103030303030303e-07,16777216,3.2263876923076923e-06,0.0,3.2263876923076923e-06,0.0,3.2263876923076923e-06,FIXPIPE,True,,写出Bound(L2写口),"K=1逐元素乘, 走AIV向量通路"
merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.5364479999999994e-05,3.0192408230452674e-07,4.566640408230452e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=45.67us vs T_IterBatch=47.84us -> MergeBatch更优; [裁决] MergeBatch" merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB)",67108864,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,4194304,8.065969230769231e-07,0.0,4.2743039999999997e-05,1.8849638999683443e-07,4.293153638999683e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=42.93us vs T_IterBatch=45.19us -> MergeBatch更优; [裁决] MergeBatch"
merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.1341119999999999e-05,4.400081646090535e-07,1.1781128164609052e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=12.14us vs T_IterBatch=11.78us -> IterBatch更优; [裁决] IterBatch" merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留,16777216,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,536870912.0,1.104672658436214e-06,1048576,2.0164923076923077e-07,0.0,1.0685759999999999e-05,3.265804723013612e-07,1.101234047230136e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=11.26us vs T_IterBatch=11.01us -> IterBatch更优; [裁决] IterBatch"
iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,6.09824e-06,3.0192408230452674e-07,6.400164082304526e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 iter_demo_form_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(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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)" streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)"
asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,3087007744,4.194304e-05,0.0005936553353846154,0.0006355983753846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0008033705353846154,0.0,0.0008033705353846154,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_归约代价可接受) 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,3087007744,4.194304e-05,0.0005936553353846154,0.0006355983753846153,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0008033705353846154,0.0,0.0008033705353846154,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_归约代价可接受)
asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,8.065969230769231e-07,0.0,2.62144e-06,0.0,2.62144e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2) 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,8.065969230769231e-07,0.0,2.62144e-06,0.0,2.62144e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2)
b4_m1_n128_k256,4,4,1,128,256,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n128_k256,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,1,128,256,256,1,标准核内流水,1,128,128,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",264192.0,0,5.28384e-06,0.0,5.28384e-06,0.0,0.0,262144.0,1.7260510288065844e-08,1024,6.3015384615384615e-09,0.0,5.28384e-06,0.0,5.28384e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c) 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",264192.0,0,5.28384e-06,0.0,5.28384e-06,0.0,0.0,262144.0,1.7260510288065844e-08,1024,6.3015384615384615e-09,0.0,5.28384e-06,0.0,5.28384e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
b8_m2_n192_k128,8,8,2,192,128,bf16,bf16,bf16,False,False,False,True,0,b8_m2_n192_k128,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,2,192,128,128,1,标准核内流水,2,192,80,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",397312.0,0,7.94624e-06,0.0,7.94624e-06,0.0,0.0,786432.0,5.178153086419753e-08,6144,3.7809230769230766e-08,0.0,7.94624e-06,0.0,7.94624e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",397312.0,0,7.94624e-06,0.0,7.94624e-06,0.0,0.0,786432.0,5.178153086419753e-08,6144,3.7809230769230766e-08,0.0,7.94624e-06,0.0,7.94624e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
b16_m4_n256_k192,16,16,4,256,192,bf16,bf16,bf16,False,False,False,True,0,b16_m4_n256_k192,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,1,1,1,1,1,"降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置",0,1,4,256,192,192,1,标准核内流水,4,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",1597440.0,0,3.19488e-05,0.0,3.19488e-05,0.0,0.0,6291456.0,4.1425224691358024e-07,32768,2.0164923076923077e-07,0.0,3.19488e-05,0.0,3.19488e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 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<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",1597440.0,0,3.19488e-05,0.0,3.19488e-05,0.0,0.0,6291456.0,4.1425224691358024e-07,32768,2.0164923076923077e-07,0.0,3.19488e-05,0.0,3.19488e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
b32_m8_n128_k256,32,32,8,128,256,bf16,bf16,bf16,False,False,False,True,0,b32_m8_n128_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,8,128,256,256,1,a_单batch全驻留,8,128,128,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,单batch全驻留: (MK+KN)*dtype=68KB <= L1,69632,0.0,1.39264e-06,0.0,1.44264e-06,1,5.0000000000000004e-08,524288.0,3.452102057613169e-08,2048,4.096e-08,0.0,1.4836e-06,7.548102057613169e-08,1.5590810205761317e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B",557056,0.0,1.56672e-05,0.0,1.5967200000000002e-05,6,3.0000000000000004e-07,8388608.0,5.52336329218107e-07,16384,3.2768e-07,0.0,1.629488e-05,2.932938271604938e-07,1.6588173827160495e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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 条件满足
b128_m8_n192_k256,128,128,8,192,256,bf16,bf16,bf16,False,False,False,True,0,b128_m8_n192_k256,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,8,192,256,256,2,b_双batch乒乓,8,192,80,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1,409600,0.0,8.192e-06,0.0,8.392e-06,4,2.0000000000000002e-07,3145728.0,2.0712612345679012e-07,12288,2.4576e-07,0.0,8.637760000000001e-06,1.1322153086419754e-07,8.7509815308642e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,47,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",3765436416.0,337641472,0.00235339776,6.493105230769231e-05,0.0024183288123076924,0.0,0.0,60129542144.0,0.00012372333774485596,8388608,1.6131938461538462e-06,0.0,0.0024183288123076924,0.0,0.0024183288123076924,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B" 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"
b4_m1_n8192_k8192,4,4,1,8192,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m1_n8192_k8192,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,1,8192,256,256,1,K段标准分块流水,1,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,4194304,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",536936448,0.0,0.00033558528,0.0,0.00033558528,0.0,0.0,536870912.0,1.104672658436214e-06,0.0,0.0,1.7033726806526807e-06,0.00033558528,1.7033726806526807e-06,0.00033728865268065273,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" 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.7159757575757577e-06,0.00058748928,1.7159757575757577e-06,0.0005892052557575758,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=16)" 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),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B",1835008,0.0,3.6700159999999995e-05,0.0,3.705016e-05,7,3.5000000000000004e-07,58720256.0,3.866354304526749e-06,8192,1.6384e-07,0.0,3.7214e-05,7.16176329218107e-07,3.7930176329218104e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B",58720256,0.0,0.0011744051199999998,0.0,0.00118560512,224,1.1200000000000001e-05,30064771072.0,0.0019795734039176954,4194304,8.388608e-05,0.0,0.0019795734039176954,5.078042126748971e-05,0.0020303538251851853,MMAD,True,,计算Bound,仅 IterBatch 条件满足 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",1610612736.0,17716740096,0.00100663296,0.003407065403076923,0.004413698363076923,0.0,0.0,1649267441664.0,0.0033935544067160493,1073741824,0.0002064888123076923,0.0,0.004413698363076923,0.0,0.004413698363076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,564,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2415919104.0,23085449216,0.00150994944,0.004439509464615385,0.005949458904615385,0.0,0.0,2199023255552.0,0.004524739208954733,1073741824,0.0002064888123076923,0.0,0.005949458904615385,0.0,0.005949458904615385,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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_m1024_n1024_k512,32,32,1024,1024,512,bf16,bf16,bf16,False,False,False,True,0,b32_m1024_n1024_k512,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),1,1,1024,1024,512,64,1,d_两侧都切K,176,176,64,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B",2097152,0.0,4.194304e-05,0.0,4.234304e-05,8,4.0000000000000003e-07,1073741824.0,7.06990501399177e-05,2097152,4.194304e-05,0.0,8.428607999999999e-05,5.078042126748971e-05,0.00013506650126748969,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",17179869184.0,395136991232,0.01073741824,0.07598788292923077,0.08672530116923077,0.0,0.0,35184372088832.0,0.07239582734327572,4294967296,0.00268435456,0.0,0.08940965572923076,0.0,0.08940965572923076,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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首读倍率=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_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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",2147483648.0,23622320128,0.00134217728,0.004542753870769231,0.005884931150769231,0.0,0.0,2199023255552.0,0.004524739208954733,268435456,5.162220307692308e-05,0.0,0.005884931150769231,0.0,0.005884931150769231,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,576,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",100663296.0,1509949440,6.291456e-05,0.0002903748923076923,0.0003532894523076923,0.0,0.0,137438953472.0,0.0002827962005596708,1073741824,0.0002064888123076923,0.0,0.0003532894523076923,0.0,0.0003532894523076923,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,18,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",536870912.0,2684354560,0.00033554432,0.0005162220307692308,0.0008517663507692308,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,6.452775384615385e-06,0.0,0.0008517663507692308,0.0,0.0008517663507692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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(输出驻留L2异步回写),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile)",33685504.0,24379392,2.105344e-05,4.688344615384615e-06,2.5741784615384616e-05,0.0,0.0,4294967296.0,8.837381267489712e-06,33554432,6.452775384615385e-06,0.0,2.5741784615384616e-05,0.0,2.5741784615384616e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",285212672.0,6073352192,0.00017825792,0.0011679523446153847,0.0013462102646153848,0.0,0.0,549755813888.0,0.0011311848022386832,1073741824,0.00067108864,0.0,0.0020172989046153846,0.0,0.0020172989046153846,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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吸收重复读),resident(输出驻留L2异步回写),4,0,方案B,820,1,1,820,1,4,94,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile)",134348800.0,97517568,8.3968e-05,1.875337846153846e-05,0.00010272137846153847,0.0,0.0,17179869184.0,3.534952506995885e-05,134217728,2.581110153846154e-05,0.0,0.00010272137846153847,0.0,0.00010272137846153847,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile)",541065216.0,5804916736,0.00033816576,0.0011163301415384615,0.0014544959015384616,0.0,0.0,549755813888.0,0.0011311848022386832,2147483648,0.00134217728,0.0,0.0027966731815384617,0.0,0.0027966731815384617,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超",30064771072.0,0.0,0.01879048192,0.0,0.01879048192,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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<rho_dv=0.53, A1b被dValue卡死, 方案B反超",30064771072.0,0.0,0.01879048192,0.0,0.01879048192,0.0,0.0,61572651155456.0,0.1266926978507325,8589934592,0.00536870912,0.0,0.1266926978507325,0.0,0.1266926978507325,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
b4_m32768_n128_k8192,4,4,32768,128,8192,bf16,bf16,bf16,False,False,False,True,0,b4_m32768_n128_k8192,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,187,1,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,8192,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,205,1,1,205,1,12,24,True,2,"L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超",2222981120.0,0.0,0.0013893632,0.0,0.0013893632,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00141033472,0.0,0.00141033472,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_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<rho_dv=0.53, A1b被dValue卡死, 方案B反超",2222981120.0,0.0,0.0013893632,0.0,0.0013893632,0.0,0.0,274877906944.0,0.0005655924011193416,33554432,2.097152e-05,0.0,0.00141033472,0.0,0.00141033472,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
b32_m131072_n8192_k128,32,32,131072,8192,128,bf16,bf16,bf16,False,False,False,True,0,b32_m131072_n8192_k128,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,745,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,128,128,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,A0,1,1,1,0,0,0,35015,True,2,"L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",1140850688.0,99321118720,0.00071303168,0.019100215138461538,0.019813246818461538,0.0,0.0,8796093022208.0,0.01809895683581893,68719476736,0.04294967296,0.0,0.06276291977846153,0.0,0.06276291977846153,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮",8053063680.0,595926712320,0.0050331648,0.11460129083076923,0.11963445563076923,0.0,0.0,52776558133248.0,0.10859374101491358,34359738368,0.02147483648,0.0,0.14110929211076922,0.0,0.14110929211076922,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核)",86973087744.0,0.0,0.05435817984,0.0,0.05435817984,0.0,0.0,140737488355328.0,0.2895833093731029,17179869184,0.01073741824,0.0,0.2895833093731029,0.0,0.2895833093731029,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) b8_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_归约代价可接受)
b8_m16_n7168_k1536,8,8,16,7168,1536,bf16,bf16,bf16,False,False,False,True,0,b8_m16_n7168_k1536,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,2,2,"B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2))",1,1,16,3584,768,256,1,K段标准分块流水,16,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,3670016,grid_K=2路切K+归约,1,1,2,0,0,0,0,True,4,"P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",176553984,393216,0.00011034624,7.561846153846153e-08,0.00011042185846153846,0.0,0.0,2818572288.0,5.799531456790123e-06,0.0,0.0,2.0698331002331e-07,0.00011042185846153846,2.0698331002331e-07,0.00011062884177156177,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=2)" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,492,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",7516192768.0,70464307200,0.00469762048,0.013550828307692308,0.018248448787692308,0.0,0.0,6734508720128.0,0.013857013827423869,939524096,0.00018067771076923076,0.0,0.018248448787692308,0.0,0.018248448787692308,MTE2,True,,访存Bound(GM读写共享+L2重复读),"IterBatch/MergeBatch 进入条件均不满足, 回落 ASW_Basic; IterBatch未过: 3_L1驻留形态(四选一, 核心要求: 单batch核内零重复读); MergeBatch未过: 1_batch关系与每核份额: BatchA==BatchB 且 b_core=B/C>=2*b0; 2_L0C容量: 2*(b0*M)*(b0*N)*4B <= L0C; 2b_L0AB容量: 合并后 b0*M/b0*N 在最小K粒度下可驻留 L0A/L0B; 5_访存Bound: 2MN/(M+N) < R16/b0" 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首读倍率=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" 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吸收重复读),resident(输出驻留L2异步回写),4,0,A0,1,1,1,0,0,0,144,True,2,"L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮",16777216.0,385875968,1.048576e-05,7.420691692307692e-05,8.469267692307693e-05,0.0,0.0,34359738368.0,7.06990501399177e-05,268435456,5.162220307692308e-05,0.0,8.469267692307693e-05,0.0,8.469267692307693e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受) 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首读倍率=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" 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"
special_k1_b64,64,64,8192,512,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_b64,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) AIV单缓冲,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行)",1114112,0.0,6.9632e-07,0.0,6.9632e-07,0.0,0.0,268435456.0,1.985939393939394e-05,536870912,0.00033554432,0.0,0.00033624063999999996,0.0,0.00033624063999999996,MTE2,True,,访存Bound(GM读写共享+L2重复读),"K=1逐元素乘, 走AIV向量通路" 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向量通路"
1 case_id batch_a batch_b m n k dtype_a dtype_b dtype_c trans_a trans_b has_bias out_nd deterministic_level plan_case_id plan_branch plan_npu plan_op plan_used_core_num plan_split_b plan_m_cnt plan_n_cnt plan_grid_k plan_core_map plan_b_core plan_merge_b0 plan_single_core_m plan_single_core_n plan_single_core_k plan_k_l1 plan_b_l1 plan_l1_form plan_base_m plan_base_n plan_base_k plan_l2_policy_in plan_l2_policy_out plan_swizzle_w plan_workspace_bytes plan_tail_strategy plan_tail_m_cnt plan_tail_n_cnt plan_tail_k_cnt plan_tail_m_main plan_tail_n_main plan_tail_block_cnt plan_tail_wave_num plan_fixpipe_unitflag plan_out_dtype_bytes plan_note gm_read_bytes l2_read_bytes t_mte2_gm t_mte2_l2 t_mte2 dma_cmd_count t_dma_cmd cube_flops t_mmad fixpipe_bytes t_fixpipe t_reduce t_steady t_drain t_total bottleneck feasible violations bound_type advice
2 to_matmul_demo 1 1 2048 2048 2048 bf16 bf16 bf16 False False False True 0 to_matmul_demo 转Matmul Ascend950PR batch_mat_mul_v3 32 1 0 0 1 折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系 0 1 0 0 2048 0 1 0 0 0 0 0 转Matmul后由 Matmul 体系决定 1 1 1 0 0 0 0 True 2 BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split 16777216 0.0 1.048576e-05 0.0 1.048576e-05 0.0 0.0 17179869184.0 3.534952506995885e-05 8388608 5.24288e-06 1.6131938461538462e-06 0.0 3.534952506995885e-05 0.0 3.534952506995885e-05 MMAD True 计算Bound BatchA=1或BatchB=1, 折叠转普通Matmul
3 special_k0_demo 128 128 256 256 0 bf16 bf16 bf16 False False False True 0 special_k0_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 0 0 1 UB驻留(AIV) 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 16777216 1.048576e-05 3.2263876923076923e-06 0.0 1.048576e-05 3.2263876923076923e-06 0.0 1.048576e-05 3.2263876923076923e-06 MTE2 FIXPIPE True 访存Bound(GM读写共享+L2重复读) 写出Bound(L2写口) K=0纯写值
4 special_k1_demo 128 128 256 256 1 bf16 bf16 bf16 False False False True 0 special_k1_demo 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 1 0 1 UB驻留(AIV) UB乒乓 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水) 131072 0.0 8.192e-08 0.0 8.192e-08 0.0 0.0 8388608.0 6.206060606060606e-07 3.103030303030303e-07 16777216 1.048576e-05 3.2263876923076923e-06 0.0 1.0567679999999999e-05 3.2263876923076923e-06 0.0 1.0567679999999999e-05 3.2263876923076923e-06 MTE2 FIXPIPE True 访存Bound(GM读写共享+L2重复读) 写出Bound(L2写口) K=1逐元素乘, 走AIV向量通路
5 merge_demo_k_trunc 2048 2048 32 32 256 bf16 bf16 bf16 False False False True 0 merge_demo_k_trunc MergeBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B均分(核间零重复读零依赖) 64 4 128 128 256 256 8 合并驻留 128 128 128 allocate(GM->L1随路驻留L2) direct_gm resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128] b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]; 输出落点: L2驻留 (整case V_in+V_out=64.0MB vs L2=128MB) 2097152 67108864 0.0 4.194304e-05 0.0 4.2743039999999997e-05 16.0 8.000000000000001e-07 134217728.0 4294967296.0 8.837381267489712e-06 131072 4194304 2.62144e-06 8.065969230769231e-07 0.0 4.5364479999999994e-05 4.2743039999999997e-05 3.0192408230452674e-07 1.8849638999683443e-07 4.566640408230452e-05 4.293153638999683e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=45.67us vs T_IterBatch=47.84us -> MergeBatch更优; [裁决] MergeBatch 两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=42.93us vs T_IterBatch=45.19us -> MergeBatch更优; [裁决] MergeBatch
6 merge_iter_arbitrate 128 128 64 64 512 bf16 bf16 bf16 False False False True 0 merge_iter_arbitrate IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 512 512 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0) 0 0 不涉及(核内不切M/N) 1 1 1 0 0 0 0 True 2 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1 双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1; 输出落点: L2驻留 524288 16777216 0.0 1.048576e-05 0.0 1.0685759999999999e-05 4 2.0000000000000002e-07 16777216.0 536870912.0 1.104672658436214e-06 32768 1048576 6.5536e-07 2.0164923076923077e-07 0.0 1.1341119999999999e-05 1.0685759999999999e-05 4.400081646090535e-07 3.265804723013612e-07 1.1781128164609052e-05 1.101234047230136e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=12.14us vs T_IterBatch=11.78us -> IterBatch更优; [裁决] IterBatch 两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=11.26us vs T_IterBatch=11.01us -> IterBatch更优; [裁决] IterBatch
7 iter_demo_form_b 128 128 64 64 256 bf16 bf16 bf16 False False False True 0 iter_demo_form_b IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 64 64 256 256 2 b_双batch乒乓 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留 262144 8388608 0.0 5.24288e-06 0.0 5.4428799999999995e-06 4 2.0000000000000002e-07 8388608.0 268435456.0 5.52336329218107e-07 32768 1048576 6.5536e-07 2.0164923076923077e-07 0.0 6.09824e-06 5.4428799999999995e-06 3.0192408230452674e-07 1.8849638999683443e-07 6.400164082304526e-06 5.631376389996834e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
8 iter_demo_form_d 64 64 64 64 8192 bf16 bf16 bf16 False False False True 0 iter_demo_form_d IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 64 64 8192 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM 4194304 134217728 0.0 8.388608e-05 0.0 8.468608e-05 16 8.000000000000001e-07 134217728.0 4294967296.0 8.837381267489712e-06 16384 524288 3.2768e-07 0.0 8.501376e-05 7.16176329218107e-07 8.572993632921812e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
9 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)
10 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 52 52 1 52 52 2 139 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: B_单batch输入驻留(整case超L2, 输出直写GM) (V_in=64.0MB, V_out=256.0MB, L2=128MB), GM首读倍率=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超 67108864.0 3087007744 4.194304e-05 0.0005936553353846154 0.0006355983753846153 0.0 0.0 274877906944.0 0.0005655924011193416 268435456 0.00016777216 0.0 0.0008033705353846154 0.0 0.0008033705353846154 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_归约代价可接受)
11 asw_demo_reduce_core 16 16 256 256 128 bf16 bf16 bf16 False False False True 0 asw_demo_reduce_core ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 16 1 1 1 1 降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置 0 1 256 256 128 128 1 标准核内流水 256 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 2097152.0 0 2.62144e-06 0.0 2.62144e-06 0.0 0.0 268435456.0 1.104672658436214e-06 2097152 8.065969230769231e-07 0.0 2.62144e-06 0.0 2.62144e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2)
12 b4_m1_n128_k256 4 4 1 128 256 bf16 bf16 bf16 False False False True 0 b4_m1_n128_k256 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 1 128 256 256 1 标准核内流水 1 128 128 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.01<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 264192.0 0 5.28384e-06 0.0 5.28384e-06 0.0 0.0 262144.0 1.7260510288065844e-08 1024 6.3015384615384615e-09 0.0 5.28384e-06 0.0 5.28384e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
13 b8_m2_n192_k128 8 8 2 192 128 bf16 bf16 bf16 False False False True 0 b8_m2_n192_k128 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 2 192 128 128 1 标准核内流水 2 192 80 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.05<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 397312.0 0 7.94624e-06 0.0 7.94624e-06 0.0 0.0 786432.0 5.178153086419753e-08 6144 3.7809230769230766e-08 0.0 7.94624e-06 0.0 7.94624e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
14 b16_m4_n256_k192 16 16 4 256 192 bf16 bf16 bf16 False False False True 0 b16_m4_n256_k192 ASW_Basic_降核 Ascend950PR batch_mat_mul_v3 1 1 1 1 1 降核: 只用1核, 每核一个L0C满载输出块, 其余核闲置 0 1 4 256 192 192 1 标准核内流水 4 256 64 allocate direct_gm resident(整case全驻留S_A) 0 0 不涉及(每核一块无尾轮) 1 1 1 0 0 0 0 True 2 P=0.25<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢) 1597440.0 0 3.19488e-05 0.0 3.19488e-05 0.0 0.0 6291456.0 4.1425224691358024e-07 32768 2.0164923076923077e-07 0.0 3.19488e-05 0.0 3.19488e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受: K > grid_K^2/(grid_K-1)*theta_c)
15 b32_m8_n128_k256 32 32 8 128 256 bf16 bf16 bf16 False False False True 0 b32_m8_n128_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 8 128 256 256 1 a_单batch全驻留 8 128 128 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 单batch全驻留: (MK+KN)*dtype=68KB <= L1; 输出落点: L2驻留 69632 2228224 0.0 1.39264e-06 0.0 1.44264e-06 1 5.0000000000000004e-08 524288.0 16777216.0 3.452102057613169e-08 2048 65536 4.096e-08 1.2603076923076923e-08 0.0 1.4836e-06 1.44264e-06 7.548102057613169e-08 4.712409749920861e-08 1.5590810205761317e-06 1.4897640974992086e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
16 b64_m16_n256_k512 64 64 16 256 512 bf16 bf16 bf16 False False False True 0 b64_m16_n256_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 16 256 512 240 1 c_一侧驻留+对侧切K 16 256 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 一侧驻留(A)+对侧切K: A驻留16KB, 预算L1/2, k_L1=240, dValueA=480B/dValueB=512B; 输出落点: L2驻留 557056 25067520 0.0 1.56672e-05 0.0 1.5967200000000002e-05 6 3.0000000000000004e-07 8388608.0 268435456.0 5.52336329218107e-07 16384 524288 3.2768e-07 1.0082461538461538e-07 0.0 1.629488e-05 1.5967200000000002e-05 2.932938271604938e-07 1.798661348528015e-07 1.6588173827160495e-05 1.6147066134852802e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
17 b128_m8_n192_k256 128 128 8 192 256 bf16 bf16 bf16 False False False True 0 b128_m8_n192_k256 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 4 1 8 192 256 256 2 b_双batch乒乓 8 192 80 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 双batch乒乓: 2*(MK+KN)*dtype=200KB <= L1; 输出落点: L2驻留 409600 13107200 0.0 8.192e-06 0.0 8.392e-06 4 2.0000000000000002e-07 3145728.0 100663296.0 2.0712612345679012e-07 12288 393216 2.4576e-07 7.561846153846153e-08 0.0 8.637760000000001e-06 8.392e-06 1.1322153086419754e-07 7.068614624881291e-08 8.7509815308642e-06 8.462686146248813e-06 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
18 b32_m16_n8192_k7168 32 32 16 8192 7168 bf16 bf16 bf16 False False False True 0 b32_m16_n8192_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 1 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 47 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 1.6131938461538462e-06 5.24288e-06 0.0 0.0024183288123076924 0.0024235716923076923 0.0 0.0024183288123076924 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
19 b4_m1_n8192_k8192 4 4 1 8192 8192 bf16 bf16 bf16 False False False True 0 b4_m1_n8192_k8192 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 1 32 B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32)) 1 1 1 8192 256 256 1 K段标准分块流水 1 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 4194304 grid_K=32路切K+归约 1 1 32 0 0 0 0 True 4 P=0.50, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 536936448 0.0 0.00033558528 0.0 0.00033558528 0.0 0.0 536870912.0 1.104672658436214e-06 0.0 0.0 1.7033726806526807e-06 1.731729603729604e-06 0.00033558528 1.7033726806526807e-06 1.731729603729604e-06 0.00033728865268065273 0.0003373170096037296 MTE2 True 访存Bound(GM读写共享+L2重复读) P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)
20 b16_m2_n4096_k7168 16 16 2 4096 7168 bf16 bf16 bf16 False False False True 0 b16_m2_n4096_k7168 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 1 16 B/M/N切出16块, 每块16核切K归约 (归约组内核c负责K段[c*K/16,(c+1)*K/16)) 1 1 2 4096 448 256 1 K段标准分块流水 2 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 8388608 grid_K=16路切K+归约 1 1 16 0 0 0 0 True 4 P=2.00, grid_K=16, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 939982848 0 0.00058748928 0.0 0.00058748928 0.0 0.0 1879048192.0 3.866354304526749e-06 0.0 0.0 1.7159757575757577e-06 1.7726896037296038e-06 0.00058748928 1.7159757575757577e-06 1.7726896037296038e-06 0.0005892052557575758 0.0005892619696037297 MTE2 True 访存Bound(GM读写共享+L2重复读) P<=C/2, B/M/N并行度买不满, 切K (grid_K=16)
21 b32_m64_n64_k7168 32 32 64 64 7168 bf16 bf16 bf16 False False False True 0 b32_m64_n64_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 64 64 7168 1024 1 d_两侧都切K 64 64 256 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: L2驻留 1835008 58720256 0.0 3.6700159999999995e-05 0.0 3.705016e-05 7 3.5000000000000004e-07 58720256.0 1879048192.0 3.866354304526749e-06 8192 262144 1.6384e-07 5.041230769230769e-08 0.0 3.7214e-05 3.705016e-05 7.16176329218107e-07 6.027486369104147e-07 3.7930176329218104e-05 3.7652908636910414e-05 MTE2 True 访存Bound(GM读写共享+L2重复读) 仅 IterBatch 条件满足
22 b64_m1024_n1024_k7168 64 64 1024 1024 7168 bf16 bf16 bf16 False False False True 0 b64_m1024_n1024_k7168 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 2 1 1024 1024 7168 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: 直写GM 58720256 1879048192 0.0 0.0011744051199999998 0.0 0.00118560512 224 1.1200000000000001e-05 30064771072.0 962072674304.0 0.0019795734039176954 4194304 134217728 8.388608e-05 0.0 0.0019795734039176954 5.078042126748971e-05 0.0020303538251851853 MMAD True 计算Bound 仅 IterBatch 条件满足
23 b128_m2048_n2048_k1536 128 128 2048 2048 1536 bf16 bf16 bf16 False False False True 0 b128_m2048_n2048_k1536 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 1536 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.004413698363076923 0.005084787003076923 0.0 0.004413698363076923 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
24 b64_m1024_n8192_k2048 64 64 1024 8192 2048 bf16 bf16 bf16 False False False True 0 b64_m1024_n8192_k2048 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 47 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 2048 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 564 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.005949458904615385 0.006620547544615385 0.0 0.005949458904615385 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
25 b32_m1024_n1024_k512 32 32 1024 1024 512 bf16 bf16 bf16 False False False True 0 b32_m1024_n1024_k512 IterBatch Ascend950PR batch_mat_mul_v3 32 32 1 1 1 切B轮转分配(核间零重复读零依赖) 1 1 1024 1024 512 64 1 d_两侧都切K 176 176 64 allocate(GM->L1随路驻留L2) direct_gm(输出仅写一次,直写GM不占L2) 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 两侧都切K: k_L1=64, K段成对流水, batch边界天然无缝; dValueA=128B/dValueB=2048B; 输出落点: L2驻留 2097152 67108864 0.0 4.194304e-05 0.0 4.234304e-05 8 4.0000000000000003e-07 1073741824.0 34359738368.0 7.06990501399177e-05 2097152 67108864 4.194304e-05 1.290555076923077e-05 0.0 8.428607999999999e-05 7.06990501399177e-05 5.078042126748971e-05 2.1742932036720483e-05 0.00013506650126748969 9.244198217663819e-05 MTE2 MMAD True 访存Bound(GM读写共享+L2重复读) 计算Bound 仅 IterBatch 条件满足
26 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2304 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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
27 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 1128 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.33; 尾轮: r=0 无尾轮 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
28 b32_m2048_n2048_k8192 32 32 2048 2048 8192 bf16 bf16 bf16 False False False True 0 b32_m2048_n2048_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 12 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 5.162220307692308e-05 0.00016777216 0.0 0.005884931150769231 0.006052703310769231 0.0 0.005884931150769231 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
29 b64_m4096_n2048_k128 64 64 4096 2048 128 bf16 bf16 bf16 False False False True 0 b64_m4096_n2048_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 12 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 576 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.0002064888123076923 0.00067108864 0.0 0.0003532894523076923 0.0010243780923076921 0.0 0.0003532894523076923 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
30 b16_m1024_n1024_k8192 16 16 1024 1024 8192 bf16 bf16 bf16 False False False True 0 b16_m1024_n1024_k8192 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 6 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 8192 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 18 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 6.452775384615385e-06 2.097152e-05 0.0 0.0008517663507692308 0.0008727378707692308 0.0 0.0008517663507692308 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_归约代价可接受)
31 b4_m32768_n128_k128 4 4 32768 128 128 bf16 bf16 bf16 False False False True 0 b4_m32768_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 187 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) resident(整case全驻留S_A: 输出驻留L2异步回写, GM写=0) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=28.96us), 选方案B工程简洁 (一套tile) 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_归约代价可接受)
32 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 561 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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_归约代价可接受)
33 b4_m131072_n128_k128 4 4 131072 128 128 bf16 bf16 bf16 False False False True 0 b4_m131072_n128_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 745 1 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 1 1 820 1 4 94 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=115.39us), 选方案B工程简洁 (一套tile) 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 2.581110153846154e-05 8.388608e-05 0.0 0.00010272137846153847 0.00018660745846153846 0.0 0.00010272137846153847 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_归约代价可接受)
34 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 820 7 1 820 7 16 1118 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: 面积型主导, A1b与方案B严格打平(T=1384.63us), 选方案B工程简洁 (一套tile) 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_归约代价可接受)
35 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 52 1 205 52 16 4395 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=8960.0MB, V_out=8192.0MB, L2=128MB), GM首读倍率=3.20; 尾轮: 周长型主导, rho=0.50<rho_dv=0.53, A1b被dValue卡死, 方案B反超 30064771072.0 0.0 0.01879048192 0.0 0.01879048192 0.0 0.0 61572651155456.0 0.1266926978507325 8589934592 0.00536870912 0.0 0.1266926978507325 0.0 0.1266926978507325 MMAD True 计算Bound ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
36 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 方案B 205 1 1 205 1 12 24 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超 L2场景: C_单batch输入超L2分组执行(组间落空回GM) (V_in=2056.0MB, V_out=32.0MB, L2=128MB), GM首读倍率=1.03; 尾轮: 周长型主导, rho=0.38<rho_dv=0.53, A1b被dValue卡死, 方案B反超 2222981120.0 0.0 0.0013893632 0.0 0.0013893632 0.0 0.0 274877906944.0 0.0005655924011193416 33554432 2.097152e-05 0.0 0.00141033472 0.0 0.00141033472 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_归约代价可接受)
37 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 35015 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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
38 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 17578 True 2 L2场景B_单batch输入驻留输出直写GM, GM首读倍率=1.00; 尾轮: r=0 无尾轮 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
39 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A1b 2 2 1 2 2 24 8754 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=4.76; 尾轮: 周长型主导, rho=0.75>=rho_dv=0.53, A1b恒优 (尾轮tile缩√rho=0.87倍凑满核) 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_归约代价可接受)
40 b8_m16_n7168_k1536 8 8 16 7168 1536 bf16 bf16 bf16 False False False True 0 b8_m16_n7168_k1536 StreamK Ascend950PR batch_mat_mul_v3 32 1 1 2 2 B/M/N切出16块, 每块2核切K归约 (归约组内核c负责K段[c*K/2,(c+1)*K/2)) 1 1 16 3584 768 256 1 K段标准分块流水 16 128 64 allocate(部分和驻留L2) resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换) 0 3670016 grid_K=2路切K+归约 1 1 2 0 0 0 0 True 4 P=14.00, grid_K=2, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终 176553984 393216 0.00011034624 7.561846153846153e-08 0.00011042185846153846 0.0 0.0 2818572288.0 5.799531456790123e-06 0.0 0.0 2.0698331002331e-07 2.566079254079254e-07 0.00011042185846153846 2.0698331002331e-07 2.566079254079254e-07 0.00011062884177156177 0.00011067846638694638 MTE2 True 访存Bound(GM读写共享+L2重复读) P<=C/2, B/M/N并行度买不满, 切K (grid_K=2)
41 b64_m1024_n7168_k7168 64 64 1024 7168 7168 bf16 bf16 bf16 False False False True 0 b64_m1024_n7168_k7168 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 6 41 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 7168 256 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 492 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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.00018067771076923076 0.00058720256 0.0 0.018248448787692308 0.018835651347692307 0.0 0.018248448787692308 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
42 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 2209 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 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
43 b8_m4096_n4096_k128 8 8 4096 4096 128 bf16 bf16 bf16 False False False True 0 b8_m4096_n4096_k128 ASW_Basic Ascend950PR batch_mat_mul_v3 32 1 24 24 1 B->M->N线性映射+ASW滑窗蛇形(W=4) 0 1 176 176 128 128 1 双缓冲驻留当前tile输入 176 176 80 allocate(输入驻留L2吸收重复读) resident(输出驻留L2异步回写) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 144 True 2 L2场景A_单batch全驻留(输入+输出), GM首读倍率=1.00; 尾轮: r=0 无尾轮 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 5.162220307692308e-05 0.00016777216 0.0 8.469267692307693e-05 0.0002524648369230769 0.0 8.469267692307693e-05 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_归约代价可接受)
44 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) direct_gm(输出直写GM, 输入优先驻留L2) 4 0 A0 1 1 1 0 0 0 8836 True 2 L2场景C_单batch输入超L2分组执行, GM首读倍率=2.00; 尾轮: r=0 无尾轮 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
45 special_k1_b64 64 64 8192 512 1 bf16 bf16 bf16 False False False True 0 special_k1_b64 特殊分支 Ascend950PR batch_mat_mul_v3 64 1 1 1 1 AIV 核间按行均分 (无 Cube tile 概念) 0 1 0 0 1 0 1 UB驻留(AIV) AIV单缓冲 0 0 0 allocate direct_gm 0 0 不涉及(AIV逐元素) 1 1 1 0 0 0 0 False 2 K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, AIV单缓冲 (B<2*AIV 逐batch单缓冲串行) 1114112 0.0 6.9632e-07 0.0 6.9632e-07 0.0 0.0 268435456.0 1.985939393939394e-05 9.92969696969697e-06 536870912 0.00033554432 0.0 0.00033624063999999996 0.0 0.00033624063999999996 MTE2 True 访存Bound(GM读写共享+L2重复读) K=1逐元素乘, 走AIV向量通路

173
BMM/BMM_Theory/tests/test_branches.py
View File

@@ -137,11 +137,13 @@ class TestTimingSanity(unittest.TestCase):
self.assertIn(mb.timing.bottleneck, ("MTE2", "MMAD")) self.assertIn(mb.timing.bottleneck, ("MTE2", "MMAD"))
def test_fixpipe_dtype_conversion(self): def test_fixpipe_dtype_conversion(self):
# C 指定 fp16 输出时, 写出量按 2B 而非 L0C 的 4B # C 指定 fp16 输出时, 写出量按 2B 而非 L0C 的 4B;
# 字节列为整芯片口径 (issue#29): fixpipe_bytes = B*MN*outB
case = mkcase(128, 64, 64, 512, dtype_c="fp16") case = mkcase(128, 64, 64, 512, dtype_c="fp16")
ib = IterBatchBranch().analyze(case) ib = IterBatchBranch().analyze(case)
expect = ib.plan.b_core * 64 * 64 * 2 expect = case.batch_c * 64 * 64 * 2
self.assertAlmostEqual(ib.timing.fixpipe_bytes, expect) self.assertAlmostEqual(ib.timing.fixpipe_bytes, expect)
self.assertAlmostEqual(ib.timing.fixpipe_bytes, case.output_bytes)
class TestIssueRegression(unittest.TestCase): class TestIssueRegression(unittest.TestCase):
@@ -423,5 +425,172 @@ class TestZeroCmdHandling(unittest.TestCase):
self.assertEqual(t.t_total, t.t_total) self.assertEqual(t.t_total, t.t_total)
class TestIssue27to30(unittest.TestCase):
"""第四轮评审 (issue#27-#30, 设计文档 docs/05).
#27 MergeBatch Cube 公式复核 (每步 2*(b0M)(b0N)K x b_core/b0 步);
#28 dtype 感知算力 (Cube/AIV 速率表);
#29 GM 首读下限 GM>=V_in + 字节列整芯片口径;
#30 Fixpipe 输出落点 (整case驻留 -> L2, 否则直写 GM).
"""
def setUp(self):
from bmm_theory.hardware import ASCEND950PR
self.s = ASCEND950PR
self.router = BranchRouter()
# ---------------- #27 ----------------
def test_issue27_merge_cube_flops_matches_formula(self):
from bmm_theory.branches.merge_batch import MergeBatchBranch
case = mkcase(2048, 32, 32, 256)
mb = MergeBatchBranch().analyze(case)
self.assertTrue(mb.capable)
p, t = mb.plan, mb.timing
b0, bc = p.merge_b0, p.b_core
# 整芯片列 = B*b0*2MNK; 等价 (b_core/b0) 步 x 每步 2*(b0M)(b0N)K x C 核
step_flops = 2.0 * (b0 * 32) * (b0 * 32) * 256
self.assertAlmostEqual(t.cube_flops,
step_flops * (bc / b0) * self.s.aic_num)
self.assertAlmostEqual(t.cube_flops,
case.batch_c * b0 * 2.0 * 32 * 32 * 256)
# t_mmad = 每核 flops / 单核算力
self.assertAlmostEqual(t.t_mmad,
(bc * b0 * 2.0 * 32 * 32 * 256) / self.s.q16)
def test_issue27_merge_gm_chip_col_equals_input(self):
# K 截断合并: GM 每字节一次 -> gm 整芯片列 = V_in (issue#29 口径)
from bmm_theory.branches.merge_batch import MergeBatchBranch
case = mkcase(2048, 32, 32, 256)
t = MergeBatchBranch().analyze(case).timing
self.assertAlmostEqual(t.gm_read_bytes, case.input_bytes)
self.assertAlmostEqual(t.l2_read_bytes, 0.0)
# ---------------- #28 ----------------
def test_issue28_cube_dtype_rate(self):
from bmm_theory.branches.iter_batch import IterBatchBranch
base = mkcase(128, 64, 64, 512) # IterBatch 形态 b, 各 dtype 均可行
t16 = IterBatchBranch().analyze(base).timing
t32 = IterBatchBranch().analyze(
mkcase(128, 64, 64, 512, dtype_a="fp32", dtype_b="fp32")).timing
t8 = IterBatchBranch().analyze(
mkcase(128, 64, 64, 512, dtype_a="fp8", dtype_b="fp8")).timing
# 同计算量, 时延反比于 dtype 算力: fp32=1/2, fp8=2x (相对 bf16)
self.assertAlmostEqual(t32.t_mmad / t16.t_mmad, 2.0, places=6)
self.assertAlmostEqual(t8.t_mmad / t16.t_mmad, 0.5, places=6)
def test_issue28_aiv_dtype_rate_k1(self):
# K=1 AIV 逐元素: bf16 通量 2x fp32 -> fp32 时延为 bf16 的 2 倍
base = mkcase(64, 8192, 512, 1)
t_bf16 = BranchRouter().route(base)["timing"]
t_fp32 = BranchRouter().route(
mkcase(64, 8192, 512, 1, dtype_a="fp32", dtype_b="fp32"))["timing"]
self.assertAlmostEqual(t_fp32.t_mmad / t_bf16.t_mmad, 2.0, places=6)
# ---------------- #29 ----------------
def test_issue29_gm_floor_and_chip_columns(self):
# 各分支代表 case: GM 整芯片列 >= V_in (R1), 且迭代/合并/转matmul/special
# 等于 V_in (无重复读结构)
from bmm_theory.branches.iter_batch import IterBatchBranch
from bmm_theory.branches.merge_batch import MergeBatchBranch
from bmm_theory.branches.stream_k import StreamKBranch
from bmm_theory.branches.asw_basic import AswBasicBranch
checks = [
(IterBatchBranch().analyze(mkcase(128, 64, 64, 512)).timing,
mkcase(128, 64, 64, 512)),
(MergeBatchBranch().analyze(mkcase(2048, 32, 32, 256)).timing,
mkcase(2048, 32, 32, 256)),
(StreamKBranch().analyze(mkcase(4, 128, 128, 10240)).timing,
mkcase(4, 128, 128, 10240)),
(AswBasicBranch().analyze(mkcase(8, 4096, 4096, 1024)).timing,
mkcase(8, 4096, 4096, 1024)),
]
for t, case in checks:
self.assertGreaterEqual(t.gm_read_bytes + 1e-6, case.input_bytes,
f"{case.case_id} GM < V_in")
# 转Matmul / 特殊分支 (K=1) 亦等于 V_in
r = self.router.route(mkcase(1, 2048, 2048, 2048))
t = r["timing"]
self.assertGreaterEqual(t.gm_read_bytes + 1e-6,
BmmCase(case_id="x", batch_a=1, batch_b=1,
m=2048, n=2048, k=2048).input_bytes)
r = self.router.route(mkcase(128, 256, 256, 1))
self.assertAlmostEqual(r["timing"].gm_read_bytes, 128 * (256 + 256) * 2)
def test_issue29_gm_floor_random_smoke(self):
# 随机多 dtype 冒烟: 所有可行方案 GM 整芯片列 >= V_in, 无 NaN
import random
rng = random.Random(20260609)
dtypes = ["bf16", "fp16", "fp32", "int8", "fp8", "fp4"]
for _ in range(400):
dt = rng.choice(dtypes)
kw = dict(dtype_a=dt, dtype_b=dt, dtype_c=rng.choice(["bf16", "fp16"]))
b = rng.choice([1, 2, 4, 8, 16, 32, 64, 128, 256, 2048])
m = rng.choice([1, 8, 32, 64, 128, 256, 1024, 4096])
n = rng.choice([1, 8, 32, 64, 128, 256, 1024, 4096])
k = rng.choice([0, 1, 32, 64, 128, 256, 512, 1024, 4096])
c = BmmCase(case_id="gm", batch_a=b, batch_b=b, m=m, n=n, k=k, **kw)
r = self.router.route(c)
t = r["timing"]
self.assertIsNotNone(t, c.case_id)
self.assertEqual(t.t_total, t.t_total) # 非 NaN
self.assertGreaterEqual(t.gm_read_bytes + 1e-6, c.input_bytes,
f"{dt} b={b} m={m} n={n} k={k} gm={t.gm_read_bytes}")
# ---------------- #30 ----------------
def test_issue30_iter_output_l2_when_whole_case_fits(self):
from bmm_theory.branches.iter_batch import IterBatchBranch
# 整 case 输入+输出 16.8MB+1.0MB <= 128MB -> 输出写 L2 写口, GM 写=0
case = mkcase(128, 64, 64, 512)
self.assertLess(case.input_bytes + case.output_bytes, self.s.l2_bytes)
t = IterBatchBranch().analyze(case).timing
self.assertAlmostEqual(t.fixpipe_bytes, case.output_bytes)
self.assertAlmostEqual(t.t_fixpipe, case.output_bytes / self.s.bw_l2)
def test_issue30_iter_output_gm_when_case_overflows(self):
from bmm_theory.branches.iter_batch import IterBatchBranch
# 输出 268MB > L2 余量 -> 直写 GM (输入优先驻留)
case = mkcase(128, 1024, 1024, 64)
self.assertGreater(case.input_bytes + case.output_bytes, self.s.l2_bytes)
t = IterBatchBranch().analyze(case).timing
self.assertAlmostEqual(t.fixpipe_bytes, case.output_bytes)
self.assertAlmostEqual(t.t_fixpipe, case.output_bytes / self.s.bw_gm)
def test_issue30_asw_scene_whole_case_labels(self):
# S_A (整case全驻留): l2_policy_out=resident, t_fixpipe 走 L2 写口
case_sa = mkcase(2, 4096, 4096, 512)
self.assertLess(case_sa.input_bytes + case_sa.output_bytes, self.s.l2_bytes)
r = self.router.route(case_sa)
self.assertEqual(r["branch"], "ASW_Basic")
self.assertTrue(r["plan"].l2_policy_out.startswith("resident"), r["plan"].l2_policy_out)
self.assertIn("A_整case全驻留", r["plan"].note)
self.assertAlmostEqual(r["timing"].t_fixpipe,
case_sa.output_bytes / self.s.bw_l2)
# S_B (整case超L2, 单batch输入可驻留): 输出直写 GM
case_sb = mkcase(64, 4096, 4096, 1024)
self.assertGreater(case_sb.input_bytes + case_sb.output_bytes, self.s.l2_bytes)
self.assertLess(4096 * 1024 * 2 * 2, self.s.l2_bytes) # 单batch输入 16.8MB
r = self.router.route(case_sb)
self.assertIn("ASW", r["branch"])
self.assertTrue(r["plan"].l2_policy_out.startswith("direct_gm"),
r["plan"].l2_policy_out)
self.assertAlmostEqual(r["timing"].t_fixpipe,
case_sb.output_bytes / self.s.bw_gm)
def test_issue30_to_matmul_output_l2_toggle(self):
# 转Matmul 粗估: 整case可驻留 -> L2; 大 case -> GM
small = mkcase(1, 2048, 2048, 2048)
self.assertLess(small.input_bytes + small.output_bytes, self.s.l2_bytes)
r = self.router.route(small)
self.assertEqual(r["branch"], "转Matmul")
self.assertAlmostEqual(r["timing"].t_fixpipe,
small.output_bytes / self.s.bw_l2)
big = mkcase(1, 8192, 8192, 4096)
self.assertGreater(big.input_bytes + big.output_bytes, self.s.l2_bytes)
r = self.router.route(big)
self.assertEqual(r["branch"], "转Matmul")
self.assertAlmostEqual(r["timing"].t_fixpipe,
big.output_bytes / self.s.bw_gm)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()