互联通信延迟数学建模设计规格

版本: 1.1.2 状态: Draft 创建日期: 2026-03-31 最后更新: 2026-04-02

变更历史

仅记录 minor 及以上变更。

版本	日期	变更说明
1.1.0	2026-04-01	结构重组为 6 章；§3 符号约定前置、竞争建模迁入数学章；协议栈延迟合并为 α_stack；新增端到端延迟 Mermaid 图
1.0.0	2026-03-31	初版：模块架构、Tier 驱动分层、4 种延迟模型、静态竞争建模、验收标准

背景与目标

背景

大模型推理部署需要数十到数百颗 chip 协同工作，通信延迟是并行扩展效率的核心瓶颈。现代 AI 集群的互联网络具有层级结构（Pod → Rack → Board → Chip → Die），各层级带宽/延迟差异显著，集合通信在不同层级上行为不同。本 spec 定义 evaluation/comm/ 子包的通信延迟数学模型，服务于数学评估路径。

目标

通信建模作为独立子包 evaluation/comm/，职责清晰
分层决策由拓扑 RoutingTable 驱动，自动检测 tier 层级
支持 4 种可插拔延迟模型（Alpha-Beta / LogP / LogGP / LoGPC）
group_size 从拓扑连通分量自动推导
链路竞争建模：静态流枚举（均匀场景）+ Fluid max-min 迭代（异构场景）
大消息（> 64 MB）场景 RMSPE < 10%

术语

术语	定义
Tier	互联网络的物理层级。Tier 级别越低 = 越内层 = 带宽越高 = 延迟越低。本系统定义 5 个 tier：d2d(5), c2c(6), b2b(7), r2r(8), p2p(9)。编号沿用 g5 仿真器的 SPC 层级体系（Tier 3 = Core, Tier 4 = NoC, Tier 5+ = 互联层级）
path_key	标识一条链路所属 tier 的字符串，取值 `"d2d"` / `"c2c"` / `"b2b"` / `"r2r"` / `"p2p"`
group_size	分层通信中，最内层 tier 内每个通信子组包含的 chip 数量
GroupCommProfile	一个通信组的完整 tier 描述，包含从内到外排列的各 tier 参数（带宽、延迟、group_size）。是带宽信息的唯一权威来源
CommArchSpec	通信架构规格，封装 GroupCommProfile 和协议参数，是延迟模型的输入
RoutingTable	拓扑路由表，存储所有 chip pair 间的最短路径、带宽、延迟信息，由路由算法预计算
PairCommSpec	一对 chip 之间的通信规格（带宽、延迟、路径类型），从 RoutingTable 查询获得
RMSPE	Root Mean Square Percentage Error，均方根百分比误差
PAXI	Protocol of Accelerated eXchange Interconnect，合见工软的 chip 间互联事务层 IP，将 AXI 总线事务映射到以太网链路
RC Link	Reliable Connection Link，SUE2.0 传输层，提供可靠传输（Go-Back-N）、CBFC 流控、速率控制
CESOC	以太网控制器子系统，包含 CEMAC（MAC）、CEPCS（PCS）、CEFEC（FEC）
SerDes	Serializer/Deserializer，物理层，8×112G PAM4，提供线路编解码与传输

数学模型

本节定义通信延迟的数学建模体系。§3.1 符号定义，§3.2 基础 Alpha-Beta 模型，§3.3 端到端延迟分解，§3.4 通用集合通信延迟框架（从 P2P 到多步组合），§3.5 均匀对称拓扑下的闭式解总览，§3.6 闭式解详细推导，§3.7 链路竞争建模，§3.8 端到端示例。

符号定义

基础参数：

符号	含义
$M$	操作涉及的全量数据。RS / AR：每 rank 输入；AG：每 rank 最终输出（操作前每 rank 持有 $M/N$）
$N$	通信组总 chip 数
$K$	通信组跨越的 tier 层数（由 GroupCommProfile 决定）
$S_k$	tier $k$ 的 group_size（$S_0$ = 最内层，即 `tiers[0].group_size`）
$S$	简写，仅 $K=2$ 时使用，$= S_0$
$G$	外层组数，仅 $K=2$ 时使用，$= N / S$
$M_i$	通用 K 层第 $i$ 层的数据量，$M_0 = M$，$M_{i+1} = M_i / S_i$
$G_{K-1}$	通用 K 层最外层组数，$= N / \prod_{j=0}^{K-2} S_j$
$u_r$	带宽利用率（`bw_urate`，0–1）

延迟参数（Alpha）：

符号	含义
$T_{\text{step}}$	单步点对点消息的总延迟，$= \alpha + \beta \cdot M$（见 (3.1)）
$\alpha$	单步启动延迟（与消息大小无关），$= \alpha_{\text{start}} + \alpha_{\text{path}}$（见 (3.2)）
$\beta$	每字节传输时间，$= 1/(bw \cdot u_r)$
$\alpha_{\text{start}}$	端侧固定开销——发送/接收两端的协议栈处理 + 内存访问（见 (3.3)）
$\alpha_{\text{path}}$	路径相关延迟——物理链路传播 + Switch 转发，从路由表获得（见 (3.4)）
$\alpha_{\text{pair}}$	P2P 专用，$= \alpha_{\text{start}} + \alpha_{\text{path}}(src, dst)$，精确路径延迟（见 (3.5a)）
$\alpha_{\text{tier},k}$	集合通信专用，$= \alpha_{\text{start}} + \text{tier}[k].\text{latency\_us}$，per-tier 均值近似（见 (3.5b)）

带宽参数：

符号	含义
$bw_{\text{pair}}$	P2P 专用，src→dst 的链路带宽，从路由表获得
$bw_{\text{tier},k}$	tier $k$ 的链路带宽，取自 `profile.tiers[k].bandwidth_gbps`（$k=0$ 最内层最快）
$bw_{\text{tier,min}}$	所有 tier 中的最小带宽，$= \min_k(bw_{\text{tier},k})$，AllToAll 专用

$M$ 统一说明：ReduceScatter 与 AllGather 是对偶操作。统一 $M$ = 全量数据后，两者单 tier 公式形式相同（均为 $\frac{N-1}{N} \cdot \frac{M}{bw \cdot u_r}$），便于验证 AllReduce = RS + AG 的组合关系。

基础 Alpha-Beta 模型

经典 Hockney 模型将单步点对点消息延迟建模为：

$T_{\text{step}} = \alpha + \beta \cdot M \tag{3.1}$

$\alpha$：每步启动延迟（与消息大小无关）
$\beta = 1/(bw \cdot u_r)$：每字节传输时间（$u_r$ 为带宽利用率 bw_urate）
$M$：消息大小（bytes）

$\alpha$ 由两个独立来源组成：

$\alpha = \alpha_{\text{start}} + \alpha_{\text{path}} \tag{3.2}$

$\alpha_{\text{start}}$：端侧固定开销——发送/接收两端的协议栈处理 + 内存访问，与路由路径无关（定义见 §3.3.1）
$\alpha_{\text{path}}$：路径相关延迟——物理链路传播 + Switch 转发，从路由表获得（定义见 §3.3.2）

这是物理层的通用分解。在公式中实际使用时，根据场景取不同的具体值——见 §3.3.3。

端到端延迟分解

下图展示一条 P2P 消息从发送端到接收端的完整延迟流水线：

端侧固定开销 $\alpha_{\text{start}}$

$\alpha_{\text{start}} = \alpha_{\text{ddr\_r}} + \alpha_{\text{ddr\_w}} + 2 \cdot (\alpha_{\text{noc}} + \alpha_{\text{stack}}) \tag{3.3}$

参数	物理含义	参考值 (μs)
$\alpha_{\text{ddr\_r}}$	DDR 读延迟（从 HBM/DDR 取数到 NoC）	0.15
$\alpha_{\text{ddr\_w}}$	DDR 写延迟（从 NoC 写入 HBM/DDR）	0.01
$\alpha_{\text{noc}}$	NoC 片上网络（计算核 ↔ 互联 IP AXI 接口）	0.02 /侧
$\alpha_{\text{stack}}$	互联协议栈总延迟（含事务层 + 传输层 + MAC/FEC）	0.05 /侧

$\alpha_{\text{stack}}$ 组成说明（以 PAXI/SUE2.0 为例）：$\alpha_{\text{stack}} = \alpha_{\text{paxi}} + \alpha_{\text{rclink}} + \alpha_{\text{cesoc}}$，其中：

PAXI Core（事务层）：Flit 编/解码、VC 分类、DA 仲裁，参考 02_architecture §2.3-2.4，≈ 0.015 μs

RC Link（传输层）：PSN 分配/校验、CBFC credit、封装/ACK，参考 12_rclink §12.1，≈ 0.015 μs

CESOC（MAC/PHY 层）：MAC framing、FEC 编解码流水线、PCS，参考 08_cesoc_phy，≈ 0.02 μs

不同互联方案（NVLink、PCIe RDMA 等）内部实现不同，但均映射到同一个 $\alpha_{\text{stack}}$ 参数，取对应 chip 的实测或规格值。

标定约束：PAXI 规格给出 C2C 直连 AXI-to-AXI 最低延迟 = 150 ns @ 400G（01_overview §1.4）。此值包含发送 + 接收两侧协议栈处理，因此：

$2 \cdot (\alpha_{\text{noc}} + \alpha_{\text{stack}}) \leq 0.15 \; \mu s$

参考值合计 $2 \times (0.02 + 0.05) = 0.14 \; \mu s$，符合约束。

关于 $\alpha_{\text{d2d}}$：若 chip 为 Chiplet 设计（多 Die），计算 Die 到互联 IP Die 的 D2D 延迟可并入 $\alpha_{\text{noc}}$；单 Die chip 无此项。不再作为独立参数。

路径相关延迟 $\alpha_{\text{path}}$

$\alpha_{\text{path}} = \sum_{e \in \text{edges}} \alpha_{\text{link},e} + \sum_{s \in \text{switches}} \alpha_{\text{sw},s} \tag{3.4}$

参数	物理含义	取值来源
$\alpha_{\text{link},e}$	链路 $e$ 的信号传播延迟（电/光信号在线缆上的传输时间）	拓扑 YAML `latency_us` 字段
$\alpha_{\text{sw},s}$	Switch $s$ 的转发延迟（包从入端口到出端口的查表、仲裁、排队时间）	拓扑 YAML Switch 配置

场景	$\alpha_{\text{path}}$	说明
C2C 直连	≈ 0（< 5 ns）	同板/同模块，线缆传播可忽略
Switch 模式	Switch 转发延迟 + 线缆传播	由拓扑 YAML 配置
多跳路由	路由表累加	含多段链路 + 多个 Switch

注意：有 GroupCommProfile 时，Switch 延迟已包含在 tier.latency_us 的路由表累加中，不额外加 switch_latency。

从物理分解到公式使用

§3.2 的 $\alpha = \alpha_{\text{start}} + \alpha_{\text{path}}$ 是物理层通用分解。在公式中根据通信场景取不同的具体形式：

P2P（点对点）——精确路径延迟：

$\alpha_{\text{pair}} = \alpha_{\text{start}} + \alpha_{\text{path}}(src, dst) \tag{3.5a}$

其中 $\alpha_{\text{path}}(src, dst)$ 是从路由表获得的 src→dst 精确路径延迟（见 (3.4)）。每对 chip pair 的 $\alpha_{\text{pair}}$ 不同。

集合通信（RS/AG/AR/A2A）——per-tier 均值近似：

$\alpha_{\text{tier},k} = \alpha_{\text{start}} + \text{TierSpec}[k].\text{latency\_us} \tag{3.5b}$

分层通信中，同一 tier 内所有 chip pair 的路径延迟高度一致，用 tier 内均值 TierSpec[k].latency_us 替代逐 pair 的 $\alpha_{\text{path}}$。这是对 (3.2) 的近似——牺牲 pair 级精度，换取 $O(K)$ 复杂度的分层公式。

集合通信延迟框架

集合通信操作（RS/AG/AR/A2A）本质上是多步 P2P 的组合。延迟计算分三层：算法定义每步的通信对，路由表提供每条路径的物理参数，竞争建模修正并发流的有效带宽。

从 P2P 到集合通信

单步 P2P 延迟已由 (3.1) 定义。集合通信由算法决定如何将操作分解为多个步骤，每步包含一组并发的 P2P 传输。

步内：第 $t$ 步有 $n_t$ 条并发流，每条流 $i$ 的参数 $(src_i, dst_i, m_i)$ 由算法决定。每条流的延迟为：

$T_i(t) = \frac{m_i}{bw_{\text{eff},i}(t) \cdot u_r} + \alpha(src_i, dst_i)$

其中 $bw_{\text{eff},i}(t)$ 是第 $t$ 步流 $i$ 的有效带宽——由路由表查询物理带宽后，根据同一步内所有并发流的链路共享情况经竞争建模（§3.7）修正得到。$\alpha(src_i, dst_i)$ 从路由表获得。

所有流完成后才能进入下一步（同步屏障），因此该步延迟为：

$T_{\text{step}}(t) = \max_{i} \; T_i(t) \tag{F.1}$

步间：步与步之间存在数据依赖（第 $t$ 步的输出是第 $t+1$ 步的输入），因此串行：

$T_{\text{total}} = \sum_{t=0}^{T_{\text{steps}}-1} T_{\text{step}}(t) \tag{F.2}$

这是最通用的形式，不假设特定算法、拓扑对称性或链路均匀性。给定任意拓扑和任意算法，均可用 (F.1) + (F.2) 逐步计算总延迟。

稳态假设：Ring 等流水线算法的实际执行有 fill（启动）和 drain（收尾）阶段，这些阶段的并发流数少于稳态。本框架假设每步均处于稳态（所有流同时活跃）。对大消息（带宽主导）误差可忽略；小消息场景下 fill/drain 占比大，精度受限。

各算法的通信步骤

算法决定了总步数 $T_{\text{steps}}$ 和每步的通信对 $(src, dst, m)$。下表定义当前支持的算法。chip 编号 $0, 1, \ldots, N-1$。

Ring ReduceScatter（$N$ chips，数据量 $M$）：

属性	值
步数	$N - 1$
第 $t$ 步每条流	$(i, \; (i{+}1) \bmod N, \; M/N)$，$i = 0, \ldots, N{-}1$
并发流数	$N$（每个 chip 同时发送）
语义	接收后与本地数据 reduce

Ring AllGather（$N$ chips，数据量 $M$）：

属性	值
步数	$N - 1$
第 $t$ 步每条流	$(i, \; (i{+}1) \bmod N, \; M/N)$，$i = 0, \ldots, N{-}1$
并发流数	$N$
语义	接收后拼接到本地缓冲

Ring RS 和 Ring AG 的 pattern 相同，区别仅在接收端的语义（reduce vs 拼接）。

Ring AllReduce = Ring RS（$N-1$ 步）串联 Ring AG（$N-1$ 步），共 $2(N-1)$ 步。

Pairwise AllToAll（$N$ chips，数据量 $M$）：

属性	值
步数	$N - 1$
第 $t$ 步每条流	$(i, \; (i{+}t{+}1) \bmod N, \; M/N)$，$i = 0, \ldots, N{-}1$
并发流数	$N$
语义	每步目标 chip 不同——第 $t$ 步与距离 $t+1$ 的 chip 交换

与 Ring 的关键区别：Ring 每步 dst 固定（邻居），AllToAll 每步 dst 变化。因此 Ring 的每步走相同物理路径，AllToAll 的每步走不同路径，竞争模式也不同。

P2P：$T_{\text{steps}} = 1$，单条流 $(src, dst, M)$。即 (F.1) 的退化形式。

均匀对称拓扑下的简化

当拓扑满足以下条件时，(F.1)+(F.2) 可简化为闭式解：

条件：同一步内所有流的路径带宽相同且路径延迟相同（即 $bw_{\text{eff},i}$ 和 $\alpha_i$ 对所有 $i$ 一致）。

此时每步延迟相同，$\max$ 退化为任意一条流：

$T_{\text{step}} = \frac{m}{bw_{\text{eff}} \cdot u_r} + \alpha$

总延迟 = 步数 $\times$ 单步延迟：

$T_{\text{total}} = T_{\text{steps}} \cdot \left(\frac{m}{bw_{\text{eff}} \cdot u_r} + \alpha\right) \tag{F.3}$

对 Ring RS（$T_{\text{steps}} = N-1$，$m = M/N$，均匀 tier 内 $bw_{\text{eff}} = bw_{\text{tier},0}$，$\alpha = \alpha_{\text{tier},0}$）：

$T = (N-1) \cdot \left(\frac{M/N}{bw_{\text{tier},0} \cdot u_r} + \alpha_{\text{tier},0}\right) = \frac{N-1}{N} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (N-1) \cdot \alpha_{\text{tier},0}$

这就是 §3.6 闭式解 (3.7) 的来源。

分层通信

当通信组跨越多个 tier（如 board 内 c2c + board 间 b2b）时，直接用 $N$-chip Ring 会导致慢链路传输大量数据。分层通信将操作拆解为多个子通信的串联，每个子通信在同一 tier 内执行，最小化慢链路上的数据量。

分层 AllReduce（双 tier，$K=2$）——3 个子通信串联：

board 内 Ring RS（$G$ 组并行，每组 $S$ chips）：每组独立执行 $S$-chip Ring RS，数据从 $M$ 压缩到 $M/S$。$G$ 组同时执行，互不干涉。
跨 board Ring AR（$G$ chips，每 board 选 1 个代表）：$G$ 个代表执行 $G$-chip Ring AllReduce，数据量 $M/S$（已压缩）。走慢链路，但数据量小。
board 内 Ring AG（$G$ 组并行，每组 $S$ chips）：每组独立执行 $S$-chip Ring AG，将代表的聚合结果广播到组内。

每个子通信独立适用 §3.4.1 的通用框架。子通信间串行（Phase 2 依赖 Phase 1 的输出），总延迟：

$T = T_{\text{Phase 1}} + T_{\text{Phase 2}} + T_{\text{Phase 3}}$

分层的核心价值：Phase 2 跨慢链路时数据量仅 $M/S$（被 Phase 1 压缩），而 flat Ring 的每步都可能跨慢链路传 $M/N$。

并行子组的延迟：Phase 1 和 Phase 3 中 $G$ 个 board 各自独立执行。如果各 board 内拓扑对称（通常如此），各组延迟相同，取任意一组即可。如果不对称，取 $\max$。

通用 $K$ 层分层：扩展为 $(2K-1)$ 个子通信——$K-1$ 层逐层 RS（从内到外）+ 最外层 AR + $K-1$ 层逆序 AG（从外到内），见 §3.6 详细推导。

闭式解（均匀对称拓扑）

以下公式是 §3.4 通用框架在均匀对称拓扑 + Ring/Pairwise 算法下的闭式特化。条件：同一 tier 内所有链路 $bw$ 和 $\alpha$ 相同。

公式总览

操作	场景	公式	备注	编号
P2P	点对点	$T = \dfrac{M}{bw_{\text{pair}} \cdot u_r} + \alpha_{\text{pair}}$	$bw_{\text{pair}}$, $\alpha_{\text{pair}}$ 来自 routing_table	(3.6)

ReduceScatter	单 tier	$T = \dfrac{N{-}1}{N} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (N{-}1) \cdot \alpha_{\text{tier},0}$	RS 后每 rank 持有 $M/N$	(3.7)
	双 tier Phase 1：board 内 RS	$T_1 = \dfrac{S{-}1}{S} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (S{-}1) \cdot \alpha_{\text{tier},0}$	内层先压缩	(3.8a)
	双 tier Phase 2：跨 board RS	$T_2 = \dfrac{G{-}1}{G} \cdot \dfrac{M/S}{bw_{\text{tier},1} \cdot u_r} + (G{-}1) \cdot \alpha_{\text{tier},1}$	慢链路仅传 $M/S$	(3.8b)
	双 tier 总延迟	$T = T_1 + T_2$	先内后外，最小化慢链路流量	(3.8)

AllGather	单 tier	$T = \dfrac{N{-}1}{N} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (N{-}1) \cdot \alpha_{\text{tier},0}$	与 RS (3.7) 形式相同（对偶）	(3.9)
	双 tier Phase 1：跨 board AG	$T_1 = \dfrac{G{-}1}{N} \cdot \dfrac{M}{bw_{\text{tier},1} \cdot u_r} + (G{-}1) \cdot \alpha_{\text{tier},1}$	小分片 $M/N$ 过慢链路，$G{-}1$ 步	(3.10a)
	双 tier Phase 2：board 内 AG	$T_2 = \dfrac{S{-}1}{S} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (S{-}1) \cdot \alpha_{\text{tier},0}$	Phase 1 后每 rank 持有 $M/S$	(3.10b)
	双 tier 总延迟	$T = T_1 + T_2$	先外后内，最小化慢链路流量	(3.10)

AllReduce	单 tier	$T = \dfrac{2(N{-}1)}{N} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + 2(N{-}1) \cdot \alpha_{\text{tier},0}$	= RS (3.7) + AG (3.9)	(3.11)
	双 tier Phase 1：内层 RS	$T_1 = \dfrac{S{-}1}{S} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (S{-}1) \cdot \alpha_{\text{tier},0}$	同 (3.8a)	(3.12a)
	双 tier Phase 2：外层 AR	$T_2 = \dfrac{2(G{-}1)}{G} \cdot \dfrac{M/S}{bw_{\text{tier},1} \cdot u_r} + 2(G{-}1) \cdot \alpha_{\text{tier},1}$	慢链路仅传 $M/S$，含 RS+AG	(3.12b)
	双 tier Phase 3：内层 AG	$T_3 = \dfrac{S{-}1}{S} \cdot \dfrac{M}{bw_{\text{tier},0} \cdot u_r} + (S{-}1) \cdot \alpha_{\text{tier},0}$	与 Phase 1 对称，同 (3.10b)	(3.12c)
	双 tier 总延迟	$T = T_1 + T_2 + T_3$	3-phase 串行	(3.12)
	通用 K 层：数据量递推	$M_0 = M, \quad M_{i+1} = M_i / S_i$	每层 RS 后数据压缩 $S_i$ 倍	(3.13a)
	Phase $i$（$0 \le i < K{-}1$，逐层 RS）	$T_i = \dfrac{S_i{-}1}{S_i} \cdot \dfrac{M_i}{bw_{\text{tier},i} \cdot u_r} + (S_i{-}1) \cdot \alpha_{\text{tier},i}$	从内到外	(3.13b)
	Phase $K{-}1$（最外层 AR）	$T_{K-1} = \dfrac{2(G_{K-1}{-}1)}{G_{K-1}} \cdot \dfrac{M_{K-1}}{bw_{\text{tier},K-1} \cdot u_r} + 2(G_{K-1}{-}1) \cdot \alpha_{\text{tier},K-1}$	$G_{K-1} = N / \prod_{j=0}^{K-2} S_j$	(3.13c)
	Phase $K$ 到 $2K{-}2$（逆序 AG）	$T_{2K{-}2{-}i} = T_i \quad (0 \le i < K{-}1)$	与 RS phase 对称	(3.13d)
	通用 K 层总延迟	$T = \displaystyle\sum_{i=0}^{2K-2} T_i$	$(2K{-}1)$ phase	(3.13)

AllToAll	任意拓扑	$T = \dfrac{N{-}1}{N} \cdot \dfrac{M}{bw_{\text{tier,min}} \cdot u_r} + (N{-}1) \cdot \alpha_{\text{tier},K-1}$	不可分层，$bw_{\text{tier,min}} = \min_k(bw_{\text{tier},k})$	(3.14)

闭式解详细推导

P2P (Pipeline Parallelism)

点对点传输，最基础的通信原语。直接使用 routing table 查询源-目的 chip pair 的带宽和延迟：

$T = \frac{M}{bw_{\text{pair}} \cdot u_r} + \alpha_{\text{pair}} \tag{3.6}$

其中 $bw_{\text{pair}}$ 和 $\alpha_{\text{pair}}$ 来自 routing_table.get(src, dst)。$\alpha_{\text{pair}} = \alpha_{\text{start}} + \alpha_{\text{path}}(src, dst)$（见 (3.5a)）。

ReduceScatter

ReduceScatter 将 $M$ 数据分为 $N$ 份，每个 rank 最终持有 $M/N$ 的 reduce 结果。Ring ReduceScatter 需要 $N-1$ 步，每步传输 $M/N$。

单 tier ($K=1$)：

$T = \frac{N-1}{N} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (N-1) \cdot \alpha_{\text{tier},0} \tag{3.7}$

带宽项推导：$N-1$ 步 $\times$ 每步 $M/N$ = 总传输量 $(N-1)/N \cdot M$。

双 tier ($K=2$)：先内后外，最小化慢链路流量。

Phase 1——board 内 ReduceScatter：$S$ 个 chip 在快链路上做 RS，每个 chip 从 $M$ 压缩到 $M/S$：

$T_1 = \frac{S-1}{S} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (S-1) \cdot \alpha_{\text{tier},0} \tag{3.8a}$

Phase 2——跨 board ReduceScatter：$G$ 组之间在慢链路上做 RS，数据量已被 Phase 1 压缩为 $M/S$：

$T_2 = \frac{G-1}{G} \cdot \frac{M/S}{bw_{\text{tier},1} \cdot u_r} + (G-1) \cdot \alpha_{\text{tier},1} \tag{3.8b}$

$T = T_1 + T_2 \tag{3.8}$

分层顺序选择：先内后外使慢链路仅传 $M/S$；若先外后内，慢链路需传全量 $M$，延迟更高。

AllGather

AllGather 是 ReduceScatter 的对偶操作。每个 rank 初始持有分片 $M/N$，操作后每 rank 持有全量 $M$。Ring AllGather 需要 $N-1$ 步，每步传输 $M/N$。

$M$ 定义为全量数据（= 每 rank 最终输出），操作前每 rank 持有 $M/N$。

单 tier ($K=1$)：

$T = \frac{N-1}{N} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (N-1) \cdot \alpha_{\text{tier},0} \tag{3.9}$

与 RS (3.7) 形式完全相同——对偶操作，总传输量相等。

双 tier ($K=2$)：先外后内，最小化慢链路流量。

Phase 1——跨 board AllGather：每个 rank 持有 $M/N$，向其他 $G-1$ 组各发送 $M/N$，共 $G-1$ 步：

$T_1 = \frac{G-1}{N} \cdot \frac{M}{bw_{\text{tier},1} \cdot u_r} + (G-1) \cdot \alpha_{\text{tier},1} \tag{3.10a}$

带宽项推导：$G-1$ 步 $\times$ 每步 $M/N$ = $(G-1)/N \cdot M$。Phase 1 后，每组 $G$ 个对应位置的 rank 互相收集，每 rank 数据从 $M/N$ 扩展到 $G \cdot M/N = M/S$。

Phase 2——board 内 AllGather：每个 rank 持有 $M/S$，在 $S$ 个 chip 间收集，共 $S-1$ 步，每步 $M/S$：

$T_2 = \frac{S-1}{S} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (S-1) \cdot \alpha_{\text{tier},0} \tag{3.10b}$

带宽项推导：$S-1$ 步 $\times$ 每步 $M/S$ = $(S-1)/S \cdot M$。

$T = T_1 + T_2 \tag{3.10}$

分层顺序选择：先外后内使慢链路仅传 $(G-1)/N \cdot M$；若先内后外，慢链路需传 $(G-1)/G \cdot M$，多 $N/G = S$ 倍。

对偶验证：RS (3.8) 和 AG (3.10) 的双 tier 总传输量均为 $\frac{N-1}{N} \cdot M$：

RS：$\frac{S-1}{S} \cdot M + \frac{G-1}{G} \cdot \frac{M}{S} = \frac{S-1}{S} \cdot M + \frac{G-1}{N} \cdot M = \frac{N-1}{N} \cdot M$
AG：$\frac{G-1}{N} \cdot M + \frac{S-1}{S} \cdot M = \frac{N-1}{N} \cdot M$

两者慢链路上的传输量也相同（均为 $\frac{G-1}{N} \cdot M$），通过相反的 phase 顺序达到了相同的最优效果。

AllReduce

AllReduce = ReduceScatter + AllGather。每个 rank 输入 $M$，操作后每 rank 持有全量聚合结果 $M$。

单 tier ($K=1$)：

$T = \frac{2(N-1)}{N} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + 2(N-1) \cdot \alpha_{\text{tier},0} \tag{3.11}$

系数验证：RS (3.7) 带宽项 $\frac{N-1}{N}$ + AG (3.9) 带宽项 $\frac{N-1}{N}$ = $\frac{2(N-1)}{N}$。

双 tier ($K=2$)：分层 3-phase（内层 RS → 外层 AR → 内层 AG）。

Phase 1——内层 ReduceScatter（同 (3.8a)）：

$T_1 = \frac{S-1}{S} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (S-1) \cdot \alpha_{\text{tier},0} \tag{3.12a}$

Phase 2——外层 AllReduce：数据量已被 Phase 1 压缩为 $M/S$，在 $G$ 组间做完整 AllReduce（含 RS + AG）：

$T_2 = \frac{2(G-1)}{G} \cdot \frac{M/S}{bw_{\text{tier},1} \cdot u_r} + 2(G-1) \cdot \alpha_{\text{tier},1} \tag{3.12b}$

Phase 3——内层 AllGather（同 (3.10b)，与 Phase 1 对称）：

$T_3 = \frac{S-1}{S} \cdot \frac{M}{bw_{\text{tier},0} \cdot u_r} + (S-1) \cdot \alpha_{\text{tier},0} \tag{3.12c}$

$T = T_1 + T_2 + T_3 \tag{3.12}$

通用 $K$ 层：$(2K-1)$ phase，从最内层到最外层逐层 ReduceScatter，最外层 AllReduce，再从最外层到最内层逆序 AllGather。

数据量递推——每层 RS 后数据压缩 $S_i$ 倍：

$M_0 = M, \quad M_{i+1} = M_i / S_i \tag{3.13a}$

Phase $i$（$0 \le i < K-1$，逐层 ReduceScatter，从内到外）：

$T_i = \frac{S_i - 1}{S_i} \cdot \frac{M_i}{bw_{\text{tier},i} \cdot u_r} + (S_i - 1) \cdot \alpha_{\text{tier},i} \tag{3.13b}$

Phase $K-1$（最外层 AllReduce，$G_{K-1} = N / \prod_{j=0}^{K-2} S_j$）：

$T_{K-1} = \frac{2(G_{K-1}-1)}{G_{K-1}} \cdot \frac{M_{K-1}}{bw_{\text{tier},K-1} \cdot u_r} + 2(G_{K-1}-1) \cdot \alpha_{\text{tier},K-1} \tag{3.13c}$

Phase $K$ 到 $2K-2$（逆序 AllGather，与 RS phase 对称）：

$T_{2K-2-i} = T_i \quad (0 \le i < K-1) \tag{3.13d}$

$T = \sum_{i=0}^{2K-2} T_i \tag{3.13}$

其中 $bw_{\text{tier},i} = \texttt{profile.tiers[i].bandwidth\_gbps}$，$\alpha_{\text{tier},i} = \alpha_{\text{start}} + \texttt{profile.tiers[i].latency\_us}$（见 (3.5b)）。

AllToAll (MoE Dispatch/Combine)

AllToAll 无"聚合"步骤，每个 rank 需向所有其他 rank 发送不同数据，不能通过分层 ReduceScatter 压缩跨层传输量——数据必须完整穿越最慢链路。Pairwise AllToAll 有 $N-1$ 个通信步骤：

$T = \frac{N-1}{N} \cdot \frac{M}{bw_{\text{tier,min}} \cdot u_r} + (N-1) \cdot \alpha_{\text{tier},K-1} \tag{3.14}$

其中 $bw_{\text{tier,min}} = \min_k(bw_{\text{tier},k})$，$\alpha_{\text{tier},K-1}$ 为最慢 tier 的 per-step 启动延迟。

注：(3.14) 是保守上界——所有步均按最慢 tier 计算。实际 Pairwise AllToAll 中，组内步走快链路（$bw_{\text{tier},0}$），仅跨组步走慢链路。精确计算需用 (F.1)+(F.2) 的逐步框架。

链路竞争建模

同一物理链路可能同时被多条通信流共享，导致有效带宽低于物理带宽。竞争建模将物理带宽修正为有效带宽，嵌入 §3.4.1 每步延迟计算的 $bw_{\text{eff},i}(t)$ 中。给定第 $t$ 步的并发流集合和路由表，竞争建模输出每条流的有效带宽。

策略一：静态流枚举（均匀场景）

适用于 Ring 等均匀流量模式。枚举一个通信步中所有并发流经过的物理链路，统计每条链路的并发流数 $F_e$，取路径上的最大值修正带宽：

$bw_{\text{eff}} = \frac{bw}{\max(1, F_{\max})}, \quad F_{\max} = \max_{e \in \text{path}} F_e$

NVSwitch 全连接拓扑：Ring 每步每条 NVLink 仅 1 条流，$F=1$，无竞争。

策略二：Fluid max-min 迭代（异构场景）

适用于异构流量模式（不同流经过不同链路组合，带宽需求不均匀）。通过迭代求解每条流的 max-min 公平带宽分配。

输入：

活跃流集合 $\mathcal{F} = \{f_1, f_2, \ldots\}$，每条流 $f_i$ 有路径 $\text{path}(f_i) = \{e_1, e_2, \ldots\}$
每条链路 $e$ 的物理带宽 $C_e$

算法：

初始化：所有流标记为 unsettled，令 $R_e = C_e$。

当存在 unsettled 流时，重复以下步骤：

对每条链路 $e$，计算当前公平份额：

$\text{fair\_share}_e = \frac{R_e}{\left|\{f \in \mathcal{F}_{\text{unsettled}} \mid e \in \text{path}(f)\}\right|}$

找到瓶颈链路及全局最小公平份额：

$r^* = \min_{e} \text{fair\_share}_e, \quad e^* = \arg\min_{e} \text{fair\_share}_e$

锁定 $e^*$ 上所有 unsettled 流的速率为 $r^*$，将这些流标记为 settled。设本轮新锁定的流集合为 $\Delta$。
从所有链路扣除本轮新锁定流占用的带宽：

$R_e \leftarrow R_e - r^* \cdot \left|\{f \in \Delta \mid e \in \text{path}(f)\}\right| \quad \forall e$

输出：每条流的分配速率 $r_i$。有效带宽取所有流中的最小分配速率：

$bw_{\text{eff}} = \min_{f_i \in \mathcal{F}} r_i$

复杂度：$O(|\mathcal{F}| \cdot |\mathcal{E}|)$，其中 $|\mathcal{F}|$ 为流数，$|\mathcal{E}|$ 为链路数。每轮至少锁定一条流，最多 $|\mathcal{F}|$ 轮，每轮遍历所有链路。

与策略一的关系：当所有流经过的链路集合相同（如 NVSwitch 上的 Ring），max-min 退化为等分，结果与静态流枚举一致。

端到端示例

场景：评估 16-GPU 2-node DeepSeek-V3 的 TP AllReduce 延迟

输入：

拓扑：2 board × 8 GPU，board 内 NVLink 450 GB/s (c2c)，board 间 IB 50 GB/s (b2b)
通信操作：AllReduce, 16 个参与者, 数据量 128 MB
模型选择：alpha_beta（默认）

处理流程：

CommEvaluator 从 attrs 解析 chip_ids ["c0"..."c15"]
查询 routing_table.get_group_comm_profile(chip_ids)：
- 按 path_key 分组：c2c 有 56 对 pair，b2b 有 64 对 pair
- 检测到 2 个 tier：{c2c: 450 GB/s, b2b: 50 GB/s}
- 推导 group_size = 8（最内层 tier 连通分量大小）
- 返回 GroupCommProfile(tiers=[TierSpec(c2c, 450, 8), TierSpec(b2b, 50, 2)])
构建 CommArchSpec(profile=GroupCommProfile(...))
创建 AlphaBetaCommModel，调用 allreduce(tp=16, comm_bytes=128MB)
分层 3-phase 计算（公式 (3.12)）：
- Phase 1 内层 RS (3.12a)：$M=128$ MB，$bw_{\text{tier},0}=450$ GB/s
- Phase 2 外层 AR (3.12b)：$M/S=16$ MB，$bw_{\text{tier},1}=50$ GB/s
- Phase 3 内层 AG (3.12c)：$M=128$ MB，$bw_{\text{tier},0}=450$ GB/s
- $T = T_1 + T_2 + T_3$（串行求和）

输出：StepMetrics(t_comm=X ms, bottleneck_tag=BW_BOUND)

详细设计

模块结构

perfmodel/evaluation/comm/
├── __init__.py                    # 导出
├── types.py                       # CommArchSpec, CommProtocolParams
├── factory.py                     # create_comm_model()
├── contention.py                  # 静态竞争分析
├── models/
│   ├── __init__.py
│   ├── base.py                    # CommModel Protocol
│   ├── alpha_beta.py              # Hockney 模型 (默认, 分层支持)
│   ├── logp.py                    # LogP 模型
│   ├── loggp.py                   # LogGP 模型
│   └── loggpc.py                  # LoGPC 模型 (含静态竞争)

核心数据结构

@dataclass(frozen=True)
class TierSpec:
    path_key: str            # "c2c" / "b2b" / "r2r" / "p2p"
    tier_level: int          # 6(c2c) / 7(b2b) / 8(r2r) / 9(p2p)
    bandwidth_gbps: float    # 该 tier 内链路的瓶颈带宽
    latency_us: float        # 该 tier 内链路的平均延迟
    group_size: int          # 该 tier 内每组的 chip 数

@dataclass(frozen=True)
class GroupCommProfile:
    tiers: tuple[TierSpec, ...]   # 从快(最内层)到慢(最外层)排列
    total_chips: int

@dataclass
class CommArchSpec:
    profile: GroupCommProfile | None = None  # 完整 tier 信息（权威来源）
    group_size: int = 0                      # 最内层 tier 的 group_size (0=平坦)
    # fallback 带宽：仅在 profile 为 None 时由 CommEvaluator 从 hardware dict 填充
    fallback_bw: float = 0.0                 # 单一带宽值，用于无拓扑信息的 flat ring

设计原则：

有 RoutingTable 时，profile.tiers[k].bandwidth_gbps 是带宽的唯一来源，按 tier 索引逐层取值

无 RoutingTable 时（fallback 路径），使用 fallback_bw 做 flat ring 估算

不存在 intra_bw/inter_bw 字段——2-level 的"内层/外层"划分是 K=2 特例，由延迟模型实现中 tiers[0] / tiers[-1] 自然表达，不需要单独命名的字段

Tier 层级体系：

Tier	path_key	物理含义	典型带宽
5	d2d	Die-to-Die（Chiplet 间）	900+ GB/s
6	c2c	Chip-to-Chip（NVLink / 板内）	200–450 GB/s
7	b2b	Board-to-Board（同 rack 跨板）	50–400 GB/s
8	r2r	Rack-to-Rack（同 pod 跨 rack）	25–100 GB/s
9	p2p	Pod-to-Pod（跨 pod）	10–50 GB/s

Tier 级别越低 = 越内层 = 带宽越高 = 延迟越低。

Tier 检测与 group_size 推导

输入：通信组的 chip_ids 列表 + RoutingTable

算法：

遍历所有 chip pair，按 PairCommSpec.path_key 分组
按 tier_level 排序（d2d → c2c → b2b → r2r → p2p）
对最内层 tier，构建只含该 tier 链路的子图，用 BFS 求连通分量
各连通分量大小相同 → group_size = 分量大小；不同 → 退化为 flat ring + 警告
每个 tier 的瓶颈带宽 = 该 tier 内所有 pair 的 $\min(bandwidth)$
每个 tier 的基准延迟 = 该 tier 内所有 pair 延迟的均值

为什么用连通分量而非 pair 数公式：公式 $S = 2P/N + 1$ 假设均匀分组，非均匀拓扑（如 3+5=8 chips）可能算出错误整数。连通分量分析是精确的。

可插拔延迟模型

CommModel Protocol

class CommModel(Protocol):
    def allreduce(self, tp: int, comm_bytes: int, comm_protocol: int) -> tuple[float, float]: ...
    def allgather(self, tp: int, comm_bytes: int, comm_protocol: int) -> tuple[float, float]: ...
    def reducescatter(self, tp: int, comm_bytes: int, comm_protocol: int) -> tuple[float, float]: ...
    def dispatch(self, moe_tp: int, ep: int, comm_bytes: int, bs: int,
                 comm_protocol: int, is_prefill: bool) -> tuple[float, float]: ...
    def combine(self, moe_tp: int, ep: int, comm_bytes: int, bs: int,
                comm_protocol: int, is_prefill: bool) -> tuple[float, float]: ...

返回 (latency_us, comm_bytes)。

comm_protocol: int：通信协议标识（实现层参数），用于选择协议参数配置，不影响延迟计算公式本身。

def create_comm_model(
    model_type: str,              # "alpha_beta" / "logp" / "loggp" / "loggpc"
    arch: CommArchSpec,
    params: CommProtocolParams,
) -> CommModel:

模型概览

模型	核心参数	分层支持	竞争建模	适用场景
Alpha-Beta	$\alpha$, $\beta$ (=1/bw)	是	否	大消息、带宽主导
LogP	$L$, $o$, $g$, $P$	否	否	小消息、CPU 开销主导
LogGP	LogP + $G$ (per-byte)	否	否	宽消息范围、自动切换
LoGPC	LogGP + $F$ (contention)	否	是(equal_share/maxmin_fair)	共享链路拓扑

链路竞争建模

两种竞争建模策略的数学定义见 §3.7。本节描述实现接口。

流枚举函数：

def compute_ring_contention(chip_ids: list[str], routing_table: RoutingTable) -> dict[str, int]:
    """Ring 稳态流枚举。返回 edge_id -> concurrent_flow_count。"""

def compute_alltoall_contention(chip_ids: list[str], routing_table: RoutingTable) -> dict[str, int]:
    """Pairwise AllToAll 流枚举。返回 edge_id -> max_concurrent_flow_count（跨所有步取最大值）。"""

策略选择

def compute_contention(
    chip_ids: list[str],
    routing_table: RoutingTable,
    collective: str,           # "ring" / "alltoall"
    strategy: str = "equal_share",  # "equal_share" / "maxmin_fair"
) -> ContentionResult:
    """
    返回 ContentionResult，包含 per-tier 有效带宽修正因子。
    """

策略	配置值	适用场景	复杂度
静态流枚举	`equal_share`	Ring 等均匀流量（默认）	$O(N)$
Fluid max-min	`maxmin_fair`	AllToAll、异构拓扑、多集合操作并发	$O(N^2 \cdot K)$

配置方式（拓扑 YAML）：

network:
  comm_params:
    contention_strategy: "equal_share"   # "equal_share" / "maxmin_fair"

集成点

上游：CommEvaluator.evaluate() 是唯一入口。从 attrs 解析 chip_ids、comm_type、comm_bytes 等参数，查询 RoutingTable 获取 GroupCommProfile，创建 CommModel 计算延迟。

下游：返回 StepMetrics，由 EvaluationEngine 聚合到 EngineResult，最终进入 ReportingEngine 生成 Gantt/成本/流量分析。

配置接口：拓扑 YAML network.comm_params.comm_model 字段选择模型类型（默认 alpha_beta）。

设计决策

group_size 推导方法

维度	连通分量分析 (选定)	pair 数公式 $S=2P/N+1$
精度	精确，处理任意拓扑	假设均匀分组，非均匀时出错
复杂度	BFS $O(N+E)$	$O(1)$ 计算
边界场景	自然处理非均匀（检测分量大小不一致）	非均匀可能算出错误整数

选择理由：precision > performance。通信组 $N \leq 64$，BFS 开销可忽略。

竞争建模方式

维度	静态流枚举	Fluid max-min 迭代	不建模
精度	中等（等分带宽）	高（异构流收敛）	低（忽略竞争）
复杂度	$O(N)$ per op	$O(N^2 \cdot K)$	$O(0)$
适用场景	Ring 等均匀流量	AllToAll、异构拓扑	NVSwitch 全连接

设计决策：两者都实现，作为可配置策略。静态流枚举为默认（覆盖大多数 Ring 场景），Fluid max-min 在异构拓扑或 AllToAll 密集场景下提供更高精度。均匀流量下两者结果一致，不会引入不一致性。

风险与局限

风险	影响	缓解措施
初版只支持 $K=2$ 层分层	$K \geq 3$ 拓扑（跨 rack）精度下降	中间 tier 参数用 $bw_{\text{tier,min}}$ 近似。$K=3$ 支持列入 Future
`_profile_cache` 需线程安全设计	并发评估可能出错	在 `__init__` 中初始化缓存，避免 `hasattr` 懒加载

验证与展望

精度目标

场景	消息范围	目标 RMSPE	测试数据集
单层 NVSwitch 8-GPU (无 NVLS)	> 64 MB	< 5%	H200 nccl-tests
双层 NVLink + IB 16-GPU	> 64 MB	< 10%	H100 Crusoe/Nebius nccl-tests
单层 NVSwitch 8-GPU (无 NVLS)	1–64 MB	< 25%	H200 nccl-tests
双层 NVLink + IB 16-GPU	1–64 MB	< 20%	H100 nccl-tests

功能验证

测试场景	预期行为	测试方法
8 chips 全 c2c	`tier_count=1`，平坦 Ring	单元测试
16 chips (8+8), c2c + b2b	`tier_count=2`, `group_size=8`, $T = T_1+T_2+T_3$	单元测试
10 chips (4+6), 非均匀	退化为 flat ring + 警告	单元测试
`routing_table=None`	走 hardware dict fallback，行为不变	单元测试
`comm_model="logp"`	使用 LogP 公式	单元测试
`contention_strategy="equal_share"`, Ring 8-chip NVSwitch	$F=1$，无竞争修正	单元测试
`contention_strategy="equal_share"`, Ring 8-chip 共享链路	共享链路带宽等分	单元测试
`contention_strategy="maxmin_fair"`, 3 条异构路径流	迭代收敛，瓶颈流锁定后释放剩余带宽	单元测试
`maxmin_fair` 均匀流量	结果与 `equal_share` 一致（退化验证）	单元测试

非功能验证

指标	目标值	测试方法
单次通信延迟计算耗时	< 0.1 ms (N ≤ 32)	benchmark
GroupCommProfile 缓存命中率	> 95%	统计

未来方向

方向	优先级	前置条件	说明
$K \geq 3$ 层分层支持	高	$K=2$ 稳定	通用 K 层循环，支持跨 rack 拓扑
Ring/Tree 自动选择	中	消息阈值标定	< ~14 MB 用 Tree，> 14 MB 用 Ring
LogP/LogGP 分层支持	中	Alpha-Beta 分层稳定	将分层逻辑泛化到其他模型
NVLS 建模	低	NVSwitch 行为数据	AllReduce 步数从 $2(N-1)$ 降到 $2$
busbw 二维标定	中	多场景实测数据	按 (TP/DP/EP × allreduce/allgather) 配置等效带宽

实现备注

本节在实现完成后补充，记录 spec 与实际实现的偏差。

[2026-03-31] group_size 推导使用 pair 数公式 S=2P/N+1 而非连通分量分析。原因：初版实现简化，精度在均匀拓扑下等价。后续应按 spec 改为连通分量。
[2026-04-01] Fluid max-min fair allocation 实现为 _maxmin_fair_allocation()。per-tier factor 转换公式: factor = capacity / min_allocated_rate（非 spec 原始的 sum_rates / capacity，因后者在 max-min 饱和时恒为 1.0）。
[2026-04-01] comm_model 和 contention_strategy 配置链路: topology YAML comm_params -> CommOverrides -> CommProtocolSpec -> hardware dict -> CommEvaluator。不使用默认值。
[2026-04-01] LoGPC 双重竞争扣减修复: CommEvaluator 对 loggpc 不做外部带宽修正，改为将精确竞争因子传入 contention_factor 参数。

变更历史​

背景与目标​

背景​

目标​

术语​

数学模型​

符号定义​

基础 Alpha-Beta 模型​

端到端延迟分解​

端侧固定开销 $\alpha_{\text{start}}$​

路径相关延迟 $\alpha_{\text{path}}$​

从物理分解到公式使用​

集合通信延迟框架​

从 P2P 到集合通信​

各算法的通信步骤​

均匀对称拓扑下的简化​

分层通信​

闭式解（均匀对称拓扑）​

公式总览​

闭式解详细推导​

P2P (Pipeline Parallelism)​

ReduceScatter​

AllGather​

AllReduce​

AllToAll (MoE Dispatch/Combine)​

链路竞争建模​

策略一：静态流枚举（均匀场景）​

策略二：Fluid max-min 迭代（异构场景）​

端到端示例​

详细设计​

模块结构​

核心数据结构​

Tier 检测与 group_size 推导​

可插拔延迟模型​

CommModel Protocol​

模型概览​

链路竞争建模​

策略选择​

集成点​

设计决策​

group_size 推导方法​

竞争建模方式​

风险与局限​

验证与展望​

精度目标​

功能验证​

非功能验证​

未来方向​

实现备注​

变更历史

背景与目标

背景

目标

术语

数学模型

符号定义

基础 Alpha-Beta 模型

端到端延迟分解

端侧固定开销 $\alpha_{\text{start}}$

路径相关延迟 $\alpha_{\text{path}}$

从物理分解到公式使用

集合通信延迟框架

从 P2P 到集合通信

各算法的通信步骤

均匀对称拓扑下的简化

分层通信

闭式解（均匀对称拓扑）

公式总览

闭式解详细推导

P2P (Pipeline Parallelism)

ReduceScatter

AllGather

AllReduce

AllToAll (MoE Dispatch/Combine)

链路竞争建模

策略一：静态流枚举（均匀场景）

策略二：Fluid max-min 迭代（异构场景）

端到端示例

详细设计

模块结构

核心数据结构

Tier 检测与 group_size 推导

可插拔延迟模型

CommModel Protocol

模型概览

链路竞争建模

策略选择

集成点

设计决策

group_size 推导方法

竞争建模方式

风险与局限

验证与展望

精度目标

功能验证

非功能验证

未来方向

实现备注