算力翻倍,推理为什么没快一倍:把 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 的层数与头数为本文假设),不含真机实测。
假设你把推理服务从一张 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 里同一份权重只服务当前批里的这几条请求,读一次权重只能做一份工作。这个「读一次能做多少工作」的比例,就是本文唯一的主角。
图里想说明的一件事是:上下两条流水线的形状几乎一样(都是「读数据→算→出新东西」),但右侧的判定完全不同——上面那行每一步能复用几千个 token,下面那行每一步只前进一格,还要把历史缓存再读一遍。
顺带说明范围:下面所有推导针对 decoder-only 的稠密模型、标准自回归解码、单机单卡(张量并行的情况在边界一节单列)。MoE、投机解码、稀疏注意力、跨机集群会让账本变复杂,同样在最后一节说明它们的偏离方式。
这一节想让你记住的一件事:prefill 是「一次读、多次用」,decode 是「一次读、一次用」。
符号约定:整篇文章只用几个字母
为了避免后面反复解释,先把符号固定下来。单位一律按量级写法:TFLOP/s 表示每秒万亿次浮点运算,TB/s 表示每秒万亿字节(十进制,1 TB = 10¹² 字节);而显存容量与权重体积按二进制单位写,GiB = 2³⁰ 字节、MiB = 2²⁰ 字节。这两种单位混用是性能文章里最常见的坑,本文会一直标明。
| 符号 | 含义 | 单位 | 本文取值来源 |
|---|---|---|---|
| 模型参数量 | 个 | 本文假设 70×10⁹ 或 8×10⁹ | |
| 每个权重占的字节数 | byte | fp16 取 2,int8 取 1 | |
| 芯片峰值浮点算力 | FLOP/s | H100 官方页 989×10¹²(密集 FP16) | |
| 显存带宽 | byte/s | H100 官方页 3.35×10¹²(HBM3) | |
| 上下文里的 token 数 | 个 | 本文取 2048,另列 512/8192/32768 | |
| 同时处理的请求数(批大小) | 条 | 由显存与调度决定 | |
| 算术强度 | FLOP/byte | 由负载结构算出,不来自硬件 | |
| 层数、每头维度、KV 头数 | — | 70B 假设 80/128/8,8B 假设 32/128/8 |
需要强调一件事: 与 是硬件的理论上限, 是负载的结构属性。前者你只能换卡,后者你可以通过批处理、精度、缓存策略去改。性能工程的全部余地,就在这三个量之间的比例上。
关于 :本文让权重与 KV 共用同一个字节数,也就是两者取同一精度档;表里标「int8」的配置指权重与 KV 同时为 int8,只量化其中一项的配置不在本文表格里。这么做是为了让公式只有四个字母,代价是读表时要记得「int8 行同时代表两处收益」。另外,本文把标称 80 GB 的显卡按「80 GiB 可用容量」估算——这是把十进制标称值近似成二进制容量,真实可用容量还要再打折扣(激活、碎片、框架开销),所以任何并发数字都是上限中的上限。
还有两个口径要提前分开,否则后面一定会读混。第一是「容量」与「带宽」不是一回事:显存容量决定你能装下多大的模型、放多少条并发,带宽决定你每秒钟能读多少字节。A100 80GB 的容量不小,但它的带宽只有「超过 2 TB/s」的量级(官方产品页原文口径),明显低于 H100 的 3.35 TB/s——这就是为什么同样放得下模型,解码速度差一截。第二是「理论峰值」与「实测」不是一回事:峰值是 datasheet 数字,真实 kernel 达不到,本文据此算出的速度都是上限。
单位还有一个容易踩的点: 是「每秒多少次浮点运算」,而模型的计算量习惯按「参数量 × 2」估算,因为一次乘加算两次浮点运算。后面凡是出现 2 倍的系数,都是在把「参数个数」换算成「浮点运算次数」,不是在把权重读两遍。
这一节想让你记住的一件事:只有 是你能改的, 和 是买来的。
屋顶线:把两个上限缝成一条线
一段代码在芯片上跑多快,取决于两个上限里更紧的那个。它每秒最多能做 次浮点运算,也每秒最多能搬 个字节;而这段代码每搬一个字节,需要做 次浮点运算。于是能跑出的浮点运算速度是:
这就是屋顶线(roofline)模型的核心不等式。它把「算」和「搬」两个上限画在同一张图上:横轴是算术强度,纵轴是可达到的算力。低强度区间是一条斜率为 的斜线——你搬多少字节就只能做多少活;高强度区间是一条水平线——搬来的数据够用了,卡在算力上。
两段的分界点叫脊点(ridge point),它的算术强度是:
代入 H100 的官方密集 FP16 算力与 HBM3 带宽:
含义很直白:在这张卡上,凡是「每搬一个字节做不到 295 次浮点运算」的负载,都是带宽受限的;做到了,才是算力受限的。注意这个数不是「越大越好」的分数,它只是硬件的一种配比——带宽充裕的卡脊点低,算力堆得猛的卡脊点高。
换个角度理解:脊点其实在告诉你「这块卡期望你每次搬运都干多少活」。它期望 295 次浮点运算,而解码只给了它一次左右——这不是显卡设计错了,是显卡为训练和 prefill 那类负载设计的,解码只是顺带跑在上面。
还要说明一个口径问题: 里的 是理论峰值,真实 kernel 拿不到。Google Research 团队在 arXiv:2211.05102(Efficiently Scaling Transformer Inference,2022 年 11 月首次提交)里报告,他们在 TPU v4 上做大 batch 的输入处理时达到 76% 的 MFU(model FLOPs utilization,即实际算力占峰值的比例)。这说明 76% 已经是这类负载很强的工程结果,而不是「没优化好」。
还有一层:数字格式一变, 的口径也会变。本文为了统一,所有配置都沿用同一个密集 FP16 峰值来估算——对 int8 权重来说这是保守口径(低精度张量核心的峰值通常更高),所以算出的时间偏长、结论方向不受影响。
这一节想让你记住的一件事:判断快慢之前先算一个除法—— 比脊点大还是小。
prefill:为什么它几乎总是算力受限
prefill 的计算量主要由权重矩阵乘贡献。 个参数、 个 token,每个参数对每个 token 贡献一次乘加,也就是约 2 次浮点运算:
搬运量的主要成分是权重(读一次即可被 个 token 共用),再加上随 token 数增长的激活值:
这里有两点必须写在前面,否则后面的账会对不上。第一, 是「把权重读一遍」的字节数,一个参数只占 个字节,所以是 乘 ,不是乘 2——2 只出现在运算次数的式子里。第二,这个式子默认注意力按分块、片上复用的方式实现;若按朴素实现(每个 query 重读全部 K/V),搬运账本要另算,本节末尾会单列。
两者相除,得到 prefill 的算术强度:
这个近似式子很值得盯着看:prefill 的算术强度基本只跟「一次处理多少 token」和「权重占几个字节」有关,跟模型有多大几乎无关。这也解释了为什么「长提示词」对 GPU 友好: 每翻一倍,算术强度翻一倍,离脊点更远。
代入数:70B、fp16、,计算量约 次浮点运算,按 989 TFLOP/s 的理论峰值算约 290 毫秒;搬运量约 字节(130 GiB 权重 + 少量激活),算术强度约 2048 FLOP/byte,是脊点 295 的约 7 倍——稳稳落在屋顶线的水平段。换成 8B 模型,计算量降到约 ,理论耗时约 33 毫秒,算术强度约 2044,几乎一样。
这里要拆掉一个常见的误解:注意力是 ,所以长上下文一定是注意力最贵。在算力账本上这件事对 70B 模型并不成立。以 70B、输入 2048 token 计,注意力的浮点运算约为 ,相比权重项的 只占约 0.1%。原因很朴素:注意力每个 token 的开销跟层数与头维度成正比,而权重项跟参数量成正比,后者大三个数量级。
真正咬人的地方在搬运账本。如果按最朴素的方式实现注意力——每个 query 都把该层全部 K/V 从显存重新读一遍——那么一层要读 份 KV 向量,全部读一遍的字节数是:
按本文假设(、、、、fp16),这条式子给出约 字节,也就是 1.4 TB。注意这是「整段提示词、所有层累计的重复读取量」,不是缓存容量——同一批 K/V 被反复读了 遍。作为对照,把全部权重读一遍只要 130 GiB,两者相差十倍以上。
换句话说:注意力在算力上可以忽略,在带宽上却可能成为主要项,这才是 FlashAttention 这类「IO 感知」算法存在的理由。它做的不是少算,是少读。
于是 prefill 的优化空间也清楚了:分子(必须做的浮点运算)几乎动不了,分母(搬运)是战场。分块复用、把中间结果留在片上、减少 HBM 往返,这些动作不会减少一次矩阵乘的浮点运算,但会让同一批字节服务更多次计算。
这一节想让你记住的一件事:prefill 的分子(算力)你很难省,它的分母(搬运)才是算法优化的战场。
decode:为什么它天然是带宽受限
decode 一上来就把账本翻了过来。生成一个 token 时, 个权重都要参与运算,但只服务这一条(或这一批)请求。批大小为 条请求时,一次解码步的计算量是:
搬运量是「读一遍权重」加上「这一批请求的全部历史 KV」。这里要分清三个颗粒度:单个 token 的 KV 字节数、一条请求完整上下文的 KV 字节数、整批一次要读的 KV 字节数。三者分别是 、 倍的那个数、再乘 :
相除,得到解码阶段的算术强度:
这个式子的第一个结论很扎心: 时,,fp16 下就是约 1.0 FLOP/byte。与脊点 295 相比,差约 300 倍。也就是说,单条请求的解码在一张为算力设计的卡上,把 99.7% 的算力闲置着,同时把显存带宽用满——不是工程师不会优化,是负载结构决定的。
由此可以直接算出单流解码的速度上限:
代入 3.35 TB/s、8B、fp16、2048 上下文:约 206 token/s,换算成延迟是每 token 约 4.9 毫秒。换成 70B:权重 130 GiB 一笔就压满带宽,单流约 24 token/s,每 token 约 42 毫秒。
图里想说明的一件事是:解码的速度上限不是由「算得多快」写死的,而是由「每步要搬多少字节 ÷ 每秒能搬多少」写死的。这条除法里能做文章的是分子——权重精度、KV 大小、上下文长度。
这个数量级与 arXiv:2211.05102 报告的低 batch 延迟方向一致:他们在 PaLM 540B 上用 int8 权重做到每 token 29 毫秒(约 34 token/s),环境是 TPU v4。跨硬件不能直接搬数字,只能搬方法:把权重的字节数砍半,单流速度大致翻倍。
再看批大小的作用。 变大时分子线性长,分母也在长(KV 项随 增加),所以算术强度上升但会趋缓;单条请求的速度则因为要读更多 KV 而下降。这意味着「批处理提吞吐、不提速度」这句话要说得更准确:它提吞吐,同时让每条请求略微变慢。
于是整条链路的吞吐是:
按 8B、fp16、2048 上下文代入: 时约 206 token/s, 时约 1477 token/s, 时约 6462 token/s, 时约 10,152 token/s;而单条请求的速度从 206 一路降到 39 token/s。吞吐涨了约 49 倍,单条慢了约 5 倍——两者是同一条曲线的两端。
这一节想让你记住的一件事:解码的每一小步都要把整个模型读一遍,所以它的天花板由带宽决定,由并发数决定的是你能把这个天花板用起来多少。
算术强度天花板:为什么上下文越长越够不到脊点
上面的式子里藏着一个反直觉的结论:解码的算术强度不是「批开大就能一直涨」,它有上限。把 推向无穷,KV 项主导分母,于是:
这个上限只跟「参数量」与「一条请求的 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 的字节数减半,天花板与并发容量同时翻倍,而权重量化只改分母里的第一项。
第四,它给出了一个反向判据:想让解码真的吃上算力,唯一的办法是提高 ——也就是用更大的模型(提高 ,但权重变大又受容量限制)、更短的上下文(减小 )、更省字节的 KV(量化或减少 KV 头)。MoE 的「激活参数少」本质上也是同一个方向。
还有一个细节值得说:这个天花板是「稳态」结论。刚开请求时 KV 很短,算术强度确实接近 甚至更高;随着上下文变长,它一步步滑向天花板。所以同一个服务在对话开头和对话末尾的瓶颈分布是不一样的——这也是为什么有些系统在长对话后半段会明显变慢。
这一节想让你记住的一件事:解码的算术强度有天花板,而天花板与上下文长度成反比。
一次请求的时间去哪了:TTFT 与 TPOT
把两段拼回一个真实请求,就得到服务侧最重要的两个延迟指标。第一个是首字延迟(TTFT,time to first token):从请求发出到这个请求的第一个 token 生成出来,这段时间基本由排队加 prefill 决定。第二个是每 token 输出时间(TPOT,time per output token):首字之后每多出一个字要多久,由 decode 决定。
两个式子的分母是同一张卡的两个不同指标,这就是为什么「首字慢」和「后续慢」需要两套完全不同的处置。首字慢,说明 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 生成) |
|---|---|---|
| 主导约束(典型情形) | 算力() | 显存带宽() |
| 本文假设下的算术强度 | 约 2048 FLOP/byte(S=2048) | 约 1.0 FLOP/byte(B=1,S=2048) |
| 与脊点 295 的关系 | 高约 7 倍,算力侧 | 低约 300 倍,带宽侧 |
| 主要搬运内容 | 权重(读一次,被 S 个 token 共用) | 权重 + 全部历史 KV |
| 随什么线性增长 | token 数 | 请求数 (吞吐),同时让每条变慢 |
| 对应服务指标 | TTFT | TPOT |
| 有效加速手段 | 更强算力、更好 kernel、低精度矩阵乘 | 更高带宽、更低精度权重、更省字节的 KV |
| 无效的加速手段 | 加大 batch(已饱和) | 增加算力(用不上)、只减 FLOPs(不是瓶颈) |
| 典型「伪优化」 | 用 attention 的 解释一切 | 用 MFU 评价解码效率 |
最后一行值得单独说。MFU 是「实际算力占峰值的比例」,它天生就是为算力受限负载设计的指标。拿它去评价解码,会得到一个注定很低的数字:本文假设下单流解码的算术强度只有脊点的 0.3%,于是任何正常工作的解码服务都会被判成「效率极低」。这不是系统有问题,是尺子拿错了。解码该看的是带宽利用率,或每 token 的实际显存流量。
同理,把两张卡的 MFU 放在一起比较也没有意义:MFU 的分母是各自的峰值算力,两张卡跑同一个带宽受限负载时,算力越高的那张 MFU 越低——你会得出「更强的卡效率更差」这种荒谬结论。
这一节想让你记住的一件事:同一个服务里,prefill 与 decode 要用两把不同的尺子量。
三个旋钮:批、精度、上下文
既然解码卡在带宽上,能动的就只有三个旋钮,而且每个旋钮的作用点不同。
第一个是批大小 。它只对解码的吞吐有实质意义,因为它改善的是「一次读权重服务多少条请求」这个复用比例。但它的上限由显存决定:每条请求的 KV 随上下文线性增长,上下文越长,能并发的条数越少。这就是「吞吐」与「内存」之间的直接交换,不是调度技巧能绕过去的。
第二个是精度。这里必须把两件事分开:权重精度与 KV 精度。权重从 fp16 到 int8,每步要读的第一个项减半,单流速度大致翻倍;KV 从 fp16 到 int8,每条请求的缓存减半,可容纳并发翻倍、算术强度天花板翻倍。两者的收益路径不同,不能用一个「int8」标签混着说。
第三个是上下文长度 。它主要影响两件事:prefill 的计算量近似线性增长(),以及每条请求的 KV 线性增长。于是在解码侧,在「并发上限由 KV 容量决定、其他条件不变」的前提下,上下文翻倍等于每请求缓存翻倍、并发上限减半、算术强度天花板减半——三重惩罚叠加,这就是长上下文「贵」的定量原因。
三个旋钮的联合作用是: 受显存限制,显存被 与 KV 精度共同决定,而 又决定你能把吞吐推到多远。所以「为什么我的服务上不去」这个问题,通常不是单一原因,而是「上下文 × 并发 × 精度」这个三元组互相挤压的结果。
值得单独提一句的是第四个「隐形旋钮」——调度策略。continuous batching 让新请求不必等当前批跑完就能插进来,它不改变任何一条公式,只是把 实际维持在一个更高的水平上;前缀缓存(prefix caching)让相同前缀的请求共享 prefill 成果,减少的是重算而不是搬运。两者都属于「在不改公式的前提下把参数拉满」。
这一节想让你记住的一件事:解码吞吐 ≈ 带宽 ÷ 每步要搬的字节,三个旋钮都在改这个分母。
五步估算:拿到一个新服务怎么算瓶颈
上面所有推导可以压成一个五分钟能做完的流程。以下五步只用纸笔和厂商规格页。
第一步,算每 token 的 KV 字节数:。以 70B、80 层、8 个 KV 头、head_dim 128、fp16 为例,得到 327,680 字节,也就是单个历史 token 占约 0.31 MiB。
第二步,算权重字节数。 是「把权重读一遍」的字节数:70B、fp16 约 130 GiB,int8 约 65 GiB。这里不要乘 2——2 只属于运算次数的换算。
第三步,算带宽上限:把「权重 + 这一批请求的 KV」除以 ,就得到该批大小下单步的理论耗时。批越大,KV 项越大,单步越慢——这个「变慢」就是批处理真正的代价。
第四步,算脊点并判断:。你的负载 比它小,就别再想着换更强的卡;比它大,才值得为算力付钱。别忘了同时算一下天花板 :如果天花板本身就低于脊点,那换成什么卡都不可能让这段解码变成算力受限。
第五步,算显存能撑多少并发:把可用显存(总容量减去权重、激活与框架开销)除以「每条请求的 KV」,就是并发上限。这个上限与第四步需要的并发一比,就知道自己的服务是「被带宽卡住」还是「被显存卡住」——两者的处置完全不同:前者要减字节,后者要减上下文或者换 KV 精度。
这个流程不能替代压测,但它能在你打开监控面板之前就告诉你「该看哪个指标」。很多性能排查之所以耗时间,是因为一开始就在错的维度上找原因。
这一节想让你记住的一件事:先算术,再看监控;算完就知道该盯带宽还是盯算力。
一张并发扫描表:数字之间怎么互相牵引
把上面四个式子按 8B、fp16、2048 上下文跑一遍,就得到一张可以直接对表的扫描表。读法是:每一行是一个批大小,第二列是单条请求的速度,第三列是整机总吞吐,第四列是算术强度,最后一列是这个批大小下 KV 缓存占用的显存。
| 批大小 | 每条请求速度(token/s) | 整机总吞吐(token/s) | 算术强度(FLOP/byte) | KV 占用(GiB) |
|---|---|---|---|---|
| 1 | 206 | 206 | 1.0 | 0.2 |
| 8 | 185 | 1477 | 7.1 | 2.0 |
| 32 | 136 | 4360 | 20.8 | 8.0 |
| 64 | 101 | 6462 | 30.9 | 16.0 |
| 128 | 67 | 8515 | 40.7 | 32.0 |
| 260 | 39 | 10152 | 48.5 | 65.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 预算」下的理论上限,真实系统还要留给激活、碎片与框架,实际能开到的并发会明显低于这个数。
想再往上推吞吐,就只剩三条路:换更大显存的卡(把 上限抬高)、压 KV 精度(把每请求缓存减半,等于上限翻倍)、缩短上下文(同上)。三条路都在改同一个分母,而不是改算力。
这一节想让你记住的一件事:吞吐与显存是同一条曲线的两端,别指望只抬一头。
算例:70B 与 8B,差在哪里
同样的方法换一个模型,可以看清「模型大小」在这张图上的作用。下表四种配置都按 2048 上下文、H100 规格、本文假设的层数与头数计算。
| 配置 | 权重(读一遍) | 单流速度上限 | 单卡可容纳并发 | 算术强度天花板 |
|---|---|---|---|---|
| 70B fp16 | 130.4 GiB | 约 24 token/s | 装不下权重 | 约 209 |
| 70B int8 | 65.2 GiB | 约 48 token/s | 约 47 条 | 约 417 |
| 8B fp16 | 14.9 GiB | 约 206 token/s | 约 260 条 | 约 60 |
| 8B int8 | 7.5 GiB | 约 412 token/s | 约 580 条 | 约 119 |
这张表最值得读的是最后一列。70B 的两行天花板都在 200 以上,说明它在更短的上下文(比如 512 token)下是有机会进入算力侧的;而 8B 的两行天花板只有 60 与 119,即便把并发开满也摸不到 295。原因不在精度,在于 里的 太小——参数量少,能摊到每个字节上的运算就少。
第二值得读的是「单卡可容纳并发」这一列与「单流速度」的组合。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 都能直接换成时间。这也是为什么「同一个模型,离线批处理的账单和在线对话的账单完全不是一回事」。
一个能立刻用起来的判据是三步:先算这段负载的 ,再算这张卡的脊点 ,最后看 落在哪一侧。落在带宽侧,就去减字节;落在算力侧,才去换更强的卡。这比笼统地说「GPU 利用率低」有用得多,因为利用率低本身从来不告诉你该做什么。
有一个反直觉的推论值得单独记住:在带宽受限的区间里,一个更省浮点运算的算法可能一点都不快。近似注意力、稀疏化、剪枝,如果它们减少的是运算而没有减少显存往返,端到端速度可能毫无变化,甚至因为额外开销变慢。arXiv:2205.14135 在摘要里点破了这件事:很多近似注意力方法为降低计算复杂度牺牲了模型质量,却常常拿不到实际的墙钟加速——他们给出的解释正是「缺少 IO 感知这个原则」。
这一节想让你记住的一件事:加卡之前先算 与 ,否则你买到的是用不上的算力。
怎么把这件事讲给不做系统的同事听
如果你要在一个非技术会议里解释「为什么换卡没变快」,可以只用三句话。
第一句:模型回答问题分两个动作——先把你说的整段话读一遍(这一步很吃算力),再一个字一个字往外写(这一步要反复把整个模型从显存里搬出来看)。
第二句:写字的阶段,每写一个字都要把模型搬一遍,所以它的速度上限是「显存每秒能搬多少」,不是「显卡每秒能算多少」;换一张算得更快的卡,不会让「搬」变快。
第三句:想让整体服务更省钱,可以让它同时处理更多条请求(提总吞吐);但想让某一条回答更快,只能靠把模型压小、缩短上下文、或换显存更快的内存——多开并发不能让单条变快。
这三句话没有任何公式,但它对应的正是本文的三个式子。讲完之后补一句范围:这是理论上限,实际能到多少要压测。
这一节想让你记住的一件事:能不能用三句话讲清、且不把「吞吐」和「速度」说混,是检验自己有没有真懂的标准。
读别人的性能数字时,先问五个问题
这一节是防御性的。你在论文、博客、厂商宣传里看到的任何一个「快 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 字节: 字节,即 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 增长的项 |
| 算术强度 | 每搬一个字节做了多少次浮点运算 | 判断落在哪一侧的核心量 |
| 脊点 | 峰值算力除以带宽,边界点的算术强度 | H100 上约 295 |
| 算术强度天花板 | 批大小趋于无穷时的算术强度上限 | 决定「加并发有没有用」 |
| 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 数算错了),要么硬件数字取错了。
这一节想让你记住的一件事:理论给的是天花板,真实曲线在天花板下弯折,弯折点往往先到。
小结:把「算力」换成「每字节做多少活」
回到开头那个问题。算力翻倍而吞吐没翻倍,是因为你的负载根本不在算力侧。判断这件事只需要三个数:负载的算术强度 、芯片的脊点 、以及两者谁大;再加一个数更稳:这段负载的算术强度天花板。
prefill 的 随 token 数线性长,70B、2048 token 时约 2048 FLOP/byte,是脊点 295 的约 7 倍,落在算力侧,所以它吃算力。decode 的 在单条请求时约 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):
- 脊点 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 毫秒);算术强度天花板 约 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 计算量约 FLOP(理论约 290 毫秒),算术强度约 2048 FLOP/byte;8B fp16 同口径约 33 毫秒、算术强度约 2044;注意力项约 FLOP,占 70B 的约 0.1%。
- 朴素注意力(每个 query 重读全部 K/V)在 2048 token、80 层下约 1.4 TB 累计搬运量()。
- 天花板随上下文变化(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)的数值不可直接横向比较,文中的对比一律以方法而非数值为准。