概念科普 📅 2026-11-14 ✍️ MagicNetWorld 编辑部

算力翻倍,推理为什么没快一倍:把 prefill 与 decode 放进同一张屋顶线

在 80 GB、3.35 TB/s 的 H100 上,一个 8B 模型的 fp16 权重约 14.9 GiB,单条请求解码(2048 token 上下文)的算术强度只有约 1 FLOP/byte,而这张卡的脊点(峰值算力 ÷ 带宽)约 295 FLOP/byte——差约 300 倍,于是解码的速度上限由带宽而不是算力决定,约 206 token/s 是理想上限。更关键的是,解码的算术强度存在天花板 2P/(S·K):2048 上下文下只有约 60,批开得再大也够不到脊点。全文按官方规格自算(70B/8B 的层数与头数为本文假设),不含真机实测。

推理系统Roofline算术强度显存带宽KV Cache性能模型

假设你把推理服务从一张 A100 换到一张 H100,账单翻了倍,你会期待吞吐也大致翻倍。真实的曲线通常让人失望:批量很小、对话很短时,换卡几乎看不出差别;只有把并发堆上去、把提示词拉长,新卡的优势才显出来。同一张卡、同一个模型,为什么有的负载对算力敏感,有的负载完全不吃这一套?

这篇文章只回答这一个问题,答案是:大模型推理的两个阶段根本不是同一类负载。处理提示词的那一段(prefill)在算浮点运算,生成回答的那一段(decode)在搬字节;这两件事的速度上限由芯片的两个不同指标决定,翻倍其中一个,只能让其中一段变快。

下面的所有数字都建立在两个前提上,先说清楚,免得读者误当产品结论。第一,硬件口径取 NVIDIA H100 官方产品页公布的密集 FP16 张量算力 989 TFLOP/s 与 HBM3 带宽 3.35 TB/s(本轮 2026-11-14 读取),两者都是理论峰值。第二,模型结构与上下文长度是本文的假设值(层数、KV 头数、head_dim 见符号表),用来把公式算成具体数字,不代表任何具体产品。全文不含真机压测。

先用一个生活化的类比把直觉建立起来。把显卡想成厨房:算力是灶眼的火力(每秒能完成多少次浮点运算),显存带宽是冰箱到灶台的传送带(每秒能搬多少字节),模型权重和一串串中间结果是食材。火力再猛,如果每做一小碟菜都要重新去冰箱把整柜食材搬一遍,你真正卡住的是传送带,不是火。解码阶段就是这种「每出一小碟就搬整柜」的活。

这个类比还解释了一个容易被忽略的细节:加大批处理,相当于让几个客人共用同一次搬运——火力没变、传送带没变,但每搬一次食材做出了更多的菜。代价是每次要搬的食材也变多了(每个客人自带一份缓存),所以批越大,单条请求反而会慢一点。

这一节想让你记住的一件事:换卡没变快,往往不是卡不行,而是你测的那段负载本来就不在算力侧。

先把「推理」拆成两段

一段请求的生命周期可以粗分成两段。第一段叫 prefill(预填充,也叫提示词处理):用户输入的几百上千个 token 一次性送进模型,每个 token 都要乘以全部权重矩阵,一次性算出所有位置的中间结果,并把每层的 Key/Value 存进 KV 缓存。这一段是典型的矩阵乘矩阵,形状很胖,GPU 特别擅长。

这里出现的第一个术语要顺手定义清楚:KV 缓存是模型在处理每个 token 时,为每一层留下的 Key 与 Value 向量,后续生成新 token 时要拿它跟历史做注意力计算,所以必须一直存在显存里。它的大小与「已经处理过多少 token」成正比,这是后面所有容量账本的起点。

第二段叫 decode(解码):模型每次只新增一个 token。为了生成这一个 token,它要把全部权重读一遍,再把这条请求历史上所有 token 的 KV 缓存读一遍,算出下一个 token 的概率分布,采样,然后重复。形状很瘦:一个 token 的向量乘一个大矩阵,属于矩阵乘向量。

两段的差别不在「模型」,而在「一次计算里,参与了多大的数据复用」。prefill 里同一份权重会被几千个 token 同时用到,读一次权重能做几千份工作;decode 里同一份权重只服务当前批里的这几条请求,读一次权重只能做一份工作。这个「读一次能做多少工作」的比例,就是本文唯一的主角。

同一张卡上 prefill 与 decode 两段负载的结构差异:前者一次读权重复用多次,后者每一步都要重读全部权重与 KV 缓存
图 1 两段负载,两个瓶颈:长提示词的 prefill 落在算力侧,低批量解码落在带宽侧(本文自绘)

图里想说明的一件事是:上下两条流水线的形状几乎一样(都是「读数据→算→出新东西」),但右侧的判定完全不同——上面那行每一步能复用几千个 token,下面那行每一步只前进一格,还要把历史缓存再读一遍。

顺带说明范围:下面所有推导针对 decoder-only 的稠密模型、标准自回归解码、单机单卡(张量并行的情况在边界一节单列)。MoE、投机解码、稀疏注意力、跨机集群会让账本变复杂,同样在最后一节说明它们的偏离方式。

这一节想让你记住的一件事:prefill 是「一次读、多次用」,decode 是「一次读、一次用」。

符号约定:整篇文章只用几个字母

为了避免后面反复解释,先把符号固定下来。单位一律按量级写法:TFLOP/s 表示每秒万亿次浮点运算,TB/s 表示每秒万亿字节(十进制,1 TB = 10¹² 字节);而显存容量与权重体积按二进制单位写,GiB = 2³⁰ 字节、MiB = 2²⁰ 字节。这两种单位混用是性能文章里最常见的坑,本文会一直标明。

符号含义单位本文取值来源
PP模型参数量个本文假设 70×10⁹ 或 8×10⁹
bb每个权重占的字节数bytefp16 取 2,int8 取 1
π\pi芯片峰值浮点算力FLOP/sH100 官方页 989×10¹²(密集 FP16)
β\beta显存带宽byte/sH100 官方页 3.35×10¹²(HBM3)
SS上下文里的 token 数个本文取 2048,另列 512/8192/32768
BB同时处理的请求数(批大小)条由显存与调度决定
II算术强度FLOP/byte由负载结构算出,不来自硬件
L, dh, nkvL,\ d_h,\ n_{kv}层数、每头维度、KV 头数—70B 假设 80/128/8,8B 假设 32/128/8

需要强调一件事:π\pi 与 β\beta 是硬件的理论上限,II 是负载的结构属性。前者你只能换卡,后者你可以通过批处理、精度、缓存策略去改。性能工程的全部余地,就在这三个量之间的比例上。

关于 bb:本文让权重与 KV 共用同一个字节数,也就是两者取同一精度档;表里标「int8」的配置指权重与 KV 同时为 int8,只量化其中一项的配置不在本文表格里。这么做是为了让公式只有四个字母,代价是读表时要记得「int8 行同时代表两处收益」。另外,本文把标称 80 GB 的显卡按「80 GiB 可用容量」估算——这是把十进制标称值近似成二进制容量,真实可用容量还要再打折扣(激活、碎片、框架开销),所以任何并发数字都是上限中的上限。

还有两个口径要提前分开,否则后面一定会读混。第一是「容量」与「带宽」不是一回事:显存容量决定你能装下多大的模型、放多少条并发,带宽决定你每秒钟能读多少字节。A100 80GB 的容量不小,但它的带宽只有「超过 2 TB/s」的量级(官方产品页原文口径),明显低于 H100 的 3.35 TB/s——这就是为什么同样放得下模型,解码速度差一截。第二是「理论峰值」与「实测」不是一回事:峰值是 datasheet 数字,真实 kernel 达不到,本文据此算出的速度都是上限。

单位还有一个容易踩的点:π\pi 是「每秒多少次浮点运算」,而模型的计算量习惯按「参数量 × 2」估算,因为一次乘加算两次浮点运算。后面凡是出现 2 倍的系数,都是在把「参数个数」换算成「浮点运算次数」,不是在把权重读两遍。

这一节想让你记住的一件事:只有 II 是你能改的,π\pi 和 β\beta 是买来的。

屋顶线:把两个上限缝成一条线

一段代码在芯片上跑多快,取决于两个上限里更紧的那个。它每秒最多能做 π\pi 次浮点运算,也每秒最多能搬 β\beta 个字节;而这段代码每搬一个字节,需要做 II 次浮点运算。于是能跑出的浮点运算速度是:

Pachieved≤min⁡(π, β⋅I)P_{\text{achieved}} \le \min\left(\pi,\ \beta \cdot I\right)

这就是屋顶线(roofline)模型的核心不等式。它把「算」和「搬」两个上限画在同一张图上:横轴是算术强度,纵轴是可达到的算力。低强度区间是一条斜率为 β\beta 的斜线——你搬多少字节就只能做多少活;高强度区间是一条水平线——搬来的数据够用了,卡在算力上。

两段的分界点叫脊点(ridge point),它的算术强度是:

I∗=πβI^{*} = \frac{\pi}{\beta}

代入 H100 的官方密集 FP16 算力与 HBM3 带宽:

I∗=989×10123.35×1012≈295 FLOP/byteI^{*} = \frac{989 \times 10^{12}}{3.35 \times 10^{12}} \approx 295\ \text{FLOP/byte}

含义很直白:在这张卡上,凡是「每搬一个字节做不到 295 次浮点运算」的负载,都是带宽受限的;做到了,才是算力受限的。注意这个数不是「越大越好」的分数,它只是硬件的一种配比——带宽充裕的卡脊点低,算力堆得猛的卡脊点高。

换个角度理解:脊点其实在告诉你「这块卡期望你每次搬运都干多少活」。它期望 295 次浮点运算,而解码只给了它一次左右——这不是显卡设计错了,是显卡为训练和 prefill 那类负载设计的,解码只是顺带跑在上面。

还要说明一个口径问题:PachievedP_{\text{achieved}} 里的 π\pi 是理论峰值,真实 kernel 拿不到。Google Research 团队在 arXiv:2211.05102(Efficiently Scaling Transformer Inference,2022 年 11 月首次提交)里报告,他们在 TPU v4 上做大 batch 的输入处理时达到 76% 的 MFU(model FLOPs utilization,即实际算力占峰值的比例)。这说明 76% 已经是这类负载很强的工程结果,而不是「没优化好」。

还有一层:数字格式一变,π\pi 的口径也会变。本文为了统一,所有配置都沿用同一个密集 FP16 峰值来估算——对 int8 权重来说这是保守口径(低精度张量核心的峰值通常更高),所以算出的时间偏长、结论方向不受影响。

这一节想让你记住的一件事:判断快慢之前先算一个除法——II 比脊点大还是小。

prefill:为什么它几乎总是算力受限

prefill 的计算量主要由权重矩阵乘贡献。PP 个参数、SS 个 token,每个参数对每个 token 贡献一次乘加,也就是约 2 次浮点运算:

Cprefill≈2⋅P⋅SC_{\text{prefill}} \approx 2 \cdot P \cdot S

搬运量的主要成分是权重(读一次即可被 SS 个 token 共用),再加上随 token 数增长的激活值:

Qprefill≈P⋅b+2⋅S⋅b⋅dmodelQ_{\text{prefill}} \approx P \cdot b + 2 \cdot S \cdot b \cdot d_{\text{model}}

这里有两点必须写在前面,否则后面的账会对不上。第一,P⋅bP \cdot b 是「把权重读一遍」的字节数,一个参数只占 bb 个字节,所以是 PP 乘 bb,不是乘 2——2 只出现在运算次数的式子里。第二,这个式子默认注意力按分块、片上复用的方式实现;若按朴素实现(每个 query 重读全部 K/V),搬运账本要另算,本节末尾会单列。

两者相除,得到 prefill 的算术强度:

Iprefill≈2PSPb+2Sbdmodel≈2Sb  (当激活项远小于权重时)I_{\text{prefill}} \approx \frac{2PS}{Pb + 2Sbd_{\text{model}}} \approx \frac{2S}{b}\ \ \text{(当激活项远小于权重时)}

这个近似式子很值得盯着看:prefill 的算术强度基本只跟「一次处理多少 token」和「权重占几个字节」有关,跟模型有多大几乎无关。这也解释了为什么「长提示词」对 GPU 友好:SS 每翻一倍,算术强度翻一倍,离脊点更远。

代入数:70B、fp16、S=2048S=2048,计算量约 2.87×10142.87\times10^{14} 次浮点运算,按 989 TFLOP/s 的理论峰值算约 290 毫秒;搬运量约 1.4×10111.4\times10^{11} 字节(130 GiB 权重 + 少量激活),算术强度约 2048 FLOP/byte,是脊点 295 的约 7 倍——稳稳落在屋顶线的水平段。换成 8B 模型,计算量降到约 3.3×10133.3\times10^{13},理论耗时约 33 毫秒,算术强度约 2044,几乎一样。

这里要拆掉一个常见的误解:注意力是 O(S2)O(S^{2}),所以长上下文一定是注意力最贵。在算力账本上这件事对 70B 模型并不成立。以 70B、输入 2048 token 计,注意力的浮点运算约为 4LS2dh≈1.7×10114LS^{2}d_h \approx 1.7\times10^{11},相比权重项的 2.87×10142.87\times10^{14} 只占约 0.1%。原因很朴素:注意力每个 token 的开销跟层数与头维度成正比,而权重项跟参数量成正比,后者大三个数量级。

O(S2)O(S^{2}) 真正咬人的地方在搬运账本。如果按最朴素的方式实现注意力——每个 query 都把该层全部 K/V 从显存重新读一遍——那么一层要读 S2S^{2} 份 KV 向量,全部读一遍的字节数是:

Qattnnaive≈L⋅S2⋅2⋅nkv⋅dh⋅bQ_{\text{attn}}^{\text{naive}} \approx L \cdot S^{2} \cdot 2 \cdot n_{kv} \cdot d_h \cdot b

按本文假设(L=80L=80、S=2048S=2048、nkv=8n_{kv}=8、dh=128d_h=128、fp16),这条式子给出约 1.4×10121.4\times10^{12} 字节,也就是 1.4 TB。注意这是「整段提示词、所有层累计的重复读取量」,不是缓存容量——同一批 K/V 被反复读了 SS 遍。作为对照,把全部权重读一遍只要 130 GiB,两者相差十倍以上。

换句话说:注意力在算力上可以忽略,在带宽上却可能成为主要项,这才是 FlashAttention 这类「IO 感知」算法存在的理由。它做的不是少算,是少读。

于是 prefill 的优化空间也清楚了:分子(必须做的浮点运算)几乎动不了,分母(搬运)是战场。分块复用、把中间结果留在片上、减少 HBM 往返,这些动作不会减少一次矩阵乘的浮点运算,但会让同一批字节服务更多次计算。

这一节想让你记住的一件事:prefill 的分子(算力)你很难省,它的分母(搬运)才是算法优化的战场。

decode:为什么它天然是带宽受限

decode 一上来就把账本翻了过来。生成一个 token 时,PP 个权重都要参与运算,但只服务这一条(或这一批)请求。批大小为 BB 条请求时,一次解码步的计算量是:

Cdecode(B)≈2⋅P⋅BC_{\text{decode}}(B) \approx 2 \cdot P \cdot B

搬运量是「读一遍权重」加上「这一批请求的全部历史 KV」。这里要分清三个颗粒度:单个 token 的 KV 字节数、一条请求完整上下文的 KV 字节数、整批一次要读的 KV 字节数。三者分别是 2Lnkvdhb2L n_{kv} d_h b、SS 倍的那个数、再乘 BB:

Qdecode(B)≈P⋅b+B⋅S⋅2L nkvdhbQ_{\text{decode}}(B) \approx P \cdot b + B \cdot S \cdot 2L\,n_{kv}d_hb

相除,得到解码阶段的算术强度:

Idecode(B)=2PBPb+B S 2Lnkvdhb=2Bb(1+B S L nkv dhP)I_{\text{decode}}(B) = \frac{2PB}{Pb + B\,S\,2L n_{kv} d_h b} = \frac{2B}{b\left(1 + \dfrac{B\,S\,L\,n_{kv}\,d_h}{P}\right)}

这个式子的第一个结论很扎心:B=1B=1 时,Idecode≈2/bI_{\text{decode}} \approx 2/b,fp16 下就是约 1.0 FLOP/byte。与脊点 295 相比,差约 300 倍。也就是说,单条请求的解码在一张为算力设计的卡上,把 99.7% 的算力闲置着,同时把显存带宽用满——不是工程师不会优化,是负载结构决定的。

由此可以直接算出单流解码的速度上限:

Tdecode(B=1)≈βPb+S 2LnkvdhbT_{\text{decode}}(B{=}1) \approx \frac{\beta}{Pb + S\,2L n_{kv} d_h b}

代入 3.35 TB/s、8B、fp16、2048 上下文:约 206 token/s,换算成延迟是每 token 约 4.9 毫秒。换成 70B:权重 130 GiB 一笔就压满带宽,单流约 24 token/s,每 token 约 42 毫秒。

解码一步的字节账本:70B fp16 权重约 130 GiB 加上 2048 上下文里单条请求的 KV,除以 3.35 TB/s 得到约 42 毫秒每步
图 2 解码一步的字节账本:整模型重读一次,除以带宽就是单步耗时的下限(本文自绘)

图里想说明的一件事是:解码的速度上限不是由「算得多快」写死的,而是由「每步要搬多少字节 ÷ 每秒能搬多少」写死的。这条除法里能做文章的是分子——权重精度、KV 大小、上下文长度。

这个数量级与 arXiv:2211.05102 报告的低 batch 延迟方向一致:他们在 PaLM 540B 上用 int8 权重做到每 token 29 毫秒(约 34 token/s),环境是 TPU v4。跨硬件不能直接搬数字,只能搬方法:把权重的字节数砍半,单流速度大致翻倍。

再看批大小的作用。BB 变大时分子线性长,分母也在长(KV 项随 BB 增加),所以算术强度上升但会趋缓;单条请求的速度则因为要读更多 KV 而下降。这意味着「批处理提吞吐、不提速度」这句话要说得更准确:它提吞吐,同时让每条请求略微变慢。

于是整条链路的吞吐是:

Ttotal(B)=B⋅βPb+B S 2LnkvdhbT_{\text{total}}(B) = \frac{B \cdot \beta}{P b + B\,S\,2L n_{kv} d_h b}

按 8B、fp16、2048 上下文代入:B=1B=1 时约 206 token/s,B=8B=8 时约 1477 token/s,B=64B=64 时约 6462 token/s,B=260B=260 时约 10,152 token/s;而单条请求的速度从 206 一路降到 39 token/s。吞吐涨了约 49 倍,单条慢了约 5 倍——两者是同一条曲线的两端。

这一节想让你记住的一件事:解码的每一小步都要把整个模型读一遍,所以它的天花板由带宽决定,由并发数决定的是你能把这个天花板用起来多少。

算术强度天花板:为什么上下文越长越够不到脊点

上面的式子里藏着一个反直觉的结论:解码的算术强度不是「批开大就能一直涨」,它有上限。把 BB 推向无穷,KV 项主导分母,于是:

Idecodemax⁡=lim⁡B→∞Idecode(B)=2PS⋅2LnkvdhbI_{\text{decode}}^{\max} = \lim_{B\to\infty} I_{\text{decode}}(B) = \frac{2P}{S \cdot 2L n_{kv} d_h b}

这个上限只跟「参数量」与「一条请求的 KV 字节数」有关,与批大小、带宽、卡数都无关。它的物理含义很直白:批再大,每条请求仍要带一份自己的历史 KV,KV 流量按请求数线性长,而权重只读一次——所以复用率终会被 KV 稀释干净。

代入 70B、fp16:2048 上下文时上限约 209 FLOP/byte,只有脊点 295 的七成;8192 上下文时降到约 52;32768 时只剩约 13。也就是说,在 H100 上,70B 模型只要上下文超过约 1450 token,解码就再也没有机会进入算力受限区——不管你把并发开到多少。

这条结论有很强的实践含义。第一,它解释了为什么「加并发」的收益会迅速衰减:从 1 条加到 64 条,算术强度从 1 涨到 49,看似涨了 49 倍;再加到 256 条只涨到 116,而 KV 占用已经从 0.6 GiB 涨到 162 GiB,早就装不下了。

第二,它给出了「长上下文为什么贵」的定量版本:上下文翻倍,KV 每 token 的成本不变,但每条请求的 KV 翻倍、算术强度天花板减半。这不是线性变贵,而是对吞吐的惩罚按比例叠加在并发上限与单步耗时两处。

第三,它顺手解释了为什么低比特 KV 量化比低比特权重量化在长上下文场景里更值钱:把 KV 的字节数减半,天花板与并发容量同时翻倍,而权重量化只改分母里的第一项。

第四,它给出了一个反向判据:想让解码真的吃上算力,唯一的办法是提高 2P/(SK)2P/(SK)——也就是用更大的模型(提高 PP,但权重变大又受容量限制)、更短的上下文(减小 SS)、更省字节的 KV(量化或减少 KV 头)。MoE 的「激活参数少」本质上也是同一个方向。

还有一个细节值得说:这个天花板是「稳态」结论。刚开请求时 KV 很短,算术强度确实接近 2/b2/b 甚至更高;随着上下文变长,它一步步滑向天花板。所以同一个服务在对话开头和对话末尾的瓶颈分布是不一样的——这也是为什么有些系统在长对话后半段会明显变慢。

这一节想让你记住的一件事:解码的算术强度有天花板,而天花板与上下文长度成反比。

一次请求的时间去哪了:TTFT 与 TPOT

把两段拼回一个真实请求,就得到服务侧最重要的两个延迟指标。第一个是首字延迟(TTFT,time to first token):从请求发出到这个请求的第一个 token 生成出来,这段时间基本由排队加 prefill 决定。第二个是每 token 输出时间(TPOT,time per output token):首字之后每多出一个字要多久,由 decode 决定。

TTFT≈tqueue+Cprefillπ⋅MFU\text{TTFT} \approx t_{\text{queue}} + \frac{C_{\text{prefill}}}{\pi \cdot \text{MFU}} TPOT≈Qdecode(B)β\text{TPOT} \approx \frac{Q_{\text{decode}}(B)}{\beta}

两个式子的分母是同一张卡的两个不同指标,这就是为什么「首字慢」和「后续慢」需要两套完全不同的处置。首字慢,说明 prefill 的算力不够或者排队太长——换更强算力、缩短提示词、做前缀缓存都能帮上忙。后续慢,说明每步搬的字节太多或者带宽不够——降精度、减 KV、提高带宽才有用;在这条路径上加算力,一分钱都花不到点子上。

举一个能对上的例子(本文自算,非实测):70B、fp16、2048 token 提示词,prefill 理论约 290 毫秒,按 50% 的实际效率估约 580 毫秒;随后每 token 约 42 毫秒,回答 200 个 token 约 8.4 秒。在这个算例里,生成段占整段请求约 94%,prefill 约占 6%。如果你看到一份评测只报「处理 2048 token 用了多少毫秒」,它测的是那 6%,不是用户的体感。

这个拆分还有一个实践上的用处:当用户抱怨「慢」时,先问是首字慢还是打字慢。首字慢要查排队与 prefill,打字慢要查解码并发与 KV 大小。一个笼统的「P99 延迟高」既不告诉你方向,也不告诉你该不该加卡。

这一节想让你记住的一件事:TTFT 看算力与排队,TPOT 看带宽与字节,两个指标不能用一个旋钮去调。

对照表:同一张卡,两个世界(典型情形:长提示词 + 低批量解码)

把两段放在一起对比,很多工程直觉会立刻变得可疑。下表是「长提示词 + 低批量解码」这一典型情形下的对照,不是无条件成立的二分法(后文会说 decode 在极短上下文、极大批量下也能逼近算力侧)。

维度prefill(提示词处理)decode(逐 token 生成)
主导约束(典型情形)算力(π\pi)显存带宽(β\beta)
本文假设下的算术强度约 2048 FLOP/byte(S=2048)约 1.0 FLOP/byte(B=1,S=2048)
与脊点 295 的关系高约 7 倍,算力侧低约 300 倍,带宽侧
主要搬运内容权重(读一次,被 S 个 token 共用)权重 + 全部历史 KV
随什么线性增长token 数 SS请求数 BB(吞吐),同时让每条变慢
对应服务指标TTFTTPOT
有效加速手段更强算力、更好 kernel、低精度矩阵乘更高带宽、更低精度权重、更省字节的 KV
无效的加速手段加大 batch(已饱和)增加算力(用不上)、只减 FLOPs(不是瓶颈)
典型「伪优化」用 attention 的 O(S2)O(S^{2}) 解释一切用 MFU 评价解码效率

最后一行值得单独说。MFU 是「实际算力占峰值的比例」,它天生就是为算力受限负载设计的指标。拿它去评价解码,会得到一个注定很低的数字:本文假设下单流解码的算术强度只有脊点的 0.3%,于是任何正常工作的解码服务都会被判成「效率极低」。这不是系统有问题,是尺子拿错了。解码该看的是带宽利用率,或每 token 的实际显存流量。

同理,把两张卡的 MFU 放在一起比较也没有意义:MFU 的分母是各自的峰值算力,两张卡跑同一个带宽受限负载时,算力越高的那张 MFU 越低——你会得出「更强的卡效率更差」这种荒谬结论。

这一节想让你记住的一件事:同一个服务里,prefill 与 decode 要用两把不同的尺子量。

三个旋钮:批、精度、上下文

既然解码卡在带宽上,能动的就只有三个旋钮,而且每个旋钮的作用点不同。

第一个是批大小 BB。它只对解码的吞吐有实质意义,因为它改善的是「一次读权重服务多少条请求」这个复用比例。但它的上限由显存决定:每条请求的 KV 随上下文线性增长,上下文越长,能并发的条数越少。这就是「吞吐」与「内存」之间的直接交换,不是调度技巧能绕过去的。

第二个是精度。这里必须把两件事分开:权重精度与 KV 精度。权重从 fp16 到 int8,每步要读的第一个项减半,单流速度大致翻倍;KV 从 fp16 到 int8,每条请求的缓存减半,可容纳并发翻倍、算术强度天花板翻倍。两者的收益路径不同,不能用一个「int8」标签混着说。

第三个是上下文长度 SS。它主要影响两件事:prefill 的计算量近似线性增长(2PS2PS),以及每条请求的 KV 线性增长。于是在解码侧,在「并发上限由 KV 容量决定、其他条件不变」的前提下,上下文翻倍等于每请求缓存翻倍、并发上限减半、算术强度天花板减半——三重惩罚叠加,这就是长上下文「贵」的定量原因。

三个旋钮的联合作用是:BB 受显存限制,显存被 SS 与 KV 精度共同决定,而 BB 又决定你能把吞吐推到多远。所以「为什么我的服务上不去」这个问题,通常不是单一原因,而是「上下文 × 并发 × 精度」这个三元组互相挤压的结果。

值得单独提一句的是第四个「隐形旋钮」——调度策略。continuous batching 让新请求不必等当前批跑完就能插进来,它不改变任何一条公式,只是把 BB 实际维持在一个更高的水平上;前缀缓存(prefix caching)让相同前缀的请求共享 prefill 成果,减少的是重算而不是搬运。两者都属于「在不改公式的前提下把参数拉满」。

这一节想让你记住的一件事:解码吞吐 ≈ 带宽 ÷ 每步要搬的字节,三个旋钮都在改这个分母。

五步估算:拿到一个新服务怎么算瓶颈

上面所有推导可以压成一个五分钟能做完的流程。以下五步只用纸笔和厂商规格页。

第一步,算每 token 的 KV 字节数:2⋅L⋅nkv⋅dh⋅b2 \cdot L \cdot n_{kv} \cdot d_h \cdot b。以 70B、80 层、8 个 KV 头、head_dim 128、fp16 为例,得到 327,680 字节,也就是单个历史 token 占约 0.31 MiB。

第二步,算权重字节数。P⋅bP \cdot b 是「把权重读一遍」的字节数:70B、fp16 约 130 GiB,int8 约 65 GiB。这里不要乘 2——2 只属于运算次数的换算。

第三步,算带宽上限:把「权重 + 这一批请求的 KV」除以 β\beta,就得到该批大小下单步的理论耗时。批越大,KV 项越大,单步越慢——这个「变慢」就是批处理真正的代价。

第四步,算脊点并判断:I∗=π/βI^{*} = \pi/\beta。你的负载 II 比它小,就别再想着换更强的卡;比它大,才值得为算力付钱。别忘了同时算一下天花板 2P/(SK)2P/(SK):如果天花板本身就低于脊点,那换成什么卡都不可能让这段解码变成算力受限。

第五步,算显存能撑多少并发:把可用显存(总容量减去权重、激活与框架开销)除以「每条请求的 KV」,就是并发上限。这个上限与第四步需要的并发一比,就知道自己的服务是「被带宽卡住」还是「被显存卡住」——两者的处置完全不同:前者要减字节,后者要减上下文或者换 KV 精度。

这个流程不能替代压测,但它能在你打开监控面板之前就告诉你「该看哪个指标」。很多性能排查之所以耗时间,是因为一开始就在错的维度上找原因。

这一节想让你记住的一件事:先算术,再看监控;算完就知道该盯带宽还是盯算力。

一张并发扫描表:数字之间怎么互相牵引

把上面四个式子按 8B、fp16、2048 上下文跑一遍,就得到一张可以直接对表的扫描表。读法是:每一行是一个批大小,第二列是单条请求的速度,第三列是整机总吞吐,第四列是算术强度,最后一列是这个批大小下 KV 缓存占用的显存。

批大小 BB每条请求速度(token/s)整机总吞吐(token/s)算术强度(FLOP/byte)KV 占用(GiB)
12062061.00.2
818514777.12.0
32136436020.88.0
64101646230.916.0
12867851540.732.0
260391015248.565.0

三件事从表里一眼可见。第一,整机吞吐一路涨:从 206 到 10,152,涨了约 49 倍——这就是「吞吐」在工程上的含义。第二,每条请求的速度一路降:从 206 降到 39,说明批处理不是白拿的,它拿吞吐换单条速度。第三,算术强度只爬到 48.5,离脊点 295 还差六倍,而且已经越来越平——它正在逼近前面算过的天花板 59.6。

这张表还藏着一个部署层面的提醒:最后一行的 KV 占用 65.0 GiB,加上权重 14.9 GiB 约 80 GiB,正好把整张卡(按 80 GiB 可用容量计)吃满。也就是说 260 条并发是「扣除权重后、纯 KV 预算」下的理论上限,真实系统还要留给激活、碎片与框架,实际能开到的并发会明显低于这个数。

想再往上推吞吐,就只剩三条路:换更大显存的卡(把 BB 上限抬高)、压 KV 精度(把每请求缓存减半,等于上限翻倍)、缩短上下文(同上)。三条路都在改同一个分母,而不是改算力。

这一节想让你记住的一件事:吞吐与显存是同一条曲线的两端,别指望只抬一头。

算例:70B 与 8B,差在哪里

同样的方法换一个模型,可以看清「模型大小」在这张图上的作用。下表四种配置都按 2048 上下文、H100 规格、本文假设的层数与头数计算。

配置权重(读一遍)单流速度上限单卡可容纳并发算术强度天花板
70B fp16130.4 GiB约 24 token/s装不下权重约 209
70B int865.2 GiB约 48 token/s约 47 条约 417
8B fp1614.9 GiB约 206 token/s约 260 条约 60
8B int87.5 GiB约 412 token/s约 580 条约 119

这张表最值得读的是最后一列。70B 的两行天花板都在 200 以上,说明它在更短的上下文(比如 512 token)下是有机会进入算力侧的;而 8B 的两行天花板只有 60 与 119,即便把并发开满也摸不到 295。原因不在精度,在于 2P/(SK)2P/(SK) 里的 PP 太小——参数量少,能摊到每个字节上的运算就少。

第二值得读的是「单卡可容纳并发」这一列与「单流速度」的组合。70B int8 单卡能开 47 条,吞吐约 1328 + 369 ≈ 看起来还行,但天花板 417 意味着它离脊点还有距离;8B int8 能开 580 条,天花板 119,同样到不了脊点。于是所有配置的共同结论是:在 2048 上下文下,解码基本都在带宽侧,区别只是差距大还是小。

这解释了一件常被误解的事:小模型在解码侧的优势不只是「算得少」,更是「权重小、能装下更多并发」。但小模型的算术强度天花板也低,所以它不可能靠加并发翻身变成算力受限——它只是把同一段带宽用得更满。

反过来说,如果你的场景是长文档理解(prefill 为主),大模型的算术强度本来就在算力侧,换小模型的收益就只剩「算得少」这一条,量级完全不同。这也解释了为什么「同一个模型换小一号」在不同业务里的收益差好几倍。

还要提醒一句:表里的「单卡可容纳并发」统一按「扣除权重后的 KV 预算 ÷ 每条请求的 KV」计算,不含激活、碎片与框架开销,属于上限中的上限;表里 int8 行指权重与 KV 同为 int8(本文让两者共用同一个字节数 b)。70B fp16 那一行写「装不下权重」就是因为 130.4 GiB 超过 80 GiB 可用容量,必须多卡并引入卡间通信,那已经是另一个账本了。

这一节想让你记住的一件事:模型大小改的是分子,卡的数量与显存改的是分母,两者的收益不能互相替代。

五个常见误判

第一个:把 prefill 的 benchmark 当服务延迟。很多「XX 卡推理快 3 倍」的宣传测的是长提示词处理,那是算力侧的成绩;真实对话里生成段占了大头(前面的算例里是 94%),属于带宽侧。换卡前先问一句:这份 benchmark 的输入长度与输出长度是多少。

第二个:把 MFU 当健康指标。前面说过,解码的 MFU 天生极低。一个正常工作的解码服务 MFU 只有百分之零点几到几,看到这类数字就报警,等于把物理规律当成故障。

第三个:以为「批处理不提速」就等于「批处理对单条没影响」。实际上批会小幅拖慢每条请求(要读更多 KV),只是幅度远小于吞吐的涨幅。反过来说,以为批越大延迟越高也不对:真正的延迟恶化通常发生在显存抖动(KV 换入换出)或接近算力侧的时候。

第四个:以为张量并行能直接降低单流延迟。张量并行确实会把权重切到多张卡,聚合带宽随之增加,读权重的理论时间按卡数减少;但每一层都要做 all-reduce,跨卡通信的带宽远低于 HBM,实际收益常常被通信吃掉大半。它换来的是「装得下」和「更大的总带宽池」,不是线性的延迟下降。

第五个,属于口径错误:把「显存容量大」当成「推理快」。容量决定你能放什么,带宽决定你读多快,两者是不同的物理量,只是常常一起出现在同一张卡的规格表上。

这一节想让你记住的一件事:先分清你看到的是算力侧成绩还是带宽侧成绩,再谈快慢。

三个看起来无关的技术,其实是同一件事

FlashAttention、PagedAttention、KV 量化,分别属于算法、系统、数值三个圈子,但在屋顶线的语言里它们是同一个动作:把搬运字节压下去,或者让同一批字节被复用更多次。

FlashAttention 做的是前者中最漂亮的一种:把注意力计算分块,让 K/V 分块在片上 SRAM 里被反复使用,而不是每算一个 query 就去 HBM 重新读一遍。arXiv:2205.14135 的摘要把这件事讲得很清楚——他们主张的关键原则是「让注意力算法感知 IO,把 HBM 与片上 SRAM 之间的读写次数降下来」,并给出 BERT-large 上 15%、GPT-2(1K 序列)3 倍、长程竞技场(1K–4K)2.4 倍的端到端加速。它算的浮点运算一点没少(那是精确注意力,不是近似),省下来的全是搬运。

PagedAttention 做的是「让同一批字节服务更多请求」:KV 缓存按页管理,消除了碎片与重复,于是同样的显存能装下更大的批。arXiv:2309.06180 报告 vLLM 在同等延迟下把吞吐提升 2–4 倍,且长序列、大模型、复杂解码算法下收益更明显。翻译成屋顶线的语言:它没有改变算术强度的公式,它改变的是批大小的上限。

KV 量化则是直接把 KV 的字节数砍掉:每条请求占的显存少了,能并发的条数多了;同时每个解码步要搬的字节也少了,算术强度天花板还翻倍。它同时作用在「容量」「带宽」与「天花板」三处,所以收益往往比直觉更大。

三者的共同点可以写成一句话:在带宽受限区间里,任何减少搬运或提高复用的改动,都会直接换成吞吐;任何只减少浮点运算的改动,几乎什么都换不到。这条判据能帮你快速否掉一批「看起来很聪明」的优化——比如在解码路径上做算子融合以减少浮点运算,如果融合没有减少显存往返,收益会接近于零。

顺带解释一个常被问的问题:为什么这些系统优化常常带着「2 到 4 倍」这样的漂亮数字,而不是十倍?因为它们的上限就是「把带宽用满」。带宽已经用满的系统,再优化也只能从「每字节做多少活」上要,那就是精度与上下文的事,不是调度器的事。

这一节想让你记住的一件事:优化的方向不是「算得更少」,是「搬得更少、或者搬一次用得更久」。

工程含义:什么时候加卡真的没用

把上面的推导收成几条可操作的判断,每条都带上它的适用条件。

第一种情况:单条请求、短对话、低并发。这时候负载在带宽侧的最左端,加卡对吞吐没有帮助(没有并发可提),对延迟的帮助被跨卡通信抵消大半——只有当权重被切开后每卡读数显著变少、且通信开销可控时,单流才会变快。想快更可靠的路是换带宽更高的内存、或者降低权重精度。

第二种情况:高并发在线服务。这时候加卡有意义,但收益来自「更多显存 → 更大批 → 更高吞吐」,而不是「更多算力」。判断标准是:你的批大小是否已经接近显存允许的上限。如果已经接近,再加卡就是把同一个上限按比例放大,吞吐大致线性上涨。

第三种情况:长提示词、批处理任务(比如离线摘要、文档问答)。这时候 prefill 占比高,负载在算力侧,加卡、换更强算力、用更好的矩阵乘 kernel 都能直接换成时间。这也是为什么「同一个模型,离线批处理的账单和在线对话的账单完全不是一回事」。

一个能立刻用起来的判据是三步:先算这段负载的 II,再算这张卡的脊点 I∗=π/βI^{*} = \pi/\beta,最后看 II 落在哪一侧。落在带宽侧,就去减字节;落在算力侧,才去换更强的卡。这比笼统地说「GPU 利用率低」有用得多,因为利用率低本身从来不告诉你该做什么。

有一个反直觉的推论值得单独记住:在带宽受限的区间里,一个更省浮点运算的算法可能一点都不快。近似注意力、稀疏化、剪枝,如果它们减少的是运算而没有减少显存往返,端到端速度可能毫无变化,甚至因为额外开销变慢。arXiv:2205.14135 在摘要里点破了这件事:很多近似注意力方法为降低计算复杂度牺牲了模型质量,却常常拿不到实际的墙钟加速——他们给出的解释正是「缺少 IO 感知这个原则」。

这一节想让你记住的一件事:加卡之前先算 II 与 I∗I^{*},否则你买到的是用不上的算力。

怎么把这件事讲给不做系统的同事听

如果你要在一个非技术会议里解释「为什么换卡没变快」,可以只用三句话。

第一句:模型回答问题分两个动作——先把你说的整段话读一遍(这一步很吃算力),再一个字一个字往外写(这一步要反复把整个模型从显存里搬出来看)。

第二句:写字的阶段,每写一个字都要把模型搬一遍,所以它的速度上限是「显存每秒能搬多少」,不是「显卡每秒能算多少」;换一张算得更快的卡,不会让「搬」变快。

第三句:想让整体服务更省钱,可以让它同时处理更多条请求(提总吞吐);但想让某一条回答更快,只能靠把模型压小、缩短上下文、或换显存更快的内存——多开并发不能让单条变快。

这三句话没有任何公式,但它对应的正是本文的三个式子。讲完之后补一句范围:这是理论上限,实际能到多少要压测。

这一节想让你记住的一件事:能不能用三句话讲清、且不把「吞吐」和「速度」说混,是检验自己有没有真懂的标准。

读别人的性能数字时,先问五个问题

这一节是防御性的。你在论文、博客、厂商宣传里看到的任何一个「快 N 倍」,都可以用五个问题快速判断它跟你有没有关系。

问题一:这个数字是 prefill 还是 decode?输入多长、输出多长?如果只报了处理长输入的耗时,那它测的是算力侧,对聊天类业务参考价值有限。

问题二:批大小是多少、延迟是多少?吞吐数字如果不带延迟,几乎无法比较——把批加到几百谁都能把吞吐做上去,代价是单条变慢与显存吃满。

问题三:基线是什么、跑在什么硬件上?跨硬件的倍数没有意义;跨实现(比如对比未优化的朴素实现)的倍数会被系统性放大。

问题四:精度是什么?权重精度与 KV 精度要分开问。fp16 换 int8 的 2 倍差异,常常被写成「优化带来的加速」,其实是换了数值格式。

问题五:这是实测还是理论?本文这样的推算只能给上限;只有带硬件、带负载、带测量方法的实测数字才可以直接采信。

五个问题问完,多数「快 N 倍」会缩水成一个有条件的结论——这不是说作者在骗人,而是性能数字天生依赖口径,不写清口径的数字等于没写。

这一节想让你记住的一件事:没有口径的性能数字不是数据,是广告。

边界与未解:这张图什么时候会骗你

第一,屋顶线是上界模型,不是预测模型。它告诉你「不可能超过多少」,不告诉你「实际是多少」。真实的 kernel 会被 L2 命中率、bank 冲突、指令发射、通信与调度拖慢,所以实测总能比理论值低一截。本文给出的 206 token/s 是理论上限,不是任何产品的承诺值。

第二,本文的模型参数是假设值(70B/8B、层数 80/32、8 个 KV 头、head_dim 128、head_dim 与 fp16),用来把算式算成具体数字;换一个模型,KV 每 token 的字节数与权重总量都会变,结论的量级会变但方向不变。所有自算数字在文末单列,与官方数字分列。

第三,MoE 会同时改动分子与分母。它每 token 只读被路由到的专家权重,分母显著变小;同时每 token 的激活参数量也小,分子同步变小。真正的变化是「每 token 要读多少字节」下降,而这正是它在解码阶段划算的原因——但稠密模型的公式不能直接套,要按激活参数与专家权重重新记账。

第四,投机解码改变了「一次解码步产出几个 token」这件事。它不改变每次前向要读的权重,但把「每读一遍权重能产出多少 token」从 1 提到「1 + 接受率 × 草稿长度」,等价于提高了权重的复用次数。用本文的语言:它没有降低带宽需求,而是提高了每次搬运的产出。

第五,continuous batching 与 chunked prefill 会让同一步里既有 prefill 又有 decode。这时两个屋顶线在时间上混合,系统的实际行为取决于调度器给每个阶段分配多少算力与带宽。本文的分析依然成立,但要对每一步分别算。

第六,多卡会引入第三个「带宽」:卡间互联。张量并行每层都要做一次 all-reduce,跨卡带宽(PCIe 或 NVLink)远低于 HBM 带宽,所以在低延迟场景里它会成为新的瓶颈,把原本的「带宽侧」从显存挪到网络上。

第七,量化之后的 kernel 效率并不等于理论值。把权重压到 int8 只是把「要搬的字节」减半,能不能真跑到两倍,还取决于反量化开销、混合精度累加与内存访问对齐;工程实现的实际收益常常低于 2 倍,这是本文公式覆盖不到的部分。

第八,真实流量里批内长度极不均匀。本文假设一步里所有请求的上下文一样长,实际是长短混杂;调度器要为此做对齐与填充,长请求会拖住整步的耗时,短请求则浪费算力。这也是 chunked prefill 这类「看起来跟屋顶线无关」的技术真正在解决的问题。

第九,也是最诚实的一条:本文没有做真机实测。所有硬件数字取自厂商公开规格页(2026-11-14 读取),所有负载数字由公式自算并标注假设。它可以帮你判断瓶颈在哪一侧、量级大概多少,但不能替代一次 A/B 压测。

这一节想让你记住的一件事:屋顶线给你的是「不可能超过」,压测给你的是「实际是多少」,两者缺一不可。

一次手算:8B 单卡在 2048 上下文下的四个数

为了把前面所有式子落到手上,这里完整走一遍一个具体配置的四步手算(8B、fp16、32 层、8 个 KV 头、head_dim 128、H100、2048 上下文)。四步全部可以用计算器完成,每一步都写清用的是哪个式子。

第一步,每 token 的 KV 字节:2×32×8×128×2=131,0722 \times 32 \times 8 \times 128 \times 2 = 131{,}072 字节,即 0.125 MiB。这里的第一个 2 表示 K 和 V 两份,最后一个 2 表示 fp16 每元素 2 字节。

第二步,一条请求的 KV:0.125 MiB 乘以 2048 个历史 token,得到 0.25 GiB。它比权重(14.9 GiB)小得多,这就是为什么单条请求几乎是纯权重读取。

第三步,单流速度上限:3.35 TB/s 除以(14.9 GiB + 0.25 GiB)换算成的字节数,约 206 token/s。注意分母里权重占 98%,所以这一步的结论对上下文长度不敏感——短上下文与长上下文的单流速度差不到 2%。

第四步,并发上限与天花板:80 GiB 可用容量(标称 80 GB)减去 14.9 GiB 权重,剩 65.1 GiB 给 KV,除以 0.25 GiB 得约 260 条;把 260 代回算术强度公式,得到 48.5,而天花板是 59.6——两者已经贴得很近,说明再往上加并发几乎没有提升空间。

这四步给出的结论是:8B 单卡服务的合理工作点是「几十到一百多条并发」,此时吞吐在数千 token/s 量级,单条速度已经降到百 token/s 以下;继续堆并发的边际收益很低,因为天花板在那里。

这也解释了一个运维现象:把并发从 64 加到 200,你可能看到吞吐只涨了 50%,而 P99 延迟涨了一倍。不是系统变差了,是它正在接近自己的算术强度天花板。

这一节想让你记住的一件事:四个数就能估出一个服务的量级,误差主要来自 kernel 效率,不来自公式。

术语表

文章里出现的术语密度不低,集中列一张表,方便回查。每个定义的措辞都尽量对应到本文的公式,而不是抽象描述。

术语一句话定义在本文哪里用到
Prefill把整段提示词一次算完的阶段,一次读权重、多次复用算力侧那一半
Decode逐 token 生成的阶段,每步重读权重与历史 KV带宽侧那一半
KV 缓存每层为历史 token 保存的 Key/Value 向量,尺寸随上下文线性增长分母里随 B 与 S 增长的项
算术强度 II每搬一个字节做了多少次浮点运算判断落在哪一侧的核心量
脊点 I∗I^{*}峰值算力除以带宽,边界点的算术强度H100 上约 295
算术强度天花板批大小趋于无穷时的算术强度上限 2P/(SK)2P/(SK)决定「加并发有没有用」
MFU实际算力占峰值的比例只对算力受限负载有意义
TTFT / TPOT首字延迟 / 每 token 输出时间对应 prefill / decode

表里最后一行是两个最容易被混用的指标。它们的分母不同:TTFT 主要由排队与 prefill 决定,TPOT 由解码每步的字节决定。一个系统可以 TTFT 很好而 TPOT 很差,也可以反过来——所以优化时必须先确定抱怨的是哪一个。

还有一个词值得单独说明:本文说的「token」是模型处理的最小单位,不等于「字」。一个汉字常常对应一到两个 token,一段 200 字的回答可能是 300 个 token。做容量估算时如果按字数当 token 数,会把 KV 与带宽需求低估三成以上。

这一节想让你记住的一件事:术语表的价值不在定义本身,而在于它把每个词都指回了同一个式子。

为什么真实曲线和这条直线不一样

理论上,吞吐随批大小线性上涨,直到撞上天花板。真实服务的曲线通常是「先线性、再弯、最后掉头」,三个原因都值得知道。

第一个原因是显存碎片与调度开销。KV 缓存按请求动态增长,分配器要预留余量,实际可用容量往往只有标称的七八成;当批接近上限时,分配失败与回收抖动会让吞吐掉下来。

第二个原因是批内长度不均。真实流量里有的请求 200 token、有的 8000 token,一步之内的耗时由最长的那个决定,短请求的时间被浪费。这也是为什么分块调度(chunked prefill)能把曲线拉直一些——它把长 prefill 切成小块,避免一次占满整步。

第三个原因是算力侧的软上限。即便算术强度没到脊点,kernel 的效率也会随批增大而波动:矩阵形状更「整齐」时利用率高,形状奇怪时利用率低。所以真实曲线在理论直线下方,并且带着波纹。

知道这三点之后,「实测不如理论」就不再是坏消息,而是预期之内的事。真正需要警惕的是反过来:实测明显高于理论上限,那说明要么口径错了(比如把 batch 里的 token 数算错了),要么硬件数字取错了。

这一节想让你记住的一件事:理论给的是天花板,真实曲线在天花板下弯折,弯折点往往先到。

小结:把「算力」换成「每字节做多少活」

回到开头那个问题。算力翻倍而吞吐没翻倍,是因为你的负载根本不在算力侧。判断这件事只需要三个数:负载的算术强度 II、芯片的脊点 I∗=π/βI^{*} = \pi/\beta、以及两者谁大;再加一个数更稳:这段负载的算术强度天花板。

prefill 的 II 随 token 数线性长,70B、2048 token 时约 2048 FLOP/byte,是脊点 295 的约 7 倍,落在算力侧,所以它吃算力。decode 的 II 在单条请求时约 1.0 FLOP/byte,比脊点低约 300 倍,落在带宽侧;而且它的天花板只有约 209(70B、2048 上下文),意味着即便把并发开到几百条,也够不到脊点——真正的限制是「每条请求都要带一份自己的历史缓存」。

于是所有在解码阶段有效的优化,本质上都是同一件事:让每一次搬运服务更多工作。PagedAttention 抬高可容纳的并发,KV 量化减少每 token 的字节并把天花板翻倍,FlashAttention 把重复读取换成片上复用,投机解码让一次前向产出多个 token。反过来,任何只减少浮点运算、不减少搬运的优化,在解码路径上的收益会接近于零。

如果只带走一句话:推理快不快,先问「每搬一个字节,做了多少次浮点运算」。这句话能让「为什么换卡没用」「为什么加并发只提吞吐」「为什么长上下文吃掉吞吐」这三个问题同时有答案。

再往前一步:这套判据还能帮你做选型。给定业务的首字延迟目标、每秒请求数与平均输出长度,你可以反推出需要多少并发,再乘以每条请求的 KV,就得到显存需求;把它和单流速度一起放进本文的式子,就能判断这套方案是「带宽不够」还是「显存不够」——这两种不够对应的采购决定完全相反。

最后提醒一句:所有模型与硬件的数字都会变,但「一个字节被用了几次」这个比例不会变。学会算这个比例,比记住任何一张卡的名字都更耐用。

如果要把这篇文章压成一张卡片,只写四行:一是脊点等于峰值算力除以带宽;二是算术强度等于总浮点运算除以总搬运字节;三是解码的算术强度有天花板,与上下文长度成反比;四是落在哪一侧,就优化哪一侧——带宽侧减字节,算力侧换算力。

这四行能回答的问题包括:换卡为什么没感觉、加并发为什么只提吞吐、长上下文为什么贵、为什么降精度比换算法有效、以及为什么有些「更省算力」的优化跑起来没变化。它们不能回答的问题包括:具体能跑到多少 token/s(要压测)、哪家厂商的卡更划算(要报价)、以及某个 kernel 在某张卡上的真实效率(要实测)。

📋 来源与核验记录

以下为本轮(2026-11-14)实际打开并核对过的来源:

  • https://arxiv.org/abs/2211.05102 —— Efficiently Scaling Transformer Inference(2022 年 11 月首次提交):低 batch 生成每 token 29 毫秒(PaLM 540B、int8 权重、TPU v4)、大 batch 输入处理 76% MFU、MQA 支持最长 32 倍上下文。本轮核读摘要页原文。
  • https://arxiv.org/abs/2205.14135 —— FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness(2022 年 5 月首次提交):IO 感知分块、HBM 与片上 SRAM 往返减少、BERT-large 15% / GPT-2 3 倍 / 长程竞技场 2.4 倍加速;摘要指出多数近似注意力方法拿不到墙钟加速。本轮核读摘要页原文。
  • https://arxiv.org/abs/2309.06180 —— Efficient Memory Management for Large Language Model Serving with PagedAttention(SOSP 2023):KV 缓存分页、近零浪费、同等延迟下吞吐 2–4 倍。本轮核读摘要页原文。
  • https://www.nvidia.com/en-us/data-center/h100/ —— NVIDIA H100 官方产品页(2026-11-14 读取):HBM3 3.35 TB/s;FP16 张量算力 989 teraFLOPS(稀疏 1,979 teraFLOPS)。
  • https://www.nvidia.com/en-us/data-center/a100/ —— NVIDIA A100 官方产品页(2026-11-14 读取):A100 80GB 显存带宽「超过 2 TB/s」。

本文自行推导(非官方数字,按上述公式与假设实算,假设层数/头数见符号表、带宽取 H100 规格 3.35 TB/s、峰值取密集 FP16 989 TFLOP/s):

  • 脊点 I∗=989/3.35≈295I^{*} = 989/3.35 \approx 295 FLOP/byte。
  • 70B fp16(80 层、8 KV 头、head_dim 128):权重 130.4 GiB;KV 每 token 327,680 字节(0.3125 MiB);2048 上下文下每条请求 KV 0.625 GiB;单流上限约 24 token/s(每 token 约 42 毫秒);算术强度天花板 2P/(SK)2P/(SK) 约 209。
  • 70B int8:权重 65.2 GiB;KV 每 token 0.156 MiB;单流上限约 48 token/s;扣除权重后 KV 预算 14.8 GiB,2048 上下文下约 47 条并发;天花板约 417;达到脊点需约 504 条并发、约 158 GiB KV,单卡不成立。
  • 8B fp16(32 层、8 KV 头、head_dim 128):权重 14.9 GiB;KV 每 token 0.125 MiB;单流上限约 206 token/s(每 token 约 4.9 毫秒);KV 预算 65.1 GiB,2048 上下文下约 260 条并发;天花板约 60;批 1/8/32/64/128/260 的总吞吐约 206/1477/4360/6462/8515/10152 token/s,对应每条请求速度约 206/185/136/101/67/39 token/s。
  • 8B int8:权重 7.5 GiB;KV 每 token 0.0625 MiB;单流上限约 412 token/s;约 580 条并发;天花板约 119。
  • prefill:70B fp16、2048 token 计算量约 2.87×10142.87\times10^{14} FLOP(理论约 290 毫秒),算术强度约 2048 FLOP/byte;8B fp16 同口径约 33 毫秒、算术强度约 2044;注意力项约 1.7×10111.7\times10^{11} FLOP,占 70B 的约 0.1%。
  • 朴素注意力(每个 query 重读全部 K/V)在 2048 token、80 层下约 1.4 TB 累计搬运量(LS2⋅2nkvdhbL S^{2} \cdot 2 n_{kv} d_h b)。
  • 天花板随上下文变化(70B fp16):512 token 约 834、2048 约 209、8192 约 52、32768 约 13;对应的「进入算力侧」在 2048 上下文下不成立。
  • TTFT 与输出 200 token 的算例(70B fp16):prefill 按 50% 效率约 580 毫秒,200 × 42 毫秒约 8.4 秒,生成段约占 94%、prefill 约占 6%。
  • 单流解码的算力利用率理论上限约 0.3%(约 1.0 ÷ 295),即约 99.7% 的算力在带宽受限区间闲置。
  • 8B 单流速度的构成中权重项占分母约 98%(14.9 GiB vs 每条请求 0.25 GiB KV),因此上下文从 512 变到 2048 时单流速度变化不到 2%。

局限性:本文不含真机压测,所有性能数字为理论上限或公式估算;跨硬件(H100 / A100 / TPU v4)的数值不可直接横向比较,文中的对比一律以方法而非数值为准。