按 Opcode 划分的周期常量
本页上的每个偏移、数值和地址都从
libtpu-0.0.40-cp314wheel 中的libtpu.so逐字节读取（BuildID md589edbbe81c5b328a958fe628a9f2207d）。其他版本会有所不同。所有.rodata地址都是虚拟地址；对该二进制而言，.rodataVMA == 文件偏移（节[11]位于0x84a0000）。
摘要
本页是 TensorCore 成本模型的数据表：烘焙进 libtpu.so 的 .rodata 中的实际周期成本整数，按代际和引擎分组，并给出 bundle 延迟成本模型求和的规则。这些数字来自两个地方，重新实现者必须将它们区分开来。(1) 一个周期类的吞吐量周期，是按代 CycleTable 从 GetCyclesForThroughput 返回的值；对 Jellyfish/Dragonfish，它是一次平坦读取 Performance[offsetLUT[class]]，对 Pufferfish 及之后，它是调用 Performance::GetResourceUsage(instruction_id, resource) 的 switch。(2) 一个 op 的延迟是单独的按代 Performance 数组项，由 LatencyTable* 读取。两个数组都位于同一个按代 Performance 对象中；下面的周期常量就是这些数组的内容。
最老的代际（JF/DF）在这里完全按字节锚定：33 项 int64 偏移 LUT、33 个类中 16 个有定价的子集、七个 8 周期 MXU 单元、九个 1 周期向量单元，以及填充它们的构造函数源块。对 Pufferfish 到 6acc60406，按类吞吐量整数从各代 switch 中的 GetResourceUsage(instr,res) 调用常量锚定，按代延迟值分布从构造函数存储流锚定；完整的按 (instruction × resource) 划分的二维网格只做了部分提取（如下标注）。
本页记录的契约：
- 周期类的吞吐量成本是
Performance[offset](JF/DF) 或GetResourceUsage(instr,res)(PF+)。 未定价类的默认值为1周期。 - 烘焙网格默认填充哨兵
0x7FFFFFFF（“不支持 / 不可调度”），并由按代Performance构造函数用手工编排的广播/块拷贝模式覆盖。 - Dragonfish == Jellyfish，除了两个单元（
[+0x28]、[+0x2c]），且二者都不是吞吐量 LUT 目标，因此 JF 和 DF 吞吐量表逐字节相同。 - Bundle 发射成本是按 lane 取最大值，而不是全局求和。 每个 op 的周期会累积到以
GetResource(class)为键的ResourceVector中；同 lane 成本相加，跨 lane 成本重叠。 - 超越函数来自标量虚函数 override 的常量，不是来自网格。
| 偏移 LUT (JF/DF) | qword_B438B70 @ 0xb438b70 — 33 × int64，class → Performance 字节偏移 |
| Resource LUT | dword_B438AEC @ 0xb438aec — 33 × int32，class → ResourceVector 槽 |
| 定价掩码 (JF) | 0x19FFC0821 — 16 个类有定价；其余默认 1 |
| 哨兵 | dword_84A2F60 @ 0x84a2f60 = 0x7FFFFFFF（不支持） |
| 广播标量 | dword_84A2B08 = 1，dword_84A2854 = 2，dword_84A2D0C = 8 |
| PerformanceJf ctor | 0x1d4930c0 — 116 次存储 → 419 个不同的 int32 单元 |
| PerformanceDf ctor | 0x1d493060 — JF + 在 +0x28 处一次 0xD00000042 存储 |
| 网格宽度 | 0xe00 字节（Performance::Performance @ 0x1d492900） |
| 置信度 | JF/DF 为 CONFIRMED（字节锚定）；PF+ 按类为 CONFIRMED；完整二维网格为 PARTIAL |
常量所在位置
每个按代 Performance 对象都是一个平坦的 0xe00 字节分配。基类构造函数 Performance::Performance @ 0x1d492900 用哨兵 0x7FFFFFFF（vbroadcastss xmm0, dword_84A2F60）广播填充整个数组，表示“该单元不支持 / 不可调度”。派生的按代构造函数随后用打包常量覆盖受支持的子集。
重新实现者会在每个 Performance 构造函数中看到三种惯用法：
| 惯用法 | 反汇编 | 效果 |
|---|---|---|
| 广播填充 | vbroadcastss xmm, dword_XXX + vmovups [base+off], xmm | 写入 4 个相同单元 |
| 16 字节块拷贝 | vmovaps xmm, xmmword_YYY + vmovups [base+off], xmm | 从 4 个 int32 的 .rodata 块写入 4 个单元 |
| 标量 / movabs 存储 | mov [base+off], imm / movabs rax,imm64; mov [base+off],rax | 写入 1 或 2 个单元 |
三个广播标量承载常见周期值：dword_84A2B08 = 1（1 周期 op）、dword_84A2854 = 2（2 周期桶）、dword_84A2D0C = 8（8 周期 MXU 桶）。具有辨识度的按指令簇来自 16 字节块；PerformanceJf 使用的 15 个不同块在下方枚举。
Jellyfish / Dragonfish — 平坦偏移 LUT（字节精确）
JF/DF 不使用 (instruction, resource) switch。JfCycleTable::GetCyclesForThroughput 通过 33 项 int64 偏移 LUT 直接读取 Performance 网格：
c
// xla::jellyfish::JfCycleTable::GetCyclesForThroughput @ 0x1c89dce0 (decompiled, exact)
int64_t GetCyclesForThroughput(JfCycleTable *this, uint32_t cls) {
if (((cls < 0x21) & (uint8_t)(0x19FFC0821ULL >> cls)) == 1) // priced?
return *(uint32_t *)(this->performance/*+0x10*/ + qword_B438B70[cls]);
return 1; // default
}
```text
定价掩码 `0x19FFC0821` 选择 33 个类中的 16 个：`{0x00, 0x05, 0x0b, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1f, 0x20}`。偏移 LUT（`qword_B438B70` @ `0xb438b70`）对每个未定价类都是 `0`，这无害，因为读取会被短路。下面列出有定价的行，包括字节偏移、在重建的 `PerformanceJf` 镜像中解析出的值、以及写入该单元的构造函数惯用法：
| Class | `offsetLUT[cls]` | Resource | JF cyc | DF cyc | 源惯用法 |
|------:|-----------------:|----------|-------:|-------:|--------------|
| `0x00` | `0x910` | `R[1]` Matmul | 8 | 8 | block `@0xa2da220` `{8,8,8,1}[0]` |
| `0x05` | `0x92c` | `R[0]` Matpush | 8 | 8 | bcast `8` (`@0x84a2d0c`) |
| `0x0b` | `0x92c` | `R[0]` Matpush | 8 | 8 | bcast `8`（与 `0x05` 共享偏移） |
| `0x12` | `0x33c` | `R[4]` VectorAlu1 | 1 | 1 | bcast `1` (`@0x84a2b08`) |
| `0x13` | `0x340` | `R[4]` VectorAlu1 | 1 | 1 | bcast `1` |
| `0x14` | `0x344` | `R[3]` VectorAlu0 | 1 | 1 | bcast `1` |
| `0x15` | `0x39c` | `R[5]` VectorAluAny | 1 | 1 | bcast `1` |
| `0x16` | `0x398` | `R[5]` VectorAluAny | 1 | 1 | bcast `1` |
| `0x17` | `0x954` | `R[2]` Xlu | 8 | 8 | bcast `8` |
| `0x18` | `0x3f8` | `R[6]` VectorEup | 1 | 1 | imm `1` |
| `0x19` | `0x368` | `R[5]` VectorAluAny | 1 | 1 | bcast `1` |
| `0x1a` | `0x3f4` | `R[6]` VectorEup | 1 | 1 | bcast `1` |
| `0x1b` | `0x960` | `R[2]` Xlu | 8 | 8 | bcast `8` |
| `0x1c` | `0x94c` | `R[2]` Xlu | 8 | 8 | block `@0xa2cf810` `{8,1,1,8}[3]` |
| `0x1f` | `0x958` | `R[2]` Xlu | 8 | 8 | bcast `8` |
| `0x20` | `0x39c` | `R[5]` VectorAluAny | 1 | 1 | bcast `1`（与 `0x15` 共享偏移） |
七个 8 周期单元是 MXU matprep/matmul/matrix-result 吞吐量端口（`0x00, 0x05, 0x0b, 0x17, 0x1b, 0x1c, 0x1f`）；九个 1 周期单元是向量/EUP/跨 lane 结果阶段。两对共享偏移（`0x05`/`0x0b` → `0x92c`；`0x15`/`0x20` → `0x39c`）。没有任何有定价偏移是 `0x28` 或 `0x2c`，因此 Dragonfish 的双单元 override 从不会触及吞吐量单元。
> **注意 — 这些值是重新推导的，不是转录的。** 完整的 `PerformanceJf` 镜像通过模拟基类哨兵填充以及每次构造函数存储重建（已核验来自 `0x1d4930c0` 的 `vmovaps`/`vbroadcastss`/`movabs` 流），然后在 `offsetLUT[cls]` 处读回。MXU 带的存储在构造函数中是显式的：`[+0x910] ← xmmword_A2DA220 {8,8,8,1}`，`[+0x920..+0x980] ← bcast 8`，`[+0x940] ← xmmword_A2CF810 {8,1,1,8}`。16 字节源块直接从 `.rodata` 读取，全部 15 个都匹配（见下文）。
### 15 个 PerformanceJf 构造函数源块
每个块都是四个 `int32`。从 `.rodata` 逐字节读取：
| Block | Value | Block | Value | Block | Value |
|-------|-------|-------|-------|-------|-------|
| `@0xa2c2f40` | `{5,1,1,1}` | `@0xa2c5b90` | `{1,1,1,4}` | `@0xa2c5ba0` | `{1,1,5,5}` |
| `@0xa2c8a30` | `{4,105,7,92}` | `@0xa2c8a40` | `{2,1,1,1}` | `@0xa2cea00` | `{2,2,1,1}` |
| `@0xa2cf810` | `{8,1,1,8}` | `@0xa2d2090` | `{1,1,4,4}` | `@0xa2d2df0` | `{1,1,1,2}` |
| `@0xa2d3c30` | `{8,1,1,1}` | `@0xa2d7660` | `{1,1,8,1}` | `@0xa2da220` | `{8,8,8,1}` |
| `@0xa2daf10` | `{4,2,1,1}` | `@0xa2db650` | `{1,1,2,2}` | `@0xa2dcd30` | `{88,8,4,1}` |
构造函数发出 116 次 store op（17 次块拷贝 + 81 次广播填充 + 9 次 `movabs` qword + 9 次 dword imm），写入正好 419 个不同的 `int32` 单元且没有重叠；其余单元保持 `0x7FFFFFFF` 哨兵。419 个单元中只有约 31 个有语义绑定（16 个吞吐量 LUT 目标 + 约 15 个延迟表单元）；其余虽已填充，但消费者尚未映射（对每单元角色为 LOW 置信度）。
### Dragonfish 差异
`PerformanceDf::PerformanceDf` @ `0x1d493060` 调用 `PerformanceJf::PerformanceJf`，替换 vtable，然后只发出一次存储：
```c
// PerformanceDf::PerformanceDf @ 0x1d493060 (decompiled, exact)
PerformanceJf::PerformanceJf(this, ids);
*(void **)this = /* Df vtable */;
*((uint64_t *)this + 5) = 0xD00000042ULL; // byte offset 0x28*((uint64_t*)this + 5) 是字节偏移 5 × 8 = 0x28；int64 0x0000000D_00000042 解码为 [+0x28] = 0x42 = 66 和 [+0x2c] = 0x0d = 13（低于 JF 的 88 / 8）。这两个单元供给 LatencyTableJellyfish 的 matmul/matprep 基础延迟槽，而不是吞吐量 LUT；它们是成本模型中 v2→v3 MXU 计数/时钟变化的反映。所有其他单元都相同（通过 diff 两个重建镜像验证：正好两个单元改变）。
Pufferfish — 对 GetResourceUsage 的 switch（按类 CONFIRMED）
从 Pufferfish 开始，GetCyclesForThroughput 是一个基于周期类的 switch；每个 case 指定一个 Performance 指令 id 和一个资源，并通过 GetResourceUsage 读取网格：
c
// xla::jellyfish::PfCycleTable::GetCyclesForThroughput @ 0x1c89de60 (decompiled, exact shape)
switch (cls) {
case 0: return PufferfishPerformance::GetResourceUsage(perf, 125, 9);
case 1: return PufferfishPerformance::GetResourceUsage(perf, 137, 9);
case 5: case 11: return PufferfishPerformance::GetResourceUsage(perf, 220, 11);
case 6: case 12: return PufferfishPerformance::GetResourceUsage(perf, 223, 11);
case 9: case 15: return PufferfishPerformance::GetResourceUsage(perf, 224, 11);
case 10: case 16: LogFatal("Unsupported PushGainsS4.", /*cycle_table.cc:575*/);
case 23: return PufferfishPerformance::GetResourceUsage(perf, 260, 11);
case 24: return PufferfishPerformance::GetResourceUsage(perf, 107, 3);
case 26: return PufferfishPerformance::GetResourceUsage(perf, 106, 3);
case 27: return PufferfishPerformance::GetResourceUsage(perf, 264, 11);
case 28: return PufferfishPerformance::GetResourceUsage(perf, 244, 11);
case 29: return PufferfishPerformance::GetResourceUsage(perf, 252, 11);
case 31: return PufferfishPerformance::GetResourceUsage(perf, 262, 11);
default: return 1;
}
```text
`(instruction_id, resource)` 对是主要常量。把每一项解析到 Pufferfish `Performance` 延迟数组后得到按类成本：
| Class | `(instr, res)` | Perf value | 角色 |
|------:|----------------|-----------:|------|
| `0x00` | `(125, 9)` | 101 | bf16 matprep |
| `0x01` | `(137, 9)` | 101 | bf16 matprep' |
| `0x05`/`0x0b` | `(220, 11)` | 7 | bf16 latch |
| `0x06`/`0x0c` | `(223, 11)` | 7 | int8 latch |
| `0x09`/`0x0f` | `(224, 11)` | 7 | fp8 latch |
| `0x0a`/`0x10` | — | fatal | `PushGainsS4` (`cycle_table.cc:575`) |
| `0x17` | `(260, 11)` | 69 | matrix-result TC |
| `0x18` | `(107, 3)` | 7 | r/w transpose |
| `0x1a` | `(106, 3)` | 7 | lane compare |
| `0x1b` | `(264, 11)` | 79 | matrix-result primary |
| `0x1c` | `(244, 11)` | 126 | matrix-result secondary |
| `0x1d` | `(252, 11)` | 126 | EUP primary |
| `0x1f` | `(262, 11)` | 69 | transcendental class |
资源参数暴露了 lane：`9` = matmul-issue（仅 PF；之后的代际使用 `11`），`11` = XLU MRB，`3` = XLU input slot。`PushGainsS4` case 已在枚举中声明，但其成本故意是致命日志，以将这些模式排除在可调度集合之外。
> **注意 — 同一类的 `(instr, res)` 值不同于跨代吞吐量列。** `GetResourceUsage(125, 9)` 返回 `101`（指令 125 的 resource-`9` 单元，即 bf16-matprep 视图），而下面的[按类跨代吞吐量表](#per-class-throughput-across-generations)把 Pufferfish class `0x00` 列为 `79`。这两个数字是二维 `(instruction × resource)` 网格的不同列；调度器使用的吞吐量行读取的是不同的资源槽，而不是 `res=9` 的 matmul-issue 单元。重新实现者不能假定这两个视图是同一个数字。二者都以 Pufferfish `Performance` 数组做字节锚定；bundle 成本模型实际消费的按资源单元在[二维网格章节](#per-gen-latency-array-distributions-confirmed-counts-full-2d-partial)中标记为 PARTIAL。
---
## 按类跨代吞吐量 {#per-class-throughput-across-generations}
从各代的 `GetCyclesForThroughput`（或 `…Helper`）`switch` 解码，并与按代 `Performance` 延迟数组交叉核对。这些是每个 bundle 发射的吞吐量周期，不是每条指令的延迟。
| Class | 角色 | JF/DF | Puff | Vip | Glite | `6acc60406` |
|------:|------|------:|-----:|----:|------:|---------:|
| `0x00` | Vector matprep, bf16 | 8 | 79 | 131 | 192 | 212 |
| `0x05` | Latch, bf16 | 8 | 79 | 131 | 192 | 212 |
| `0x0b` | Transposed bf16 latch | 8 | 79 | 131 | 192 | 212 |
| `0x09` | Latch, fp8 | (dflt 1) | — | 114 | 192 | 204 |
| `0x12`–`0x16` | XLU rot / shuffle / bcast / reduce | 1 | 1 | 1 | 1 | 2 |
| `0x17` | Matrix-result read (TC) | 8 | 53 | 114 | 192 | 212 |
| `0x18`/`0x19`/`0x1a` | RW-xpose / cross-lane / lane-cmp | 1 | 1 | 1 | 1 | 1 |
| `0x1b` | Matrix-result, primary | 8 | 79 | 115 | 122 | 127 |
| `0x1c` | Matrix-result, secondary | 8 | 30 | 30 | 49 | 49 |
| `0x1d` | EUP unary primary | — | 1 | 1 | 13 | 10 |
| `0x1e` | EUP unary secondary | — | — | — | 13 | 11 |
| sin/cos (scalar) | transcendental estimate | 198 | 198 | 154 | 142 | 142 |
| tan (scalar) | transcendental estimate | 219 | 219 | 170 | 151 | 151 |
`—` 表示该代际不实现该类（`switch` 落到默认值 `1`）。matmul/matprep 簇匹配按格式的 MXU 周期：**bf16** Vf=131 / Gl=192 / Gf=212；**fp8** Vf=114–115 / Gl=192 / Gf=204；**fp32** 共享 bf16。这些可与 [matmul 模式修饰符](matmul-mode-modifiers.md)以及按代 MXU 延迟表（[JF/DF](mxu-latency-jf-df.md)，以及按代 `Performance` 页面 [PF](performance-pf.md)、[VF](performance-vf.md)）交叉检查。
### 超越函数标量成本（虚函数 override，CONFIRMED）
`EstimateSinCosCost`/`EstimateTanCost` 是按代的 `const` 虚函数，返回固定估计值，与操作数大小无关：
| Gen | SinCos | Tan | 函数 |
|-----|-------:|----:|-----------|
| Jellyfish / Dragonfish | 198 | 219 | `0x1c89dd20` / `0x1c89dd40` |
| Pufferfish | 198 | 219 | `0x1c89dfc0` / `0x1c89dfe0` |
| Viperfish | 154 | 170 | `0x1c89e480` / `0x1c89e4a0` |
| Ghostlite | 142 | 151 | `0x1c89ea00` / `0x1c89ea20` |
| `6acc60406` | 142 | 151 | `0x1c89f0e0` / `0x1c89f100` |
每个值都从函数体读取（`return <imm>;`）。这种趋势（sin/cos 从 PF 到 GF 缩短约 25 %）对应于各代 XLU 流水线 / 发射吞吐量的加速。
---
## 按代延迟数组分布（CONFIRMED 计数；完整二维为 PARTIAL） {#per-gen-latency-array-distributions-confirmed-counts-full-2d-partial}
按代 `Performance` 对象还保存 `LatencyTable*` 读取的*延迟*数组。下面的值直方图通过解析每个构造函数中的每条 `mov dword [base+off], imm` 提取。构造函数地址和数组大小如下：
| Gen | Performance 类 | Ctor | num_instr | latency bytes | resource_count |
|-----|-------------------|------|----------:|--------------:|---------------:|
| Pufferfish | `xla::pufferfish::PufferfishPerformance` | `0x1c8be080` | 336 | 1344 | 20 |
| Viperfish | `xla::viperfish::ViperfishPerformance` | `0x1c8c4840` | 384 | 1536 | 28 |
| Ghostlite | `xla::ghostlite::GhostlitePerformance` | `0x1c8cbc80` | 476 | 1904 | 31 |
| `6acc60406` | (`gxc::gfc` Performance, unnamed `sub_1C8D3740`) | `0x1c8d3740` | 465 | 1860 | 31 |
延迟直方图中的显著簇（为简洁起见省略完整的逐值表）：Pufferfish 集中在 `1`（144 项）、`83`/`101`（各 48 项）、`126`（16 项）；Viperfish 集中在 `1`/`2`（147/113）、`121`（25）、`131`（27）；Ghostlite 集中在 `1`/`2`（149/181）、`182`（24）、`192`（27）；`6acc60406` 集中在 `1`/`2`（154/198）、`204`（12）、`212`（15）。200+ 周期项集中在指令 id 289..330，即 bf16/fp8 MXU latch/matmul/matres op。
> **PARTIAL — 这里未枚举完整的 `(instruction × resource)` 二维网格。** 每个 `Performance` 构造函数发出 599 (PF) / 759 (VF) / 831 (GL) / 759 (GF) 次 dword 存储，分布在延迟数组和二维 `resource_usage` 数组之间；本页锚定按类吞吐量常量（具名 switch case，CONFIRMED）以及延迟值分布（CONFIRMED 计数），但没有列出每一个按资源单元。提取可机械地基于 `Performance::GetResources()::kResources` 完成，并留作后续。按代 `Performance` 页面（[PF](performance-pf.md)、[VF](performance-vf.md)）跟踪这项工作。
---
## Bundle 延迟成本模型如何求和
周期常量供给两层记账（设计详见 [bundle 感知成本](bundle-aware-cost.md)）：
1. **Op 层级。** 对每个 LLO op，emitter 计算其周期类（MXU op 使用 `CycleTableInstruction`；向量/内存 op 使用 emitter `Record*` 路径），读取 `GetCyclesForThroughput(class)`，并把 `(double)cycles` 加到该 op 的 `ResourceVector` 中的 `GetResource(class)` 槽。这是 `AccumulateInstructionUsage` → `ResourceVector::Acc` 路径（`[rdi + Resource*8] += cycles`）。
2. **Bundle 层级。** 从速率视角看，VLIW bundle 是一个发射槽，但多个 op 会共享它。调度器组合每个 op 的资源向量，使**相同资源成本相加**（同一功能单元上顺序执行），而**不同资源成本重叠**（bundle 的贡献是按 lane 取最大值）。最慢的占用 lane 决定 bundle 的发射成本。
内存传输 op 基于公式而不是单个常量：每字节周期为 `bytes_per_window / (lane_count × dtype_bytes) × per-lane-cycle`，由 `cost_model_util::Record*MemXferCycles` 类族组合而成。Matmul 成本为 `K_tile × per-(format, mxu) cycle`。超越函数在逐步流水线计数之上添加标量 `EstimateSinCosCost()` / `EstimateTanCost()`。绝对时间转换使用 `Target::TensorCoreFrequencyInMegaHertz()`（通过 `qword_A2E0208` 处的 `1.0e6` 因子将周期转换为微秒）；成本模型本身完全以周期工作。
> **注意 — 发布的成本模型由数据表驱动，不是 ML。** `LearnedCostModelClientOptions` *proto* 确实存在用于配置，但这个二进制中没有发布 `LearnedCostModelClient` 类实例（通过 symbol grep 验证，只有 proto message 方法）。上面的每个成本数字都是静态 `.rodata` 常量；“learned”代码路径会回退到这些表。参见 [学习式成本模型客户端](learned-cost-model-client.md)。
---
## 交叉引用
- [CycleTable 类族](cycletable-family.md) — 读取这些常量的按代分发器；周期类枚举和资源 LUT。
- [JfCycleTable](jf-cycletable.md) — 完整的 JF/DF 平坦偏移 LUT 读取路径。
- [VfCycleTable](vf-cycletable.md) — Viperfish 的 `switch` over `GetResourceUsage` 路径。
- [Performance 类族概览](performance-overview.md) · [Performance JF/DF](performance-jf-df.md) · [PF](performance-pf.md) · [VF](performance-vf.md) — 保存这些数组的网格。
- [MXU 延迟概览](mxu-latency-overview.md) · [MXU 延迟 JF/DF](mxu-latency-jf-df.md) — 按 `(MatmulModifier × Resource)` 的 matmul/matprep override。
- [Matmul 模式修饰符](matmul-mode-modifiers.md) — 索引 MXU 周期簇的 `MatmulDataFormat` / `GainLatchMode` 修饰符。
- [Resource 枚举](resource-enum.md) — 每个 op 的周期累积进入的 `ResourceVector` 槽。
- [Bundle 感知成本](bundle-aware-cost.md) — op 层级与 bundle 层级的求和规则。
- [学习式成本模型客户端](learned-cost-model-client.md) — 为什么这些静态表而非 ML 预测器驱动发布成本模型。
- [Bundle 模型概览](../isa/bundle-model-overview.md) — VLIW bundle 层。
- **二进制：** `extracted/libtpu-0.0.40-cp314-cp314-manylinux_2_31_x86_64/libtpu/libtpu.so`（build-id `89edbbe81c5b328a958fe628a9f2207d`）
- **索引项：** Part VII — 成本与延迟模型 / 核心模型 — [返回索引](../index.md)