T_cmd=0 仲裁改为策略优先 MergeBatch: K截断即优先(指令/命令次数省b0倍,未量化收益), L1绑定恒劣; 路由层以策略覆盖时延模型差额并显式标注

BMM/BMM_Theory/bmm_theory/branches/merge_batch.py

@@ -7,8 +7,9 @@
 核心思想: 合并 b0 个 batch 的 A'[b0*M,K] @ B'[K,b0*N] 为单次 DMA 搬入,
 减少 GM->L1 搬移命令数 (省 b0 倍 T_cmd); 交叉项被算出但丢弃 (冗余比例 (b0-1)/b0),
 进入条件 5 保证 case 为访存 Bound, 冗余算力被搬移时延掩盖.
-T_cmd=0 时 (无命令固定开销) 合并失去唯一收益来源, 分界仲裁直接判 MergeBatch
-不胜出 (beats_iterbatch 对 T_cmd<=0 做 +inf 处理, 见函数内说明).
+T_cmd=0 时 (无命令固定时延/未标定) 命令时延收益不可量化, 但合并仍省 b0 倍
+搬移命令/主机指令数 (指令发射/调度/同步收益未建模) —— beats_iterbatch 按既定
+策略裁决: K截断即优先 MergeBatch (模型内代价仅 drain 惩罚), L1 绑定恒劣.
 """
 
 from __future__ import annotations
@@ -224,8 +225,11 @@ class MergeBatchBranch(Branch):
 
         MergeBatch 最优  ⟺  K截断 (k_L1=K) 且 b_core > b0*(T_comp+T_write)/T_cmd
         L1 绑定情形 MergeBatch 恒劣于 IterBatch (搬移次数相同, 只放大 drain).
-        T_cmd=0 时阈值趋于无穷: 合并的唯一收益 (省 DMA 命令开销) 消失,
-        只剩 drain 放大与冗余计算, MergeBatch 无胜出通道 (见 evaluate 对拍也一致).
+
+        T_cmd=0 (无命令时延/未标定) 时阈值趋于 +inf, 但 MergeBatch 还有**未量化的
+        结构性收益**: 大 B 小 MN 时搬移命令数/主机指令数省 b0 倍 (每条命令的指令
+        发射/调度/同步开销未建模). 因此 T_cmd<=0 采用既定策略: K截断即可胜
+        (模型内代价仅为 drain 惩罚, 访存 Bound case 下小且方向已知); L1 绑定仍恒劣.
         """
         s = self.spec
         m, n, k = case.m, case.n, case.k
@@ -244,10 +248,18 @@ class MergeBatchBranch(Branch):
         drain_pen = (b0 - 1) * (t_comp + t_write)
 
         if s.t_cmd <= 0:
-            # T_cmd=0: 阈值 b0*(T_comp+T_write)/T_cmd -> +inf, 不可除零, 直接判负
-            detail = (f"k_L1={'K(截断)' if k_truncated else f'{k_l1_iter:.0f}<K(L1绑定)'}; "
-                      f"T_cmd=0: 合并无命令开销节省 (阈值=+inf), MergeBatch 无胜出通道; "
-                      f"仅剩 drain 惩罚=(b0-1)*(T_comp+T_write)={drain_pen*1e6:.2f}us")
+            # T_cmd=0: 命令时延收益不可量化 -> 阈值 +inf; 按策略裁决 (见 docstring).
+            # 大 B 小 MN 时合并把 b_core 条搬移/计算命令序列并为 b_core/b0 条,
+            # 指令发射/调度/同步收益存在但未量化 —— K截断时判胜, 由路由层以策略覆盖
+            # 时延模型比较; L1 绑定 (搬移次数与 IterBatch 相同) 仍恒劣.
+            if k_truncated:
+                detail = (f"k_L1=K(截断); T_cmd=0: 命令时延收益不可量化(阈值=+inf), "
+                          f"但合并省 {b0} 倍搬移命令/指令数 (结构性收益, 未量化) -> "
+                          f"策略优先 MergeBatch; 模型内代价 drain 惩罚="
+                          f"{drain_pen*1e6:.2f}us")
+                return True, detail
+            detail = (f"k_L1={k_l1_iter:.0f}<K(L1绑定); T_cmd=0: 搬移命令次数与 "
+                      f"IterBatch 相同, 合并只放大 drain 惩罚={drain_pen*1e6:.2f}us -> 恒劣")
             return False, detail
 
         threshold = b0 * (t_comp + t_write) / s.t_cmd

BMM/BMM_Theory/bmm_theory/router.py

@@ -7,7 +7,9 @@
        仲裁规则 (v1.1 §4.5 统一分界):
          MergeBatch 最优 <=> K截断(k_L1=K) 且 b_core > b0*(T_comp+T_write)/T_cmd
          L1 绑定时 MergeBatch 恒劣于 IterBatch;
-       两分支同时合法时用端到端时延模型 T_total 仲裁.
+       两分支同时合法时用端到端时延模型 T_total 仲裁;
+       例外: T_cmd<=0 (命令时延不可量化/未标定) 时, 指令级收益未建模,
+       按既定策略: K截断即可优先 MergeBatch (覆盖时延模型仅来自 drain/冗余的差额).
   3. StreamK 检查: P <= C/2 且满足切K条件 -> StreamK (B/M/N 买不满时买 K)
   4. 兜底: ASW_Basic 切 M/N (含降核模式)
 """
@@ -90,14 +92,28 @@ class BranchRouter:
             t_ib = ib.timing.t_total
             lat_win = self.merge_batch.name if t_mb <= t_ib else self.iter_batch.name
             win = self.merge_batch.name if mb_win else self.iter_batch.name
-            arbitration = (
-                f"两分支均合法, 仲裁: "
-                f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
-                f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
-                f"[裁决] {win}" + ("" if win == lat_win else f" (分界条件与时延模型不一致, 以时延模型为准: {lat_win})")
-            )
-            if win != lat_win:
-                win = lat_win  # 时延模型为最终裁决
+            # 冲突解决: 默认"时延模型为最终裁决"; 例外是 T_cmd<=0 且分界条件判
+            # MergeBatch 胜 (K截断) 的情形 —— 此时时延模型不含指令级收益
+            # (MergeBatch 搬移命令数/主机指令数省 b0 倍, 未量化), 按既定策略
+            # 优先 MergeBatch (时延模型内的差额只是 drain 惩罚/冗余, 方向已知小量).
+            policy_merge = (self.spec.t_cmd <= 0 and mb_win and
+                            win != lat_win and win == self.merge_batch.name)
+            if policy_merge:
+                arbitration = (
+                    f"两分支均合法, 仲裁: "
+                    f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
+                    f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
+                    f"[裁决] {win} (T_cmd<=0 策略: 命令/指令级收益未建模, 时延模型差异仅来自 "
+                    f"drain/冗余, 以 MergeBatch 优先策略裁决)")
+            else:
+                arbitration = (
+                    f"两分支均合法, 仲裁: "
+                    f"[分界条件] MergeBatch最优={mb_win} ({detail}); "
+                    f"[时延模型] T_MergeBatch={t_mb*1e6:.2f}us vs T_IterBatch={t_ib*1e6:.2f}us -> {lat_win}更优; "
+                    f"[裁决] {win}" + ("" if win == lat_win else f" (分界条件与时延模型不一致, 以时延模型为准: {lat_win})")
+                )
+                if win != lat_win:
+                    win = lat_win  # 时延模型为最终裁决
         elif any(capable.values()):
             win = next(n for n, v in capable.items() if v)
             arbitration = f"仅 {win} 条件满足"