第二部分：核心计算公式速记表

把所有"为什么是 23 ms / 95% 利用率"的数字根源全部拆开。客户问的时候能现场推导。

这一部分是物理直觉的量化版本。第一部分讲"为什么"，这一部分讲"具体多少"。所有数字都以某型号卡 + 70B 模型为基准。

2.1 硬件常数（必须脱口而出）

量	数值	单位换算
某型号卡 HBM 带宽	3 TB/s	= 3000 GB/s
某型号卡 FP16 算力	1000 TFLOPS	= 10¹⁵ FLOPS
某型号卡 FP8 算力	2000 TFLOPS	= 2×10¹⁵ FLOPS
某型号卡 NVLink	400 GB/s	同机卡间
PCIe 5.0	64 GB/s	GPU ↔ CPU

关键阈值

算力 / 带宽 ≈ 333

意思是 GPU 每搬 1 字节，理论上能做 333 次 FP16 运算。

如果一个操作"每字节做的计算 < 333"，它就是 memory-bound（搬运瓶颈）。

这叫 arithmetic intensity（算术强度）阈值，记住 333 。

2.2 搬运时间（Memory Movement Time）

核心公式

T搬运 = 要搬的字节数 ÷ HBM 带宽

案例 1：70B FP16 模型搬运一次

T = 140 GB ÷ 3 TB/s = 140 / 3000 s = 46.7 ms

案例 2：70B FP8 模型搬运一次（量化后）

T = 70 GB ÷ 3 TB/s = 23.3 ms

这就是"23 毫秒"的来历。FP8 量化让 Decode 每个 token 的搬运时间直接砍半。

案例 3：70B INT4 模型搬运一次

T = 35 GB ÷ 3 TB/s = 11.7 ms

速记表

模型大小	精度	权重	单次搬运耗时
7B	FP16	14 GB	4.7 ms
7B	FP8	7 GB	2.3 ms
70B	FP16	140 GB	46.7 ms
70B	FP8	70 GB	23.3 ms
70B	INT4	35 GB	11.7 ms
235B	FP8	235 GB	78 ms

核心心智模型：Decode 阶段，每生成一个 token，至少要花上面这个时间。这是物理下限，跟你软件怎么优化没关系。

2.3 计算时间（Compute Time）

核心公式

T计算 = 所需 FLOPs ÷ GPU 算力

一个 Token 的 FLOPs 数量

经验公式（Transformer 模型）：

FLOPs per token ≈ 2 × 参数量

70B 模型：每个 token 需要 140 GFLOPs = 1.4×10¹¹ FLOPs 7B 模型：每个 token 需要 14 GFLOPs

案例：70B FP8 模型，Decode 1 个 token 的纯计算时间

T = 1.4×10¹¹ ÷ 2×10¹⁵ = 7×10⁻⁵ s = 0.07 ms

关键对比（70B FP8，Decode 1 个 token）

阶段	耗时	占比
计算	0.07 ms	0.3%
搬运	23.3 ms	99.7%

Decode 阶段 99.7% 的时间花在搬运，0.3% 在算。这就是 memory-bound 的真相。

2.4 GPU 算力利用率（MFU - Model FLOPs Utilization）

核心公式

利用率 = 实际用掉的算力 ÷ GPU 理论峰值算力

等价写法：

利用率 = T计算 ÷ T实际耗时 = T计算 ÷ T搬运

（memory-bound 场景下，实际耗时 = 搬运时间）

案例：70B FP8，Decode 1 个 token（batch=1）

利用率 = 0.07 ms ÷ 23.3 ms = 0.3%

99.7% 算力闲置。这就是"95% 闲置"的来源（手册写的是保守估计 1-5%）。

Prefill 阶段为什么是 60-80%

Prefill 一次处理 N 个 token（比如 1000 个），搬运还是搬一次 70 GB，但计算量变成 N 倍：

T计算 = 0.07 ms × 1000 = 70 ms

T搬运 = 23.3 ms

此时计算时间 > 搬运时间，瓶颈翻转成 compute-bound

利用率 = T搬运 ÷ T计算 = 23.3 ÷ 70 ≈ 33%

实际算上 batch、并行优化能到 60-80%。

2.5 Batching 让利用率回升（核心商业逻辑）

关键洞察：搬运一次 70 GB，能同时给 N 个用户算 token。搬运时间不变，计算时间变 N 倍。

公式

Decode 利用率(batch=N) = (0.07 ms × N) ÷ 23.3 ms

速记表（70B FP8，Decode）

Batch size	计算时间	搬运时间	瓶颈	利用率
1	0.07 ms	23.3 ms	搬运	0.3%
8	0.56 ms	23.3 ms	搬运	2.4%
32	2.2 ms	23.3 ms	搬运	9.5%
128	9 ms	23.3 ms	搬运	38%
333	23.3 ms	23.3 ms	平衡点	100%
512	36 ms	23.3 ms	计算	变成 compute-bound

Batch = 333 是理论甜点（来自 arithmetic intensity 阈值）。

这就是为什么 Continuous Batching 能拉 3-10 倍吞吐，它在把利用率从 0.3% 拉向 30%+。

2.6 KV Cache 占用（决定最大 batch）

单 TOKEN 的 KV CACHE 大小

KV per token = 2 × n_layers × n_heads × d_head × bytes

70B 模型（Llama 架构，FP16）：约 320 KB / token

FP8 量化后：约 160 KB / token

速记表

场景	KV per token	总占用
70B FP16, 2K 上下文	320 KB	0.6 GB
70B FP16, 32K 上下文	320 KB	10 GB
70B FP16, 128K 上下文	320 KB	40 GB
70B FP8 KV, 32K	160 KB	5 GB

最大 batch 反推

8 张某型号卡（640 GB 显存）跑 70B FP8：

模型权重：70 GB

剩余给 KV：570 GB

32K 上下文每用户 10 GB，最多 57 个并发用户

如果 KV 也 FP8，5 GB/用户，114 个并发

2.7 吞吐 / 延迟 / 首字延迟

TPOT（Time Per Output Token，每个输出 token 的时间）

TPOT = T搬运 = 23.3 ms （batch=1, 70B FP8）

batch 越大，单用户的 TPOT 不变（搬运时间不变），但总吞吐 = batch × (1/TPOT) 线性增长。

单卡吞吐（tokens/s）

吞吐 = batch ÷ TPOT

70B FP8 在某型号卡单卡：

batch=32 → 32 / 0.0233 = 1373 tokens/s

batch=128 → 128 / 0.0233 = 5494 tokens/s

TTFT（Time To First Token，首字延迟）

TTFT = TPrefill = (prompt 长度 × 2 × 参数量) ÷ 算力

1000 token prompt，70B FP8：

TTFT = (1000 × 1.4×10¹¹) ÷ 2×10¹⁵ = 70 ms

总响应时间

Ttotal = TTFT + TPOT × 输出长度

500 token 输出：70 ms + 23.3 ms × 500 = 11.7 秒

2.8 跨机通信（KV Cache 传输 / 分离式部署）

核心公式

T传输 = 数据量 ÷ 网络带宽

案例：32K 上下文 KV Cache 跨机传输（10 GB）

网络	带宽	传输时间
普通以太网 10 GbE	1.25 GB/s	8000 ms
100 GbE	12.5 GB/s	800 ms
IB HDR 200 Gb	25 GB/s	400 ms
IB NDR 400 Gb	50 GB/s	200 ms
NVLink（同机）	400 GB/s	25 ms

不上 IB，分离式部署的 KV Cache 传输能吃掉 800 ms，用户感知卡顿。

2.9 客户现场速算清单

把这 6 个数字背下来，能现场推所有问题：

数字	含义
3 TB/s	某型号卡 HBM 带宽
2000 TFLOPS	某型号卡 FP8 算力
333	算术强度阈值（batch 甜点）
70 GB	70B FP8 权重
23 ms	70B FP8 单次搬运（= 单 token Decode 下限）
2 × 参数量	每 token FLOPs

现场推导模板

客户问："你们这个模型某型号卡上能跑多快？"

你答："70B FP8 在某型号卡上，Decode 单 token 物理下限是 23 ms（权重 70 GB ÷ 带宽 3 TB/s）。Batch=1 时单卡 43 tokens/s，但那 GPU 利用率只有 0.3%。开 Continuous Batching 到 128，吞吐能拉到 5500 tokens/s，利用率到 40%。再叠 Speculative Decoding 大概 1.5 万 tokens/s 单卡。"

2.10 一张图记住所有逻辑

搬运时间 = 模型大小 / 带宽 ← 物理下限 计算时间 = 2 × 参数量 × tokens / 算力 ← 算力消耗 利用率 = 计算时间 / max(计算, 搬运) ← 浪费率 甜点 batch = 算力 / 带宽 ≈ 333 ← 平衡点

所有加速技术都在动这四个变量里的某一个：

量化 → 缩小"搬运时间"分子

Batching → 把"计算时间"加上去填满搬运

Speculative Decoding → 让"计算时间"那一项一次算多个 token

PagedAttention / Prefix Caching → 让"显存"装得下更大的 batch

分离式部署 → 让 Prefill / Decode 各自跑在自己的 sweet spot 上