From fdd3c8883c358618387f89c735f3017a39e6c114 Mon Sep 17 00:00:00 2001 From: admin Date: Mon, 7 Sep 2026 20:31:51 +0800 Subject: [PATCH] =?UTF-8?q?Fix=20#35:=20MergeBatch=20L1=E7=BB=91=E5=AE=9A?= =?UTF-8?q?=E6=83=85=E5=BD=A2=20DMA=20=E5=91=BD=E4=BB=A4=E6=95=B0=E5=A4=9A?= =?UTF-8?q?=E8=AE=A1=20b0=20=E5=80=8D=E4=BF=AE=E5=A4=8D=20+=20=E5=88=86?= =?UTF-8?q?=E7=95=8C=E6=B3=9B=E5=8C=96=E5=8F=A3=E5=BE=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - evaluate: 每核命令数 = ceil(b_core/b0) * ceil(K/k_l1^m) (K截断退化为 b_core/b0, 数值不变; L1绑定消除 b0 倍多计 —— v1.1 §4.4 恒劣恒等式的 n_K 是未合并粒度, 误代入合并后段数会多计 b0 倍, 可把仲裁方向翻错) - beats_iterbatch: 泛化为实际命令数比较 (cmds_iter=b_core*ceil(K/k_l1_iter) vs cmds_mb=ceil(b_core/b0)*ceil(K/k_l1^m), 节省>T_cmd vs drain 惩罚); K截断时严格 退化为文档闭式 b_core > b0*(T_comp+T_write)/T_cmd; 截断判定改用合并口径 plan.k_l1>=K (未合并截断不代表合并后截断); 覆盖 dValue 512B cap 第三情形; T_cmd<=0 策略路径改为 cmds_mb MergeBatch, m=8/16 -> IterBatch (修复前全判 IterBatch; 交叉点 m≈4~8, 物理合理) - 测试: TestIssue35 回归 5 例 (命令数公式/K截断不变/口径一致/路由家族/裁决文案); test_beats_iterbatch_policy 的 (128,64,64,512) 期望 True->False (第三情形: 合并侧 dValue cap 截断, 命令数 4=4 打平, 恒劣 —— 原期望基于误分类) - docs/01_MergeBatch分支.md: 分界小节补第三情形行 + 命令数口径警示 + 泛化净收益式 - 验证: 68/68 unittest; examples 重生成可复现 0 diff (仅仲裁文案 + 16.0->16 格式, plans.csv 不变); 压力 10000 例 (seed7/6000+seed2024/4000): 0 崩溃/0 NaN/0 违规/ 0 不可行/0 GML1 搬移命令数 (省 b0 倍 T_cmd); 交叉项被算出但丢弃 (冗余比例 (b0-1)/b0), 进入条件 5 保证 case 为访存 Bound, 冗余算力被搬移时延掩盖. -T_cmd=0 时 (无命令固定时延/未标定) 命令时延收益不可量化, 但合并仍省 b0 倍 +T_cmd=0 时 (无命令固定时延/未标定) 命令时延收益不可量化, 但合并仍可减少 搬移命令/主机指令数 (指令发射/调度/同步收益未建模) —— beats_iterbatch 按既定 -策略裁决: K截断即优先 MergeBatch (模型内代价仅 drain 惩罚), L1 绑定恒劣. +策略裁决: 合并后实际每核命令数更少即优先 MergeBatch (模型内代价仅 drain 惩罚), +命令数打平恒劣 (issue#35 泛化口径, 覆盖 dValue 512B cap 截断等第三情形). """ from __future__ import annotations @@ -194,7 +195,7 @@ class MergeBatchBranch(Branch): 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 # 保留语义标记 (plan.note/调试用) # 每 K 分块计算时延 (未合并基准, v1.1 §4.1 符号) / 单 batch 输出写回 (R4) t_comp_chunk = 2.0 * m * n * k_l1 / qc t_write = m * n * out_b / w_fix @@ -202,14 +203,14 @@ class MergeBatchBranch(Branch): # 搬移 (issue#31): 合并组/切 K 各 (组, K段) 数据互不重叠, 每个输入字节恰好 # 从 GM 读一次 (K截断与 L1 绑定均如此; 切 K 末段按实际剩余计, 不再整段上取) # -> GM 数据量 = V_in, 数据时延 = V_in/芯片带宽 (全核并发); - # 搬移命令数只决定 T_cmd (与 IterBatch 的同/少 b0 倍关系不变): - # K截断: 每核 b_core/b0 次合并搬入 (每次 b0 个 batch 全 K) - # L1绑定: k_L1^m = k_L1/b0, n_K^m = b0*n_K, 命令数与 IterBatch 相同 - if k_truncated: - dma_cmds = b_core / b0 - else: - n_k = -(-k // k_l1) - dma_cmds = b_core * n_k + # 搬移命令数只决定 T_cmd (issue#35 修正: 真实命令数 = 合并组数 x 每组 K 段数, + # 不得把"命令数与 IterBatch 相同 = b_core*n_K"(v1.1 §4.4, n_K 为未合并粒度) + # 误代入合并后段数 —— 那样会多计 b0 倍): + # K截断: n_K^m = 1 -> cmds = ceil(b_core/b0) (比 IterBatch 省 b0 倍) + # L1绑定: k_L1^m = k_L1/b0 理想情形退化为 b_core*n_K, 与 IterBatch 相同; + # dValue 512B cap 截断等情形按实际 ceil(K/k_l1^m) 计 + n_k = -(-k // k_l1) + dma_cmds = -(-b_core // b0) * n_k t_dma_cmd = dma_cmds * s.t_cmd t_mte2_data = case.input_bytes / s.bw_gm t_mte2 = t_mte2_data + t_dma_cmd @@ -243,54 +244,83 @@ class MergeBatchBranch(Branch): def beats_iterbatch(self, case: BmmCase) -> tuple: """返回 (MergeBatch是否更优, 说明). - MergeBatch 最优 ⟺ K截断 (k_L1=K) 且 b_core > b0*(T_comp+T_write)/T_cmd - L1 绑定情形 MergeBatch 恒劣于 IterBatch (搬移次数相同, 只放大 drain). + v1.1 §4.5 统一分界的泛化口径 (issue#35): 直接比较两分支**实际每核 DMA + 命令数**与 drain 惩罚 —— + cmds_iter = b_core * ⌈K/k_l1_iter⌉ (IterBatch 逐 batch 逐 K 段一条) + cmds_mb = ⌈b_core/b0⌉ * ⌈K/k_l1^m⌉ (合并组数 x 每组 K 段数) + 搬移节省 = (cmds_iter - cmds_mb) * T_cmd + drain 惩罚 = (b0-1) * (T_comp + T_write) (T_comp 按未合并基线分块) + MergeBatch 最优 ⟺ 搬移节省 > drain 惩罚. - T_cmd=0 (无命令时延/未标定) 时阈值趋于 +inf, 但 MergeBatch 还有**未量化的 - 结构性收益**: 大 B 小 MN 时搬移命令数/主机指令数省 b0 倍 (每条命令的指令 - 发射/调度/同步开销未建模). 因此 T_cmd<=0 采用既定策略: K截断即可胜 - (模型内代价仅为 drain 惩罚, 访存 Bound case 下小且方向已知); L1 绑定仍恒劣. + 与 v1.1 §4.5 闭式的等价性: + - K 截断 (k_l1^m = K): cmds_mb = b_core/b0, 退化为文档闭式 + b_core > b0*(T_comp+T_write)/T_cmd; + - L1 绑定理想情形 (k_l1^m = k_l1^iter/b0): 命令数相同, 节省=0 -> 恒劣; + - dValue 512B 推荐值截断等第三情形 (文档二分未覆盖): 按实际命令数比较. + + 截断判定用**合并后** plan.k_l1 >= K (与 make_plan/evaluate 同源, + issue#35): 未合并 k_l1 截断不代表合并后仍截断 (合并使 L1 占用放大 b0 倍, + 且受 dValue 512B 推荐值截断), v1.1 line 219 的字面定义 (未合并口径) 与 + line 161 的合并公式矛盾时以后者为准. + + T_cmd<=0 (无命令时延/未标定) 时阈值不可量化: 按既定策略, 合并后每核命令数 + 更少 (cmds_mb < cmds_iter, 结构性指令/调度收益未建模) 即判 MergeBatch 优先; + 命令数打平则恒劣 (合并只放大 drain). """ s = self.spec m, n, k = case.m, case.n, case.k - dt = case.dtype_in_bytes out_b = case.dtype_out_bytes b_core = case.batch_c // s.aic_num - # IterBatch 基准的 k_L1 (未合并): L1 双缓冲单 batch - k_l1_iter = min(k, s.l1_bytes / (2 * (m + n) * dt)) - k_truncated = k_l1_iter >= k + # IterBatch 基线的每核命令数 (与 iter_batch.evaluate 同源: 形态 a/b 时 + # k_l1=K 一次一条; c/d 形态按 l1_form 判定的 k_l1 分段) + from .iter_batch import IterBatchBranch + _, k_l1_iter, _ = IterBatchBranch(s).l1_form(case) + if not k_l1_iter: + k_l1_iter = k + n_k_iter = -(-k // min(k_l1_iter, k)) + cmds_iter = b_core * n_k_iter + # MergeBatch 实际每核命令数 (issue#35: 合并组数 x 每组 K 段数) plan = self.make_plan(case) b0 = plan.merge_b0 - # T_comp 按输入 dtype 算力 (issue#28); T_write 保持 v1.1 直写 GM 语义 + n_k_mb = -(-k // min(plan.k_l1, k)) + cmds_mb = -(-b_core // b0) * n_k_mb + k_truncated = plan.k_l1 >= k # 合并口径截断判定 (issue#35) + regime = f"K截断(k_l1^m={plan.k_l1}>=K)" if k_truncated else \ + f"L1绑定(k_l1^m={plan.k_l1} 阈值 +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") + # T_cmd=0: 命令时延收益不可量化 -> 按结构性命令数比较的策略裁决 + # (合并把搬移/计算命令序列并少, 指令发射/调度/同步收益存在但未量化); + # 命令数打平时合并只放大 drain -> 恒劣. + if cmds_mb < cmds_iter: + detail = (f"{regime}; T_cmd=0: 命令时延收益不可量化(阈值=+inf), " + f"合并后每核命令数 {cmds_mb} < IterBatch {cmds_iter} " + f"(结构性收益, 未量化) -> 策略优先 MergeBatch; " + f"模型内代价 drain 惩罚={drain_pen*1e6:.2f}us") return True, detail - detail = (f"k_L1={k_l1_iter:.0f} 恒劣") + detail = (f"{regime}; T_cmd=0: 每核命令数 MergeBatch={cmds_mb} 不少于 " + f"IterBatch={cmds_iter}, 合并只放大 drain 惩罚=" + f"{drain_pen*1e6:.2f}us -> 恒劣") return False, detail - threshold = b0 * (t_comp + t_write) / s.t_cmd - - win = k_truncated and (b_core > threshold) - detail = (f"k_L1={'K(截断)' if k_truncated else f'{k_l1_iter:.0f} drain_pen + detail = (f"{regime}; 每核命令数 MergeBatch={cmds_mb} vs IterBatch={cmds_iter}, " + f"搬移节省={savings*1e6:.2f}us vs drain惩罚=(b0-1)*(T_comp+T_write)=" + f"{drain_pen*1e6:.2f}us -> {'MergeBatch优' if win else 'IterBatch优'}") + if k_truncated: + detail += (f" (闭式等价: b_core={b_core} vs 阈值 " + f"b0*(T_comp+T_write)/T_cmd={b0 * (t_comp + t_write) / s.t_cmd:.1f})") return win, detail # ------------------------------------------------------------------ diff --git a/BMM/BMM_Theory/bmm_theory/router.py b/BMM/BMM_Theory/bmm_theory/router.py index 7feb8f5..4b8dd4e 100644 --- a/BMM/BMM_Theory/bmm_theory/router.py +++ b/BMM/BMM_Theory/bmm_theory/router.py @@ -110,10 +110,10 @@ class BranchRouter: 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})") + f"[裁决] {lat_win}" + ("" if win == lat_win else + f" (分界条件判{win}, 与时延模型不一致, 以时延模型为准)") ) - if win != lat_win: - win = lat_win # 时延模型为最终裁决 + win = lat_win # 时延模型为最终裁决 elif any(capable.values()): win = next(n for n, v in capable.items() if v) arbitration = f"仅 {win} 条件满足" diff --git a/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md b/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md index ab853ac..83b3738 100644 --- a/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md +++ b/BMM/BMM_Theory/docs/02_分支理论/01_MergeBatch分支.md @@ -47,25 +47,36 @@ k_L1 被 512B 截断省出的 L1 空间容纳更多 batch，提升 batch 间流 $$T_{mb} = \underbrace{\frac{b_{core}}{b_0}\cdot n_K^m\cdot(T_{load}^m + T_{cmd})}_{\text{搬移(合并)}} + \underbrace{b_0(T_{comp}+T_{write})}_{\text{末合并 batch drain}}$$ -两种情形： +两种经典情形 (v1.1 §4.3/§4.4) 与第三情形 (issue#35): -| 情形 | k_L1^m | n_K^m | 搬移命令数 | 结论 | +| 情形 | k_L1^m | n_K^m | 每核搬移命令数 (⌈b_core/b₀⌉·n_K^m) | 结论 | |---|---|---|---|---| -| **K 截断** (k_L1=K) | K 不减半 | 1 | b_core/b₀（少 b₀ 倍） | MergeBatch 可胜 | -| **L1 绑定** (k_L1 恒劣; 反之若 IterBatch 走 +c/d 形态切 K 而合并侧每核命令数更少, 则按实际节省判定。 + +> **每核命令数口径 (issue#35)**: 真实命令数 = **合并组数 × 每组 K 段数** = +> ⌈b_core/b₀⌉·⌈K/k_L1^m⌉。注意 v1.1 §4.4 "命令数与 IterBatch 相同 = b_core·n_K" 中的 +> n_K 是**未合并**粒度 (⌈K/k_L1^iter⌉); 误代入合并后段数 ⌈K/k_L1^m⌉ 会多计 b₀ 倍 +> (修复前 evaluate 即此错, L1 绑定情形命令时延虚高 b₀ 倍, 可把仲裁方向翻错)。 > **GM 数据量口径 (issue#31)**: 各 (合并组, K段) 的数据互不重叠, 每个输入字节恰好从 GM > 读一次 —— K 截断与 L1 绑定两种情形的**芯片 GM 读取量都 = V_in** (末段按实际剩余计, > 无 padding 上取)。上式的 T_load 级联只用于刻画命令/双缓冲调度结构: 数据时延按 -> V_in/W_GM 计, n_K 只放大 DMA 命令项 (b_core/b₀ 或 b_core·n_K) × T_cmd。 +> V_in/W_GM 计, n_K 只放大 DMA 命令项 ⌈b_core/b₀⌉·n_K^m × T_cmd (issue#35 口径)。 ## 5. MergeBatch vs IterBatch 净收益 -$$\text{净收益} = \underbrace{b_{core}\Big(1-\frac{1}{b_0}\Big)T_{cmd}}_{\text{搬移命令节省}} - \underbrace{(b_0-1)(T_{comp}+T_{write})}_{\text{drain 惩罚}}$$ +泛化分界 (issue#35, 覆盖三种情形): 直接比较两分支**实际每核 DMA 命令数** —— -大 B（b_core 大）且小 MN（T_comp 小）时 MergeBatch 最优。T_cmd 的物理成因：Nd2Nz 描述符配置（7 字段写 DMA 寄存器）+ 地址生成 + 突发启动 + L1 同步握手。 +$$\text{净收益} = \underbrace{(cmds_{iter}-cmds_{mb})\,T_{cmd}}_{\text{搬移命令节省}} - \underbrace{(b_0-1)(T_{comp}+T_{write})}_{\text{drain 惩罚}},\qquad \begin{array}{l}cmds_{iter}=b_{core}\lceil K/k_{L1}^{iter}\rceil\\ cmds_{mb}=\lceil b_{core}/b_0\rceil\lceil K/k_{L1}^m\rceil\end{array}$$ + +K 截断时严格退化为 v1.1 §4.5 闭式 b_core > b₀(T_comp+T_write)/T_cmd；L1 绑定理想情形命令数打平、净收益恒负。大 B（b_core 大）且小 MN（T_comp 小）时 MergeBatch 最优。T_cmd 的物理成因：Nd2Nz 描述符配置（7 字段写 DMA 寄存器）+ 地址生成 + 突发启动 + L1 同步握手。 ## 6. 与源码的差异（v1.1 §5.1） diff --git a/BMM/BMM_Theory/examples/result_evaluate.csv b/BMM/BMM_Theory/examples/result_evaluate.csv index 4c70d9d..d56b38f 100644 --- a/BMM/BMM_Theory/examples/result_evaluate.csv +++ b/BMM/BMM_Theory/examples/result_evaluate.csv @@ -2,7 +2,7 @@ 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,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,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),"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_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,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),"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),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"瓶颈在 MTE2 搬移链 (GM 读写共享总线 + L2 重复读): 可增大 tile 提升 dValue/单核搬移量、利用 L2 驻留吸收重复读 (ASW swizzle/分组方向), 或评估输出驻留 L2 以减少 GM 直写与读竞争" diff --git a/BMM/BMM_Theory/examples/result_recommend.csv b/BMM/BMM_Theory/examples/result_recommend.csv index 6f11540..29afe21 100644 --- a/BMM/BMM_Theory/examples/result_recommend.csv +++ b/BMM/BMM_Theory/examples/result_recommend.csv @@ -2,8 +2,8 @@ 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,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,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),"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),"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" +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,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截断(k_l1^m=256>=K); 每核命令数 MergeBatch=16 vs IterBatch=64, 搬移节省=2.40us vs drain惩罚=(b0-1)*(T_comp+T_write)=0.23us -> MergeBatch优 (闭式等价: b_core=64 vs 阈值 b0*(T_comp+T_write)/T_cmd=6.0)); [时延模型] 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),"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 (L1绑定(k_l1^m=256 IterBatch优); [时延模型] T_MergeBatch=11.06us 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),"resident(整case输入+输出<=L2: 输出驻留L2异步回写, GM写=0)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,双batch乒乓: 2*(MK+KN)*dtype=128KB <= L1; 输出落点: L2驻留,8388608,0.0,5.24288e-06,0.0,5.4428799999999995e-06,4,2.0000000000000002e-07,268435456.0,5.52336329218107e-07,1048576,2.0164923076923077e-07,0.0,5.4428799999999995e-06,1.8849638999683443e-07,5.631376389996834e-06,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 iter_demo_form_d,64,64,64,64,8192,bf16,bf16,bf16,False,False,False,True,0,iter_demo_form_d,IterBatch,Ascend950PR,batch_mat_mul_v3,32,32,1,1,1,切B轮转分配(核间零重复读零依赖),2,1,64,64,8192,1024,1,d_两侧都切K,64,64,256,allocate(GM->L1随路驻留L2),"direct_gm(整case超L2: 输入优先驻留L2, 输出直写GM不占L2)",0,0,不涉及(核内不切M/N),1,1,1,0,0,0,0,True,2,"两侧都切K: k_L1=1024, K段成对流水, batch边界天然无缝; dValueA=2048B/dValueB=128B; 输出落点: 直写GM",134217728,0.0,8.388608e-05,0.0,8.468608e-05,16,8.000000000000001e-07,4294967296.0,8.837381267489712e-06,524288,3.2768e-07,0.0,8.501376e-05,7.16176329218107e-07,8.572993632921812e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),仅 IterBatch 条件满足 streamk_demo,4,4,128,128,10240,bf16,bf16,bf16,False,False,False,True,0,streamk_demo,StreamK,Ascend950PR,batch_mat_mul_v3,32,1,1,1,32,"B/M/N切出4块, 每块32核切K归约 (归约组内核c负责K段[c*K/32,(c+1)*K/32))",1,1,128,128,320,256,1,K段标准分块流水,128,128,64,allocate(部分和驻留L2),"resident(部分和4B驻留L2, 防精度丢失不随C的fp16/fp8转换)",0,8388608,grid_K=32路切K+归约,1,1,32,0,0,0,0,True,4,"P=1.00, grid_K=32, 部分和驻留L2按4B写出, AIV归约后按C dtype=2B写最终",20971520,0,1.31072e-05,0.0,1.31072e-05,0.0,0.0,1342177280.0,2.761681646090535e-06,0.0,0.0,3.4067453613053613e-06,1.31072e-05,3.4067453613053613e-06,1.651394536130536e-05,MTE2,True,,访存Bound(GM读写共享+L2重复读),"P<=C/2, B/M/N并行度买不满, 切K (grid_K=32)" diff --git a/BMM/BMM_Theory/tests/test_branches.py b/BMM/BMM_Theory/tests/test_branches.py index 69f0942..1350aec 100644 --- a/BMM/BMM_Theory/tests/test_branches.py +++ b/BMM/BMM_Theory/tests/test_branches.py @@ -388,18 +388,21 @@ class TestZeroCmdHandling(unittest.TestCase): """T_cmd=0 (无命令时延/未标定) 时整链路不得除零/崩溃, 按策略优先 MergeBatch.""" def test_beats_iterbatch_policy(self): - # T_cmd<=0: 阈值 +inf 不可除零; K截断按策略判 MergeBatch 胜 (指令级收益未量化), - # L1 绑定仍恒劣 + # T_cmd<=0: 阈值 +inf 不可除零; 合并后每核命令数更少即按策略判 MergeBatch 胜 + # (指令级收益未建模), 命令数打平/更多则恒劣 (issue#35 泛化口径) from bmm_theory.hardware import NpuSpec from bmm_theory.branches.merge_batch import MergeBatchBranch spec0 = NpuSpec(t_cmd_ns=0.0) mb = MergeBatchBranch(spec0) - # (b, m, n, k, K截断与否) - cases = [(2048, 32, 32, 256, True), (128, 64, 64, 512, True), + # (b, m, n, k, MergeBatch应胜与否=合并后命令数更少) + # (128,64,64,512): issue#35 —— 合并侧被 dValue 512B cap 截断 (k_l1^m=256, + # n_K^m=2), 而 IterBatch 走 b 形态 k_l1=K=512, 每核命令数 4=4 打平, 合并只 + # 放大 drain -> 恒劣; 原期望 True 建立在未合并口径的误分类上 (第三情形) + cases = [(2048, 32, 32, 256, True), (128, 64, 64, 512, False), (256, 128, 128, 4096, False)] - for b, m, n, k, truncated in cases: + for b, m, n, k, mb_wins in cases: win, detail = mb.beats_iterbatch(mkcase(b, m, n, k)) - self.assertEqual(win, truncated, f"{b},{m},{n},{k}: {detail}") + self.assertEqual(win, mb_wins, f"{b},{m},{n},{k}: {detail}") self.assertIn("T_cmd=0", detail) def test_route_with_zero_cmd_prefers_merge(self): @@ -798,5 +801,71 @@ class TestIssue33(unittest.TestCase): self.assertTrue(er.feasible) +class TestIssue35(unittest.TestCase): + """issue#35: MergeBatch L1 绑定情形 DMA 命令数多计 b0 倍修复 + 分界泛化口径. + + 用户 case 家族: B=128, M=1~16, N=128, K=512, bf16. b_core=4, b0=4, + 合并后 k_l1^m=240/224 < K=512 (L1 绑定区), 真实每核命令数 = 1x3=3 条 + (< IterBatch 的 4 条), 修复前被多计为 12 条导致仲裁翻错方向. + """ + + def setUp(self): + self.router = BranchRouter() + self.mb = MergeBatchBranch() + self.ib = IterBatchBranch() + + def test_merged_cmd_count_formula(self): + # 每核命令数 = ceil(b_core/b0) * ceil(K/k_l1^m) (K截断时 = b_core/b0) + case = mkcase(128, 16, 128, 512) + r = self.mb.analyze(case) + self.assertTrue(r.capable) + p = r.plan + expect = -(-p.b_core // p.merge_b0) * (-(-case.k // p.k_l1)) + self.assertEqual(r.timing.dma_cmd_count, expect) + # 本 case: b0=4, k_l1=224 -> 1*3 = 3 条 (修复前 12 条) + self.assertEqual((p.merge_b0, p.k_l1), (4, 224)) + self.assertEqual(r.timing.dma_cmd_count, 3) + + def test_cmd_count_truncated_unchanged(self): + # K 截断情形数值不变: cmds = b_core/b0 = IterBatch 的 1/b0 + case = mkcase(2048, 32, 32, 256) + mb = self.mb.analyze(case) + ib = self.ib.analyze(case) + self.assertGreaterEqual(mb.plan.k_l1, case.k) # 合并后仍截断 + self.assertEqual(mb.timing.dma_cmd_count, + -(-mb.plan.b_core // mb.plan.merge_b0)) + self.assertAlmostEqual( + mb.timing.dma_cmd_count / ib.timing.dma_cmd_count, + 1.0 / mb.plan.merge_b0, places=6) + + def test_boundary_uses_merged_k_l1(self): + # 截断判定与 plan.k_l1 口径一致: k_l1^m < K 时不得声称 K截断 + case = mkcase(128, 1, 128, 512) + _, detail = self.mb.beats_iterbatch(case) + p = self.mb.make_plan(case) + self.assertLess(p.k_l1, case.k) + self.assertIn("L1绑定", detail) + self.assertNotIn("K截断", detail) + + def test_user_case_family_routing(self): + # B=128,M=1~16,N=128,K=512: 修复后小 M 由 MergeBatch 胜 (命令节省 > + # drain 惩罚), 大 M 由 IterBatch 胜 (drain 随 M 增长, 节省固定) + expect = {1: "MergeBatch", 2: "MergeBatch", 4: "MergeBatch", + 8: "IterBatch", 16: "IterBatch"} + for m, branch in expect.items(): + r = self.router.route(mkcase(128, m, 128, 512)) + self.assertEqual(r["branch"], branch, f"m={m}: {r['arbitration']}") + self.assertEqual(r["candidates"], {"MergeBatch": True, "IterBatch": True}) + self.assertEqual(r["self_check_violations"], []) + + def test_arbitration_text_final_winner_consistent(self): + # 仲裁文本 [裁决] 位必须是最终胜者 (分界与时延不一致时括注说明) + import re + r = self.router.route(mkcase(128, 2, 128, 512)) + m = re.search(r"\[裁决\] (\w+)", r["arbitration"]) + self.assertIsNotNone(m) + self.assertEqual(m.group(1), r["branch"]) + + if __name__ == "__main__": unittest.main()