Internal Wiki

主题

2 阶段 Replica-Group 构造 ​

本页所有地址均适用于 libtpu-0.0.40-cp314 wheel 中的 libtpu.so（build-id 89edbbe81c5b328a958fe628a9f2207d，build libtpu_lts_20260413_b_RC00）。其他版本会不同。.text VMA 等于文件偏移（基址 0xe63c000）；所有地址都是 VMA。引用的每个符号都存在于完整符号二进制中，并已与 IDA 反编译交叉核对。

摘要 ​

扭转环面 all-reduce 是前后相接的两个 collective：先沿加倍的 2K ICI 环做 reduce-scatter，然后在与该环正交的 K×R 平面上做 all-gather。XLA 看不到 ICI 链路——它看到的是 HLO ReplicaGroup 设备列表。本页的两个函数 TwistedTorusND::GetPhase0ReplicaGroups (0x137d3560) 和 TwistedTorusND::GetPhase1ReplicaGroups (0x137d3de0) 是这些列表的构造器：每个函数遍历扭转坐标折叠，并发出一个 std::vector<ReplicaGroup>，其中第 i 个 group 正好是参与该阶段第 i 个 collective 的逻辑设备集合。它们是与 BuildStrategy 互补的发射侧：BuildStrategy 写入 LLO all-reduce emitter 消费的按颜色 ring neighbour 表，而这两个函数写入 XLA collective scheduler 作为键使用的 device-id group 列表。两种视图描述的是同一个扭转几何。

整个构造归约为来自 UpdateMinMaxDims 的三个数字——K（短轴）、2K（长轴）、R = (num-2K-axes ≥ 2) ? 2K : K——以及一个坐标折叠 GetReplicaPair3DOnTwistedTorus，它把每个 (i, j_or_m, k) 循环三元组映射到物理芯片，再通过 GetPhysicalToLogicalMapping3D 构建的 [Y][X][Z] 表映射到该芯片的 {core0, core1} 逻辑设备对。Phase0 在 2K 环上扫描 j（group 索引 k·R + i，K·R 个 group，每个有 2K 个成员）；Phase1 扫描 (i, k) 平面（group 索引 m 或 {2m, 2m+1}，2K·LogicalDevicesPerChip 个 group，每个有 R·K 个成员）。两个阶段之间的不对称——Phase0 总是把芯片的两个 core 放在同一 group，Phase1 可能把它们拆到偶/奇 group 对中——就是本页记录的 4K-vs-2K group sizing。

本页负责说明两阶段构建、group sizing，以及单阶段 shard gate GetPerColorShardIdTable (0x137d2d80)。它不会重新推导按 (i,j,k) 的坐标折叠（见 GetReplicaPair3DOnTwistedTorus）、K/2K 形状分类（见 Shape Folds），或字节精确的 megacore gate（见 Megacore Even/Odd Split）。本页链接这些内容并使用其结果。

对重新实现而言，契约是：

  • 三个派生标量。 K = min_dim，2K = max_dim，R = num-2K-axes ≥ 2 ? 2K : K，全部在 UpdateMinMaxDims 之后读取。R 是两个阶段共享的平面维度；2K 是环维度。
  • Phase0 构建。 K·R 个 group；group 索引 k·R + i；每个 group 包含扭转环在 j = 0..2K-1 步放置的 2K 个芯片；芯片的两个 megacore core 加入同一个 group。
  • Phase1 构建。 2K·LogicalDevicesPerChip(0) 个 group；group 索引 m（单个）或 {2m, 2m+1}（偶/奇拆分）；每个 group 包含长轴切片 m 上 R·K 个芯片；拆分时 core0→偶数，core1→奇数。
  • Shard gate。 GetPerColorShardIdTable 对任何 ≥ 2 的 shard count 触发 fatal error：扭转 collective 只支持 single-phase-sharding，因此上面的两阶段 RS→AG 就是完整算法。
Phase0 (reduce-scatter)TwistedTorusND::GetPhase0ReplicaGroups 0x137d3560 (all_reduce_strategies.cc:2302)
Phase1 (all-gather)TwistedTorusND::GetPhase1ReplicaGroups 0x137d3de0 (all_reduce_strategies.cc:2334)
Shard gateTwistedTorusND::GetPerColorShardIdTable 0x137d2d80（仅 1-phase）
坐标折叠（两者都会调用）GetReplicaPair3DOnTwistedTorus 0x1c893400 — 页面
物理→逻辑映射（两者都会构建）GetPhysicalToLogicalMapping3D 0x1c88a280 — [Y][X][Z] → {core0, core1}
K / 2K / R[obj+0x5f8] / [obj+0x5f0] / (num-2K-axes ≥ 2 ? 2K : K)；num-2K-axes [obj+0x600]
Phase0 groups / membersK·R 个 group，每个 2K 个成员（成员索引 j）
Phase1 groups / members2K · LogicalDevicesPerChip(0) 个 group，每个 R·K 个成员（成员索引 (i,k)）
ReplicaGroup 元素大小48 字节（operator new(48·groups)，两个阶段相同）
置信度HIGH — Phase0/Phase1 循环嵌套、group 索引和 sizing 已由反编译验证；megacore split gate 推迟到相邻页面

1. 共享序言——三个标量和两个映射 ​

两个阶段构建器在其循环嵌套之前都会运行完全相同的序言。重新实现者应像二进制一样把它精确地抽出为公共逻辑。

算法 ​

c
function GetPhaseNReplicaGroups(target, dev_assign, dev_assign2, arg, all_cores):
    UpdateMinMaxDims(target)                       // K, 2K, num-2K, num-K  (Shape Folds)
    CHECK(target.num_dims_ == 3)                   // [obj+0x59c]==3, "num_dims_ == kMaxDims"
    InitColorDimensions(target)                    // `color_dims[6][3]`  (BuildStrategy)
    phys_to_log = GetPhysicalToLogicalMapping3D(target, dev_assign2, all_cores)
                                                   // 0x1c88a280 — [Y][X][Z] -> {core0, core1}
    K  = target[obj+0x5f8]                          // min_dim   (Phase0 v19, Phase1 v92)
    twoK = target[obj+0x5f0]                        // max_dim   (Phase0 v89, Phase1 v96)
    R  = (target[obj+0x600] >= 2) ? twoK : K        // num-2K-axes >= 2 ? 2K : K
                                                   // Phase0 v20/v94, Phase1 v19/v95 (cmovge)
```text

`K`、`2K` 和 `num-2K-axes` 是 `UpdateMinMaxDims` 在 `[obj+0x5f8]`、`[obj+0x5f0]`、`[obj+0x600]` 处的输出（[Shape Folds](shape-folds.md)）。`R` 是序言中的一个分支：单个加倍轴（`K_K_2K`）时为 `K`，两个加倍轴（`K_2K_2K`）时为 `2K`，由 `num-2K-axes ≥ 2` 上的 `cmovge` 选择。`R` 是*平面*维度——不是环的那个轴计数——并在两个阶段中都作为循环边界出现。

> **注意 —** `num_dims_ == 3` (`kMaxDims`) CHECK 会在进入两个阶段构建器时触发检查（`all_reduce_strategies.cc:2304` / `:2336`）。扭转 collective 的这一半被硬连到 3-D slice；坐标折叠中的 `num_max_dims == 2` CHECK（[`GetReplicaPair3DOnTwistedTorus`](get-replica-pair-3d.md)）强制对应的 2 轴上限。面向 >3 dims 的重新实现者必须重建两者，而不只是改循环边界。

### `GetPhysicalToLogicalMapping3D`——device-id 来源

`ReplicaGroup` 收到的每个成员 device id 都来自这个映射（`0x1c88a280`），而不是来自循环索引。它是按 `[Y][X][Z]` 索引的 `vector<vector<vector<pair<long,long>>>>`——维度分别为 `[chip_cfg+0x5c]`、`[chip_cfg+0x58]`、`[chip_cfg+0x60]`——每个叶子都初始化为 `{-1,-1}`，然后通过遍历 `DeviceAssignment` 填充：

```c
function GetPhysicalToLogicalMapping3D(target, dev_assign, all_cores):  // 0x1c88a280
    map[Y][X][Z] = pair{-1, -1}  for all                 // 0x1c88a5bf / 0x1c88a5e6
    for each logical device in dev_assign:
        flat_id = sum(coord_k * stride_k)                 // imul/add chain 0x1c88a700..
        loc     = TpuTopology::LogicalDeviceForId(0, flat_id)   // 0x20ad4120
        (cY, cX, cZ) = loc.chip_coordinates()             // 0x20ad62e0
        if partition slot 0: map[cY][cX][cZ].first  = logical_id   // 0x1c88a882
        else               : map[cY][cX][cZ].second = logical_id   // 0x1c88a8de
    return map

.first 是芯片的 core0 逻辑 id，.second 是 core1。坐标折叠会为每个 (i,j,k) 三元组返回这两个半边之一，阶段构建器随后把它（以及在 megacore Phase0 情况下的兄弟半边）追加到当前 group。保留为 {-1,-1} 的叶子表示该芯片不存在于 assignment 中——循环不会索引缺失芯片，因为它们的边界就是 slice 范围。

易错点 — 映射按 [Y][X][Z] 索引，这与 UpdateMinMaxDims 读取 obj 维度字段的顺序相同（[obj+0xb8]=Y，[obj+0xc0]=X，[obj+0xc8]=Z）。循环变量↔轴约定是 Y↔j、X↔i、Z↔k，这一点由两个阶段中 GetReplicaPair3DOnTwistedTorus 调用点的实参顺序确认。把映射构建为 [X][Y][Z] 的重新实现者会读到错误芯片，group 会静默打乱。

2. Phase 0——沿 2K 环的 Reduce-Scatter ​

GetPhase0ReplicaGroups (0x137d3560) 为第一个 collective 构建 group：沿加倍的 2K ICI 环执行的 reduce-scatter。正交平面中的每个 (i, k) 位置对应一个 group，每个 group 的成员是扭转环穿过的 2K 个芯片。

算法 ​

c
function GetPhase0ReplicaGroups(target, da, da2, arg, all_cores):   // 0x137d3560
    <shared prologue: K, 2K, R, phys_to_log>                        // §1
    n_groups = K * R                                                // v21 = v19 * v20
    groups   = vector<ReplicaGroup>(n_groups)                       // operator new(48 * n_groups)
    cores_per_chip = target.CoresPerChip(0)                         // 0x137d360d (v88)

    for i = 0 .. R-1:                                               // OUTER  (v94 == R)
        for j = 0 .. 2K-1:                                          // MIDDLE (v89 == 2K) -- the ring
            for k = 0 .. K-1:                                       // INNER  (v87 == K)
                pair = GetReplicaPair3DOnTwistedTorus(              // 0x1c893400
                           phys_to_log, &target[obj+0xb8],
                           2K, K, num_2K, arg, i, j, k)
                g = i + R*k                                         // group index k*R + i  (v50)
                groups[g].add_replica_id(pair.first)               // core0 (0x137d3adc)
                if not skip_second_core:                            // megacore predicate below
                    groups[g].add_replica_id(pair.second)          // core1 (0x137d3737)
```text

### Group 数量、索引和成员

| 数量 | 值 |
|---|---|
| Group 数量 | `K · R` |
| Group 索引 | `k · R + i` |
| 每个 group 的成员数 | `2K`（如果追加两个 core，则 `×2`） |
| 成员顺序 | 扭转环步进顺序 `j = 0..2K-1` |

Group `(i, k)` 是平面位置 `(i, k)` 处的 reduce-scatter 环：它为 `j = 0..2K-1` 收集扭转在环步 `j` 放置的芯片。因为 `j` 是**中层**循环，而 group 索引 `k·R + i` 不依赖 `j`，固定 `(i, k)` 的所有 `2K` 个环步都会落入同一个 group——该 group *就是*这个环。接缝（坐标折叠在 `j ≥ K` 时应用的 `+K`-mod-`2K` 跳转）意味着连续的 `j` 值并不是连续的物理芯片；它们是在日期线处拼接起来的两个 `K` 段。每个 `j` 的芯片数学见 [`GetReplicaPair3DOnTwistedTorus`](get-replica-pair-3d.md)。

### Phase0 megacore 同组

Phase0 无条件追加 `pair.first`，然后把 `pair.second`（芯片的另一个 core）追加**到同一个 group**，除非 megacore 谓词跳过第二次追加：

```c
// skip_second_core (Phase0), decompile @ 0x137d35... around the LABEL_19 guard
if Megacore(chip_cfg):
    skip = (cores_per_chip == 1) || (chip_cfg[+124] > 1)
else:
    skip = (cores_per_chip == 1)

Phase0 的决定性性质是：只要两个 core 都被追加，它们就进入同一个 group（两次追加写入相同的 groups[g] 指针，先 0x137d3adc 再 0x137d3737）。reduce-scatter 环让芯片的两个 core 共同驻留在同一环上；core 直到 all-gather 才分叉出去。精确谓词属于 Megacore Even/Odd Split 的范围；对 Phase0 来说，唯一的 group 形状后果是“一个 group，两个 core”。

注意 — arg 参数（a5，weight-update shard count）会原样传递给 GetReplicaPair3DOnTwistedTorus，除此之外 Phase0 不使用它。它只在 shard count ≥ 1 时选择备用坐标折叠，而 shard gate（§4）使该路径在 v0.0.40 中不可达。实践中 Phase0 总是以 arg == 0 运行。

3. Phase 1——在 K×R 平面上的 All-Gather ​

GetPhase1ReplicaGroups (0x137d3de0) 为第二个 collective 构建 group：在与 2K 环正交的平面上执行 all-gather。每个长轴切片 m 对应一个 group（或一对偶/奇 group），每个 group 的成员是该切片的 R·K 个芯片。

算法 ​

c
function GetPhase1ReplicaGroups(target, da, da2, arg, all_cores, b):   // 0x137d3de0
    <shared prologue: K, 2K, R, phys_to_log>                           // §1
    ldpc     = target.LogicalDevicesPerChip(0)                         // 0x1d615b00
    n_groups = 2K * ldpc                                               // v20 = v18[2K] * ldpc
    groups   = vector<ReplicaGroup>(n_groups)                          // operator new(48 * n_groups)
    cores_per_chip = target.CoresPerChip(0)                            // call @ 0x137d3e8a (v93)

    for m = 0 .. 2K-1:                                                 // OUTER  (v96 == 2K)
        g_single = m                                                   // 48*m offset (v94)
        g_even   = 2*m                                                 // (v90)
        g_odd    = 2*m + 1                                             // (v91)
        for i = 0 .. R-1:                                              // MIDDLE (v95 == R)
            for k = 0 .. K-1:                                          // INNER  (v92 == K)
                pair = GetReplicaPair3DOnTwistedTorus(                 // 0x1c893400
                           phys_to_log, &target[obj+0xb8],
                           2K, K, num_2K, arg, i, m, k)
                if split:                                              // even/odd split predicate
                    groups[g_even].add_replica_id(pair.first)         // core0 -> 2m   (0x137d43d5)
                    groups[g_odd ].add_replica_id(pair.second)        // core1 -> 2m+1 (0x137d3ff2)
                else:
                    groups[g_single].add_replica_id(pair.first)       // -> m          (0x137d3fee)
```text

### Group 数量、索引和成员

| 数量 | 值 |
|---|---|
| Group 数量 | `2K · LogicalDevicesPerChip(0)` |
| Group 索引（无拆分） | `m` |
| Group 索引（拆分） | `{2m, 2m+1}` |
| 每个 group 的成员数 | `R · K` |
| 成员顺序 | `(i, k)` 平面扫描 |

Group `m`（或 group 对 `{2m, 2m+1}`）是在长轴切片 `m` 上执行 all-gather 的平面：它收集环位置 `m` 处 `K×R` 横截面中的每个 `(i, k)` 芯片。因为 `m` 是**外层**循环，固定 `m` 的所有 `R·K` 个平面芯片都会落入该切片的 group 中——该平面*就是* all-gather 域。all-gather 在与环正交的平面上重组 Phase0 reduce-scatter 沿环分散的内容；两者合起来形成一个逻辑 all-reduce。

> **怪异点 —** 成员循环边界是 `R`，不是 `2K`，即使 *group count* 乘数是 `2K`。平面是 `K × R`（`R = K` 或 `2K`，取决于形状）；与它正交的环始终是 `2K`。因此 Phase1 有 `2K` 个切片（每个环步一个），每个切片有 `R·K` 个芯片，而 Phase0 有 `K·R` 个环，每个环有 `2K` 个芯片——两个阶段用两种不同方式划分同一个 `K·R·2K` 设备网格，并且乘积相同（每个逻辑设备满足 `(2K)·(R·K) == (K·R)·(2K)`）。

---

## 4. Group Sizing——4K-vs-2K 拆分

两个阶段之间唯一的不对称是**芯片的两个 core 是共享一个 group，还是分叉到一对 group 中**。Phase0 总是把两个 core 放在同一 group（§2）。Phase1 可能拆分它们，而这个拆分会把 group 数量从 `2K` 翻倍为 `4K`。

Phase1 group 数量是 `2K · LogicalDevicesPerChip(0)`（反编译精确，`0x137d3eb1`）。拆分取决于每个芯片贡献一个还是两个逻辑设备：

| 配置 | `LogicalDevicesPerChip(0)` | Phase1 group 数量 | 每个 `m` 的追加 |
|---|---|---|---|
| megacore | 1 | `2K` | 单个 group `m`（两个 core → 一个逻辑设备） |
| non-megacore，1 core/chip | 1 | `2K` | 单个 group `m` |
| non-megacore，2 cores/chip | 2 | `4K` | **拆分**：core0 → group `2m`（偶），core1 → group `2m+1`（奇） |

当芯片呈现两个不同的逻辑参与者时——即 non-megacore 2-core 情况——会到达 split 分支（反编译中的 `LABEL_50`，`{2m, 2m+1}` 追加）。在这里两个 core 会在**不相交的平面半边**（偶/奇 group）上 all-gather，从而在两个 core 之间平衡平面的 ICI 链路。**Megacore** 芯片把两个物理 core 折叠成一个逻辑设备（`LogicalDevicesPerChip = 1`），并使用单个 group `m`，得到没有偶/奇拆分的 `2K` 个 group。

> **注意 —** `4K` 偶/奇拆分是 **non-megacore 2-logical-device** 情况，*不是* megacore 行为；megacore 折叠为一个逻辑设备，并使用 `2K` group 的单路径。Group 数量是 `2K · LogicalDevicesPerChip(0)`，其中 `LogicalDevicesPerChip(0)`（`0x1d615b00` → `TpuTopology::LogicalDevicesPerChip`）通过 `Megacore ? 1 : CoreCount` getter 解析。精确的 split 谓词（`CoresPerChip != 1` 测试，加上 megacore `chip_cfg[+124]` 子条件）见 [Megacore Even/Odd Split](megacore-even-odd.md)。
>
> **注意 —** Phase0 不受此拆分影响：它的第二 core 追加（存在时）目标是与第一个相同的 group（`0x137d3adc` 和 `0x137d3737` 写入同一个 `groups[g]`）。因此 reduce-scatter 环始终是 `2K` 个芯片，且每个芯片的 `1` 或 `2` 个 core 共同分组，绝不会拆成 `4K` 个 group。只有 all-gather 平面会把 core 分开。

---

## 5. Sizing 示例——一个 `K, K, 2K` Slice

一个具体形状可以让两个划分和乘积对齐。取 `K_K_2K` 情况且 `K = 2`，因此 `2K = 4`，一个加倍轴（`num-2K-axes = 1`）⇒ `R = K = 2`。网格是 `K·R·2K = 2·2·4 = 16` 个芯片；假设 non-megacore，2 cores/chip ⇒ `LogicalDevicesPerChip = 2`，32 个逻辑设备。

| | Phase0（沿 `2K` 的 RS） | Phase1（平面上的 AG） |
|---|---|---|
| Group 数量 | `K·R = 4` | `2K·LDPC = 8`（`4K` 拆分） |
| Members / group | `2K = 4` 个芯片（`×2` cores = 8 ids） | `R·K = 4` 个芯片（每个 1 core） |
| Group 索引 | `k·R + i` ∈ {0,1,2,3} | `{2m, 2m+1}` ∈ {0..7} |
| 扫描索引 | `j = 0..3`（环步） | `(i,k)` 遍历 `2×2` 平面 |
| 总 replica ids | `4 groups × 4 chips × 2 cores = 32` | `8 groups × 4 ids = 32` |

两个阶段都覆盖全部 32 个逻辑设备，但按正交方式划分：Phase0 有 4 个由 4 个芯片组成的环（每个 8 个 core）；Phase1 有 8 个由 4 个 core 组成的平面半边。Reduce-scatter 沿每个 4 芯片环分散 tensor，然后 all-gather 在每个 4 芯片平面上重组它——这就是标准 RS→AG all-reduce，映射到 twist 上。

如果同一个 slice 是 **megacore**，`LogicalDevicesPerChip` 将为 1 ⇒ Phase1 group 数量 `2K·1 = 4`（无偶/奇拆分），4 个 group 中每个都持有其切片的 4 个芯片，作为 4 个单一逻辑设备。Phase0 在两种模式下相同（4 个由 4 个芯片组成的环），只是在每个芯片贡献一个还是两个追加 id 上不同。

> **怪异点 —** Phase1 group 数量 `8` 超过 Phase0 数量 `4`，精确原因是 `LDPC = 2` 乘数，而不是平面更大。对于这个形状，平面（`R·K = 4`）与环（`2K = 4`）是*相同大小*；额外的 Phase1 group 来自把每个芯片的两个 core 分叉到偶/奇 pair 中。只按平面范围为 `vector<ReplicaGroup>` 定大小的重新实现者会少分配一个 `LDPC` 倍数。

---

## 6. 单阶段 Shard Gate——`GetPerColorShardIdTable`

`GetPerColorShardIdTable` (`0x137d2d80`) 是让 §2–§4 两阶段构造成为*完整*扭转环面 collective 的 gate：它拒绝任何试图把 weight update 分片到超过一个 phase 的尝试。

### 算法

```c
function GetPerColorShardIdTable(target, da, shard_table, shard_count, all_cores):  // 0x137d2d80
    n = shard_table->size                          // **shard_table  (v16 = (*a4)[0])
    if all_cores: n *= shard_table->stride         // a6 -> v16 *= v17
    else if shard_table->stride != 1: return ...   // "not all cores" early-out
    if n != TpuTopology::LogicalDeviceCount(0):     // 0x137d2d80 body @ +... (LABEL guard)
        return error  // "2D all-reduce ... only ... where all available cores participate"
    if shard_count >= 2:                            // a5 >= 2  (the 1-phase gate)
        return Unimplemented(
            "3D twisted torus weight update sharding algorithm "
            "currently supports only 1-phase sharding.")     // .rodata @ 0xa06c3fb (91 bytes)
    UpdateMinMaxDims(target); CHECK(num_dims_ == 3)
    ... build the per-color shard-id table (1-phase) ...

shard_count 参数（a5，也就是两个阶段构建器作为 arg 传入坐标折叠的同一个 long）会与 >= 2 比较；任何 ≥ 2 都会用 "3D twisted torus weight update sharding algorithm currently supports only 1-phase sharding." 字符串触发 fatal error（.rodata 0xa06c3fb，91 字节，反编译逐字验证）。配套的 all_cores bool（a6）控制 “all available cores participate” 前置条件；不满足时返回 "2D all-reduce algorithm only implemented for cases where all available cores participate the reduction." 字符串（0xa04a6b0）。

对重新实现者的后果是：扭转环面 collective 是一个 shard，分解为 Phase0 reduce-scatter（§2）再接 Phase1 all-gather（§3）。v0.0.40 中没有 twist 的多 shard 流水线——GetReplicaPair3DOnTwistedTorus 的 arg ≥ 1 分支（结构上不同的 fold）存在，但在这个 gate 后不可达。构建 single-phase 路径；除非后续版本放宽 < 2 gate，否则把 multi-shard fold 视为死代码。

易错点 — 这里的 “1-phase sharding” 指的是一个 weight-update shard，不是一个 collective。Collective 本身明确是两个 collective（RS 然后 AG）。GetPhase0/GetPhase1 中的 “phase”（RS/AG 拆分）和这个 Unimplemented 字符串中的 “phase”（shard count）是不同轴；混淆它们会让重新实现者误以为 Phase1 是被禁止的第二个 shard，但它不是。

7. Function Map ​

FunctionAddressRole
TwistedTorusND::GetPhase0ReplicaGroups0x137d3560沿 2K 的 RS group 列表；K·R 个 group，索引 k·R+i，成员 j
TwistedTorusND::GetPhase1ReplicaGroups0x137d3de0平面上的 AG group 列表；2K·LDPC 个 group，索引 m/{2m,2m+1}，成员 (i,k)
TwistedTorusND::GetPerColorShardIdTable0x137d2d80仅 1-phase gate（shard_count ≥ 2 → Unimplemented）
GetReplicaPair3DOnTwistedTorus0x1c893400按 (i,j,k) 的芯片 fold；两个阶段都会调用
GetPhysicalToLogicalMapping3D0x1c88a280[Y][X][Z] → {core0, core1} device-id 来源
Target::LogicalDevicesPerChip0x1d615b00Phase1 group-count 乘数（Megacore ? 1 : cores）
Target::CoresPerChip0x1d615b40cores_per_chip 第二 core / split 谓词输入
TwistedTorusND::GetPhase0Cores / GetPhase1Cores0x137d6de0 / 0x137d6ec0并行的按阶段 core-ID 向量（cost model）

8. 未解决内容 ​

  • 精确的 Phase1 split 谓词。 本页确立了 group sizing（2K vs 4K）以及哪种情况会 split（non-megacore 2-core）。字节精确分支——共同控制 LABEL_50 的 Megacore(chip_cfg) 测试、CoresPerChip != 1，以及 megacore chip_cfg[+124] <= 1 子条件——在 Megacore Even/Odd Split 解码。Sizing 置信度 HIGH；谓词的完整真值表推迟到那里。
  • GetPhase0Cores / GetPhase1Cores。 ReplicaGroup proto 构造（本页）已解码；cost estimator 遍历的并行 *Cores device-ID 向量（EstimatePhysicalLinksUsed 0x1c8939c0）已定位但未转录。MEDIUM。
  • arg ≥ 1 multi-shard fold。 两个阶段构建器都会把 arg 转发到坐标折叠，而坐标折叠有一个不同的 arg == 1 入口块；在 v0.0.40 中它被 §5 的 < 2 gate 后的 CHECK 使得不可达。它的 collective 语义（第二个 shard 会划分什么）未被执行验证。LOW。见 GetReplicaPair3DOnTwistedTorus。

交叉引用 ​

Twist 算法（本节） ​

相邻章节 ​