Fix review issues #11-#16: StreamK fixpipe 单次计账 / K=1 AIV单缓冲方案 / MergeBatch b0 L0A/L0B 上限+路由可行回退 / advice-StreamK / 输入校验 / .gitignore+死代码清理

.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.venv/
+venv/
+
+# 临时/调试文件 (避免误提交 issue 复现 csv、diff 产物等)
+*.tmp
+*.bak
+*~
+*.swp
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store
+Thumbs.db

BMM/BMM_Theory/README.md

@@ -76,17 +76,18 @@ BMM_Theory/
 │       ├── special.py         # 特殊分支 (K=0/1, AIV 通路)
 │       ├── stream_k.py        # StreamK (切K + 归约)
 │       └── asw_basic.py       # ASW_Basic (含降核/swizzle/L2分组/尾轮决策)
-├── docs/                      # 文档 (架构 + 理论梳理)
+├── docs/                      # 文档 (架构 + 理论梳理 + 软件测评)
 │   ├── 01_软件架构.md
-│   └── 02_分支理论/
+│   ├── 02_分支理论/
-│       ├── 00_总纲_分支决策树.md
+│   │   ├── 00_总纲_分支决策树.md
-│       ├── 01_MergeBatch分支.md
+│   │   ├── 01_MergeBatch分支.md
-│       ├── 02_IterBatch分支.md
+│   │   ├── 02_IterBatch分支.md
-│       ├── 03_转Matmul分支.md
+│   │   ├── 03_转Matmul分支.md
-│       ├── 04_特殊分支.md
+│   │   ├── 04_特殊分支.md
-│       ├── 05_StreamK分支.md
+│   │   ├── 05_StreamK分支.md
-│       ├── 06_ASW_Basic分支.md      # 尾轮策略已内化为其必要环节
+│   │   ├── 06_ASW_Basic分支.md      # 尾轮策略已内化为其必要环节
-│       └── 07_尾轮处理策略.md        # 尾轮完整推导 (参考)
+│   │   └── 07_尾轮处理策略.md        # 尾轮完整推导 (参考)
+│   └── 03_测评报告/             # 外部测评报告 (v1.0/v2.0 及后续复评)
 ├── examples/                  # 示例输入输出
 └── tests/                     # 单元测试 (固化文档边界 case + issue 回归)
 ```

BMM/BMM_Theory/bmm_theory/branches/merge_batch.py

@@ -94,10 +94,14 @@ class MergeBatchBranch(Branch):
         b = case.batch_c
         b_core = b // s.aic_num
 
-        # Step 1: 合并数 b0 (L0C + 算存比双上限, 尽量取 b_core 的因子)
+        # Step 1: 合并数 b0 (L0C + L0A/L0B + 算存比 + b_core 四类上限, 尽量取 b_core 的因子)
+        # L0A/L0B 上限 (issue#13): 合并 tile = (b0*M)x(b0*N), base_k 有 16 (fractal) 硬底,
+        # 须满足 b0*M*16*dt*2 <= L0A 且 b0*N*16*dt*2 <= L0B, 否则合并后 L0 tile 无法驻留.
         b0_l0c = math.sqrt(s.l0c_bytes / (2 * m * n * 4))
         b0_ai = s.r16 * (m + n) / (2 * m * n)
-        b0_max = int(min(b0_l0c, b0_ai, b_core))
+        b0_l0a = s.l0a_bytes / (2 * m * s.fractal * dt)
+        b0_l0b = s.l0b_bytes / (2 * n * s.fractal * dt)
+        b0_max = int(min(b0_l0c, b0_ai, b0_l0a, b0_l0b, b_core))
         b0 = max(MIN_B0, self._factor_floor(b_core, b0_max))
 
         # Step 2: L0 级 K 粒度 k_L0

BMM/BMM_Theory/bmm_theory/branches/special.py

@@ -24,11 +24,14 @@ class SpecialBranch(Branch):
         c1 = case.k <= 1
         checks = [ConditionCheck("1_K<=1 (Cube 无用)", c1, f"K={case.k}")]
         if case.k == 1:
-            # K=1 触发 AIV 通路需 B >= 2*AIV核数 且单 batch 输入输出能驻留 UB
+            # K=1 的 AIV 通路恒可用 (issue#12): B>=2*AIV 开 UB 乒乓; B<128 退化为
-            c2 = case.batch_c >= 2 * self.spec.aiv_num
+            # AIV 单缓冲 (无乒乓, 逐 batch 串行搬入), 不再是无方案空洞.
+            b = case.batch_c
+            pingpong = b >= 2 * self.spec.aiv_num
+            mode = "UB乒乓" if pingpong else "AIV单缓冲(逐batch串行, B<2*AIV)"
             checks.append(ConditionCheck(
-                "2_K=1的AIV触发: B >= 2*AIV核数 (开UB乒乓)",
+                "2_K=1的AIV通路: 恒可用 (B>=128 开UB乒乓, 否则单缓冲)",
-                c2, f"B={case.batch_c} vs {2*self.spec.aiv_num}"))
+                True, f"B={b}, 模式={mode}"))
         return checks
 
     # ------------------------------------------------------------------
@@ -36,11 +39,15 @@ class SpecialBranch(Branch):
         s = self.spec
         if case.k == 0:
             sub = "K=0纯写值"
+            mode = ""
             note = "无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核"
         else:
             sub = "K=1逐元素乘"
-            note = ("退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; "
+            pingpong = case.batch_c >= 2 * s.aiv_num
-                    "走 AIV 通路 GM->UB->Mul->GM, UB 乒乓")
+            mode = "UB乒乓" if pingpong else "AIV单缓冲"
+            note = (f"退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; "
+                    f"走 AIV 通路 GM->UB->Mul->GM, {mode} "
+                    f"({'B>=2*AIV 双batch乒乓流水' if pingpong else 'B<2*AIV 逐batch单缓冲串行'})")
         return ImplPlan(
             case_id=case.case_id, branch=self.name,
             used_core_num=s.aiv_num,  # 用 AIV 核
@@ -48,7 +55,8 @@ class SpecialBranch(Branch):
             core_map="AIV 核间按行均分 (无 Cube tile 概念)",
             b_core=0, merge_b0=1,
             single_core_m=0, single_core_n=0, single_core_k=case.k,
-            k_l1=0, b_l1=1, l1_form="UB驻留(AIV)",
+            k_l1=0, b_l1=1,
+            l1_form="UB驻留(AIV)" if case.k == 0 else "UB驻留(AIV) " + mode,
             base_m=0, base_n=0, base_k=0,
             l2_policy_in="allocate", l2_policy_out="direct_gm",
             swizzle_w=0, workspace_bytes=0,

BMM/BMM_Theory/bmm_theory/branches/stream_k.py

@@ -145,13 +145,14 @@ class StreamKBranch(Branch):
         t_mmad = t_mmad_tile / grid_k
         t_mte2 = t_mte2_tile / grid_k
 
-        # 归约: 部分和 4B 驻留 L2, AIV 归约 (含最终按 C dtype 写回)
+        # 归约: 部分和 4B 驻留 L2, AIV 归约 (含部分和写/读回/求和/最终按 C dtype 写回)
+        # 口径 (issue#11): 归约整体为串行追加 (t_drain=t_reduce, reduce_serial=True),
+        # 部分和写出已计入 eval_streamk_reduce 的 t_write_partial —— 稳态 Fixpipe 不再
+        # 重复计账. 此前按 grid_k*tile*4B/单核带宽份额另计一次, 既重复计账又把整组
+        # 部分和串行压到单核写口, 高估 grid_k 倍 (streamk_demo 曾虚高到 55us/FIXPIPE).
         t_reduce = eval_streamk_reduce(tile_elems, grid_k, out_b, s)
-
+        fix_bytes = 0.0
-        # Fixpipe: 部分和写出按 4B (L0C dtype, 防精度丢失), 驻留 L2.
+        t_fix = 0.0
-        # 最终归约结果的 C dtype 写回已在 t_reduce 内计, 此处不重复 (issue#9 口径对齐).
-        fix_bytes = grid_k * tile_elems * 4
-        t_fix = fix_bytes / s.bw_l2_pc
 
         flops_pc = 2.0 * tile_elems * k / grid_k
         gm_bytes = k * (2 * math.sqrt(tile_elems)) * dt / grid_k

BMM/BMM_Theory/bmm_theory/evaluator.py

@@ -75,8 +75,18 @@ class PlanEvaluator:
             tips.append("瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 "
                         "(MergeBatch 交叉项) 可消除")
         elif bn == "FIXPIPE":
-            tips.append("瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), "
+            if plan.branch == "StreamK":
-                        "或评估输出驻留 L2 异步回写策略")
+                # StreamK 部分和按 L0C dtype 4B 防精度丢失, 不随 C 的 fp16/fp8 转换,
+                # dtype 减半提示不适用 (issue#14); 写账已并入归约, 需查归约侧配置
+                tips.append("瓶颈标注在 Fixpipe: StreamK 的部分和写出已并入归约计账 "
+                            "(4B 防精度丢失, 不可随 C dtype 减半), 请核查 L2 写口/"
+                            "归约并行度(grid_K) 设置")
+            else:
+                tips.append("瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), "
+                            "或评估输出驻留 L2 异步回写策略")
+        elif bn == "REDUCE":
+            tips.append("瓶颈在 StreamK 归约 (串行追加): 可增大 grid_K 摊薄归约 "
+                        "或核对确定性要求是否允许 StreamK")
         if plan.branch == "MergeBatch" and plan.k_l1 < case.k:
             tips.append("警告: MergeBatch 处于 L1 绑定情形 (k_L1<K), 理论证明其恒劣于 "
                         "IterBatch (v1.1 §4.4), 建议改用 IterBatch")

BMM/BMM_Theory/bmm_theory/models.py

@@ -84,6 +84,26 @@ class BmmCase:
     deterministic_level: int = 0   # 确定性等级, >=2 禁用 StreamK
 
     # ---- 派生属性 ----
+    def __post_init__(self):
+        """输入合法性校验 (issue#15): 非法维度/负值静默产出伪方案, 必须明确报错."""
+        bad = []
+        for nm, v, lo, ok0 in (("batch_a", self.batch_a, 1, False),
+                               ("batch_b", self.batch_b, 1, False),
+                               ("m", self.m, 1, False),
+                               ("n", self.n, 1, False),
+                               ("k", self.k, 0, True)):
+            if not isinstance(v, int):
+                bad.append(f"{nm}={v!r} 非整数")
+            elif v < lo or (v == 0 and not ok0):
+                bad.append(f"{nm}={v} 非法 (需 >= {lo})")
+        if bad:
+            raise ValueError("case 维度非法: " + "; ".join(bad) +
+                             " (m/n/batch 必须为正, k 可为 0)")
+        for nm, dt in (("dtype_a", self.dtype_a), ("dtype_b", self.dtype_b),
+                       ("dtype_c", self.dtype_c)):
+            if str(dt).strip().lower() not in DTYPE_BYTES:
+                raise ValueError(f"不支持的 dtype: {dt!r}, 支持 {sorted(DTYPE_BYTES)}")
+
     @property
     def batch_c(self) -> int:
         return max(self.batch_a, self.batch_b)

BMM/BMM_Theory/bmm_theory/router.py

@@ -78,11 +78,9 @@ class BranchRouter:
         mb = self.merge_batch.analyze(case)
         ib = self.iter_batch.analyze(case)
 
-        candidates = []
+        # 候选表: [(分支名, BranchResult)], 顺序 = 仲裁优先级
-        if mb.capable:
+        cand_map = {self.merge_batch.name: mb, self.iter_batch.name: ib}
-            candidates.append((self.merge_batch.name, mb))
+        capable = {n: r.capable for n, r in cand_map.items()}
-        if ib.capable:
-            candidates.append((self.iter_batch.name, ib))
 
         arbitration = ""
         if mb.capable and ib.capable:
@@ -100,8 +98,8 @@ class BranchRouter:
             )
             if win != lat_win:
                 win = lat_win  # 时延模型为最终裁决
-        elif candidates:
+        elif any(capable.values()):
-            win = candidates[0][0]
+            win = next(n for n, v in capable.items() if v)
             arbitration = f"仅 {win} 条件满足"
         else:
             # 切B分支都不满足, 尝试 StreamK 再回落 ASW
@@ -115,11 +113,37 @@ class BranchRouter:
                 f"IterBatch未过: {ib.failed_conditions()}; "
                 f"MergeBatch未过: {mb.failed_conditions()}")
 
-        chosen = mb if win == self.merge_batch.name else ib
+        # 可行性保障 (issue#13): 仲裁胜出方案必须通过约束自检, 否则按
+        # (另一切B候选 -> StreamK -> ASW_Basic) 顺序回退到首个可行方案.
+        from .constraints import check_plan_constraints
+
+        def _feasible(n):
+            r = cand_map[n]
+            return r.plan is not None and not check_plan_constraints(case, r.plan, self.spec)
+
+        if _feasible(win):
+            chosen = cand_map[win]
+        else:
+            loser = self.merge_batch.name if win == self.iter_batch.name else self.iter_batch.name
+            fallback_note = (f"; 但 {win} 方案自检违规: "
+                             f"{'; '.join(check_plan_constraints(case, cand_map[win].plan, self.spec))}")
+            if capable.get(loser) and _feasible(loser):
+                chosen, win = cand_map[loser], loser
+                fallback_note += f", 回退可行候选 {loser}"
+            else:
+                sk = self.stream_k.analyze(case)
+                if sk.capable and sk.plan is not None and \
+                        not check_plan_constraints(case, sk.plan, self.spec):
+                    return self._wrap_checked(case, sk, arbitration + fallback_note + ", 落 StreamK")
+                asw = self.asw_basic.analyze(case)
+                if asw.plan is not None and not check_plan_constraints(case, asw.plan, self.spec):
+                    return self._wrap_checked(case, asw, arbitration + fallback_note + ", 回落 ASW_Basic")
+                chosen, win = cand_map[win], win  # 无可行方案: 保留原裁决, 由自检标注
+            arbitration += fallback_note
+
         result = BranchResult(capable=True, plan=chosen.plan, timing=chosen.timing)
         return self._wrap_checked(case, result, arbitration,
-                                  candidates={n: r.capable for n, r in
+                                  candidates=capable)
-                                              [(self.merge_batch.name, mb), (self.iter_batch.name, ib)]})
 
     # ------------------------------------------------------------------
     def _wrap_checked(self, case: BmmCase, result: BranchResult, note: str,
@@ -155,15 +179,3 @@ class BranchRouter:
         return {"branch": branch, "plan": plan, "timing": None,
                 "arbitration": "[无方案] " + note, "candidates": {},
                 "self_check_violations": []}
-
-    # ------------------------------------------------------------------
-    @staticmethod
-    def _wrap(result: BranchResult, note: str) -> dict:
-        return {
-            "branch": result.plan.branch if result.plan else "未知",
-            "plan": result.plan,
-            "timing": result.timing,
-            "arbitration": note + (f" | {result.note}" if result.note else ""),
-            "candidates": {},
-            "self_check_violations": [],
-        }

BMM/BMM_Theory/docs/02_分支理论/04_特殊分支.md

@@ -20,7 +20,8 @@ K 维度是 Cube（MMAD）存在的意义——`C = Σ_k A[..,k]·B[k,..]` 的
 
 - 数据流：GM→UB（读 A、B）→ Mul → GM（写 C），全程 AIV；
 - 时延：`T = max(搬入, 搬出)`，AIV 算力远剩，瓶颈在搬移：`T ≈ B·(MK + KN + MN)·dt / W_GM`；
-- **触发条件**：`B ≥ 2×AIV核数 = 128`（开 UB 乒乓需要每核至少 2 个 batch 块）且单 batch 输入输出能驻留 UB。
+- **触发条件**：`B ≥ 2×AIV核数 = 128`（开 UB 乒乓需要每核至少 2 个 batch 块）且单 batch 输入输出能驻留 UB；
+- **B < 128 时并不无解**（issue#12）：退化为 **AIV 单缓冲**——无乒乓、逐 batch 串行搬入计算，仍远优于 Cube 通路（K=1 时 Cube 16×16×16 浪费 15/16），只是流水掩盖能力下降。软件 `special.py` 按 `B ≥ 128` 自动选择"UB乒乓 / AIV单缓冲"模式。
 
 ## 4. 软件处理
 

BMM/BMM_Theory/examples/result_evaluate.csv

@@ -1,11 +1,11 @@
 case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice
 to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除"
 special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
-special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV),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 乒乓",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
+special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
 merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.2743039999999997e-05,3.0192408230452674e-07,4.3044964082304525e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"
 merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.0685759999999999e-05,4.400081646090535e-07,1.1125768164609053e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"
 iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,5.4428799999999995e-06,3.0192408230452674e-07,5.744804082304526e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"
 iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.468608e-05,7.16176329218107e-07,8.540225632921811e-05,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"
-streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,8388608,5.162220307692308e-05,3.4067453613053613e-06,5.162220307692308e-05,3.4067453613053613e-06,5.5028948438228435e-05,FIXPIPE,True,,写出Bound,"瓶颈在 Fixpipe 写出: 检查输出 dtype (fp16/fp8 可减半写出量), 或评估输出驻留 L2 异步回写策略"
+streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,6.5536e-06,3.4067453613053613e-06,9.960345361305361e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"
 asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景B_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,0.0,4.194304e-05,0.0,4.194304e-05,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,"瓶颈在 Cube 计算: 已接近理论算力上限, 检查是否有冗余计算 (MergeBatch 交叉项) 可消除"
 asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0.0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,2.62144e-06,0.0,2.62144e-06,0.0,2.62144e-06,MTE2_GM,True,,访存Bound(GM),"瓶颈在 GM 搬入: 可考虑增大 tile 提升 dValue/单核搬移量, 或利用 L2 驻留吸收重复读 (MergeBatch/ASW swizzle 方向)"

BMM/BMM_Theory/examples/result_recommend.csv

@@ -1,11 +1,11 @@
 case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice
 to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"BatchA=1或BatchB=1, 折叠转普通Matmul"
 special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,K=0纯写值
-special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV),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 乒乓",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"K=1逐元素乘, 走AIV向量通路"
+special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"K=1逐元素乘, 走AIV向量通路"
 merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.2743039999999997e-05,3.0192408230452674e-07,4.3044964082304525e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=43.04us vs T_IterBatch=45.22us -> MergeBatch更优; [裁决] MergeBatch"
 merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.0685759999999999e-05,4.400081646090535e-07,1.1125768164609053e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=11.49us vs T_IterBatch=11.13us -> IterBatch更优; [裁决] IterBatch"
 iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,5.4428799999999995e-06,3.0192408230452674e-07,5.744804082304526e-06,MTE2_GM,True,,访存Bound(GM),仅 IterBatch 条件满足
 iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.468608e-05,7.16176329218107e-07,8.540225632921811e-05,MTE2_GM,True,,访存Bound(GM),仅 IterBatch 条件满足
-streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,8388608,5.162220307692308e-05,3.4067453613053613e-06,5.162220307692308e-05,3.4067453613053613e-06,5.5028948438228435e-05,FIXPIPE,True,,写出Bound,"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写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,6.5536e-06,3.4067453613053613e-06,9.960345361305361e-06,MTE2_GM,True,,访存Bound(GM),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)"
 asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景B_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,0.0,4.194304e-05,0.0,4.194304e-05,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
 asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0.0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,2.62144e-06,0.0,2.62144e-06,0.0,2.62144e-06,MTE2_GM,True,,访存Bound(GM),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2)

BMM/BMM_Theory/smoke.txt

@@ -0,0 +1,41 @@
+=== to_matmul_demo: B=1 M=2048 N=2048 K=2048 bf16 -> [转Matmul]
+    仲裁: BatchA=1或BatchB=1, 折叠转普通Matmul
+    方案: 核数=32 切分=B1xM0xN0xK1 b_core=0 b0=1 k_L1=0 L1形态=
+    时延: 总=35.35us 稳态=35.35 drain=0.00 | MTE2=10.49(GM=10.49+cmd=0.00) MMAD=35.35 FIX=5.24 | 瓶颈=MMAD
+=== special_k0_demo: B=128 M=256 N=256 K=0 bf16 -> [特殊分支]
+    仲裁: K=0纯写值
+    方案: 核数=64 切分=B1xM1xN1xK1 b_core=0 b0=1 k_L1=0 L1形态=UB驻留(AIV)
+    时延: 总=10.49us 稳态=10.49 drain=0.00 | MTE2=0.00(GM=0.00+cmd=0.00) MMAD=0.00 FIX=10.49 | 瓶颈=FIXPIPE
+=== special_k1_demo: B=128 M=256 N=256 K=1 bf16 -> [特殊分支]
+    仲裁: K=1逐元素乘, 走AIV向量通路
+    方案: 核数=64 切分=B1xM1xN1xK1 b_core=0 b0=1 k_L1=0 L1形态=UB驻留(AIV) UB乒乓
+    时延: 总=10.49us 稳态=10.49 drain=0.00 | MTE2=0.08(GM=0.08+cmd=0.00) MMAD=0.62 FIX=10.49 | 瓶颈=FIXPIPE
+=== merge_demo_k_trunc: B=2048 M=32 N=32 K=256 bf16 -> [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=43.04us vs T_IterBatch=45.22us -> MergeBatch更优; [裁决] MergeBatch
+    方案: 核数=32 切分=B32xM1xN1xK1 b_core=64 b0=4 k_L1=256 L1形态=合并驻留
+    时延: 总=43.04us 稳态=42.74 drain=0.30 | MTE2=42.74(GM=41.94+cmd=0.80) MMAD=8.84 FIX=2.62 | 瓶颈=MTE2_GM
+=== merge_iter_arbitrate: B=128 M=64 N=64 K=512 bf16 -> [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.49us vs T_IterBatch=11.13us -> IterBatch更优; [裁决] IterBatch
+    方案: 核数=32 切分=B32xM1xN1xK1 b_core=4 b0=1 k_L1=512 L1形态=b_双batch乒乓
+    时延: 总=11.13us 稳态=10.69 drain=0.44 | MTE2=10.69(GM=10.49+cmd=0.20) MMAD=1.10 FIX=0.66 | 瓶颈=MTE2_GM
+=== iter_demo_form_b: B=128 M=64 N=64 K=256 bf16 -> [IterBatch]
+    仲裁: 仅 IterBatch 条件满足
+    方案: 核数=32 切分=B32xM1xN1xK1 b_core=4 b0=1 k_L1=256 L1形态=b_双batch乒乓
+    时延: 总=5.74us 稳态=5.44 drain=0.30 | MTE2=5.44(GM=5.24+cmd=0.20) MMAD=0.55 FIX=0.66 | 瓶颈=MTE2_GM
+=== iter_demo_form_d: B=64 M=64 N=64 K=8192 bf16 -> [IterBatch]
+    仲裁: 仅 IterBatch 条件满足
+    方案: 核数=32 切分=B32xM1xN1xK1 b_core=2 b0=1 k_L1=1024 L1形态=d_两侧都切K
+    时延: 总=85.40us 稳态=84.69 drain=0.72 | MTE2=84.69(GM=83.89+cmd=0.80) MMAD=8.84 FIX=0.33 | 瓶颈=MTE2_GM
+=== streamk_demo: B=4 M=128 N=128 K=10240 bf16 -> [StreamK]
+    仲裁: P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)
+    方案: 核数=32 切分=B1xM1xN1xK32 b_core=1 b0=1 k_L1=256 L1形态=K段标准分块流水
+    时延: 总=9.96us 稳态=6.55 drain=3.41 | MTE2=6.55(GM=6.55+cmd=0.00) MMAD=2.76 FIX=0.00 | 瓶颈=MTE2_GM
+=== asw_demo_full: B=2 M=8192 N=8192 K=1024 bf16 -> [ASW_Basic]
+    仲裁: ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
+    方案: 核数=32 切分=B1xM47xN47xK1 b_core=0 b0=1 k_L1=256 L1形态=双缓冲驻留当前tile输入
+    时延: 总=565.59us 稳态=565.59 drain=0.00 | MTE2=41.94(GM=41.94+cmd=0.00) MMAD=565.59 FIX=167.77 | 瓶颈=MMAD
+=== asw_demo_reduce_core: B=16 M=256 N=256 K=128 bf16 -> [ASW_Basic_降核]
+    仲裁: ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2)
+    方案: 核数=16 切分=B1xM1xN1xK1 b_core=0 b0=1 k_L1=128 L1形态=标准核内流水
+    时延: 总=2.62us 稳态=2.62 drain=0.00 | MTE2=2.62(GM=2.62+cmd=0.00) MMAD=1.10 FIX=2.62 | 瓶颈=MTE2_GM
+[recommend] 10 个 case -> t.csv

BMM/BMM_Theory/t.csv

@@ -0,0 +1,11 @@
+case_id,batch_a,batch_b,m,n,k,dtype_a,dtype_b,dtype_c,trans_a,trans_b,has_bias,out_nd,deterministic_level,plan_case_id,plan_branch,plan_npu,plan_op,plan_used_core_num,plan_split_b,plan_m_cnt,plan_n_cnt,plan_grid_k,plan_core_map,plan_b_core,plan_merge_b0,plan_single_core_m,plan_single_core_n,plan_single_core_k,plan_k_l1,plan_b_l1,plan_l1_form,plan_base_m,plan_base_n,plan_base_k,plan_l2_policy_in,plan_l2_policy_out,plan_swizzle_w,plan_workspace_bytes,plan_tail_strategy,plan_tail_m_cnt,plan_tail_n_cnt,plan_tail_k_cnt,plan_tail_m_main,plan_tail_n_main,plan_tail_block_cnt,plan_tail_wave_num,plan_fixpipe_unitflag,plan_out_dtype_bytes,plan_note,gm_read_bytes,l2_read_bytes,t_mte2_gm,t_mte2_l2,t_mte2,dma_cmd_count,t_dma_cmd,cube_flops,t_mmad,fixpipe_bytes,t_fixpipe,t_reduce,t_steady,t_drain,t_total,bottleneck,feasible,violations,bound_type,advice
+to_matmul_demo,1,1,2048,2048,2048,bf16,bf16,bf16,False,False,False,True,0,to_matmul_demo,转Matmul,Ascend950PR,batch_mat_mul_v3,32,1,0,0,1,"折叠为 Matmul [2048,2048]x[2048,2048], 复用 Matmul 切分体系",0,1,0,0,2048,0,1,,0,0,0,,,0,0,转Matmul后由 Matmul 体系决定,1,1,1,0,0,0,0,True,2,"BatchB=1免费折叠: 左矩阵 [1,2048,2048] 视图折叠为 [2048,2048], 零重排零 split",16777216,0.0,1.048576e-05,0.0,1.048576e-05,0.0,0.0,17179869184.0,3.534952506995885e-05,8388608,5.24288e-06,0.0,3.534952506995885e-05,0.0,3.534952506995885e-05,MMAD,True,,计算Bound,"BatchA=1或BatchB=1, 折叠转普通Matmul"
+special_k0_demo,128,128,256,256,0,bf16,bf16,bf16,False,False,False,True,0,special_k0_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,0,0,1,UB驻留(AIV),0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=0纯写值: 无任何计算, C=bias 或 0, 纯 AIV 写值; 按行均分到 AIV 核",0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,K=0纯写值
+special_k1_demo,128,128,256,256,1,bf16,bf16,bf16,False,False,False,True,0,special_k1_demo,特殊分支,Ascend950PR,batch_mat_mul_v3,64,1,1,1,1,AIV 核间按行均分 (无 Cube tile 概念),0,1,0,0,1,0,1,UB驻留(AIV) UB乒乓,0,0,0,allocate,direct_gm,0,0,不涉及(AIV逐元素),1,1,1,0,0,0,0,False,2,"K=1逐元素乘: 退化为 C=A⊙B 无累加深度, Cube 16x16x16 粒度浪费 15/16; 走 AIV 通路 GM->UB->Mul->GM, UB乒乓 (B>=2*AIV 双batch乒乓流水)",131072,0.0,8.192e-08,0.0,8.192e-08,0.0,0.0,8388608.0,6.206060606060606e-07,16777216,1.048576e-05,0.0,1.048576e-05,0.0,1.048576e-05,FIXPIPE,True,,写出Bound,"K=1逐元素乘, 走AIV向量通路"
+merge_demo_k_trunc,2048,2048,32,32,256,bf16,bf16,bf16,False,False,False,True,0,merge_demo_k_trunc,MergeBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B均分(核间零重复读零依赖),64,4,128,128,256,256,8,合并驻留,128,128,128,allocate(GM->L1随路驻留L2),direct_gm,0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"b0=4 (L0C上限5.7/算存比上限19.0/b_core=64); K截断; 合并后单次DMA搬入 A'[128,256]+B'[256,128]",2097152,0.0,4.194304e-05,0.0,4.2743039999999997e-05,16.0,8.000000000000001e-07,134217728.0,8.837381267489712e-06,131072,2.62144e-06,0.0,4.2743039999999997e-05,3.0192408230452674e-07,4.3044964082304525e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=True (k_L1=K(截断); b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0; drain惩罚=(b0-1)*(T_comp+T_write)=0.23us, 搬移节省=b_core*(1-1/b0)*T_cmd=2.40us); [时延模型] T_MergeBatch=43.04us vs T_IterBatch=45.22us -> MergeBatch更优; [裁决] MergeBatch"
+merge_iter_arbitrate,128,128,64,64,512,bf16,bf16,bf16,False,False,False,True,0,merge_iter_arbitrate,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,512,512,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=256KB <= L1,524288,0.0,1.048576e-05,0.0,1.0685759999999999e-05,4,2.0000000000000002e-07,16777216.0,1.104672658436214e-06,32768,6.5536e-07,0.0,1.0685759999999999e-05,4.400081646090535e-07,1.1125768164609053e-05,MTE2_GM,True,,访存Bound(GM),"两分支均合法, 仲裁: [分界条件] MergeBatch最优=False (k_L1=K(截断); b_core=4 vs 阈值 b0*(T_comp+T_write)/T_cmd=17.6; drain惩罚=(b0-1)*(T_comp+T_write)=0.44us, 搬移节省=b_core*(1-1/b0)*T_cmd=0.10us); [时延模型] T_MergeBatch=11.49us vs T_IterBatch=11.13us -> IterBatch更优; [裁决] IterBatch"
+iter_demo_form_b,128,128,64,64,256,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_b,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),4,1,64,64,256,256,2,b_双batch乒乓,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1,262144,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,8388608.0,5.52336329218107e-07,32768,6.5536e-07,0.0,5.4428799999999995e-06,3.0192408230452674e-07,5.744804082304526e-06,MTE2_GM,True,,访存Bound(GM),仅 IterBatch 条件满足
+iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(输出仅写一次,直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝",4194304,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,134217728.0,8.837381267489712e-06,16384,3.2768e-07,0.0,8.468608e-05,7.16176329218107e-07,8.540225632921811e-05,MTE2_GM,True,,访存Bound(GM),仅 IterBatch 条件满足
+streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",327680.0,0.0,6.5536e-06,0.0,6.5536e-06,0.0,0.0,41943040.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,6.5536e-06,3.4067453613053613e-06,9.960345361305361e-06,MTE2_GM,True,,访存Bound(GM),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)"
+asw_demo_full,2,2,8192,8192,1024,bf16,bf16,bf16,False,False,False,True,0,asw_demo_full,ASW_Basic,Ascend950PR,batch_mat_mul_v3,32,1,47,47,1,B->M->N线性映射+ASW滑窗蛇形(W=4),0,1,176,176,1024,256,1,双缓冲驻留当前tile输入,176,176,80,allocate(输入驻留L2吸收重复读),direct_gm(输出直写GM不占L2),4,0,方案B,52,52,1,52,52,2,139,True,2,"L2场景B_输入驻留输出直写GM, r_in=1.00; 尾轮: 周长型主导, rho=0.06<rho_dv=0.53, A1b被dValue卡死, 方案B反超",67108864.0,0.0,4.194304e-05,0.0,4.194304e-05,0.0,0.0,274877906944.0,0.0005655924011193416,268435456,0.00016777216,0.0,0.0005655924011193416,0.0,0.0005655924011193416,MMAD,True,,计算Bound,ASW_Basic兜底 (StreamK未过: 1_并行缺口: P=B*MN*4B/L0C <= C/2; 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2; 3_归约代价可接受)
+asw_demo_reduce_core,16,16,256,256,128,bf16,bf16,bf16,False,False,False,True,0,asw_demo_reduce_core,ASW_Basic_降核,Ascend950PR,batch_mat_mul_v3,16,1,1,1,1,"降核: 只用16核, 每核一个L0C满载输出块, 其余核闲置",0,1,256,256,128,128,1,标准核内流水,256,256,64,allocate,direct_gm,0,0,不涉及(每核一块无尾轮),1,1,1,0,0,0,0,True,2,"P=16.00<C, 降核是理性选择 (强切则 tile 跌破搬移效率下限反而更慢)",2097152.0,0.0,2.62144e-06,0.0,2.62144e-06,0.0,0.0,268435456.0,1.104672658436214e-06,2097152,2.62144e-06,0.0,2.62144e-06,0.0,2.62144e-06,MTE2_GM,True,,访存Bound(GM),ASW_Basic兜底 (StreamK未过: 2_单核K段下限: K/grid_K >= 256B/dtype 且 grid_K>=2)

BMM/BMM_Theory/tests/test_branches.py

@@ -150,12 +150,17 @@ class TestIssueRegression(unittest.TestCase):
     def setUp(self):
         self.router = BranchRouter()
 
-    def test_issue4_k1_small_batch_no_crash(self):
+    def test_issue4_k1_small_batch_real_plan(self):
-        # issue#4 P0: K=1 且 B<128 不得崩溃, 应标注"暂无理论方案"
+        # issue#4/#12: K=1 且 B<128 不崩溃, 且给出 AIV 单缓冲真实方案 (不再是无方案占位)
-        r = self.router.route(mkcase(64, 8192, 32, 1, dtype_a="int8", dtype_b="int8"))
+        case = mkcase(64, 8192, 32, 1, dtype_a="int8", dtype_b="int8")
-        self.assertIsNotNone(r["plan"])  # 占位方案, 不为 None
+        r = self.router.route(case)
-        self.assertEqual(r["plan"].used_core_num, 0)  # 标注无方案
+        self.assertIsNotNone(r["plan"])
-        self.assertIn("暂无理论方案", r["arbitration"])
+        self.assertEqual(r["branch"], "特殊分支")
+        self.assertEqual(r["plan"].used_core_num, 64)  # AIV 核
+        self.assertNotIn("暂无理论方案", r["arbitration"])
+        self.assertIn("单缓冲", r["plan"].note)
+        from bmm_theory.constraints import check_plan_constraints
+        self.assertEqual(check_plan_constraints(case, r["plan"]), [])
 
     def test_issue5_asw_reduced_core_base_k_dtype_aware(self):
         # issue#5: ASW 降核 base_k 按 dtype 反推, fp32 不再 L0A 溢出
@@ -204,5 +209,62 @@ class TestIssueRegression(unittest.TestCase):
         self.assertNotEqual(r["branch"], "StreamK")
 
 
+class TestIssueRegression2(unittest.TestCase):
+    """第二轮复评问题 (#11-#16) 回归."""
+
+    def setUp(self):
+        self.router = BranchRouter()
+
+    def test_issue11_streamk_fixpipe_no_double_count(self):
+        # issue#11: 部分和写出只经 t_reduce 计账一次; 稳态 fixpipe 不得再计
+        from bmm_theory.branches.stream_k import StreamKBranch
+        case = mkcase(4, 128, 128, 10240)
+        sk = StreamKBranch().analyze(case)
+        t = sk.timing
+        self.assertAlmostEqual(t.t_fixpipe, 0.0)   # 归约串行口径下无稳态 fixpipe 账
+        self.assertAlmostEqual(t.fixpipe_bytes, 0.0)
+        # 端到端 = max(MTE2, MMAD) + 归约, 不再虚高到 55us/FIXPIPE
+        expect = max(t.t_mte2, t.t_mmad) + t.t_reduce
+        self.assertAlmostEqual(t.t_total, expect)
+        self.assertEqual(t.bottleneck, "MTE2_GM")
+
+    def test_issue12_k1_pingpong_still_ok(self):
+        # issue#12: K=1 且 B>=128 仍走 UB 乒乓 (原行为不变)
+        r = self.router.route(mkcase(128, 256, 256, 1))
+        self.assertEqual(r["branch"], "特殊分支")
+        self.assertIn("乒乓", r["plan"].l1_form)
+        self.assertIsNotNone(r["timing"])
+
+    def test_issue13_merge_b0_l0ab_capped(self):
+        # issue#13: MergeBatch 瘦长 case 的 b0 受 L0A/L0B 容量约束 (B=811 M=33 N=1 fp32)
+        from bmm_theory.constraints import check_plan_constraints
+        case = mkcase(811, 33, 1, 2459, dtype_a="fp32", dtype_b="fp32", dtype_c="fp32")
+        r = self.router.route(case)
+        self.assertEqual(r["branch"], "MergeBatch")
+        p = r["plan"]
+        self.assertLessEqual(p.base_m * p.base_k * 4 * 2, 64 * 1024)  # L0A 容量内
+        self.assertLessEqual(p.base_n * p.base_k * 4 * 2, 64 * 1024)  # L0B 容量内
+        self.assertEqual(check_plan_constraints(case, p), [])
+
+    def test_issue13_router_fallback_when_winner_infeasible(self):
+        # issue#13: 仲裁胜出的 MergeBatch 自检违规时, 回退到可行候选 IterBatch
+        from bmm_theory.constraints import check_plan_constraints
+        case = mkcase(256, 1, 256, 4096, dtype_a="int8", dtype_b="int8")  # 原 0.2% 违规样例
+        r = self.router.route(case)
+        self.assertEqual(r["branch"], "IterBatch")       # 回退
+        self.assertIn("自检违规", r["arbitration"])
+        self.assertIn("回退", r["arbitration"])
+        self.assertEqual(check_plan_constraints(case, r["plan"]), [])
+
+    def test_issue15_input_validation(self):
+        # issue#15: 非法维度/负值必须抛错, 不再静默产出伪方案
+        for kw in (dict(m=0), dict(m=-5), dict(n=0), dict(k=-1),
+                   dict(batch_a=0), dict(batch_b=-3)):
+            with self.assertRaises(ValueError, msg=str(kw)):
+                BmmCase(case_id="bad", **kw)
+        with self.assertRaises(ValueError):
+            BmmCase(case_id="bad", m=64, n=64, k=1, dtype_a="xxx")
+
+
 if __name__ == "__main__":
     unittest.main()