b300eq: TP2PP4 MRR64 retest (pass-1 + ordered v2 + MRR48 control) — c64 gains +27%/+19%, TTFT collapse, -14% 1K c32 config cost attributed

- deploy_glm53_pp4_mrr64.sh: byte-diff vs original = MRR 48->64 only; decode graph stack-default bs<=256 (no graph change needed, arm never fell off graph) - pass-1 + v2 (fresh instance, retraction-prone 16K c64 ordered last): all 6 points aligned <=1.8% -> post-retraction contamination hypothesis disproved; anchor regression is reproducible MRR64 behavior - MRR48 fresh-instance control (4.1 c32 = 266.42): decomposes -17% anchor into -3.3% instance freshness + -14.4% MRR64 config cost (per-req TPOT p50 87->102ms, three instances, mechanism unidentified) - 16K c64: pool-capped ~59 active, 3 retractions both runs (deterministic); out -5% vs MRR48 queue-mode but TTFT P95 135->89s - report/README/provenance/CURRENT.md overwritten in place per user instruction; feishu wiki revision 13
2026-09-10 21:29:05 +08:00 · 2026-09-10 21:29:05 +08:00 · 97c208cfdb
commit 97c208cfdb
parent b9e8c0c4a2
17 changed files with 788 additions and 64 deletions
--- a/deploy/CURRENT.md
+++ b/deploy/CURRENT.md
@ -14,7 +14,7 @@
 | 60.5 | `glm53-nvfp4`（Up 2d，09-09 只读核验） | **NVFP4 团队生产**（deploy_glm53_605.sh，md5 fcd9109b）。生产机铁律：不实验、不重启、不覆盖脚本。**交付升级路径已更新为 v3（09-09 hit90 场景优胜 TP4PP2-hicache@0.90，池 647,040/c4 并发独立文档/hit90 cc8 out +34% vs 现役）：脚本 `experiments/pro6000/glm53_nvfp4_hit90_dp_dcp_bench/scripts/deploy_glm53_605_v3.sh` + 补丁束（60.8:/root/glm53_r37_patch_bundle_v3.tar.gz，md5 6922e534，需 scp 至 60.5）+ 需 docker pull cu13 镜像；未执行、未落 60.5 磁盘（60.5:/root 仅有原脚本，核验过）。此前 v2（TP2PP4-hicache，冷缓存口径优胜）被 v3 取代，仍留仓库可作"容量优先 6 条文档/512k 单条最快"备选；回滚=原脚本** | `profiles/pro6000/glm53_nvfp4_pro6000_sglang_tp8eagle.env`（方案 A 口径）；待切 `glm53_nvfp4_pro6000_sglang_tp4pp2_hicache.env`（容量优先备选 `..._tp2pp4_hicache.env`） |
 | 60.6 | 无容器，但 8 卡被外部裸金属实验占用（`/data/hzy/sparse-opd-*`，09-08 晚实测） | 外部任务，勿动（此前台账漏记） | — |
 | 60.7 | 基本空（4 卡仍有 `/home/user/dirA_exp` 外部小任务，09-08 晚实测） | 09-08 已拆除清空（方案 F 前身单机实验 + 场景一深优资产留盘），不再恢复 | — |
-| 60.8 | `glm53-nvfp4`（Up，:30000，restart=unless-stopped） | **TP4PP2-nomtp@0.90 hit90 优胜口径在役**（09-09 晚接替同日早间的 TP2PP4@0.85：同 r37 栈 cu13+9 挂载+de-GLOO，仅改 tp4/pp2 + memfrac 0.90；KV 池 **647,040**；实测实例原样保留切 restart 策略，未重建容器。启动 `bash /root/deploy_ppmtp_r37.sh '--tp 4 --pp-size 2 --disable-overlap-schedule --max-prefill-tokens 16384 --disable-custom-all-reduce --context-length 1048576' nomtp 8192 0.90 1 1 0 0`）。hit90（90% 命中 i128k/o512）out cc1/2/3/4/8/16 = **28.8/47.5/63.9/76.2/106.4/125.7**（vs TP2PP4 基线 cc4 +14%/cc8 +15%）；并发独立 128k 文档 **4 条**（cap cc4 98.5 零排队）、512k 单条 ✓ TTFT 135.8s、质量门 **7/7**；同轮判决：DP attention 容量负收益判死、DCP 对 DSA 静默算错禁用、MTP@128k accept 2.07 判负。让步项（知情）：容量 4 条（TP2PP4 为 6）、512k 单条慢 33%。回滚 TP2PP4 = 同命令改 `'--tp 2 --pp-size 4'` + memfrac 0.85。**09-10 B300 对标战役**：停役（容器 rename 保全 `glm53-nvfp4-insvc`）→ 双臂 B300 场景矩阵（TP2PP4-D 口径 24 点 + E7b 配方）→ E7b 高并发调参复测（初测 MRR16+图1-8 掉图断崖 → MRR64+图桶 1-64，`deploy_glm53_e7b_hicc.sh`，三场景 c8-c64 共 10 点全 OK；报告正文采用复测值：掉图断崖已修复、16K 仍 TP2PP4 占优（E7b 被 prefill 墙封 ~100 tok/s 平台）、decode 密集 1K→4K E7b 全档反超（c64 out 826.5 tok/s 全场最高、超 TP2PP4 72%）、边界仅 TP2PP4 可达、与 B300 绝对差 4-5×；报告飞书 wiki `A7V3wZTQeifCB4krdi6cA834nW9`，已整文更新）→ **原容器恢复并二次核验**（rename 回 + start，fired up/health 200/16K 单发+C4 抽测 ok、KV 池 647,040 与启动口径逐字一致） | `profiles/pro6000/glm53_nvfp4_pro6000_sglang_tp4pp2_hicache.env`；实验全量 `experiments/pro6000/glm53_nvfp4_hit90_dp_dcp_bench/`；B300 对标 `experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/`；前史 `experiments/pro6000/glm53_nvfp4_128k_capacity_topology/`（TP2PP4 口径）+ r37 `experiments/pro6000/glm53_ppmtp_r37_verify_graph/` |
+| 60.8 | `glm53-nvfp4`（Up，:30000，restart=unless-stopped） | **TP4PP2-nomtp@0.90 hit90 优胜口径在役**（09-09 晚接替同日早间的 TP2PP4@0.85：同 r37 栈 cu13+9 挂载+de-GLOO，仅改 tp4/pp2 + memfrac 0.90；KV 池 **647,040**；实测实例原样保留切 restart 策略，未重建容器。启动 `bash /root/deploy_ppmtp_r37.sh '--tp 4 --pp-size 2 --disable-overlap-schedule --max-prefill-tokens 16384 --disable-custom-all-reduce --context-length 1048576' nomtp 8192 0.90 1 1 0 0`）。hit90（90% 命中 i128k/o512）out cc1/2/3/4/8/16 = **28.8/47.5/63.9/76.2/106.4/125.7**（vs TP2PP4 基线 cc4 +14%/cc8 +15%）；并发独立 128k 文档 **4 条**（cap cc4 98.5 零排队）、512k 单条 ✓ TTFT 135.8s、质量门 **7/7**；同轮判决：DP attention 容量负收益判死、DCP 对 DSA 静默算错禁用、MTP@128k accept 2.07 判负。让步项（知情）：容量 4 条（TP2PP4 为 6）、512k 单条慢 33%。回滚 TP2PP4 = 同命令改 `'--tp 2 --pp-size 4'` + memfrac 0.85。**09-10 B300 对标战役**：停役（容器 rename 保全 `glm53-nvfp4-insvc`）→ 双臂 B300 场景矩阵（TP2PP4-D 口径 24 点 + E7b 配方）→ E7b 高并发调参复测（初测 MRR16+图1-8 掉图断崖 → MRR64+图桶 1-64，`deploy_glm53_e7b_hicc.sh`，三场景 c8-c64 共 10 点全 OK；报告正文采用复测值：掉图断崖已修复、16K 仍 TP2PP4 占优（E7b 被 prefill 墙封 ~100 tok/s 平台）、decode 密集 1K→4K E7b 全档反超（c64 out 826.5 tok/s 全场最高、超 TP2PP4 72%）、边界仅 TP2PP4 可达、与 B300 绝对差 4-5×；报告飞书 wiki `A7V3wZTQeifCB4krdi6cA834nW9`，已整文更新）→ TP2PP4 高并发调参复测（初测 C=64 受 MRR48 封顶 48 活跃+16 排队、decode 图默认覆盖 bs≤256 从未掉图 → MRR64，`deploy_glm53_pp4_mrr64.sh` 逐 token 仅改 MRR；三场景 c32/c64 共 6 点两轮对齐 ≤1.8%（pass-1 + v2 有序版）+ 全新实例 MRR48 对照归因；正文采用 v2 值：4.1/4.2 c64 out +27%/+19%（433/572）、三场景 c64 TTFT P95 全塌缩（20.0/337.9/134.8s → 7.2/7.3/89.2s）、16K c64 到池顶 ~59 活跃 + 3 次回退（确定性行为）、1K 短输入 c32 付 −14% MRR64 配置代价（276→266→228 = −3% 新鲜度 −14% 配置，三实例可复现、机制未定位）、16K c32 无代价；报告已再次整文更新）→ **原容器恢复并三次核验**（rename 回 + start，fired up/health 200/16K 抽测 ok、KV 池 647,040 与启动口径逐字一致、显存水位 77.2/82.3 GiB 与停役前一致） | `profiles/pro6000/glm53_nvfp4_pro6000_sglang_tp4pp2_hicache.env`；实验全量 `experiments/pro6000/glm53_nvfp4_hit90_dp_dcp_bench/`；B300 对标 `experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/`；前史 `experiments/pro6000/glm53_nvfp4_128k_capacity_topology/`（TP2PP4 口径）+ r37 `experiments/pro6000/glm53_ppmtp_r37_verify_graph/` |
 ## 方案 A-F 一览（GLM-5.3-NVFP4 @ pro6000，2026-09-08 双场景报告口径）
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/README.md
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/README.md
@ -3,11 +3,11 @@
 日期：2026-09-10 ｜ 机器：174.1.60.8（8×RTX 6000D，96GB GDDR7，无 NVLink）
 模型：GLM-5.3-NVFP4（modelopt）｜ 镜像：`nightly-dev-20260828-daf63171`（两臂同）
 对标基线：飞书《GLM 5.3 ｜ SGLang ｜ Low-latency & High-Throughput 测试结果》（B300 报告，wiki UPB2w4Y5yi65qwkMxJJcZko5nUc）
-完整报告：本目录 `REPORT.md`（= 飞书发布版 A7V3wZTQeifCB4krdi6cA834nW9；E7b 高并发复测后整文更新，正文采用复测值）
+完整报告：本目录 `REPORT.md`（= 飞书发布版 A7V3wZTQeifCB4krdi6cA834nW9；两臂高并发复测后整文更新，正文一律采用复测值）
 ## 目标
-在 6000D 上复刻 B300 报告的全部场景（主场景 16K→512、4.1 短输入、4.2 长输出、5.1 长上下文、5.2 边界），对两套在役部署方案各跑一遍完整矩阵，产出对齐 B300 8 章结构的对标报告。E7b 初测暴露 MRR16 + decode 图 bs1-8 的高并发掉图断崖后，按用户决策调参为 MRR64 + 图桶 1-64（`deploy_glm53_e7b_hicc.sh`，其余配方逐字不变）复测三场景 C=8/16/32/64 共 10 点，**报告正文一律采用复测值**（C=1 与 5.1/5.2 点受池上限约束、与调参无关，沿用初测值；C=8 锚点前后偏差 ≤3% 证两轮环境无漂移）。测后 60.8 在役服务（TP4PP2@0.90）原容器恢复并二次验证。
+在 6000D 上复刻 B300 报告的全部场景（主场景 16K→512、4.1 短输入、4.2 长输出、5.1 长上下文、5.2 边界），对两套在役部署方案各跑一遍完整矩阵，产出对齐 B300 8 章结构的对标报告。两臂各完成一轮当日调参复测：E7b 初测暴露 MRR16 + decode 图 bs1-8 的高并发掉图断崖，按用户决策调参为 MRR64 + 图桶 1-64（`deploy_glm53_e7b_hicc.sh`，其余配方逐字不变）复测三场景 C=8/16/32/64 共 10 点；TP2PP4 初测的 C=64 点受 MRR48 封顶（48 活跃+16 排队；decode 图栈默认覆盖 bs≤256、本臂从未掉图），按用户决策调参为 MRR64（`deploy_glm53_pp4_mrr64.sh`，逐 token diff 仅 MRR 一处）复测三场景 C=32/C=64 共 6 点两轮（pass-1 + v2 有序版，全部点位对齐 ≤1.8%），另以全新实例跑原版 MRR48 的 4.1 C=32 单点做归因对照。**报告正文一律采用复测值**（C=1 与 5.1/5.2 点受池上限约束、与调参无关，沿用初测值）。测后 60.8 在役服务（TP4PP2@0.90）原容器恢复，当日三轮拆台均按 rename→start 流程保全恢复并逐轮验证。
 ## 实验臂
@ -16,29 +16,33 @@
 | tp2pp4 | **D 生产口径**（deploy_glm53_pp4.sh） | TP2PP4、mem0.85、MRR48、cps16384、radix 关、KV fp8_e4m3 池 1,040,384、无投机、index_topk_freq=4（=原生默认，恒等）、ctx 1,048,576 | 6/7（仅 tool-call：无 parser，历史已知） |
 | e7b | **TP8+EAGLE3+AR 初测**（deploy_glm53_607_exp.sh + CAR 补丁注入） | TP8、EAGLE 4/1/5、mem0.90、MRR16、cps8192、radix 开+hicache×3、KV fp8_e4m3 GPU 池 276,480、decode 图 bs1-8、ctx 270,336、custom-AR 1stage（`SGLANG_CUSTOM_ALLREDUCE_ALGO=1stage`，8 rank `SSKJ_CAR_PATCH_ACTIVE` 验证） | 7/7 |
 | e7b64 | **TP8+EAGLE3+AR 高并发复测**（deploy_glm53_e7b_hicc.sh，= e7b 仅改 MRR 16→64 + decode 图桶 1-64） | 其余配方与 e7b 逐字一致；图捕获后 avail 6.11 GB/卡，KV 池 276,480 不变 | 7/7 |
 | pp4mrr64 | **D 生产口径高并发复测**（deploy_glm53_pp4_mrr64.sh，= tp2pp4 仅改 MRR 48→64） | 其余配方与 tp2pp4 逐字一致；decode 图栈默认覆盖 bs≤256（无需扩图）；KV 池 1,040,384 不变；16K 场景活跃上限转为池 ~59 条 | 6/7（v2 实例复验，仅 tool-call 已知项） |
 | mrr48ctl | **归因对照**（原版 deploy_glm53_pp4.sh 全新实例，4.1 C=32 单点） | = tp2pp4 逐字一致（MRR48）；用于分解 4.1 C=32 锚点 −17%（−3% 实例新鲜度 + −14% MRR64 配置代价） | 未跑（配置同 tp2pp4 已验） |
 ## 场景矩阵与并发档位（用户裁决收敛：16K 封 64、64K/128K 封 8/4）
 | B300 章节 | 场景 | 并发档位 | TP2PP4 活跃上限 | E7b 活跃上限 |
 |---|---|---|---|---|
-| §3 主场景 | 16K→512 | 1/8/16/32/64 | 48（MRR） | 16（池 276,480÷17.4K；复测臂 MRR64 不再是约束） |
+| §3 主场景 | 16K→512 | 1/8/16/32/64 | ~59（池 1,040,384÷17.4K；复测臂 MRR64 超配，c64 3 次回退） | 16（池 276,480÷17.4K；复测臂 MRR64 不再是约束） |
-| §4.1 | 1K→128 | 1/8/32/64 | 48 | 64（复测臂 MRR；初测 16） |
+| §4.1 | 1K→128 | 1/8/32/64 | 64（复测臂 MRR；初测 48） | 64（复测臂 MRR；初测 16） |
-| §4.2 | 1K→4K | 1/8/32/64 | 48 | ~52（池；复测臂 c64 有 12 条排队；初测 c64 中止 rc=143，复测已补齐） |
+| §4.2 | 1K→4K | 1/8/32/64 | 64（复测臂 MRR；初测 48） | ~52（池；复测臂 c64 有 12 条排队；初测 c64 中止 rc=143，复测已补齐） |
 | §5.1 | 64K→512 | 1/4/8 | 15（池） | 4（池） |
 | §5.1 | 128K→512 | 1/2/4 | 7（池） | 2（池） |
 | §5.2 | 256K→1 | 1/2/3 | 3（池） | 1（池贴边） |
 | §5.2 | 512K→1 | 1 | 1 | 结构性不可（ctx） |
 | §5.2 | 896K→1（代 B300"约1M"） | 1 | 1 | 结构性不可（ctx） |
-测量协议：冷缓存（shared-frac 0）+ 每点 flush + 服务端命中核验 ≤0.01（超限重试一次）；nreq=max(8, 2×cc)；P95 nearest-rank 对齐 B300；语料耗尽（21.23M/21.30M）下用回收窗口（`--pool-override` 基址映射见 REPORT 附录 A；复测臂为全新容器实例，同基址文本对 hicache 宿主层重新成为处女文本，命中核验全 0.0）。有效测量点 44 个（tp2pp4 24 + e7b/e7b64 合计 20：初测 10 点沿用 + 复测 10 点采用），全点 0 retraction、0 OOM。
+测量协议：冷缓存（shared-frac 0）+ 每点 flush + 服务端命中核验 ≤0.01（超限重试一次）；nreq=max(8, 2×cc)；P95 nearest-rank 对齐 B300；语料耗尽（21.23M/21.30M）下用回收窗口（`--pool-override` 基址映射见 REPORT 附录 A；复测臂为全新容器实例，同基址文本对 hicache 宿主层重新成为处女文本，命中核验全 0.0）。有效测量点 57 个（tp2pp4 24 + pp4mrr64 复测 12 + mrr48ctl 对照 1 + e7b/e7b64 合计 20），全点 0 OOM；唯一 retraction 点 = TP2PP4 主场景 C=64（MRR64 对 16K 池超配，两轮各 3 次，其余全点 0）。
-## 判决速览（详见 REPORT.md，E7b 数值均为复测值）
+## 判决速览（详见 REPORT.md，两臂数值均为复测值）
- **掉图断崖已修复（复测核心判决）**：初测 MRR16 + 图 bs1-8 把 E7b 窗口封死 C≤8（16K c16 TPOT 298ms 断崖）；调参 MRR64 + 图桶 1-64 后 C=16 TPOT 降至 228.8ms，16K c16/32/64 输出 92.1/97.6/99.6 tok/s（较初测 +18~33%），窗口扩到 C=64。
+- **掉图断崖已修复（E7b 复测核心判决）**：初测 MRR16 + 图 bs1-8 把 E7b 窗口封死 C≤8（16K c16 TPOT 298ms 断崖）；调参 MRR64 + 图桶 1-64 后 C=16 TPOT 降至 228.8ms，16K c16/32/64 输出 92.1/97.6/99.6 tok/s（较初测 +18~33%），窗口扩到 C=64。
- **分界负载形态化**：prefill 密集（16K 主场景）仍 TP2PP4 占优——c64 out 211 vs 99.6 = 2.1×（自初测 2.5× 收窄），E7b 输出被 prefill 墙（chunk8192+TP8 无 PP 流水）封在 ~100 tok/s 平台；短输入 c32/64 TP2PP4 领先收窄到 1.2×（276/341 vs 229/272），且 E7b c64 TTFT 反超（12.15 vs 19.96s）。
+- **TP2PP4 C=64 档全面提升（pp4mrr64 复测核心判决）**：初测 C=64 损失全部来自 MRR48（48 活跃+16 排队；decode 图默认覆盖 bs≤256 从未掉图）。MRR64 后：4.1 c64 输出 341→433（+27%）、4.2 c64 482→572（+19%）、16K c64 TTFT 135→89s（−34%）；4.1/4.2 c64 TTFT 从 20.0/337.9s 塌缩到 7.2/7.3s。16K c64 到达池顶（活跃 ~59、吞吐 −5%、3 次回退为确定性行为，两轮一致）。
- **decode 密集（1K→4K）E7b 全档反超**：c8/32/64 = 402/676/**826.5 tok/s**，c64 为全场最高输出吞吐（超 TP2PP4 同点 482 达 72%），TTFT 12.18s、TPOT 85.1ms 双优；初测排队断崖（c32 TTFT 305s）消除为 6.19s。
+- **MRR64 的 −14% 代价（1K 短输入 c32）与归因对照**：4.1 c32 锚点 276→228（−17%），全新实例 MRR48 对照 266.42 分解 = −3% 实例新鲜度 + −14% MRR64 配置本身（逐请求 TPOT p50 87→102ms 均匀抬高，三实例可复现、机制未定位）；4.2 c32 −6%、16K c32 持平。MRR 按负载形态选：1K 短输入为主且并发 ≤48 可保持 MRR48。
 - **分界负载形态化**：prefill 密集（16K 主场景）仍 TP2PP4 占优——c64 out 201 vs 99.6 = 2.0×，E7b 输出被 prefill 墙（chunk8192+TP8 无 PP 流水）封在 ~100 tok/s 平台；短输入 c32 两方案打平（228 vs 229）、c64 TP2PP4 1.6×（433 vs 272）且 TTFT/TPOT 双优。
 - **decode 密集（1K→4K）E7b 全档反超**：c8/32/64 = 402/676/**826.5 tok/s**，c64 为全场最高输出吞吐（超 TP2PP4 同点 572 达 45%），TPOT 85.1ms 仍优、TTFT 被 TP2PP4 MRR64 反超（7.30 vs 12.18s）；初测排队断崖（c32 TTFT 305s）消除为 6.19s。
 - **E7b C=1 优势不变**：16K out 49.6 vs 16.7=3.0×、TPOT 13.7 vs 50.3ms=3.7×；1K→4K out 135 vs 20.3=6.7×、TPOT 8.7ms。
- **TP2PP4 甜点 c16+**：16K 近线性至 c64（MRR48 未饱和）；边界 256K/512K/896K 只有 TP2PP4 可达（input 7,050/5,662/4,153 tok/s）；E7b ctx 270,336 结构性封顶。
+- **TP2PP4 甜点 c16+**：16K 爬至 c64 池顶（活跃 ~59 封顶）；边界 256K/512K/896K 只有 TP2PP4 可达（input 7,050/5,662/4,153 tok/s）；E7b ctx 270,336 结构性封顶。
 - **DSA 复现**：C=1 TPOT 对上下文不敏感（50.3/50.0/49.7ms @16/64/128K），并发才是驱动（c8: 70.9→161.8ms）。
 - **vs B300**：定性结构复现（LL/HT 分野一致），绝对差 4-5×，边界 prefill 差距收窄至 ~2×；主场景分界本机更靠前（C8 vs C64-128，容量上限而非算力），decode 密集场景调参后 E7b 全档无交叉（B300 报告未呈现该形态）。
@ -57,6 +61,12 @@
 165db732fa3237a80a4d53a963a128e7  deploy_glm53_e7b_hicc.sh  (scripts/，E7b 高并发版：MRR64+图桶1-64，其余与 607_exp 逐字一致)
 fe46da2eb22f5ae23eb963bb9d467922  run_retest_e7b64.sh       (scripts/，10 点复测驱动，run-id 96xx)
 376bedfd42fa29ba9de8bfdf0c67c3b2  gen_retest_compare.py     (scripts/，复测前后对比表生成器)
 533440efc04e89bf5bbec3e0efbb35ed  deploy_glm53_pp4_mrr64.sh (scripts/，TP2PP4 高并发版：仅 MRR 48→64，其余与 deploy_glm53_pp4.sh 逐 token 一致)
 c9b6361d8679c41e59aced298e0f50bf  run_retest_pp4mrr64.sh    (scripts/，pass-1 6 点复测驱动，run-id 966x)
 7d8578169b2e7d3d1c9d461f53c44e87  run_retest_pp4mrr64_v2.sh (scripts/，v2 有序版：回退点 16K c64 排末位，run-id 967x，正文采用值)
 889c242859e46a0d41240a818f754bd1  launch_v2_after_pass1.sh  (scripts/，pass-1→拆台→重部署→QG→v2 全自动衔接 wrapper)
 1ff8a21f12a79a3b2aaa8c2dafb4af32  control_mrr48_41c32.sh    (scripts/，MRR48 归因对照 + 自动链接在役恢复)
 20cea216bce9aeda4ec4ecea4569a3de  gen_retest_compare_pp4.py (scripts/，TP2PP4 复测前后对比表生成器)
 def3c64c5dc19e1d507080e3366c3762  deploy_glm53_pp4.sh       (见 dual_scenario_bench/scripts/，md5 对照一致)
 21db641f1d997e26fcf1ddc97163b87e  deploy_glm53_607_exp.sh   (见 dual_scenario_bench/scripts/，md5 对照一致)
 a8fc9a504c041acc40831a848b4985d8  patches/custom_all_reduce.py
@ -67,6 +77,6 @@ gen_report_tables.py 为本地表格生成器（md5 未入台账，60.8 侧执
 ## 原始数据
- 本目录 `results/{tp2pp4,e7b,e7b64}/`：all_results.jsonl（逐点 SUMMARY + 命中核验）、status.txt、server_facts.txt（启动参数+池分配日志摘录）、gpu_inventory_idle/final.csv、vram_timeline.csv（30s 采样全矩阵；csv/log 属 gitignore 中间件，关键事实折叠于 provenance.md）
+- 本目录 `results/{tp2pp4,e7b,e7b64,pp4mrr64}/`：all_results*.jsonl（逐点 SUMMARY + 命中核验）、status*.txt、server_facts*.txt（启动参数+池分配日志摘录）、gpu_inventory_idle/final.csv、vram_timeline.csv（30s 采样全矩阵；csv/log 属 gitignore 中间件，关键事实折叠于 provenance.md）；pp4mrr64/ 含 pass-1、v2（正文采用值）、mrr48ctl（归因对照）三套 jsonl + retest_compare_pp4_v2.md 前后对比表
- 60.8 侧：`/root/bench_logs/b300eq_tp2pp4_20260910_1138/`、`/root/bench_logs/b300eq_e7b_20260910_1428/`（初测留档基线）、`/root/bench_logs/b300eq_e7b64_20260910_1732/`（复测，正文采用值）+ `/root/bench_logs/retest_compare.md`（前后对比，本目录 results/e7b64/ 有同名镜像）
+- 60.8 侧：`/root/bench_logs/b300eq_tp2pp4_20260910_1138/`、`/root/bench_logs/b300eq_e7b_20260910_1428/`（初测留档基线）、`/root/bench_logs/b300eq_e7b64_20260910_1732/`（E7b 复测，正文采用值）+ `/root/bench_logs/retest_compare.md`（前后对比）、`/root/bench_logs/b300eq_pp4mrr64_20260910_1927/`（TP2PP4 复测 pass-1）、`/root/bench_logs/b300eq_pp4mrr64v2_20260910_2021/`（TP2PP4 复测 v2，正文采用值）+ `/root/bench_logs/retest_compare_pp4_v2.md`、`/root/bench_logs/b300eq_mrr48ctl_20260910_2112/`（MRR48 对照）
 - E7b 256K C=1：all_results.jsonl 同 tag 共 4 条，最后一条为干净重测值（生成器 dict 载入后写覆盖，天然生效）
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/REPORT.md
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/REPORT.md
@ -1,23 +1,25 @@
 # GLM-5.3-NVFP4 ｜ RTX 6000D ｜ SGLang 双方案 B300 对标场景压测报告
- 测试日期：2026-09-10（单日单机完成两臂；E7b 臂当日调参 MRR 64 + decode 图 ≤64 后完成高并发复测，正文一律采用复测值）
+- 测试日期：2026-09-10（单日单机完成两臂；两臂均完成当日调参复测——E7b：MRR 64 + decode 图桶 ≤64，TP2PP4：MRR 48→64——正文一律采用复测值）
 - 测试机：174.1.60.8（6000D，8 卡）
 - 对标基线：飞书《GLM 5.3 ｜ SGLang ｜ Low-latency & High-Throughput 测试结果》（B300 报告，wiki UPB2w4Y5yi65qwkMxJJcZko5nUc）
- 测后状态：60.8 在役服务（TP4PP2@0.90 口径，KV 池 647,040）已原容器恢复并二次验证（两轮测试后均按 rename→start 流程恢复；本轮复测拆台后 fired up + health 200 + 16K 单发与 C=4 抽测 ok，配置与池逐字一致）
+- 测后状态：60.8 在役服务（TP4PP2@0.90 口径，KV 池 647,040）已原容器恢复并终验（当日三轮拆台均按 rename→start 流程保全恢复；末轮恢复后 fired up + health 200 + 16K 单发抽测 ok，池 647,040 与显存水位 77.2/82.3 GiB 逐字一致）
 ## 1. 结论摘要
 本轮在单台 8 卡 RTX 6000D 上，用 GLM-5.3-**NVFP4** 完整复刻 B300 报告的场景矩阵，测试了两套在役部署方案。两套方案代表完整部署形态，不是单参数 A/B：**TP2PP4** 为 D 生产口径（吞吐/长上下文形态），**TP8+EAGLE3+AR** 为 E7b 配方（低延迟形态，含 custom allreduce 1stage 补丁）。
 - **低并发优先 E7b（TP8+EAGLE3+AR）**：主场景 `16K→512, C=1` 输出 49.6 tok/s、TPOT 13.7 ms，对 TP2PP4（16.7 tok/s、50.3 ms）分别是 **3.0×** 与 **3.7×**；长输出 `1K→4K, C=1` 输出 135 tok/s、TPOT 8.7 ms，对 TP2PP4（20.3、49.8 ms）是 **6.7×** 与 **5.7×**。
- **prefill 密集场景（16K 输入）高并发优先 TP2PP4**：主场景 C=64 达到 6,748 input tok/s / 211 output tok/s，对 E7b（3,188 / 99.6）为 **2.1×**；短输入 C=32/64 TP2PP4 仍占优（276/341 vs 229/272 tok/s）但差距收窄到 **1.2×**。
+- **prefill 密集场景（16K 输入）高并发优先 TP2PP4**：主场景 C=64 达到 6,419 input tok/s / 201 output tok/s，对 E7b（3,188 / 99.6）为 **2.0×**；短输入 C=32 两方案打平（228 vs 229 tok/s，TP2PP4 的 MRR64 配置代价见下条）、C=64 TP2PP4 拉开（433 vs 272，**+59%**）。
 - **E7b 初测的掉图断崖是配置产物，调参后已消除**：初测 MRR=16 + decode 图仅覆盖 bs 1–8，并发 >8 即掉图（主场景 C=16 TPOT P95 298 ms）。按决策调参为 **MRR=64 + decode 图桶 1–64**（其余配方逐字不变）后复测：C=16 TPOT P95 降至 228.8 ms，16K 场景 C=16/32/64 输出 92.1/97.6/99.6 tok/s（较初测 +18~33%），E7b 可用并发窗口从 C≤8 扩到 **C=64**。
- **TP2PP4 甜点在 C=16 之后**：主场景输出吞吐从 C=8 的 101 近线性爬到 C=64 的 211 tok/s（MRR48 尚未饱和）；其 4.2 长输出 C=64 的 482 tok/s 已被 E7b 反超（826.5），但 16K 主场景仍是本机 prefill 吞吐之王。
+- **TP2PP4 初测的 C=64 损失全部来自 MRR=48（48 活跃+16 排队），调至 64 后 C=64 档全面提升**：decode 图为栈默认覆盖 bs≤256、本臂从未掉图，MRR 才是唯一瓶颈。MRR64 复测（其余配方逐字不变）：4.1 短输入 C=64 输出 341→433（+27%）、4.2 长输出 C=64 输出 482→572（+19%）、主场景 C=64 TTFT P95 135→89 s（−34%）；4.1/4.2 的 C=64 TTFT P95 分别从 20.0/337.9 s 塌缩到 7.2/7.3 s。
- **decode 密集负载（1K 进、长出）E7b 全并发档最优**：`1K→4K` C=8/32/64 输出 402/676/**826.5 tok/s**——C=64 为全场最高输出吞吐（超 TP2PP4 同点 482 达 72%），TTFT P95 12.2 s、TPOT P95 85.1 ms，EAGLE accept 3.8~4.0。
+- **MRR64 的代价与边界**：1K 短输入 C=32 锚点 276→228（−17%；全新实例 MRR48 对照实验定案：−3% 为实例新鲜度、−14% 为 MRR64 配置本身——逐请求 TPOT p50 87→102 ms 均匀抬高，三实例可复现、机制未定位）、1K→4K C=32 −6%、16K C=32 持平（−0.5%）；16K C=64 吞吐 −5%（201 vs 211，池超配 3 次回退）。MRR 按负载形态选，见建议 3。
 - **TP2PP4 甜点在 C=16 之后，MRR64 后主场景 C=64 到达 16K 池顶**：输出吞吐从 C=8 的 101 爬到 C=64 的 201 tok/s（活跃 ~59 条为池所封顶）；其 4.2 长输出 C=64 的 572 tok/s 已被 E7b 反超（826.5），但 16K 主场景仍是本机 prefill 吞吐之王。
 - **decode 密集负载（1K 进、长出）E7b 全并发档最优**：`1K→4K` C=8/32/64 输出 402/676/**826.5 tok/s**——C=64 为全场最高输出吞吐（超 TP2PP4 同点 572 达 45%），TTFT P95 12.2 s、TPOT P95 85.1 ms，EAGLE accept 3.8~4.0。
 - **长上下文与容量边界只有 TP2PP4 可达**：128K C=1 两方案输出打平（11.8 vs 11.9 tok/s）但 TP2PP4 TTFT 减半（18.2 s vs 37.6 s）；256K/512K/896K 边界 E7b 结构性不可测（ctx 270,336 封顶 + KV 池 276,480 贴边），TP2PP4 全部完成（256K C=1/2/3、512K/896K C=1）。
- **DSA 特性在 6000D 复现**：TP2PP4 C=1 的 TPOT 对上下文长度不敏感（16K/64K/128K = 50.3/50.0/49.7 ms 恒定），并发才是 TPOT 驱动因子（16K 行 C=8→C=64：70.9→203.7 ms）。
+- **DSA 特性在 6000D 复现**：TP2PP4 C=1 的 TPOT 对上下文长度不敏感（16K/64K/128K = 50.3/50.0/49.7 ms 恒定），并发才是 TPOT 驱动因子（16K 行 C=8→C=64：70.9→261.5 ms，末档含池超配回退的批扰动）。
 - **与 B300 的绝对差距约 4~5×**，边界 prefill 差距收窄到约 2×（256K C=1 input 7,050 vs 17,457；896K 4,153 vs 约1M 行 7,897）。硬件与量化口径不同（B300 报告未写明量化方式），绝对值仅量级可比，两份报告的结构性结论一致（见第 9 章）。
- 全部 44 个有效测量点 **0 回退（retraction）、0 OOM**，冷缓存命中核验全部 ≤0.01（E7b 256K C=1 首测触 hicache 宿主层陷阱，用全新文本重测达标，见 5.2 注记；E7b 复测 10 点命中核验全部 0.0）。
+- 全部有效测量点 **0 OOM**、冷缓存命中核验全部 ≤0.01（E7b 256K C=1 首测触 hicache 宿主层陷阱，用全新文本重测达标，见 5.2 注记；E7b64 复测 10 点、TP2PP4 MRR64 复测两轮 12 点与 MRR48 对照 1 点命中核验全部 0.0）；回退（retraction）仅出现在 TP2PP4 主场景 C=64 一点（MRR64 对 16K 池超配，两轮各 3 次，其余全部点 0 回退）。
 ## 2. 测试环境与配置
@ -29,19 +31,21 @@
 | 并行 | TP2 × PP4 | TP8 |
 | 投机解码 | 无 | EAGLE3，num_steps=4，topk=1，draft_tokens=5 |
 | `mem-fraction-static` | 0.85 | 0.90 |
-| 最大活跃请求（MRR） | 48 | 64 |
+| 最大活跃请求（MRR） | 64（复测口径；初测 48，见演进注记） | 64 |
 | Chunk Prefill | 16,384 | 8,192 |
 | KV dtype | fp8_e4m3 | fp8_e4m3 |
 | KV 池（服务端实测） | **1,040,384 tokens**（12.6~13.4 GB/rank，无宿主层） | **276,480 tokens GPU**（15.8 GB/rank）+ 分层缓存 hicache×3 宿主层（write_through） |
 | radix cache | 关（`disable_radix_cache=True`） | 开（分层缓存） |
 | 上下文上限 | 1,048,576（config 原生） | 270,336（显存约束下的部署值） |
-| CUDA graph | 常规捕获 | decode/verify 图桶 bs 1–64（1,2,3,4,6,8,12,16,24,32,48,64） |
+| CUDA graph | 常规捕获（decode 图栈默认覆盖 bs≤256，MRR64 全程在图内） | decode/verify 图桶 bs 1–64（1,2,3,4,6,8,12,16,24,32,48,64） |
 | custom allreduce | — | 1stage 补丁注入（`SGLANG_CUSTOM_ALLREDUCE_ALGO=1stage` 环境强制；8 rank `SSKJ_CAR_PATCH_ACTIVE` 日志验证全出现） |
 | `index_topk_freq` | 4（override，等于原生默认，恒等） | 原生默认 4 |
 | 质量门 | 6/7（仅 tool-call 失败：D 口径未配 parser，历史已知；其余全过） | **7/7** |
 **E7b 臂配置演进注记**：E7b 初测为 MRR=16 + decode 图桶 bs 1–8，高并发点（C>8）出现 decode 掉图 + MRR 排队双击。按决策将 MRR 调至 64、decode 图桶扩至 1–64（部署脚本 `deploy_glm53_e7b_hicc.sh`，其余配方与在役 E7b 逐字一致），三场景 C=8/16/32/64 共 10 点全部重测，正文一律采用复测值；C=1 各点与 5.1/5.2 长上下文点受 KV 池上限约束（活跃 1~4 条），行为与该调参无关，沿用初测值。C=8 锚点前后偏差 ≤3%（16K 81.4→83.9、1K 152→151、1K→4K 412→402 tok/s），证明两轮环境无漂移。初测原始数据留档于服务器 `b300eq_e7b_20260910_1428/` 与库内 `results/e7b/`。
 **TP2PP4 臂配置演进注记**：TP2PP4 初测为 MRR=48，主场景/4.1/4.2 的 C=64 点实际运行为 48 活跃+16 排队（decode 图为栈默认覆盖 bs≤256，本臂从未掉图，MRR 才是 C=64 的活跃上限）。按决策将 MRR 调至 64（部署脚本 `deploy_glm53_pp4_mrr64.sh`，与初测脚本逐 token diff 仅 MRR 一处），三场景 C=32/C=64 共 6 点重测两轮——pass-1 常规顺序，v2 全新实例并把易触发回退的主场景 C=64 排末位以排除状态污染；两轮全部点位对齐 ≤1.8%，证明回退后遗污染假设不成立、结果为 MRR64 的可复现行为。另以全新实例跑原版 MRR48 的 4.1 C=32 单点做归因对照（276 初测 → 266 对照 → 228 复测：−3% 实例新鲜度 + −14% MRR64 配置代价）。正文一律采用 v2 复测值；C≤16 各点与 5.x 长上下文行沿用初测值（MRR 在这些档位不构成约束）。初测原始数据留档于服务器 `b300eq_tp2pp4_20260910_1138/` 与库内 `results/tp2pp4/`，复测两轮与对照留档 `b300eq_pp4mrr64_20260910_1927/`、`b300eq_pp4mrr64v2_20260910_2021/`、`b300eq_mrr48ctl_20260910_2112/`。
 因此，下文比较回答的是"两种部署形态谁更适合该负载"，不能把差异单独归因于 EAGLE、PP 流水、chunk、radix 或图覆盖中的某一项（与 B300 报告同款声明）。
 **测量协议**（对齐 B300 口径）：
@ -56,9 +60,9 @@
 | 场景 | TP2PP4 活跃上限 | E7b 活跃上限 |
 |-|-|-|
-| 16K | 48（MRR） | 16（池 276,480 ÷ 约17.4K；MRR64 不再是约束） |
+| 16K | ~59（池 1,040,384 ÷ 17.4K；MRR64 超配，C=64 有 3 次回退） | 16（池 276,480 ÷ 约17.4K；MRR64 不再是约束） |
-| 1K→128 | 48（MRR） | 64（MRR） |
+| 1K→128 | 64（MRR） | 64（MRR） |
-| 1K→4K | 48（MRR） | ~52（池；C=64 有 12 条排队） |
+| 1K→4K | 64（MRR） | ~52（池；C=64 有 12 条排队） |
 | 64K | 15（池） | 4（池） |
 | 128K | 7（池） | 2（池） |
 | 256K | 3（池） | 1（池 262K KV / 276K 贴边） |
@ -76,17 +80,17 @@ B300 跑了 C=1/8/32/64/128/256；本机按 MRR 上限收敛为 C=1/8/16/32/64
 | 8 | TP8+EAGLE3+AR | 2,684 | 83.9 | 32.47 s | 136.1 ms |
 | 16 | TP2PP4 | 4,674 | **146** | **25.78 s** | **98.5 ms** |
 | 16 | TP8+EAGLE3+AR | 2,947 | 92.1 | 59.91 s | 228.8 ms |
-| 32 | TP2PP4 | **6,185** | **193** | **46.43 s** | **152.0 ms** |
+| 32 | TP2PP4 | **6,156** | **192** | **46.31 s** | **153.2 ms** |
 | 32 | TP8+EAGLE3+AR | 3,123 | 97.6 | 140.33 s | 213.6 ms |
-| 64 | TP2PP4 | **6,748** | **211** | **134.78 s** | **203.7 ms** |
+| 64 | TP2PP4 | **6,419** | **201** | **89.22 s** | 261.5 ms |
-| 64 | TP8+EAGLE3+AR | 3,188 | 99.6 | 293.21 s | 214.6 ms |
+| 64 | TP8+EAGLE3+AR | 3,188 | 99.6 | 293.21 s | **214.6 ms** |
 趋势：
- **分界仍在 C=8，但差距显著收窄**：C=1 E7b 全指标占优；C=8 起 TP2PP4 四指标反超。输出吞吐差距从初测的 2.5× 收到 2.1×（211 vs 99.6），TPOT P95 在 C=64 已接近（203.7 vs 214.6 ms）。
+- **分界仍在 C=8，但差距显著收窄**：C=1 E7b 全指标占优；C=8 起 TP2PP4 输出/输入/TTFT 反超。输出吞吐差距 2.0×（201 vs 99.6）；TPOT P95 在 C=64 反被 E7b 反超（261.5 vs 214.6 ms——TP2PP4 该点活跃 ~59 条贴池顶 + 3 次回退，E7b 池限 16 活跃反而批更轻）。
 - **调参消除掉图断崖**：E7b 输出从 C=8 的 83.9 单调爬到 C=64 的 99.6 tok/s（+19%），C=16 TPOT P95 从初测 298 ms 降到 228.8 ms，C=32/64 稳定在 ~214 ms——decode 图全程覆盖运行批。EAGLE accept 随并发从 2.56 爬到 2.95。
- **prefill 墙成为 E7b 的输出上限**：其 input TPS 从 C=8 的 2,684 到 C=64 仅 +19%（3,188），TP2PP4 同区间 +108%（3,236→6,748）——chunk 8192 + TP8 无 PP 流水 vs chunk 16384 + PP4 摊满。16K 场景 E7b 输出被 prefill 封死在 ~100 tok/s 平台，并发再高也不突破。
+- **prefill 墙成为 E7b 的输出上限**：其 input TPS 从 C=8 的 2,684 到 C=64 仅 +19%（3,188），TP2PP4 同区间 +98%（3,236→6,419）——chunk 8192 + TP8 无 PP 流水 vs chunk 16384 + PP4 摊满。16K 场景 E7b 输出被 prefill 封死在 ~100 tok/s 平台，并发再高也不突破。
- **E7b 本场景活跃上限 = KV 池（~16 条）**：C=32/64 为排队观察点（TTFT P95 140/293 s）；TP2PP4 到 C=64 仍在爬坡（C=32→64 +9%，MRR48 未饱和），其 TTFT P95 134.8 s 同样需要准入控制。
+- **两臂的 C=64 都撞各自的容量墙**：E7b 活跃上限 = KV 池（~16 条，C=32/64 为排队观察点，TTFT P95 140/293 s）；TP2PP4 MRR64 后活跃 ~59 条 = 16K 池顶（C=32→64 输出仅 +4%，3 次回退），但 TTFT P95 从 MRR48 排队态的 134.8 s 压到 89.2 s（−34%）——同样需要准入控制。
 ## 4. 短输入与长输出
@ -98,12 +102,12 @@ B300 跑了 C=1/8/32/64/128/256；本机按 MRR 上限收敛为 C=1/8/16/32/64
 | 1 | TP8+EAGLE3+AR | **518** | **64.7** | **326 ms** | **14.3 ms** |
 | 8 | TP2PP4 | 815 | 102 | **1.69 s** | 72.9 ms |
 | 8 | TP8+EAGLE3+AR | **1,211** | **151** | 2.17 s | **53.7 ms** |
-| 32 | TP2PP4 | **2,204** | **276** | **4.87 s** | **98.5 ms** |
+| 32 | TP2PP4 | 1,825 | 228 | **5.49 s** | **120.7 ms** |
-| 32 | TP8+EAGLE3+AR | 1,833 | 229 | 7.09 s | 150.6 ms |
+| 32 | TP8+EAGLE3+AR | **1,833** | **229** | 7.09 s | 150.6 ms |
-| 64 | TP2PP4 | **2,724** | **341** | 19.96 s | **101.8 ms** |
+| 64 | TP2PP4 | **3,466** | **433** | **7.16 s** | **116.7 ms** |
-| 64 | TP8+EAGLE3+AR | 2,178 | 272 | **12.15 s** | 292.7 ms |
+| 64 | TP8+EAGLE3+AR | 2,178 | 272 | 12.15 s | 292.7 ms |
-短输入下 E7b 在 C≤8 显著占优（C=8 输出 151 vs 102，1.5×）；C=32/64 TP2PP4 输出仍领先（276 vs 229、341 vs 272）但差距只有 **1.2×**（初测为 2.7~3.3×），且 E7b 的 C=64 TTFT P95 反而更优（12.15 vs 19.96 s）——代价是 TPOT P95 292.7 ms（64 条同时在飞；TP2PP4 同点 MRR48 只保持 48 活跃，TPOT 101.8 ms）。B300 同场景 Low-Latency 到 C=128 才被反超，本机在 C=8~32 之间，主因是 MRR/池容量而非算力。
+短输入下 E7b 在 C=8 显著占优（151 vs 102，1.5×）；C=32 两方案打平（229 vs 228——TP2PP4 的 MRR64 配置代价吃掉了初测 MRR48 276 的领先，见 2 节演进注记）；C=64 TP2PP4 重新拉开（433 vs 272，**1.6×**）且 TTFT/TPOT 双优（7.16 s/116.7 ms vs 12.15 s/292.7 ms）——MRR64 后 64 条满飞无排队，而 E7b 池上限 ~52 活跃、TPOT 被大稳态批拖高。B300 同场景 Low-Latency 到 C=128 才被反超，本机在 C=8~64 之间，主因是容量/配置而非算力。
 ### 4.2 `1K -> 4K`
@ -113,16 +117,16 @@ B300 跑了 C=1/8/32/64/128/256；本机按 MRR 上限收敛为 C=1/8/16/32/64
 | 1 | TP8+EAGLE3+AR | **135** | **320 ms** | **8.7 ms** |
 | 8 | TP2PP4 | 101 | 1.87 s | 79.4 ms |
 | 8 | TP8+EAGLE3+AR | **402** | **1.65 s** | **24.3 ms** |
-| 32 | TP2PP4 | 367 | **4.14 s** | 90.5 ms |
+| 32 | TP2PP4 | 347 | **4.95 s** | 101.2 ms |
 | 32 | TP8+EAGLE3+AR | **676** | 6.19 s | **54.6 ms** |
-| 64 | TP2PP4 | 482 | 337.92 s | 95.5 ms |
+| 64 | TP2PP4 | 572 | **7.30 s** | 112.5 ms |
-| 64 | TP8+EAGLE3+AR | **826.5** | **12.18 s** | **85.1 ms** |
+| 64 | TP8+EAGLE3+AR | **826.5** | 12.18 s | **85.1 ms** |
 长输出放大了两形态的差异——调参后 E7b 在本场景全并发档反超：
- **E7b 全档最优，C=64 = 826.5 tok/s 为全场最高输出吞吐**：C=1/8/32/64 输出 135/402/676/826.5，对 TP2PP4（20.3/101/367/482）为 6.7×/4.0×/1.8×/1.7×；C=64 同时拿下 TTFT（12.18 vs 337.92 s）与 TPOT（85.1 vs 95.5 ms）双优。EAGLE accept 3.7~4.0——长输出让草稿模型进入"顺笔"状态，显著高于 4.1 短输出行（2.0~2.1）。
+- **E7b 全档最优，C=64 = 826.5 tok/s 为全场最高输出吞吐**：C=1/8/32/64 输出 135/402/676/826.5，对 TP2PP4（20.3/101/347/572）为 6.7×/4.0×/1.9×/1.4×；C=64 TPOT 仍优（85.1 vs 112.5 ms），TTFT 被 TP2PP4 的 MRR64 反超（7.30 vs 12.18 s）。EAGLE accept 3.7~4.0——长输出让草稿模型进入"顺笔"状态，显著高于 4.1 短输出行（2.0~2.1）。
 - **初测的排队断崖已消除**：C=32 TTFT P95 从初测 304.75 s（nreq=64 / MRR=16 四波串行）降到 6.19 s；C=64 从未完成变为 12.18 s。MRR64 下 1K→4K 的池上限约 52 条活跃，C=64 仅 12 条排队，请求几乎全程满飞。
- **TP2PP4 本场景全程被压**：其优势场景是 prefill 密集（16K 主场景），1K 短进长出下既无 prefill 墙可摊、也无投机解码加成；C=64 输出 482 tok/s 且 TTFT P95 338 s，只适合离线批处理。
+- **TP2PP4 本场景被压，但 MRR64 修复了它的 C=64**：1K 短进长出下既无 prefill 墙可摊、也无投机解码加成；C=64 输出 482→572 tok/s（+19%）、TTFT P95 从 337.92 s 塌缩到 7.30 s（48 活跃+16 排队 → 64 满飞），不再只限离线批处理，但输出仍被 E7b 反超 45%。
 ## 5. 长上下文观察
@ -168,21 +172,22 @@ B300 跑了 C=1/8/32/64/128/256；本机按 MRR 上限收敛为 C=1/8/16/32/64
 ## 6. 显存状态
- **TP2PP4**：服务加载后空载 64.6 GiB/卡，矩阵峰值 **85.0 GiB/卡**（主场景 C=64 时逼近打满，最紧张卡余量约 0.6 GiB）。mem 0.85 下 KV 池按卡容量贴满分配，属预期；继续上调 MRR 或上下文没有余量，扩容前必须先降 mem-fraction。
+- **TP2PP4**：服务加载后空载 64.6 GiB/卡，矩阵峰值 **84.8 GiB/卡**（MRR64 复测矩阵，主场景 C=64 活跃 ~59 条贴池顶时；初测 MRR48 峰值 85.0 GiB、最紧张卡余量约 0.6 GiB）。mem 0.85 下 KV 池按卡容量贴满分配，属预期；MRR64 已把 16K 场景推到池顶，继续上调并发或上下文没有余量，扩容前必须先降 mem-fraction。
 - **TP8+EAGLE3+AR**：空载 77.5 GiB/卡（EAGLE 草稿权重 + mem 0.90 大池 + 13 档 decode 图，图捕获完成后余 6.11 GB/卡），复测矩阵峰值 **81.7 GiB/卡**（余量约 3.9 GiB；初测臂含 64K/128K/256K 长上下文的 hicache 传输，峰值 83.6 GiB/卡）。
- 两臂全矩阵 **0 OOM、0 retraction**（全部 44 点 retractions_total=0）——B300 未披露该指标，本机在自身容量上限内运行无回退。
+- 全矩阵 **0 OOM**；唯一出现回退（retraction）的点是 TP2PP4 主场景 C=64（MRR64 对 16K 池超配，两轮复测各 3 次；MRR48 初测同点 0 回退）——B300 未披露该指标，除该点外全部点 retractions_total=0。
 - 显存时间线逐 30 s 采样留档（vram_timeline.csv），可复核任一时刻的卡间分布。
 ## 7. 建议
 1. **低并发交互/agent 长思考（C≤8）用 E7b**：主场景 C=1 TPOT 13.7 ms、长输出 C=8 输出 402 tok/s；该区间对 TP2PP4 的优势最大（3.0~6.7×）。
-2. **prefill 密集/长上下文（16K 主场景、输入 ≥64K）用 TP2PP4**：主场景 C=64 输出 211 tok/s（E7b 99.6）、128K C=1 TTFT 18.2 s、896K 可达；MRR48 内未饱和，吞吐上限即 MRR。
+2. **prefill 密集/长上下文（16K 主场景、输入 ≥64K）用 TP2PP4**：主场景 C=64 输出 201 tok/s（E7b 99.6）、128K C=1 TTFT 18.2 s、896K 可达；MRR64 后 16K 场景活跃 ~59 条为池封顶，1K 场景吞吐上限即 MRR=64。
-3. **负载形态分界线（调参后）**：decode 密集（短进长出，1K→4K）任何并发档 E7b 全优（C=64 输出 826 vs 482 tok/s）；prefill 密集（16K 主场景）C≥8 TP2PP4 全优（211 vs 100）；短输入短输出（1K→128）C≤8 E7b、C≥32 TP2PP4（差距仅 1.2×）。选型看输入/输出长度分布，不能只看并发。
+3. **MRR 按负载形态选（本轮单变量结论）**：需要 C=64 档或低 TTFT 时 MRR64 收益确定——4.1 C=64 +27%、4.2 C=64 +19%、三场景 C=64 TTFT P95 全部塌缩（20.0/337.9/134.8 s → 7.2/7.3/89.2 s）；但 1K 短输入 C≤32 档付出 ~14% 配置代价（4.1 C=32 276→228，全新实例 MRR48 对照定案），16K 场景无代价。以 1K 短输入为主且并发 ≤48 的生产口可保持 MRR48；两档并存可按场景路由。
-4. **E7b 剩余瓶颈在 prefill 墙与 KV 池，不再在图**：MRR64 + 图桶 1–64 已消掉掉图断崖（本报告即复测值）；16K 主场景输出封顶 ~100 tok/s 是 chunk 8192 + TP8 无 PP 流水所致。扩并发容量的唯一杠杆是 KV 池（hicache 宿主层只救命中场景，不增并发容量）。
+4. **负载形态分界线（调参后）**：decode 密集（短进长出，1K→4K）任何并发档 E7b 全优（C=64 输出 826 vs 572 tok/s）；prefill 密集（16K 主场景）C≥8 TP2PP4 全优（201 vs 100）；短输入短输出（1K→128）C=8 E7b、C=32 打平、C=64 TP2PP4（1.6×）。选型看输入/输出长度分布，不能只看并发。
-5. **边界与超长上下文只有 TP2PP4 口径可服务**：E7b 若要对标 B300 512K/约1M 行，需要 ctx ≥524,288 与池 ≥52 万 tokens 的部署形态，本版（ctx 270,336 / 池 276,480）结构性不可达。
+5. **E7b 剩余瓶颈在 prefill 墙与 KV 池，不再在图**：MRR64 + 图桶 1–64 已消掉掉图断崖（本报告即复测值）；16K 主场景输出封顶 ~100 tok/s 是 chunk 8192 + TP8 无 PP 流水所致。扩并发容量的唯一杠杆是 KV 池（hicache 宿主层只救命中场景，不增并发容量）。
-6. **不要把两臂差异单归因 EAGLE**：两臂同时差在并行拓扑、chunk、radix、MRR 与图覆盖；单变量消融未做（与 B300 报告建议 3 同款）。
+6. **边界与超长上下文只有 TP2PP4 口径可服务**：E7b 若要对标 B300 512K/约1M 行，需要 ctx ≥524,288 与池 ≥52 万 tokens 的部署形态，本版（ctx 270,336 / 池 276,480）结构性不可达。
-7. **生产容量同时设吞吐和延迟 SLO**：TP2PP4 主场景 C=64 输出最高但 TTFT P95 已到 135 s；E7b 主场景 C=64 TTFT P95 293 s（池限 16 活跃的排队）。只看峰值 TPS 会掩盖排队长尾。
+7. **不要把两臂差异单归因 EAGLE**：两臂同时差在并行拓扑、chunk、radix、MRR 与图覆盖；单变量消融未做（与 B300 报告建议 3 同款）。MRR64 在 1K 短输入的 −14% 代价同样只有三实例 A/B 事实、机制未定位。
-8. **分层缓存运维**：宿主层缓存不受 `flush_cache` 影响，任何冷缓存测量/复测必须更换输入文本（见 5.2 注记）。
+8. **生产容量同时设吞吐和延迟 SLO**：TP2PP4 主场景 C=64 输出最高但 TTFT P95 仍达 89 s；E7b 主场景 C=64 TTFT P95 293 s（池限 16 活跃的排队）。只看峰值 TPS 会掩盖排队长尾。
 9. **分层缓存运维**：宿主层缓存不受 `flush_cache` 影响，任何冷缓存测量/复测必须更换输入文本（见 5.2 注记）。
 ## 8. 原始结果与复现
@ -190,9 +195,12 @@ B300 跑了 C=1/8/32/64/128/256；本机按 MRR 上限收敛为 C=1/8/16/32/64
  - TP2PP4 臂：`/root/bench_logs/b300eq_tp2pp4_20260910_1138/`（all_results.jsonl 24 点、status.txt、server_facts.txt、gpu_inventory、vram_timeline.csv）
  - E7b 臂初测（MRR16/图 1–8，留档基线）：`/root/bench_logs/b300eq_e7b_20260910_1428/`（all_results.jsonl 20 条：16 点 OK + 4.2 C=64 用户中止 + 256K C=1 干净重测；status.txt 含 4 个结构性跳过与 HIT_FAIL_FINAL 首测记录）
  - E7b 臂复测（MRR64/图 1–64，**正文采用值**）：`/root/bench_logs/b300eq_e7b64_20260910_1732/`（all_results.jsonl 10 点全 OK：16K/4.1/4.2 三场景 C=8/16/32/64，命中核验全 0.0、0 retraction）；前后对比表 `/root/bench_logs/retest_compare.md`
  - TP2PP4 MRR64 复测 pass-1：`/root/bench_logs/b300eq_pp4mrr64_20260910_1927/`（6 点全 OK，与 v2 对齐 ≤1.8%）
  - TP2PP4 MRR64 复测 v2（**正文采用值**，全新实例 + 回退点排末位）：`/root/bench_logs/b300eq_pp4mrr64v2_20260910_2021/`（6 点全 OK；16K C=64 3 次回退为 MRR64 池超配的确定性行为）；前后对比表 `/root/bench_logs/retest_compare_pp4_v2.md`
  - TP2PP4 MRR48 对照（归因实验，全新实例单点）：`/root/bench_logs/b300eq_mrr48ctl_20260910_2112/`（4.1 C=32 = 266.42 tok/s）
  - 资产 md5 台账：`/root/bench_logs/b300eq_md5_ledger.txt`
- 本地镜像：`D:\sskj\b300eq\{tp2pp4,e7b,e7b64}\`（上述全部文件）、`D:\sskj\b300eq\report_tables.md`（表格生成器输出）、`D:\sskj\b300eq\retest_compare.md`（复测前后对比）
+- 本地镜像：`D:\sskj\b300eq\{tp2pp4,e7b,e7b64}\`（上述全部文件）、`D:\sskj\b300eq\pp4mrr64_mirror\`（TP2PP4 复测两轮 + 对照全量）、`D:\sskj\b300eq\report_tables.md`（表格生成器输出）、`D:\sskj\b300eq\retest_compare.md`（E7b64 前后对比）、`D:\sskj\b300eq\pp4mrr64_mirror\retest_compare_pp4_v2.md`（TP2PP4 前后对比）
- 部署脚本：`/root/deploy_glm53_pp4.sh`（md5 def3c64c…，与库内 sskj main 副本一致）、`/root/deploy_glm53_607_exp.sh`（E7b 在役配方）、`/root/deploy_glm53_e7b_hicc.sh`（165db732…，E7b 高并发版：MRR64 + 图桶 1–64，其余与前者逐字一致）；复测驱动 `/root/run_retest_e7b64.sh`（fe46da2e…）、对比生成器 `/root/gen_retest_compare.py`；CAR 补丁：`/root/patches/custom_all_reduce.py`（a8fc9a50…）+ `custom_all_reduce_utils.py`（65a4d22b…），三处（60.7 原件/本地/库内）md5 一致
+- 部署脚本：`/root/deploy_glm53_pp4.sh`（md5 def3c64c…，与库内 sskj main 副本一致）、`/root/deploy_glm53_pp4_mrr64.sh`（533440ef…，TP2PP4 高并发版：仅 MRR 48→64 一处差异）、`/root/deploy_glm53_607_exp.sh`（E7b 在役配方）、`/root/deploy_glm53_e7b_hicc.sh`（165db732…，E7b 高并发版：MRR64 + 图桶 1–64，其余与前者逐字一致）；复测驱动 `/root/run_retest_e7b64.sh`（fe46da2e…）、`/root/run_retest_pp4mrr64.sh`（c9b6361d…，pass-1）、`/root/run_retest_pp4mrr64_v2.sh`（7d857816…，v2 有序版）、`/root/launch_v2_after_pass1.sh`（889c2428…，衔接 wrapper）、`/root/control_mrr48_41c32.sh`（1ff8a21f…，对照 + 自动恢复链）；对比生成器 `/root/gen_retest_compare.py`、`/root/gen_retest_compare_pp4.py`；CAR 补丁：`/root/patches/custom_all_reduce.py`（a8fc9a50…）+ `custom_all_reduce_utils.py`（65a4d22b…），三处（60.7 原件/本地/库内）md5 一致
 - 测量工具：`/root/bench_corpus_v2.py`（md5 1e34dd8d…，p95 nearest-rank + 逐请求 dump）、`/root/extract_summary.py`（4c126d06…）、`/root/run_b300_matrix.sh`（5892b446…，矩阵驱动：alive/idle_wait/prewarm/flush/命中核验/重试/VRAM 采样）
 - 复现命令（单点示例）：
@ -203,6 +211,7 @@ python3 /root/bench_corpus_v2.py --input-len 262144 --output-len 1 --shared-frac
  --dump-records $L/b52_256k_c1_v2_records.jsonl
 # 全矩阵：nohup bash /root/run_b300_matrix.sh <arm> > <progress.log> 2>&1 &
 # E7b 高并发复测（MRR64/图≤64，10 点）：nohup bash /root/run_retest_e7b64.sh > <progress.log> 2>&1 &
 # TP2PP4 MRR64 复测（v2 有序，回退点排末位）：nohup bash /root/run_retest_pp4mrr64_v2.sh > <progress.log> 2>&1 &
 ```
 ## 9. 与 B300 对比观察
@ -211,16 +220,16 @@ python3 /root/bench_corpus_v2.py --input-len 262144 --output-len 1 --shared-frac
 - **定性结构完全复现**：低延迟配方（B300 Low-Latency = TP8+EAGLE vs 本机 E7b = TP8+EAGLE3+AR）在 C=1 占优、吞吐配方（B300 High-Throughput = DP8+DeepEP vs 本机 TP2PP4 = D 生产口径）在高并发占优——两套硬件上"低延迟 vs 高吞吐"的分野方向一致。
 - **分界点本机更靠前，且调参后由负载形态决定**：B300 的交叉点在 C=64~128（主场景 HT C=128 反超 33%）；本机主场景交叉仍在 C=8 附近（容量上限所致：本臂 MRR64/池贴边 16 活跃 vs B300 配方 256/默认，先于算力撞墙），但 decode 密集场景（1K→4K）E7b 调参后全档占优、无交叉——这一形态差异 B300 报告未呈现。
- **绝对差距 4~5×（主场景）**：C=1 输出 246 vs 49.6 tok/s（5.0×）、input 7,882 vs 1,587（5.0×）；吞吐侧峰值 997 vs 211（4.7×）、31,889 vs 6,748（4.7×）。与显存带宽硬件代差量级一致。
+- **绝对差距 4~5×（主场景）**：C=1 输出 246 vs 49.6 tok/s（5.0×）、input 7,882 vs 1,587（5.0×）；吞吐侧峰值 997 vs 201（5.0×）、31,889 vs 6,419（5.0×）。与显存带宽硬件代差量级一致。
 - **边界 prefill 差距收窄到 ~2×**：256K C=1 input 7,050 vs 17,457（2.5×）→ 512K 5,662 vs 12,421（2.2×）→ 896K/约1M 4,153 vs 7,897（1.9×）。计算密集的超长 prefill 是 6000D 相对最能打的位置（PP 流水摊满 + 带宽占比下降）。
- **TPOT 差距小于吞吐差距**：B300 LL C=1 4.36 ms vs E7b 13.7 ms（3.1×）；高并发侧 B300 HT C=128 165 ms vs TP2PP4 C=64 204 ms（1.2×）——NVFP4 + DSA 把 decode 单步成本压得相对不差，差距主要在吞吐面。
+- **TPOT 差距小于吞吐差距**：B300 LL C=1 4.36 ms vs E7b 13.7 ms（3.1×）；高并发侧 B300 HT C=128 165 ms vs TP2PP4 C=64 261.5 ms（1.6×，本机该点为池顶运行、含 3 次回退的批扰动；MRR48 排队态为 203.7 ms）——NVFP4 + DSA 把 decode 单步成本压得相对不差，差距主要在吞吐面。
- **饱和形态不同**：B300 LL 在 C=64 后进入 24K input tok/s 平台、HT 在 C=128 达峰后 C=256 回退 19%；本机 TP2PP4 到 C=64 仍在爬坡（MRR 未饱和），E7b 调参后在 16K 场景呈 ~100 tok/s 输出平台（池限 16 活跃 + prefill 墙）、在 1K→4K 场景爬到 826 tok/s 无回退。本机没有一档出现吞吐回退——"甜点=并发上限"由 MRR/池决定而非算力。
+- **饱和形态不同**：B300 LL 在 C=64 后进入 24K input tok/s 平台、HT 在 C=128 达峰后 C=256 回退 19%；本机 TP2PP4 到 C=64 到达 16K 池顶（活跃 ~59 条封顶，C=32→64 输出仅 +4%），E7b 调参后在 16K 场景呈 ~100 tok/s 输出平台（池限 16 活跃 + prefill 墙）、在 1K→4K 场景爬到 826 tok/s 无回退。本机没有一档出现吞吐回退——"甜点=并发上限"由 MRR/池决定而非算力。
 - **EAGLE 配方差异**：B300 LL 为 5 steps/6 draft tokens，本机 E7b 为 4 steps/topk1/5 draft tokens；本机实测 accept 2.0~4.0（短输出 2.0、主场景 2.1~3.0、长输出 3.7~4.0，随 decode 深入上升）。B300 未披露 accept，无法直接对比投机效率。
 - **容量边界差距最大**：B300 两模式都完成约 1M 输入 C=1/2/4；本机仅 TP2PP4 可达 896K 且 C=1 单条（池 1,040,384 刚容一条），E7b 连 512K 都结构性不可测（ctx 270,336）。96 GB 卡上"上下文边界=显存边界"比 B300 严酷得多。
 ## 附录 A：语料窗口映射（回收窗口）
-语料总量 21,296,780 tokens，此前场景一/二战役已消费至 21,235,008。冷缓存协议下回收复用：窗口基址 `--pool-override` 显式指定，每点窗口在基址上顺序推进（逐记录 `corpus_window.start/end` 留档），每点 flush + 命中核验 ≤0.01 保证冷。E7b 复测臂沿用与初测相同的窗口基址（2,300,000 / 4,500,000 / 4,700,000）——复测为全新容器实例，这些文本对 hicache 宿主层重新成为"处女文本"，冷缓存协议成立（复测 10 点命中核验全部 0.0）。
+语料总量 21,296,780 tokens，此前场景一/二战役已消费至 21,235,008。冷缓存协议下回收复用：窗口基址 `--pool-override` 显式指定，每点窗口在基址上顺序推进（逐记录 `corpus_window.start/end` 留档），每点 flush + 命中核验 ≤0.01 保证冷。E7b 复测臂沿用与初测相同的窗口基址（2,300,000 / 4,500,000 / 4,700,000）——复测为全新容器实例，这些文本对 hicache 宿主层重新成为"处女文本"，冷缓存协议成立（复测 10 点命中核验全部 0.0）。TP2PP4 复测两轮（pass-1/v2）与 MRR48 对照同样沿用该三处基址（radix 关 + flush 即冷，13 次测量命中核验全部 0.0）。
 | 场景 | 窗口基址 | 备注 |
 |-|-|-|
@ -243,25 +252,26 @@ python3 /root/bench_corpus_v2.py --input-len 262144 --output-len 1 --shared-frac
 | b3_16k_c8 | TP8+EAGLE3+AR | 16/16 | 97.66 | 83.88 | 2684.26 | 12.12/32.47/32.47 | 69.2/136.1/136.1 | 0 | 2.556 |
 | b3_16k_c16 | TP2PP4 | 32/32 | 112.16 | 146.08 | 4674.5 | 15.53/25.78/25.84 | 79.2/98.5/101.2 | 0 | None |
 | b3_16k_c16 | TP8+EAGLE3+AR | 32/32 | 177.89 | 92.1 | 2947.27 | 19.76/59.91/63.69 | 129.7/228.8/275.9 | 0 | 2.485 |
-| b3_16k_c32 | TP2PP4 | 64/64 | 169.54 | 193.27 | 6184.73 | 26.52/46.43/47.89 | 113.7/152.0/157.3 | 0 | None |
+| b3_16k_c32 | TP2PP4 | 64/64 | 170.33 | 192.38 | 6156.1 | 26.48/46.31/47.97 | 114.5/153.2/159.2 | 0 | None |
 | b3_16k_c32 | TP8+EAGLE3+AR | 64/64 | 335.79 | 97.58 | 3122.67 | 82.65/140.33/154.66 | 138.1/213.6/277.5 | 0 | 2.777 |
-| b3_16k_c64 | TP2PP4 | 128/128 | 310.79 | 210.87 | 6747.91 | 63.05/134.78/139.99 | 139.2/203.7/214.3 | 0 | None |
+| b3_16k_c64 | TP2PP4 | 128/128 | 326.73 | 200.58 | 6418.52 | 50.76/89.22/147.41 | 185.0/261.5/313.1 | 3 | None |
 | b3_16k_c64 | TP8+EAGLE3+AR | 128/128 | 657.79 | 99.63 | 3188.2 | 204.27/293.21/322.84 | 142.5/214.6/276.6 | 0 | 2.954 |
 | b41_1k_c1 | TP2PP4 | 8/8 | 52.95 | 19.34 | 154.7 | 0.38/0.39/0.39 | 49.1/49.3/49.3 | 0 | None |
 | b41_1k_c1 | TP8+EAGLE3+AR | 8/8 | 15.82 | 64.74 | 517.93 | 0.30/0.33/0.33 | 13.2/14.3/14.3 | 0 | 2.028 |
 | b41_1k_c8 | TP2PP4 | 16/16 | 20.1 | 101.91 | 815.3 | 1.31/1.69/1.69 | 68.6/72.9/72.9 | 0 | None |
 | b41_1k_c8 | TP8+EAGLE3+AR | 16/16 | 13.53 | 151.33 | 1210.61 | 1.25/2.17/2.17 | 42.1/53.7/53.7 | 0 | 1.992 |
-| b41_1k_c32 | TP2PP4 | 64/64 | 29.73 | 275.55 | 2204.4 | 3.89/4.87/4.88 | 85.6/98.5/106.8 | 0 | None |
+| b41_1k_c32 | TP2PP4 | 64/64 | 35.92 | 228.08 | 1824.68 | 4.60/5.49/5.52 | 104.1/120.7/137.5 | 0 | None |
 | b41_1k_c32（MRR48 对照·全新实例） | TP2PP4 | 64/64 | 30.75 | 266.42 | 2131.36 | 4.04/4.92/4.93 | 88.4/103.0/110.0 | 0 | None |
 | b41_1k_c32 | TP8+EAGLE3+AR | 64/64 | 35.75 | 229.18 | 1833.42 | 2.99/7.09/7.10 | 111.9/150.6/179.8 | 0 | 2.035 |
-| b41_1k_c64 | TP2PP4 | 128/128 | 48.11 | 340.53 | 2724.25 | 8.14/19.96/20.01 | 93.3/101.8/125.1 | 0 | None |
+| b41_1k_c64 | TP2PP4 | 128/128 | 37.82 | 433.2 | 3465.61 | 5.46/7.16/7.24 | 104.3/116.7/147.3 | 0 | None |
 | b41_1k_c64 | TP8+EAGLE3+AR | 128/128 | 60.18 | 272.24 | 2177.88 | 4.76/12.15/13.48 | 191.1/292.7/331.5 | 0 | 2.094 |
 | b42_1k4k_c1 | TP2PP4 | 8/8 | 1614.16 | 20.3 | 5.08 | 0.39/0.40/0.40 | 49.2/49.8/49.8 | 0 | None |
 | b42_1k4k_c1 | TP8+EAGLE3+AR | 8/8 | 242.18 | 135.31 | 33.83 | 0.31/0.32/0.32 | 7.3/8.7/8.7 | 0 | 3.701 |
 | b42_1k4k_c8 | TP2PP4 | 16/16 | 649.69 | 100.87 | 25.22 | 1.35/1.87/1.87 | 79.0/79.4/79.4 | 0 | None |
 | b42_1k4k_c8 | TP8+EAGLE3+AR | 16/16 | 162.84 | 402.47 | 100.62 | 0.95/1.65/1.65 | 18.5/24.3/24.3 | 0 | 3.951 |
-| b42_1k4k_c32 | TP2PP4 | 64/64 | 714.14 | 367.08 | 91.77 | 1.98/4.14/4.15 | 86.1/90.5/91.1 | 0 | None |
+| b42_1k4k_c32 | TP2PP4 | 64/64 | 756.13 | 346.69 | 86.67 | 2.85/4.95/4.97 | 91.0/101.2/101.4 | 0 | None |
 | b42_1k4k_c32 | TP8+EAGLE3+AR | 64/64 | 387.9 | 675.81 | 168.95 | 2.58/6.19/6.20 | 43.0/54.6/60.4 | 0 | 3.82 |
-| b42_1k4k_c64 | TP2PP4 | 128/128 | 1088.63 | 481.6 | 120.4 | 80.74/337.92/338.47 | 91.2/95.5/96.3 | 0 | None |
+| b42_1k4k_c64 | TP2PP4 | 128/128 | 916.56 | 572.01 | 143.0 | 3.47/7.30/7.32 | 109.7/112.5/115.4 | 0 | None |
 | b42_1k4k_c64 | TP8+EAGLE3+AR | 128/128 | 634.35 | 826.5 | 206.62 | 4.36/12.18/12.50 | 69.9/85.1/101.5 | 0 | 3.878 |
 | b51_64k_c1 | TP2PP4 | 8/8 | 285.91 | 14.33 | 1833.72 | 10.28/10.32/10.32 | 49.8/50.0/50.0 | 0 | None |
 | b51_64k_c1 | TP8+EAGLE3+AR | 8/8 | 182.23 | 22.48 | 2877.06 | 17.04/17.17/17.17 | 11.2/13.5/13.5 | 0 | 2.468 |
@ -282,4 +292,4 @@ python3 /root/bench_corpus_v2.py --input-len 262144 --output-len 1 --shared-frac
 | b52_512k_c1 | TP2PP4 | 1/1 | 92.6 | 0.01 | 5662.03 | 92.60/92.60/92.60 | — | 0 | None |
 | b52_896k_c1 | TP2PP4 | 1/1 | 220.91 | 0.0 | 4153.24 | 220.91/220.91/220.91 | — | 0 | None |
-注：E7b 的 16K/4.1/4.2 场景 C=8~C=64 共 10 点为调参后（MRR64/decode 图 1–64）复测值，即正文采用值；C=1 各点与 5.1/5.2 行沿用初测值（活跃数受池上限约束，与调参无关）。E7b 256K/512K/896K C>1 为结构性跳过；256K C=1 为全新文本干净重测值（窗口 9,900,000）。初测（MRR16/图 1–8）全量原始数据留档于 `results/e7b/`。
+注：TP2PP4 的 16K/4.1/4.2 场景 C=32/C=64 共 6 点为 MRR64 复测 v2 值（正文采用值；pass-1 两轮对齐 ≤1.8% 留档 `results/pp4mrr64/`），C=1/C=8/C=16 与 5.1/5.2 行沿用初测 MRR48 值（MRR 在这些档位不构成约束）；"MRR48 对照"行是 4.1 C=32 的全新实例归因实验（276 初测 → 266 对照 → 228 复测 = −3% 实例新鲜度 −14% MRR64 配置代价）。E7b 的 16K/4.1/4.2 场景 C=8~C=64 共 10 点为调参后（MRR64/decode 图 1–64）复测值，即正文采用值；C=1 各点与 5.1/5.2 行沿用初测值（活跃数受池上限约束，与调参无关）。E7b 256K/512K/896K C>1 为结构性跳过；256K C=1 为全新文本干净重测值（窗口 9,900,000）。初测全量原始数据留档于 `results/tp2pp4/`（MRR48）与 `results/e7b/`（MRR16/图 1–8）。
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_mrr48ctl.jsonl
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_mrr48ctl.jsonl
@ -0,0 +1 @@
 {"tag": "b41_1k_c32", "arm": "pp4mrr48ctl", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9681, "corpus_window": {"start": 4500000, "end": 4565536}, "ok": 64, "failed": 0, "wall_s": 30.75, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 8192, "output_throughput_tok_s": 266.42, "input_throughput_tok_s": 2131.36, "ttft_s": {"mean": 4.0402, "p50": 4.0687, "p95": 4.916, "max": 4.9315, "min": 1.6735}, "tpot_s": {"mean": 0.0884, "p50": 0.0878, "p95": 0.103, "max": 0.11, "min": 0.0809}, "e2e_s": {"mean": 15.2685, "p50": 15.3453, "p95": 15.5575, "max": 15.6425, "min": 15.0932}, "per_req_out_tok_s_e2e": {"mean": 8.3842, "p50": 8.4491, "p95": 8.4775, "max": 8.4806, "min": 8.1828}, "per_req_decode_tok_s": {"mean": 11.465, "p50": 11.4809, "p95": 12.363, "max": 12.4651, "min": 9.1633}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 36, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_pass1.jsonl
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_pass1.jsonl
@ -0,0 +1,6 @@
 {"tag": "b3_16k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9661, "corpus_window": {"start": 2300000, "end": 3348576}, "ok": 64, "failed": 0, "wall_s": 170.68, "input_len": 16384, "shared_len": 0, "unique_len": 16384, "output_len": 512, "output_tokens_total": 32768, "output_throughput_tok_s": 191.98, "input_throughput_tok_s": 6143.37, "ttft_s": {"mean": 26.5048, "p50": 27.0902, "p95": 46.4142, "max": 47.902, "min": 5.226}, "tpot_s": {"mean": 0.1148, "p50": 0.1149, "p95": 0.1529, "max": 0.1584, "min": 0.0713}, "e2e_s": {"mean": 85.1644, "p50": 85.6885, "p95": 86.1924, "max": 86.3287, "min": 84.3109}, "per_req_out_tok_s_e2e": {"mean": 6.0124, "p50": 6.0573, "p95": 6.0716, "max": 6.0728, "min": 5.9308}, "per_req_decode_tok_s": {"mean": 9.1855, "p50": 8.7353, "p95": 13.0741, "max": 14.0525, "min": 6.3271}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 256, "new_tokens": 4194304, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b3_16k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9662, "corpus_window": {"start": 2300000, "end": 4397152}, "ok": 128, "failed": 0, "wall_s": 326.79, "input_len": 16384, "shared_len": 0, "unique_len": 16384, "output_len": 512, "output_tokens_total": 65536, "output_throughput_tok_s": 200.55, "input_throughput_tok_s": 6417.5, "ttft_s": {"mean": 50.7799, "p50": 49.8304, "p95": 89.0393, "max": 146.8059, "min": 5.3643}, "tpot_s": {"mean": 0.1847, "p50": 0.1857, "p95": 0.2618, "max": 0.313, "min": 0.0538}, "e2e_s": {"mean": 145.1904, "p50": 145.9843, "p95": 149.0379, "max": 286.567, "min": 39.4665}, "per_req_out_tok_s_e2e": {"mean": 3.6818, "p50": 3.6238, "p95": 3.6472, "max": 12.973, "min": 1.7867}, "per_req_decode_tok_s": {"mean": 6.0216, "p50": 5.4382, "p95": 9.4602, "max": 18.6186, "min": 3.201}, "spec_accept_length_mean": null, "retractions_total": 3, "cache_hit_from_logs": {"prefill_batches": 532, "new_tokens": 8589312, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b41_1k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9663, "corpus_window": {"start": 4500000, "end": 4565536}, "ok": 64, "failed": 0, "wall_s": 35.58, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 8192, "output_throughput_tok_s": 230.24, "input_throughput_tok_s": 1841.95, "ttft_s": {"mean": 4.4841, "p50": 4.6833, "p95": 5.3728, "max": 5.3824, "min": 0.4799}, "tpot_s": {"mean": 0.1035, "p50": 0.1018, "p95": 0.1191, "max": 0.1346, "min": 0.0962}, "e2e_s": {"mean": 17.6355, "p50": 17.7518, "p95": 18.0249, "max": 18.1344, "min": 17.3667}, "per_req_out_tok_s_e2e": {"mean": 7.2594, "p50": 7.2851, "p95": 7.3661, "max": 7.3704, "min": 7.0584}, "per_req_decode_tok_s": {"mean": 9.7882, "p50": 9.8997, "p95": 10.4804, "max": 10.4815, "min": 7.4906}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 32, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b41_1k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9664, "corpus_window": {"start": 4500000, "end": 4631072}, "ok": 128, "failed": 0, "wall_s": 38.17, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 16384, "output_throughput_tok_s": 429.24, "input_throughput_tok_s": 3433.95, "ttft_s": {"mean": 5.5975, "p50": 5.8971, "p95": 7.303, "max": 7.3229, "min": 0.3871}, "tpot_s": {"mean": 0.105, "p50": 0.1022, "p95": 0.1191, "max": 0.1498, "min": 0.0899}, "e2e_s": {"mean": 18.9379, "p50": 19.1349, "p95": 19.3038, "max": 19.5071, "min": 18.5527}, "per_req_out_tok_s_e2e": {"mean": 6.7607, "p50": 6.8239, "p95": 6.8916, "max": 6.8993, "min": 6.5617}, "per_req_decode_tok_s": {"mean": 9.6961, "p50": 9.8648, "p95": 10.9748, "max": 11.2171, "min": 6.7276}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 44, "new_tokens": 524288, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b42_1k4k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9665, "corpus_window": {"start": 4700000, "end": 4765536}, "ok": 64, "failed": 0, "wall_s": 769.61, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 4096, "output_tokens_total": 262144, "output_throughput_tok_s": 340.62, "input_throughput_tok_s": 85.15, "ttft_s": {"mean": 2.8816, "p50": 2.3118, "p95": 4.8777, "max": 4.8873, "min": 0.3856}, "tpot_s": {"mean": 0.0925, "p50": 0.0992, "p95": 0.1004, "max": 0.1005, "min": 0.0837}, "e2e_s": {"mean": 381.5542, "p50": 411.1625, "p95": 414.2572, "max": 415.1497, "min": 344.0864}, "per_req_out_tok_s_e2e": {"mean": 10.8071, "p50": 11.4442, "p95": 11.809, "max": 11.904, "min": 9.8663}, "per_req_decode_tok_s": {"mean": 10.8859, "p50": 11.4629, "p95": 11.8826, "max": 11.9505, "min": 9.948}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 60, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b42_1k4k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9666, "corpus_window": {"start": 4700000, "end": 4831072}, "ok": 128, "failed": 0, "wall_s": 917.54, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 4096, "output_tokens_total": 524288, "output_throughput_tok_s": 571.4, "input_throughput_tok_s": 142.85, "ttft_s": {"mean": 3.3071, "p50": 1.6982, "p95": 7.249, "max": 7.27, "min": 0.3884}, "tpot_s": {"mean": 0.1102, "p50": 0.1104, "p95": 0.1133, "max": 0.1185, "min": 0.1}, "e2e_s": {"mean": 454.4814, "p50": 455.407, "p95": 465.1982, "max": 486.5096, "min": 415.9375}, "per_req_out_tok_s_e2e": {"mean": 9.0166, "p50": 8.9946, "p95": 9.3778, "max": 9.8476, "min": 8.4192}, "per_req_decode_tok_s": {"mean": 9.084, "p50": 9.0613, "p95": 9.467, "max": 9.9975, "min": 8.439}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 228, "new_tokens": 524288, "cached_tokens": 0, "hit_rate": 0.0}}}
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_v2.jsonl
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/all_results_v2.jsonl
@ -0,0 +1,6 @@
 {"tag": "b41_1k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9671, "corpus_window": {"start": 4500000, "end": 4565536}, "ok": 64, "failed": 0, "wall_s": 35.92, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 8192, "output_throughput_tok_s": 228.08, "input_throughput_tok_s": 1824.68, "ttft_s": {"mean": 4.6017, "p50": 4.71, "p95": 5.4921, "max": 5.5164, "min": 0.4391}, "tpot_s": {"mean": 0.1041, "p50": 0.1035, "p95": 0.1207, "max": 0.1375, "min": 0.0971}, "e2e_s": {"mean": 17.8172, "p50": 17.8119, "p95": 18.0286, "max": 18.187, "min": 17.6927}, "per_req_out_tok_s_e2e": {"mean": 7.1844, "p50": 7.1868, "p95": 7.2269, "max": 7.2346, "min": 7.038}, "per_req_decode_tok_s": {"mean": 9.737, "p50": 9.7435, "p95": 10.3684, "max": 10.3817, "min": 7.3313}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 32, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b41_1k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9672, "corpus_window": {"start": 4500000, "end": 4631072}, "ok": 128, "failed": 0, "wall_s": 37.82, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 16384, "output_throughput_tok_s": 433.2, "input_throughput_tok_s": 3465.61, "ttft_s": {"mean": 5.4604, "p50": 5.8986, "p95": 7.1577, "max": 7.2407, "min": 0.3928}, "tpot_s": {"mean": 0.1043, "p50": 0.0999, "p95": 0.1167, "max": 0.1473, "min": 0.0898}, "e2e_s": {"mean": 18.7041, "p50": 18.7087, "p95": 19.063, "max": 19.1341, "min": 18.5506}, "per_req_out_tok_s_e2e": {"mean": 6.8437, "p50": 6.8424, "p95": 6.8924, "max": 6.9, "min": 6.6896}, "per_req_decode_tok_s": {"mean": 9.7799, "p50": 10.0872, "p95": 11.0923, "max": 11.2174, "min": 6.8403}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 44, "new_tokens": 524288, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b42_1k4k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9673, "corpus_window": {"start": 4700000, "end": 4765536}, "ok": 64, "failed": 0, "wall_s": 756.13, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 4096, "output_tokens_total": 262144, "output_throughput_tok_s": 346.69, "input_throughput_tok_s": 86.67, "ttft_s": {"mean": 2.8487, "p50": 2.2062, "p95": 4.9526, "max": 4.9666, "min": 0.3857}, "tpot_s": {"mean": 0.091, "p50": 0.1, "p95": 0.1012, "max": 0.1014, "min": 0.0798}, "e2e_s": {"mean": 375.3459, "p50": 414.2945, "p95": 416.7195, "max": 417.0268, "min": 328.3758}, "per_req_out_tok_s_e2e": {"mean": 11.0403, "p50": 12.0491, "p95": 12.4404, "max": 12.4735, "min": 9.8219}, "per_req_decode_tok_s": {"mean": 11.1193, "p50": 12.0715, "p95": 12.4793, "max": 12.5369, "min": 9.8601}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 68, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b42_1k4k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9674, "corpus_window": {"start": 4700000, "end": 4831072}, "ok": 128, "failed": 0, "wall_s": 916.56, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 4096, "output_tokens_total": 524288, "output_throughput_tok_s": 572.01, "input_throughput_tok_s": 143.0, "ttft_s": {"mean": 3.4732, "p50": 2.1089, "p95": 7.2969, "max": 7.3202, "min": 0.387}, "tpot_s": {"mean": 0.1097, "p50": 0.1102, "p95": 0.1125, "max": 0.1154, "min": 0.1013}, "e2e_s": {"mean": 452.9018, "p50": 454.1397, "p95": 465.3856, "max": 473.7285, "min": 416.137}, "per_req_out_tok_s_e2e": {"mean": 9.0488, "p50": 9.0208, "p95": 9.4307, "max": 9.8429, "min": 8.6463}, "per_req_decode_tok_s": {"mean": 9.1186, "p50": 9.0811, "p95": 9.5525, "max": 9.8755, "min": 8.6658}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 196, "new_tokens": 524288, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b3_16k_c32", "arm": "pp4mrr64", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9675, "corpus_window": {"start": 2300000, "end": 3348576}, "ok": 64, "failed": 0, "wall_s": 170.33, "input_len": 16384, "shared_len": 0, "unique_len": 16384, "output_len": 512, "output_tokens_total": 32768, "output_throughput_tok_s": 192.38, "input_throughput_tok_s": 6156.1, "ttft_s": {"mean": 26.475, "p50": 27.0154, "p95": 46.313, "max": 47.9669, "min": 5.2614}, "tpot_s": {"mean": 0.1145, "p50": 0.1156, "p95": 0.1532, "max": 0.1592, "min": 0.0695}, "e2e_s": {"mean": 84.9718, "p50": 86.193, "p95": 86.7916, "max": 86.8312, "min": 83.4017}, "per_req_out_tok_s_e2e": {"mean": 6.0273, "p50": 6.1226, "p95": 6.1376, "max": 6.139, "min": 5.8965}, "per_req_decode_tok_s": {"mean": 9.2192, "p50": 8.8289, "p95": 13.2592, "max": 14.4106, "min": 6.2935}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 256, "new_tokens": 4194304, "cached_tokens": 0, "hit_rate": 0.0}}}
 {"tag": "b3_16k_c64", "arm": "pp4mrr64", "summary": {"concurrency": 64, "num_requests": 128, "run_id": 9676, "corpus_window": {"start": 2300000, "end": 4397152}, "ok": 128, "failed": 0, "wall_s": 326.73, "input_len": 16384, "shared_len": 0, "unique_len": 16384, "output_len": 512, "output_tokens_total": 65536, "output_throughput_tok_s": 200.58, "input_throughput_tok_s": 6418.52, "ttft_s": {"mean": 50.7606, "p50": 49.8362, "p95": 89.2249, "max": 147.4077, "min": 5.3842}, "tpot_s": {"mean": 0.185, "p50": 0.1854, "p95": 0.2615, "max": 0.3131, "min": 0.0533}, "e2e_s": {"mean": 145.3021, "p50": 145.6727, "p95": 148.6968, "max": 286.8298, "min": 39.2402}, "per_req_out_tok_s_e2e": {"mean": 3.6798, "p50": 3.6103, "p95": 3.6332, "max": 13.0478, "min": 1.785}, "per_req_decode_tok_s": {"mean": 6.0154, "p50": 5.4114, "p95": 9.3655, "max": 18.8041, "min": 3.1997}, "spec_accept_length_mean": null, "retractions_total": 3, "cache_hit_from_logs": {"prefill_batches": 532, "new_tokens": 8589312, "cached_tokens": 0, "hit_rate": 0.0}}}
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/retest_compare_pp4_v2.md
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/retest_compare_pp4_v2.md
@ -0,0 +1,19 @@
 | 场景 | 并发 | 点型 | Output TPS 旧→新 | Δ | TPOT P95 旧→新 | TTFT P95 旧→新 | E7b64 同点 out 参考 |
 |---|---|---|---|---|---|---|---|
 | 主场景 16K→512 | 32 | 锚点 | 193 → **192** | -0% | 152.0 ms → 153.2 ms | 46.43 s → 46.31 s | 97.6 |
 | 主场景 16K→512 | 64 | 目标 | 211 → **201** | -5% | 203.7 ms → 261.5 ms | 134.78 s → 89.22 s | 99.6 |
 | 4.1 短输入 1K→128 | 32 | 锚点 | 276 → **228** | -17% | 98.5 ms → 120.7 ms | 4.87 s → 5.49 s | 229 |
 | 4.1 短输入 1K→128 | 64 | 目标 | 341 → **433** | +27% | 101.8 ms → 116.7 ms | 19.96 s → 7.16 s | 272 |
 | 4.2 长输出 1K→4K | 32 | 锚点 | 367 → **347** | -6% | 90.5 ms → 101.2 ms | 4.14 s → 4.95 s | 676 |
 | 4.2 长输出 1K→4K | 64 | 目标 | 482 → **572** | +19% | 95.5 ms → 112.5 ms | 337.92 s → 7.30 s | 826 |
 ## 附录：PP4MRR64 复测全量指标
 | 场景点 | ok/nreq | wall(s) | out tok/s | in tok/s | TTFT mean/p95/max(s) | TPOT mean/p95/max(ms) | retractions | hit |
 |---|---|---|---|---|---|---|---|---|
 | b3_16k_c32 | 64/64 | 170.33 | 192.38 | 6156.1 | 26.48/46.31/47.97 | 114.5/153.2/159.2 | 0 | 0.0 |
 | b3_16k_c64 | 128/128 | 326.73 | 200.58 | 6418.52 | 50.76/89.22/147.41 | 185.0/261.5/313.1 | 3 | 0.0 |
 | b41_1k_c32 | 64/64 | 35.92 | 228.08 | 1824.68 | 4.60/5.49/5.52 | 104.1/120.7/137.5 | 0 | 0.0 |
 | b41_1k_c64 | 128/128 | 37.82 | 433.2 | 3465.61 | 5.46/7.16/7.24 | 104.3/116.7/147.3 | 0 | 0.0 |
 | b42_1k4k_c32 | 64/64 | 756.13 | 346.69 | 86.67 | 2.85/4.95/4.97 | 91.0/101.2/101.4 | 0 | 0.0 |
 | b42_1k4k_c64 | 128/128 | 916.56 | 572.01 | 143.0 | 3.47/7.30/7.32 | 109.7/112.5/115.4 | 0 | 0.0 |
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/server_facts_v2.txt
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/server_facts_v2.txt
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/status_pass1.txt
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/status_pass1.txt
@ -0,0 +1,6 @@
 b3_16k_c32 OK
 b3_16k_c64 OK
 b41_1k_c32 OK
 b41_1k_c64 OK
 b42_1k4k_c32 OK
 b42_1k4k_c64 OK
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/status_v2.txt
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/pp4mrr64/status_v2.txt
@ -0,0 +1,6 @@
 b41_1k_c32 OK
 b41_1k_c64 OK
 b42_1k4k_c32 OK
 b42_1k4k_c64 OK
 b3_16k_c32 OK
 b3_16k_c64 OK
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/provenance.md
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/results/provenance.md
@ -55,3 +55,12 @@ vram_timeline.csv（30s 采样）全程峰值 **85,013 MiB**（主场景 C=64，
 ## 执行资产 md5（60.8 = 本目录 = 60.7 原件，三方一致）
 见 `md5_ledger.txt`。corpus 语料：`/root/corpus_ids.json`（21,296,780 tokens，消费至 21,235,008，回收窗口协议见 REPORT.md 附录 A）。
 ### PP4MRR64 复测臂（MRR 48→64；pass-1 20260910_1927 + v2 20260910_2021 + MRR48 对照 20260910_2112）
 - 部署：`deploy_glm53_pp4_mrr64.sh`（md5 533440ef…），与 `deploy_glm53_pp4.sh`（def3c64c）逐 token diff 仅 `MRR=48→64` 一处；KV 池 1,040,384 / mem0.85 / cps16384 / radix 关全部不变；decode 图保持栈默认（max_bs 256、桶含 56/64）——本臂从未掉图，MRR 才是初测 C=64 点的活跃上限（48 活跃+16 排队）
 - pass-1（19:27–20:14，run-id 9661–9666）：6 点全 OK、命中核验全 0.0；16K c64 出现 3 次 retraction（64×17.4K≈1.11M tokens > 池 1,040,384，活跃封顶 ~59 条）
 - v2（20:21–21:07，run-id 9671–9676，**正文采用值**）：全新实例 + 易回退点 16K c64 排末位，用于排除"retraction 后遗污染后续点"假设；6 点与 pass-1 全部对齐 ≤1.8%（4.1 c32 228.08 vs 230.2、4.1 c64 433.2 vs 429.2、4.2 c32 346.69 vs 340.6、4.2 c64 572.01 vs 571.4、16K c32 192.38 vs 192.0、16K c64 200.58 vs 200.6）→ 污染假设否证，1K 锚点回退为 MRR64 部署的可复现行为；16K c64 再次 3 次 retraction（确定性行为）
 - v2 矩阵 VRAM 峰值 84,791 MiB（GPU2，16K c64 池顶运行时采样）；QG 复验 PASS=6 FAIL=1（tool-call 已知项）
 - MRR48 归因对照（21:12–21:14，run-id 9681）：原版 `deploy_glm53_pp4.sh` 全新实例跑 4.1 c32 单点 = **266.42 tok/s**（TPOT p50 87.8ms，复现初测 87ms 水平）→ −17% 锚点分解：275.6（初测，第 9 点热实例）→ 266.4（新鲜度 −3.3%）→ 228.1（MRR64 配置代价 −14.4%）；逐请求 TPOT p50 87→102ms 均匀抬高、三实例可复现、机制未定位
 - 恢复核验第三轮（21:13–21:17，`control_mrr48_41c32.sh` 自动链）：rm glm53-pp4 → VRAM 排干 → rename 回 + start → fired up → health 200 → 16K/32tok 抽测 ok；KV 池 647,040（8 rank 一致）；显存 GPU0-3 77.2 GiB / GPU4-7 82.3 GiB 与停役前一致
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/control_mrr48_41c32.sh
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/control_mrr48_41c32.sh
@ -0,0 +1,122 @@
 #!/bin/bash
 # control_mrr48_41c32.sh — single-variable control for the 4.1 c32 anchor finding
 #
 # Finding to attribute: pp4mrr64 (MRR 48->64, everything else identical) measures
 # 4.1 c32 = 230.2 (pass-1) and 228.1 (v2, fresh instance, retraction-free) vs
 # 275.6 on the original MRR48 arm (-16~17%). Retraction contamination is ruled
 # out (v2). Remaining confound: the original 275.6 was the 9th point on a
 # long-warmed instance. This control redeploys the ORIGINAL MRR48 config
 # (deploy_glm53_pp4.sh, md5 def3c64c*) as a FRESH instance and measures the
 # same 4.1 c32 point first. ~276 => the regression is a real MRR64 cost;
 # ~230 => the old value was an instance-age artifact and MRR64 is free.
 # Afterwards chains restore_insvc_pp4mrr64.sh (in-service restoration runs
 # regardless of the control outcome).
 #
 # Usage: nohup bash /root/control_mrr48_41c32.sh \
 #          > /root/bench_logs/control_mrr48.log 2>&1 &
 set -u
 V2DIR=/root/bench_logs/b300eq_pp4mrr64v2_20260910_2021
 DEPLOY=/root/deploy_glm53_pp4.sh
 RESTORE=/root/restore_insvc_pp4mrr64.sh
 CORPUS=/root/corpus_ids.json
 BENCH=/root/bench_corpus_v2.py
 EXTRACT=/root/extract_summary.py
 URL=http://127.0.0.1:30000
 CTLFAIL=0
 echo "=== [ctl] waiting for v2 matrix completion $(date +%T) ==="
 ok=0
 for i in $(seq 1 240); do
  n=$(wc -l < "$V2DIR/status.txt" 2>/dev/null || echo 0)
  if [ "$n" -ge 6 ]; then ok=1; break; fi
  sleep 30
 done
 if [ "$ok" != "1" ]; then
  echo "=== [ctl] ABORT: v2 did not reach 6 status lines in 2h — going straight to restore ==="
  CTLFAIL=1
 else
  echo "--- v2 final status:"; cat "$V2DIR/status.txt"
  echo "=== [ctl] md5 gate on original deploy script $(date +%T) ==="
  md5sum "$DEPLOY"
  if ! md5sum "$DEPLOY" | grep -q "^def3c64c"; then
    echo "=== [ctl] ABORT: deploy_glm53_pp4.sh md5 mismatch (expect def3c64c*) — restore only ==="
    CTLFAIL=1
  fi
 fi
 if [ "$CTLFAIL" = "0" ]; then
  echo "=== [ctl] removing v2 test container glm53-pp4 $(date +%T) ==="
  for i in 1 2 3 4 5; do
    docker rm -f glm53-pp4 >/dev/null 2>&1 && break
    echo "[warn] docker rm retry $i, waiting 25s"; sleep 25
  done
  echo "=== [ctl] waiting VRAM drain <2000MiB $(date +%T) ==="
  for i in $(seq 1 90); do
    used=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits | sort -rn | head -1)
    [ "$used" -lt 2000 ] && break
    sleep 10
  done
  nvidia-smi --query-gpu=index,memory.used --format=csv,noheader
  echo "=== [ctl] deploying ORIGINAL MRR48 config $(date +%T) ==="
  bash "$DEPLOY" > /root/bench_logs/deploy_mrr48ctl.log 2>&1
  rc=$?
  echo "=== [ctl] deploy rc=$rc $(date +%T) ==="
  if [ "$rc" != "0" ]; then
    tail -30 /root/bench_logs/deploy_mrr48ctl.log; CTLFAIL=1
  fi
 fi
 if [ "$CTLFAIL" = "0" ]; then
  echo "=== [ctl] waiting for 'fired up' $(date +%T) ==="
  ok=0
  for i in $(seq 1 90); do
    docker logs glm53-pp4 2>&1 | grep -q "The server is fired up" && { ok=1; break; }
    sleep 10
  done
  if [ "$ok" != "1" ]; then
    echo "=== [ctl] ABORT: no fired up — restore only ==="; CTLFAIL=1
  else
    echo "=== [ctl] config gate: expect max_running_requests=48, pool 1040384 $(date +%T) ==="
    docker logs glm53-pp4 2>&1 | grep -E "max_total_num_tokens" | tail -4
    if ! docker logs glm53-pp4 2>&1 | grep -q "max_running_requests=48"; then
      echo "=== [ctl] CONFIG MISMATCH (MRR != 48) — skipping control point, restore only ==="
      CTLFAIL=1
    fi
  fi
 fi
 if [ "$CTLFAIL" = "0" ]; then
  STAMP=$(date +%Y%m%d_%H%M)
  LOG=/root/bench_logs/b300eq_mrr48ctl_${STAMP}
  mkdir -p "$LOG"
  echo "=== [ctl] control point b41_1k_c32 (MRR48 fresh) $(date +%T) LOGDIR=$LOG ==="
  # same protocol as run_retest_pp4mrr64_v2.sh run_point: prewarm -> flush -> bench -> extract
  timeout 1800 python3 "$BENCH" --corpus "$CORPUS" --input-len 1024 --output-len 16 \
    --shared-frac 0 --concurrency 1 --num-requests 1 --run-id 9699 \
    --pool-override 4500000 --url $URL/generate --container glm53-pp4 \
    > "$LOG/prewarm_1024.log" 2>&1 || true
  curl -s -m 60 -X POST $URL/flush_cache >/dev/null; sleep 3
  timeout 7200 python3 "$BENCH" --corpus "$CORPUS" --input-len 1024 --output-len 128 \
    --shared-frac 0 --concurrency 32 --num-requests 64 --run-id 9681 \
    --pool-override 4500000 --url $URL/generate --container glm53-pp4 \
    --dump-records "$LOG/b41_1k_c32_records.jsonl" > "$LOG/b41_1k_c32.log" 2>&1
  brc=$?
  echo "=== [ctl] bench rc=$brc $(date +%T) ==="
  if [ "$brc" = "0" ]; then
    python3 "$EXTRACT" "$LOG/b41_1k_c32.log" b41_1k_c32 pp4mrr48ctl "$LOG/all_results.jsonl"
    grep -E "hit_rate=" "$LOG/b41_1k_c32.log" | tail -1
  else
    echo "=== [ctl] control point FAILED rc=$brc ==="; CTLFAIL=1
  fi
  nvidia-smi --query-gpu=index,memory.used --format=csv,noheader > "$LOG/vram_after_point.txt"
 fi
 echo "=== [ctl] chaining in-service restoration (always) $(date +%T) ctlfail=$CTLFAIL ==="
 bash "$RESTORE" >> /root/bench_logs/restore_insvc_pp4mrr64.log 2>&1
 rrc=$?
 echo "=== [ctl] restore rc=$rrc $(date +%T) ==="
 tail -12 /root/bench_logs/restore_insvc_pp4mrr64.log
 echo "=== [ctl] DONE ctlfail=$CTLFAIL restore_rc=$rrc $(date) ==="
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/deploy_glm53_pp4_mrr64.sh
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/deploy_glm53_pp4_mrr64.sh
@ -0,0 +1,57 @@
 #!/bin/bash
 # ============================================================
 # GLM-5.3-NVFP4 D 生产口径部署（6000D 8卡，TP2 PP4）— MRR64 复测版
 # 2026-09-10
 #
 #   - 基线：deploy_glm53_pp4.sh（md5 def3c64c，B300 对标战役 TP2PP4 臂）
 #     唯一差异 = MRR 48 -> 64（用户决策：并发上限提到 64）
 #   - decode CUDA graph 保持栈默认覆盖 bs<=256（含 64，桶列表含 56/64），
 #     本臂从未有掉图问题；MRR48 才是 c64 点的活跃上限（48 活跃+16 排队）
 #   - 其余配方逐字不变：mem0.85、cps16384、radix 关、无投机、
 #     index_topk_freq=4 override、镜像 nightly-dev-20260828-daf63171
 #
 # 用法：nohup bash /root/deploy_glm53_pp4_mrr64.sh > <log> 2>&1 &
 # ============================================================
 set -uo pipefail
 CONTAINER="glm53-pp4"
 IMAGE="lmsysorg/sglang:nightly-dev-20260828-daf63171"
 MODEL="/data/hf_models/GLM-5.3-NVFP4"
 PORT=30000
 TP=2; PP=4; MEM=0.85; MRR=64; CPS=16384
 docker rm -f ${CONTAINER} 2>/dev/null || true
 sleep 2
 docker run -d --name ${CONTAINER} --gpus all --shm-size 64g --ipc=host \
  --restart unless-stopped \
  -p ${PORT}:${PORT} \
  -v /data/hf_models:/data/hf_models \
  ${IMAGE} \
  python3 -m sglang.launch_server \
    --model-path ${MODEL} \
    --tp-size ${TP} --pp-size ${PP} \
    --mem-fraction-static ${MEM} \
    --max-running-requests ${MRR} \
    --disable-radix-cache \
    --disable-shared-experts-fusion \
    --moe-runner-backend flashinfer_cutlass \
    --disable-flashinfer-autotune \
    --disable-custom-all-reduce \
    --chunked-prefill-size ${CPS} \
    --host 0.0.0.0 --port ${PORT} \
    --json-model-override-args '{"index_topk_freq": 4}'
 echo "容器已启动，等待就绪..."
 for i in $(seq 1 60); do
  code=$(curl -s -o /dev/null -w '%{http_code}' http://localhost:${PORT}/health 2>/dev/null)
  if [ "$code" = "200" ]; then
    echo "READY after ${i}0s"
    docker ps --filter name=${CONTAINER} --format '{{.Names}} {{.Status}}'
    # 确认 override 生效
    echo "override args: $(docker inspect ${CONTAINER} --format '{{.Config.Cmd}}' | grep -o 'index_topk_freq[^,}]*')"
    exit 0
  fi
  sleep 10
 done
 echo "TIMEOUT"; exit 1
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/gen_retest_compare_pp4.py
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/gen_retest_compare_pp4.py
@ -0,0 +1,109 @@
 #!/usr/bin/env python3
 """gen_retest_compare_pp4.py <tp2pp4_all_results.jsonl> <pp4mrr64_all_results.jsonl> [e7b64_all_results.jsonl]
 Before/after table for the TP2PP4 (D-arm) MRR64 retest:
  TP2PP4 (MRR48; decode graph already covered bs<=256 by stack default)
  vs
  PP4MRR64 (MRR64; everything else byte-identical)
 Retested points: the three cc64 targets (running batch 48 -> 64 active; 16K
 becomes pool-capped ~59) plus the three cc32 anchors (32 < 48, config-identical
 control). Optional third arg adds the E7b64 same-point output-TPS reference
 column for cross-arm context. Emits B300-style markdown + full-metrics appendix.
 """
 import json
 import sys
 POINTS = [
    ("b3_16k_c32",   "主场景 16K→512", 32, "锚点"),
    ("b3_16k_c64",   "主场景 16K→512", 64, "目标"),
    ("b41_1k_c32",   "4.1 短输入 1K→128", 32, "锚点"),
    ("b41_1k_c64",   "4.1 短输入 1K→128", 64, "目标"),
    ("b42_1k4k_c32", "4.2 长输出 1K→4K", 32, "锚点"),
    ("b42_1k4k_c64", "4.2 长输出 1K→4K", 64, "目标"),
 ]
 def load(path, arm):
    rows = {}
    with open(path, encoding="utf-8") as f:
        for line in f:
            rec = json.loads(line)
            if rec.get("arm") == arm:
                rows[rec["tag"]] = rec["summary"]  # later records override
    return rows
 def g(s, path):
    cur = s
    for key in path.split("."):
        if cur is None:
            return None
        cur = cur.get(key)
    return cur
 def fmt_tps(v):
    if v is None:
        return "—"
    return f"{v:,.0f}" if v >= 100 else f"{v:,.1f}"
 def fmt_s(v):
    if v is None:
        return "—"
    return f"{v:,.2f} s" if v >= 1 else f"{v*1000:,.0f} ms"
 def fmt_ms(v):
    return "—" if v is None else f"{v*1000:,.1f} ms"
 def ratio(new, old):
    if new is None or old in (None, 0):
        return ""
    d = (new - old) / old * 100
    return f"{d:+.0f}%"
 def main():
    old = load(sys.argv[1], "tp2pp4")
    new = load(sys.argv[2], "pp4mrr64")
    ref = load(sys.argv[3], "e7b64") if len(sys.argv) > 3 else {}
    print("| 场景 | 并发 | 点型 | Output TPS 旧→新 | Δ | TPOT P95 旧→新 | TTFT P95 旧→新 | E7b64 同点 out 参考 |")
    print("|---|---|---|---|---|---|---|---|")
    for tag, scene, cc, kind in POINTS:
        o, n, r = old.get(tag), new.get(tag), ref.get(tag)
        if n is None and o is None:
            continue
        ref_cell = fmt_tps(g(r, "output_throughput_tok_s")) if r else "—"
        cells = [scene, str(cc), kind]
        if o is None:
            cells += ["(无旧数据)", "", fmt_tps(g(n, "output_throughput_tok_s")) + " (新)", fmt_ms(g(n, "tpot_s.p95")), fmt_s(g(n, "ttft_s.p95")), ref_cell]
        elif n is None:
            cells += [fmt_tps(g(o, "output_throughput_tok_s")) + " (旧)", "", "(无新数据)", "", "", ref_cell]
        else:
            cells += [
                f"{fmt_tps(g(o,'output_throughput_tok_s'))} → **{fmt_tps(g(n,'output_throughput_tok_s'))}**",
                ratio(g(n, "output_throughput_tok_s"), g(o, "output_throughput_tok_s")),
                f"{fmt_ms(g(o,'tpot_s.p95'))} → {fmt_ms(g(n,'tpot_s.p95'))}",
                f"{fmt_s(g(o,'ttft_s.p95'))} → {fmt_s(g(n,'ttft_s.p95'))}",
                ref_cell,
            ]
        print("| " + " | ".join(cells) + " |")
    print("\n## 附录：PP4MRR64 复测全量指标\n")
    print("| 场景点 | ok/nreq | wall(s) | out tok/s | in tok/s | TTFT mean/p95/max(s) | TPOT mean/p95/max(ms) | retractions | hit |")
    print("|---|---|---|---|---|---|---|---|---|")
    for tag, _, _, _ in POINTS:
        n = new.get(tag)
        if n is None:
            continue
        ttft, tpot = n.get("ttft_s") or {}, n.get("tpot_s") or {}
        def trio(d, ms=False):
            m, p, x = d.get("mean"), d.get("p95"), d.get("max")
            if m is None:
                return "—"
            if ms:
                return f"{m*1000:.1f}/{p*1000:.1f}/{x*1000:.1f}"
            return f"{m:.2f}/{p:.2f}/{x:.2f}"
        hit = (n.get("cache_hit_from_logs") or {}).get("hit_rate")
        print(f"| {tag} | {n.get('ok')}/{n.get('num_requests')} | {n.get('wall_s')} "
              f"| {n.get('output_throughput_tok_s')} | {n.get('input_throughput_tok_s')} "
              f"| {trio(ttft)} | {trio(tpot, True)} | {n.get('retractions_total')} "
              f"| {hit} |")
 if __name__ == "__main__":
    main()
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/launch_v2_after_pass1.sh
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/launch_v2_after_pass1.sh
@ -0,0 +1,91 @@
 #!/bin/bash
 # launch_v2_after_pass1.sh — hands-off transition from pass-1 to the v2 clean pass
 #
 # Pass-1 (pp4mrr64, logdir b300eq_pp4mrr64_20260910_1927) ran 16K c64 second;
 # that point hit the KV pool boundary at MRR64 (~59 active x 17.4K ~= 1,040,384)
 # and retracted 3 requests. Every point measured after it regressed uniformly
 # (4.1 c32 anchor -16%, 4.2 c32 anchor -7%; the 16K c32 anchor measured before
 # the event held at -0.7%) => persistent post-retraction server state. This
 # wrapper waits for pass-1 to finish, tears down the test container, redeploys
 # a FRESH identical instance (same deploy_glm53_pp4_mrr64.sh), runs the quality
 # gate (expect PASS=6 FAIL=1, tool-call only), then launches
 # run_retest_pp4mrr64_v2.sh which orders the retraction-prone 16K c64 LAST.
 #
 # Usage: nohup bash /root/launch_v2_after_pass1.sh \
 #          > /root/bench_logs/launch_v2.log 2>&1 &
 set -u
 P1=/root/bench_logs/b300eq_pp4mrr64_20260910_1927
 DEPLOY=/root/deploy_glm53_pp4_mrr64.sh
 V2=/root/run_retest_pp4mrr64_v2.sh
 QG=/root/quality_gate_605.sh
 echo "=== [v2launch] waiting for pass-1 completion (status lines) $(date +%T) ==="
 ok=0
 for i in $(seq 1 240); do
  n=$(wc -l < "$P1/status.txt" 2>/dev/null || echo 0)
  if [ "$n" -ge 6 ]; then ok=1; break; fi
  sleep 30
 done
 if [ "$ok" != "1" ]; then
  echo "=== [v2launch] ABORT: pass-1 did not reach 6 status lines in 2h ==="
  cat "$P1/status.txt" 2>/dev/null
  exit 1
 fi
 echo "--- pass-1 final status:"; cat "$P1/status.txt"
 grep -E "hit_rate=" /root/bench_logs/b300eq_pp4mrr64_progress.log | tail -1
 echo "=== [v2launch] removing test container glm53-pp4 $(date +%T) ==="
 for i in 1 2 3 4 5; do
  docker rm -f glm53-pp4 >/dev/null 2>&1 && break
  echo "[warn] docker rm retry $i (zombie pid?), waiting 25s"
  sleep 25
 done
 docker ps -a --filter name=glm53-pp4 --format '{{.Names}} {{.Status}}' || true
 echo "=== [v2launch] waiting VRAM drain <2000MiB $(date +%T) ==="
 for i in $(seq 1 90); do
  used=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits | sort -rn | head -1)
  [ "$used" -lt 2000 ] && break
  sleep 10
 done
 nvidia-smi --query-gpu=index,memory.used --format=csv,noheader
 echo "=== [v2launch] redeploying fresh pp4mrr64 instance $(date +%T) ==="
 bash "$DEPLOY" > /root/bench_logs/deploy_pp4mrr64_v2.log 2>&1
 rc=$?
 echo "=== [v2launch] deploy rc=$rc $(date +%T) ==="
 if [ "$rc" != "0" ]; then
  tail -30 /root/bench_logs/deploy_pp4mrr64_v2.log
  exit 1
 fi
 echo "=== [v2launch] waiting for 'fired up' (true readiness) $(date +%T) ==="
 ok=0
 for i in $(seq 1 90); do
  if docker logs glm53-pp4 2>&1 | grep -q "The server is fired up"; then ok=1; break; fi
  sleep 10
 done
 if [ "$ok" != "1" ]; then
  echo "=== [v2launch] ABORT: no 'fired up' within 15min ==="
  docker logs --tail 30 glm53-pp4 2>&1
  exit 1
 fi
 docker logs glm53-pp4 2>&1 | grep -E "max_running_requests|max-total-tokens|max_total_num_tokens" | tail -5
 echo "=== [v2launch] quality gate $(date +%T) ==="
 QGLOG=/root/bench_logs/qg_pp4mrr64_v2.log
 timeout 900 bash "$QG" > "$QGLOG" 2>&1
 tail -3 "$QGLOG"
 qp=$(grep -oE "PASS=[0-9]+" "$QGLOG" | tail -1 | cut -d= -f2)
 qf=$(grep -oE "FAIL=[0-9]+" "$QGLOG" | tail -1 | cut -d= -f2)
 if [ -z "$qp" ] || [ "$qp" -lt 6 ]; then
  echo "=== [v2launch] ABORT: quality gate PASS=$qp FAIL=$qf (expect PASS=6 FAIL=1) ==="
  cat "$QGLOG"
  exit 1
 fi
 echo "=== [v2launch] quality gate PASS=$qp FAIL=$qf — OK ==="
 echo "=== [v2launch] launching v2 ordered matrix $(date +%T) ==="
 nohup bash "$V2" > /root/bench_logs/b300eq_pp4mrr64v2_progress.log 2>&1 &
 echo "=== [v2launch] v2 matrix launched (pid $!), progress: /root/bench_logs/b300eq_pp4mrr64v2_progress.log ==="
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/run_retest_pp4mrr64.sh
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/run_retest_pp4mrr64.sh
@ -0,0 +1,131 @@
 #!/bin/bash
 # run_retest_pp4mrr64.sh — TP2PP4 (D-arm) MRR64 retest
 #
 # The D-arm's decode CUDA graph always covered bs<=256 (stack default, buckets
 # include 56/64) — there was never a graph-drop on this arm. The binding cap
 # at cc64 was MRR=48 (48 active + 16 queued). This retest raises MRR to 64
 # (deploy_glm53_pp4_mrr64.sh, everything else byte-identical) and retests:
 #   - the three cc64 points (16K/4.1/4.2) — the only points where the
 #     running batch changes (48 -> 64 active; 16K becomes pool-capped ~59)
 #   - the three cc32 points as on-config-identical anchors (32 < 48 < 64,
 #     behavior unchanged; any delta = environment drift)
 # Same protocol as run_b300_matrix.sh: cold points, recycled corpus windows,
 # per-point idle-wait -> scenario prewarm (first point) -> flush -> bench ->
 # hit verification. run-ids 966x distinguish from 95xx/96xx arms.
 #
 # Usage: nohup bash /root/run_retest_pp4mrr64.sh \
 #          > /root/bench_logs/b300eq_pp4mrr64_progress.log 2>&1 &
 set -u
 ARM=pp4mrr64
 CONTAINER=glm53-pp4
 CORPUS=/root/corpus_ids.json
 BENCH=/root/bench_corpus_v2.py
 EXTRACT=/root/extract_summary.py
 URL=http://127.0.0.1:30000
 STAMP=$(date +%Y%m%d_%H%M)
 LOG=/root/bench_logs/b300eq_${ARM}_${STAMP}
 mkdir -p "$LOG"
 RESULTS="$LOG/all_results.jsonl"
 STATUS="$LOG/status.txt"
 : > "$STATUS"
 echo "=== [$ARM] retest start $(date) LOGDIR=$LOG ==="
 # ---- server facts snapshot ----
 alive() { [ -n "$(docker ps --filter name=$CONTAINER --filter status=running -q)" ]; }
 alive || { echo "=== [$ARM] ABORT: container $CONTAINER not running ==="; exit 1; }
 docker inspect "$CONTAINER" --format '{{.Config.Cmd}}' > "$LOG/server_cmd.txt" 2>&1
 docker logs "$CONTAINER" 2>&1 | grep -E "max_total_num_tokens|KV Cache is allocated|context_len|chunked_prefill_size|max_running_request|cuda_graph|Capture cuda graph|fired up" | head -40 > "$LOG/server_facts.txt" 2>&1
 nvidia-smi --query-gpu=index,name,memory.total,memory.used --format=csv > "$LOG/gpu_inventory_idle.csv" 2>&1
 md5sum "$CORPUS" "$BENCH" "$EXTRACT" > "$LOG/md5_assets.txt" 2>&1
 echo "--- server_cmd: $(cat "$LOG/server_cmd.txt")"
 echo "--- server_facts:"; cat "$LOG/server_facts.txt"
 # ---- per-rank VRAM sampler (whole-arm timeline, 30s cadence) ----
 ( while true; do
    echo "# $(date +%s) $(date +%T)"
    nvidia-smi --query-gpu=index,memory.used,utilization.gpu --format=csv,noheader
    sleep 30
  done ) > "$LOG/vram_timeline.csv" 2>&1 &
 SAMPLER=$!
 trap 'kill $SAMPLER 2>/dev/null' EXIT
 idle_wait() {
  for i in $(seq 1 90); do
    local last
    last=$(docker logs --since 90s "$CONTAINER" 2>&1 | grep 'running-req' | tail -1)
    if [ -z "$last" ] || echo "$last" | grep -q 'running-req: 0'; then return 0; fi
    sleep 10
  done
  echo "[warn] idle_wait timeout, continuing"
 }
 flush() { curl -s -m 60 -X POST $URL/flush_cache >/dev/null; sleep 3; }
 prewarm() {  # $1=input_len $2=base — one uncounted request at scenario length
  timeout 1800 python3 "$BENCH" --corpus "$CORPUS" --input-len "$1" --output-len 16 \
    --shared-frac 0 --concurrency 1 --num-requests 1 --run-id 9699 \
    --pool-override "$2" --url $URL/generate --container "$CONTAINER" \
    > "$LOG/prewarm_$1.log" 2>&1 || true
 }
 bench_call() {  # $1=log $2=tag $3=isl $4=osl $5=cc $6=nreq $7=base $8=rid
  timeout 7200 python3 "$BENCH" --corpus "$CORPUS" --input-len "$3" --output-len "$4" \
    --shared-frac 0 --concurrency "$5" --num-requests "$6" --run-id "$8" \
    --pool-override "$7" --url $URL/generate --container "$CONTAINER" \
    --dump-records "$LOG/${2}_records.jsonl" > "$1" 2>&1
 }
 run_point() {  # tag isl osl cc nreq base rid [prewarm=1]
  local TAG=$1 ISL=$2 OSL=$3 CC=$4 NREQ=$5 BASE=$6 RID=$7 PW=${8:-0}
  alive || { echo "$TAG CONTAINER_DEAD" >> "$STATUS"; echo "=== $TAG ABORT: container dead ==="; exit 1; }
  echo "=== [$ARM] $TAG isl=$ISL osl=$OSL cc=$CC nreq=$NREQ base=$BASE start $(date +%T) ==="
  idle_wait
  [ "$PW" = "1" ] && prewarm "$ISL" "$BASE"
  flush
  local rc=0
  bench_call "$LOG/${TAG}.log" "$TAG" "$ISL" "$OSL" "$CC" "$NREQ" "$BASE" "$RID" || rc=$?
  if [ "$rc" = "0" ]; then
    python3 "$EXTRACT" "$LOG/${TAG}.log" "$TAG" "$ARM" "$RESULTS"; rc=$?
  fi
  if [ "$rc" = "4" ]; then
    echo "=== $TAG hit_rate>0.01, retrying once ==="
    idle_wait; flush
    bench_call "$LOG/${TAG}_retry.log" "${TAG}_retry" "$ISL" "$OSL" "$CC" "$NREQ" "$BASE" "$RID" || rc=$?
    if [ "$rc" = "0" ]; then
      python3 "$EXTRACT" "$LOG/${TAG}_retry.log" "${TAG}_retry" "$ARM" "$RESULTS"; rc=$?
    fi
    if [ "$rc" = "4" ]; then
      echo "$TAG HIT_FAIL_FINAL" >> "$STATUS"
      echo "=== $TAG hit_rate still >0.01 after retry — ABORTING ARM (contamination) ==="
      exit 1
    fi
  fi
  if [ "$rc" = "0" ]; then
    echo "$TAG OK" >> "$STATUS"
  else
    echo "$TAG BENCH_FAIL rc=$rc" >> "$STATUS"
    echo "=== $TAG bench rc=$rc (recorded, continuing) ==="
  fi
  echo "=== $TAG done $(date +%T) ==="
 }
 # ---- same recycled window bases as the original tp2pp4 arm ----
 B_16K=2300000; B_1K=4500000; B_1K4=4700000
 # ===== B300 §3: main scenario 16K -> 512 (c32 anchor + c64 target) =====
 run_point b3_16k_c32 16384 512 32 64  $B_16K 9661 1
 run_point b3_16k_c64 16384 512 64 128 $B_16K 9662
 # ===== B300 §4.1: short input 1K -> 128 =====
 run_point b41_1k_c32 1024 128 32 64  $B_1K 9663 1
 run_point b41_1k_c64 1024 128 64 128 $B_1K 9664
 # ===== B300 §4.2: long output 1K -> 4K =====
 run_point b42_1k4k_c32 1024 4096 32 64  $B_1K4 9665 1
 run_point b42_1k4k_c64 1024 4096 64 128 $B_1K4 9666
 nvidia-smi --query-gpu=index,name,memory.total,memory.used --format=csv > "$LOG/gpu_inventory_final.csv" 2>&1
 echo "=== [$ARM] RETEST ALL DONE $(date) — $LOG ==="
 echo "--- status:"; cat "$STATUS"
--- a/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/run_retest_pp4mrr64_v2.sh
+++ b/experiments/pro6000/glm53_nvfp4_b300_equivalent_matrix/scripts/run_retest_pp4mrr64_v2.sh
@ -0,0 +1,126 @@
 #!/bin/bash
 # run_retest_pp4mrr64_v2.sh — TP2PP4 (D-arm) MRR64 retest, PASS 2 (fresh instance)
 #
 # Pass 1 finding: the 16K c64 point (run 2nd) hit the KV pool boundary at
 # MRR64 (~59 active x 17.4K ~= pool 1,040,384) and retracted 3 requests; every
 # point measured AFTER that event regressed uniformly (4.1 c32 anchor -16%,
 # 4.2 c32 anchor -7%; the 16K c32 anchor measured BEFORE the event held at
 # -0.7%). Uniform per-request TPOT elevation + in_tps/out_tps regressing by the
 # same factor => persistent post-retraction server state, not an MRR64 property
 # and not short-run noise. This pass re-runs the same 6 points on a FRESH
 # instance with the retraction-prone point (16K c64) LAST, so every reported
 # number is measured in a retraction-free server state.
 # run-ids 967x. Same protocol otherwise (cold, recycled windows, hit checks).
 #
 # Usage: nohup bash /root/run_retest_pp4mrr64_v2.sh \
 #          > /root/bench_logs/b300eq_pp4mrr64v2_progress.log 2>&1 &
 set -u
 ARM=pp4mrr64
 CONTAINER=glm53-pp4
 CORPUS=/root/corpus_ids.json
 BENCH=/root/bench_corpus_v2.py
 EXTRACT=/root/extract_summary.py
 URL=http://127.0.0.1:30000
 STAMP=$(date +%Y%m%d_%H%M)
 LOG=/root/bench_logs/b300eq_pp4mrr64v2_${STAMP}
 mkdir -p "$LOG"
 RESULTS="$LOG/all_results.jsonl"
 STATUS="$LOG/status.txt"
 : > "$STATUS"
 echo "=== [pp4mrr64v2] retest start $(date) LOGDIR=$LOG ==="
 alive() { [ -n "$(docker ps --filter name=$CONTAINER --filter status=running -q)" ]; }
 alive || { echo "=== [pp4mrr64v2] ABORT: container $CONTAINER not running ==="; exit 1; }
 docker inspect "$CONTAINER" --format '{{.Config.Cmd}}' > "$LOG/server_cmd.txt" 2>&1
 docker logs "$CONTAINER" 2>&1 | grep -E "max_total_num_tokens|KV Cache is allocated|context_len|chunked_prefill_size|max_running_request|cuda_graph|Capture cuda graph|fired up" | head -40 > "$LOG/server_facts.txt" 2>&1
 nvidia-smi --query-gpu=index,name,memory.total,memory.used --format=csv > "$LOG/gpu_inventory_idle.csv" 2>&1
 md5sum "$CORPUS" "$BENCH" "$EXTRACT" > "$LOG/md5_assets.txt" 2>&1
 echo "--- server_cmd: $(cat "$LOG/server_cmd.txt")"
 echo "--- server_facts:"; cat "$LOG/server_facts.txt"
 ( while true; do
    echo "# $(date +%s) $(date +%T)"
    nvidia-smi --query-gpu=index,memory.used,utilization.gpu --format=csv,noheader
    sleep 30
  done ) > "$LOG/vram_timeline.csv" 2>&1 &
 SAMPLER=$!
 trap 'kill $SAMPLER 2>/dev/null' EXIT
 idle_wait() {
  for i in $(seq 1 90); do
    local last
    last=$(docker logs --since 90s "$CONTAINER" 2>&1 | grep 'running-req' | tail -1)
    if [ -z "$last" ] || echo "$last" | grep -q 'running-req: 0'; then return 0; fi
    sleep 10
  done
  echo "[warn] idle_wait timeout, continuing"
 }
 flush() { curl -s -m 60 -X POST $URL/flush_cache >/dev/null; sleep 3; }
 prewarm() {  # $1=input_len $2=base
  timeout 1800 python3 "$BENCH" --corpus "$CORPUS" --input-len "$1" --output-len 16 \
    --shared-frac 0 --concurrency 1 --num-requests 1 --run-id 9699 \
    --pool-override "$2" --url $URL/generate --container "$CONTAINER" \
    > "$LOG/prewarm_$1.log" 2>&1 || true
 }
 bench_call() {  # $1=log $2=tag $3=isl $4=osl $5=cc $6=nreq $7=base $8=rid
  timeout 7200 python3 "$BENCH" --corpus "$CORPUS" --input-len "$3" --output-len "$4" \
    --shared-frac 0 --concurrency "$5" --num-requests "$6" --run-id "$8" \
    --pool-override "$7" --url $URL/generate --container "$CONTAINER" \
    --dump-records "$LOG/${2}_records.jsonl" > "$1" 2>&1
 }
 run_point() {  # tag isl osl cc nreq base rid [prewarm=1]
  local TAG=$1 ISL=$2 OSL=$3 CC=$4 NREQ=$5 BASE=$6 RID=$7 PW=${8:-0}
  alive || { echo "$TAG CONTAINER_DEAD" >> "$STATUS"; echo "=== $TAG ABORT: container dead ==="; exit 1; }
  echo "=== [pp4mrr64v2] $TAG isl=$ISL osl=$OSL cc=$CC nreq=$NREQ base=$BASE start $(date +%T) ==="
  idle_wait
  [ "$PW" = "1" ] && prewarm "$ISL" "$BASE"
  flush
  local rc=0
  bench_call "$LOG/${TAG}.log" "$TAG" "$ISL" "$OSL" "$CC" "$NREQ" "$BASE" "$RID" || rc=$?
  if [ "$rc" = "0" ]; then
    python3 "$EXTRACT" "$LOG/${TAG}.log" "$TAG" "$ARM" "$RESULTS"; rc=$?
  fi
  if [ "$rc" = "4" ]; then
    echo "=== $TAG hit_rate>0.01, retrying once ==="
    idle_wait; flush
    bench_call "$LOG/${TAG}_retry.log" "${TAG}_retry" "$ISL" "$OSL" "$CC" "$NREQ" "$BASE" "$RID" || rc=$?
    if [ "$rc" = "0" ]; then
      python3 "$EXTRACT" "$LOG/${TAG}_retry.log" "${TAG}_retry" "$ARM" "$RESULTS"; rc=$?
    fi
    if [ "$rc" = "4" ]; then
      echo "$TAG HIT_FAIL_FINAL" >> "$STATUS"
      echo "=== $TAG hit_rate still >0.01 after retry — ABORTING ARM (contamination) ==="
      exit 1
    fi
  fi
  if [ "$rc" = "0" ]; then
    echo "$TAG OK" >> "$STATUS"
  else
    echo "$TAG BENCH_FAIL rc=$rc" >> "$STATUS"
    echo "=== $TAG bench rc=$rc (recorded, continuing) ==="
  fi
  echo "=== $TAG done $(date +%T) ==="
 }
 # ---- same recycled window bases as the original tp2pp4 arm ----
 B_16K=2300000; B_1K=4500000; B_1K4=4700000
 # ===== ordered so the retraction-prone point runs LAST =====
 run_point b41_1k_c32   1024 128  32 64  $B_1K 9671 1
 run_point b41_1k_c64   1024 128  64 128 $B_1K 9672
 run_point b42_1k4k_c32 1024 4096 32 64  $B_1K4 9673 1
 run_point b42_1k4k_c64 1024 4096 64 128 $B_1K4 9674
 run_point b3_16k_c32   16384 512 32 64  $B_16K 9675 1
 run_point b3_16k_c64   16384 512 64 128 $B_16K 9676
 nvidia-smi --query-gpu=index,name,memory.total,memory.used --format=csv > "$LOG/gpu_inventory_final.csv" 2>&1
 echo "=== [pp4mrr64v2] RETEST ALL DONE $(date) — $LOG ==="
 echo "--- status:"; cat "$STATUS"
		`@ -0,0 +1 @@`
							{"tag": "b41_1k_c32", "arm": "pp4mrr48ctl", "summary": {"concurrency": 32, "num_requests": 64, "run_id": 9681, "corpus_window": {"start": 4500000, "end": 4565536}, "ok": 64, "failed": 0, "wall_s": 30.75, "input_len": 1024, "shared_len": 0, "unique_len": 1024, "output_len": 128, "output_tokens_total": 8192, "output_throughput_tok_s": 266.42, "input_throughput_tok_s": 2131.36, "ttft_s": {"mean": 4.0402, "p50": 4.0687, "p95": 4.916, "max": 4.9315, "min": 1.6735}, "tpot_s": {"mean": 0.0884, "p50": 0.0878, "p95": 0.103, "max": 0.11, "min": 0.0809}, "e2e_s": {"mean": 15.2685, "p50": 15.3453, "p95": 15.5575, "max": 15.6425, "min": 15.0932}, "per_req_out_tok_s_e2e": {"mean": 8.3842, "p50": 8.4491, "p95": 8.4775, "max": 8.4806, "min": 8.1828}, "per_req_decode_tok_s": {"mean": 11.465, "p50": 11.4809, "p95": 12.363, "max": 12.4651, "min": 9.1633}, "spec_accept_length_mean": null, "retractions_total": 0, "cache_hit_from_logs": {"prefill_batches": 36, "new_tokens": 262144, "cached_tokens": 0, "hit_rate": 0.0}}}