FlagOS不可不知小技巧|FlagOS分层优化设计如何赋能大模型推理
大模型推理的性能瓶颈主要来自两层物理约束:Decode 阶段受显存带宽与容量的限制,Prefill 阶段受算力与序列长度平方项的限制。本文以 FlagOS 算法、精度、编译、算子、调度五层分层优化设计为主线,说明每一层分别解决了什么问题、收益落在哪里。
优化大模型推理性能时,一个常见的起点是装一个 profiler 去定位最热的算子,而这个起点往往就是错的。推理的瓶颈并不集中在单个算子上,而是分布在两个物理特性截然相反的位置:Decode 阶段受显存带宽与容量的双重约束,Prefill 阶段受算力与序列长度平方项的约束。两者的解法彼此独立,用错方向不仅无效,还会互相抵消。
全文的结构可以先用一句话交代清楚。第一部分定位瓶颈,说明 Decode 与 Prefill 分别被什么物理条件限制;第二部分依次展开 FlagOS 的算法、精度、编译、算子、调度五层分层优化设计,逐层说明它解决什么问题、收益落在哪里,其中算子层的收益最集中,也是 FlagGems 所处的层级,承载 FlashAttention、融合算子与量化线性层这些真正落到硬件上的实现;第三部分把这五层对应到 FlagTree、FlagGems、vLLM-Plugin-FL、FlagScale 等具体组件,说明分层设计如何拼成一条可跑通的链路;第四部分汇总四个常见的认知误区,包括换平台后结论可能反转这类反例。

全文知识结构,先定位瓶颈,再逐层下手
一、两层约束:Decode 受限于显存,Prefill 受限于算力
内存墙
Decode 阶段每吐一个 token,都要把前面所有 token 的 Key 和 Value 重新读一遍。这件事的算术强度极低:一次矩阵向量乘,绝大部分时间用于把权重和 KV Cache 从显存搬入计算单元,瓶颈因此不在计算本身,而在等待数据搬运。
KV Cache 的规模由几个结构性因素决定:层数、KV 头数、每个头的维度、序列长度与批大小。其中序列长度与批大小,对应的正是上下文有多长、同时要服务多少请求,也就是说缓存占用从一开始就和并发能力绑定在一起。这正是内存墙的来源:KV Cache 持续占用大量 GPU 显存,而显存是固定资源,缓存占得越多、能同时容纳的请求就越少,并发批处理的大小被直接限制。所以内存墙真正限制的不是单条请求的速度,而是系统能同时服务的请求数量,它影响的是吞吐。
计算墙
Prefill 要把整段 prompt 一次性并行算完,此时算术强度很高,属于计算密集,硬件峰值浮点算力成为瓶颈。问题在于注意力部分的成本随序列长度二次增长:序列翻倍,计算量变为四倍,在长上下文场景下这一项会迅速耗尽预算。
优化需分层核算:三层漏斗
把两道墙放在一起看,会得到一个三层漏斗,三层各自决定了浪费发生在哪里:算法层决定理论计算量(FLOPs)与内存需求,注意力结构冗余、参数全激活的浪费在这里;编译/框架层决定计算图的执行路径与中间结果的显存寿命,算子之间反复读写显存、内存碎片的浪费在这里;算子/硬件层决定指令的执行效率,访存没对齐、流水线空转的浪费在这里。
这三层之间还存在一条反向的约束:底层硬件特性会反过来影响顶层算法设计。最典型的例子是 Hopper 之后 FP8 成为原生能力,于是先训完再量化开始让位于训练时就考虑低精度;Tensor Core 对特定分块尺寸的偏好,也会倒推上层去调整 head_dim 与 batch 的组织方式。
阿姆达尔定律在这里很直接:把一个占总耗时 20% 的环节优化到零,整体最多快 25%。因此顺序不是从上往下,也不是从下往上,而是先在漏斗上找到真正的瓶颈,再决定动哪一层。

两道墙对比,Decode 卡吞吐,Prefill 卡首字延迟
两条主线,六个手段
打计算墙,即最大化硬件计算能力,衡量的指标是 MFU(算力利用率),手段三条:算子融合与内核优化、混合精度与量化、流水线效率;打内存墙,即最大化显存带宽利用率,手段三条:访存模式优化、分块与数据重用、零冗余策略。这六条不是并列的口号,它们与 FlagOS 后面的五层优化一一对应:
-
混合精度与量化 → 第二层
-
算子融合与内核优化 → 第三层、第四层
-
分块与数据重用 → 第四层 FlashAttention 的分块
-
零冗余策略 → 第五层 PagedAttention 消碎片
-
访存模式优化、流水线效率 → 贯穿编译层的内存规划和通信重叠
MFU 这个指标值得单独说明,它把优化了多少变成一个可比较的量:实际跑出的 FLOPs 除以硬件峰值 FLOPs。同一个模型,Prefill 阶段的 MFU 能到几十个点,Decode 阶段常常掉到个位数。这并非优化不到位——Decode 阶段访存密集,算力始终在等待数据。因此判断 MFU 的高低之前,必须先确认它属于哪一道墙,否则这个数值没有可比性。
二、第一层:算法层,把缓存本身变小
既然 Decode 被 KV Cache 锁死,最有效的做法是让缓存本身变小,而非让搬运变快。标准多头注意力(MHA)里每个 Query 头配自己独立的 Key 头和 Value 头,H 个头就有 H 份缓存,缩减路径由此展开:MQA(Multi-Query Attention) 让所有 Query 头共用一份 KV,缓存直接降到 1/H,代价是表达能力受损、训练不好收敛;GQA(Grouped-Query Attention) 是折中方案,H 个 Query 头分 G 组、每组共享一份 KV,缓存降到 1/(H/G)。
Llama-3-8B 采用的就是 GQA,让多个 Query 头共享同一份 KV,显存里的缓存开销随之明显下降;如果换回标准 MHA、每个 Query 头各占一份 KV,在同样的上下文长度下缓存会成倍膨胀,长上下文场景很可能直接放不进显存。这个例子的意义在于:它是算法层的结构选择,不是工程调优技巧,但它对端到端吞吐的影响比后面任何一层都大。

MHA / GQA / MQA 三种注意力结构下的 KV Cache 开销对比
MoE:另一类取舍
混合专家(MoE)把模型规模有多大与单次需要计算多少分离开:总参数量可以做很大,但每个 token 只激活其中一小部分专家。在端到端视角下这是用显存换计算,划算,但引入了一个新瓶颈——专家分布在多张卡上,token 要跨卡路由,通信成了新的墙,所以 MoE 模型的优化重点往往从算子转向了 All2All 通信,优化的对象已经从 GEMM 转向了网络通信。这里还有一个边界需要说清楚:MoE 的收益依赖路由均衡,token 全挤在少数几个专家上时,被选中的几张卡就是瓶颈、其余卡空转,实际收益远低于理论值。
三、第二层:精度层,用更低位宽压缩缓存占用
省显存的第二条路,是让每个数字占的位更少。这里先要分清两条路线:PTQ(训练后量化)拿训好的模型直接量化,不用重训、工程成本低,是当前部署的主流选择;QAT(量化感知训练)在训练时就模拟量化误差,精度更好,但需要重训。端到端部署里基本默认 PTQ,因为它不动训练流程。

四条量化路线对比,先看量化对象是谁
具体方案有三条路:

这里有一个容易被忽略的细节:KV Cache 本身也能量化。vLLM 的 kv_cache_dtype 参数设成 fp8 就能让缓存占用直接减半,同样的显存能装下更多请求,并发随之提升。无需改动模型、无需重训,这是端到端优化中性价比最高的一档。
未展开的另一半:稀疏
资料里写的是量化和稀疏性技术,但量化部分讲透了,稀疏只出现在标题里。这里补充两句,因为这两件事经常被混为一谈:道理是同一个,用更少的数据表示同样的信息;区别在作用点——量化是让每个数字占更少的位,稀疏是让大量数字直接等于零,不存也不算。
两者的工程成熟度差距显著。量化在当下已是部署标配,稀疏则对硬件有较强依赖。NVIDIA 自 Ampere 架构起提供 2:4 结构化稀疏——每连续 4 个权重中固定保留 2 个非零,由稀疏 Tensor Core 加速,这一比例由硬件写死。非结构化的随机剪枝在通用 GPU 上难以取得收益,因为零值分布离散,硬件仍须按密集矩阵完整读取一遍。
所以在端到端这条链上,稀疏的位置很靠后:它是模型压缩阶段的决定,不是部署阶段可以临时打开的开关。FP8 在部署当天即可决定启用,稀疏则必须在剪枝或训练阶段把结构定死。这两件事放在同一页很容易被当成一类手段,实际上一个是运行时参数,一个是模型结构,混着说基本会被追问到底。
一段可直接套用的启动配置
把上面几层落到参数上,对应这条命令:
vllm serve meta-llama/Meta-Llama-3-8B-Instruct \
--max-model-len 32768 \
--block-size 16 \
--kv-cache-dtype fp8 \
--gpu-memory-utilization 0.92 \
--enable-prefix-caching \
--max-num-seqs 256 \
--tensor-parallel-size 1
每一行对应一个独立的决策,其中两个最容易写错,需要展开说明。--gpu-memory-utilization 0.92 的含义是 vLLM 按这个比例预分配显存做 KV Cache,这里有一处容易出错:官方文档写得很清楚,在经典路径下默认是 0.92,启用可扩展 KV Cache(extensible KV cache,按预热后实测的空闲显存来定尺寸)时默认是 1.0,两个默认值并非笔误,而是两套显存估算策略——一个基于保守预估,一个基于实测;不同环境走的路径不同,默认值也就不同,因此不能直接套用其他环境给出的 0.92,需要先确认所用版本的实际行为。--kv-cache-dtype fp8 则要注意文档里这项默认是 auto,也就是跟随模型 dtype,必须显式写成 fp8 才能得到减半效果,不写等同于未启用。
一个必须明确的适用边界
--kv-cache-dtype fp8 和 --gpu-memory-utilization 在做同一件事的两个方向:一个减少单位占用,一个增加总量。同时开到最大,实际并发不会线性增长,因为激活值、CUDA Graph、临时缓冲区也在这个预算池里。参数并非叠得越多越好,它们争夺的是同一份预算。
四、第三层:编译层,算子融合究竟节省了什么
算法和精度决定了"要算多少、要搬多少",编译层决定的是"这些计算怎么组织",它要解决的是同一个计算在不同组织方式下访问显存的次数差异。
融合节省的是访存往返,而非计算量
一个 matmul + bias + relu 的组合,三个算子各干各的,数据要走三趟 DRAM:
DRAM → SRAM(读 A、B) → 算 matmul → 结果写回 DRAM
DRAM → SRAM(读中间结果、bias) → 加 bias → 写回 DRAM
DRAM → SRAM(读中间结果) → relu → 写回 DRAM
融合之后,中间结果留在寄存器或共享内存里,只在最后写一次 DRAM。省下的不是计算量,是三次全局内存往返的带宽。这解释了一个常见困惑:为什么融合在 Decode(访存密集)收益巨大,到了纯计算密集的场景就没什么感觉——它优化的是搬运,不是算术。配套的还有常量折叠和死代码消除:能在编译期算完的不留到运行期,永远走不到的分支直接删掉。

编译器级优化,算子融合把三次 DRAM 往返收成一次
内存寿命分析
编译/框架层还要管显存的生命周期,手段有三个:内存池化,预先分配大块,避免频繁 cudaMalloc 带来的碎片和同步开销;张量生命周期分析,尽早释放不再被引用的张量,让后面的分配能复用这块空间;原地操作(in-place),在不影响语义的前提下覆写输入,省掉一份同尺寸的临时缓冲。这一层的收益很难在单算子 benchmark 中体现,但它决定了长序列、大批量场景下是否会 OOM。
通信与计算重叠
多卡下,张量并行(TP)每层都要 AllReduce,流水线并行(PP)要在阶段之间传激活,通信计算串行跑,卡就在等网络。做法是把通信切小块,和计算流水交错:第 i 层的梯度在传的时候,第 i+1 层已经在算了。硬件没变快,但空闲被填满了,这是典型的用调度换时间。
五、第四层:算子层,FlashAttention 如何避免物化分数矩阵
编译层管的是计算怎么组织,算子层管的是这段计算本身怎么写。这一层的工作分成两类:一类是把自动调优搜索出的最优调度最终编译成硬件指令;另一类是两种极致优化——FlashAttention 这类结构改写,以及 PTX 或针对特定芯片微架构的手写内核。
朴素注意力的问题:物化整张分数矩阵
要理解 FlashAttention 为什么必须存在,需要先看标准注意力的做法存在什么缺陷。注意力要先算 S = QK^T,得到一个 seq_len × seq_len 的分数矩阵,再做 softmax,再乘 V。问题就出在这张矩阵上:它的规模随序列长度呈平方增长,再乘以注意力头的数量,长上下文下显存占用会迅速膨胀到与模型权重同一个量级,而它只是中间结果,算完即弃,从不复用。
FlashAttention 的做法是根本不把这张矩阵实例化出来:把 Q/K/V 切成小块,一块一块算,用递增的 running max 和 running sum 维护 softmax 的统计量,最后拼出等价结果,显存从 O(N²) 降到 O(N)。它的两个动作就是分块和重新计算——分块是为了不存整张矩阵,重计算是反向传播时不存中间结果、用的时候再算一遍。
核心就是 online softmax 那三步。这段可以直接跑:
import math, random
random.seed(0)
def softmax(xs):
m = max(xs)
ex = [math.exp(x - m) for x in xs]
return [e / sum(ex) for e in ex]
def attn_naive(q, K, V):
"""朴素做法:一次算出整行分数,再 softmax 加权"""
scores = [sum(a * b for a, b in zip(q, k)) for k in K]
w = softmax(scores)
return [sum(wi * v[d] for wi, v in zip(w, V)) for d in range(len(V[0]))]
def attn_flash(q, K, V, block=4):
"""分块做法:同一时刻只持有一个块的分数,靠 running max/sum 增量修正"""
d = len(V[0])
m_prev, l_prev = -math.inf, 0.0
acc = [0.0] * d
for st in range(0, len(K), block):
Kb, Vb = K[st:st + block], V[st:st + block]
s = [sum(a * b for a, b in zip(q, k)) for k in Kb]
只算当前块
m_new = max(m_prev, max(s))
新的最大值
l_new = math.exp(m_prev - m_new) * l_prev \
sum(math.exp(x - m_new) for x in s)
修正归一化因子
acc = [a * (math.exp(m_prev - m_new) * l_prev / l_new) for a in acc]
for si, vi in zip(s, Vb):
p = math.exp(si - m_new) / l_new
acc = [a + p * x for a, x in zip(acc, vi)]
m_prev, l_prev = m_new, l_new
return acc
q = [random.gauss(0, 1) for _ in range(8)]
K = [[random.gauss(0, 1) for _ in range(8)] for _ in range(20)]
V = [[random.gauss(0, 1) for _ in range(8)] for _ in range(20)]
a = attn_naive(q, K, V)
b = attn_flash(q, K, V, block=4)
print('max err =', max(abs(x - y) for x, y in zip(a, b)))
4.44e-16
assert max(abs(x - y) for x, y in zip(a, b)) < 1e-12
这段代码跑出来误差是 4.44e-16,也就是浮点数的舍入级别——分块算和整行算,结果是一样的。上面的例子只包含一个 query,因此节省的是整行分数;真实场景一次处理多行 query,朴素实现需要物化整块矩阵,序列越长这块矩阵越大。这就是为什么 FlashAttention 在长上下文里是必需品,而不是优化项。
最后 5% 的收益:手写内核的代价
在 FlashAttention 之后还有一句更进一步的说明:使用 PTX,或者针对特定国产芯片微架构定制手写内核,可以压榨出最后 5% 的性能。这句话实际是在承认天花板——编译器能释放 90% 的性能,剩下的部分需要人工针对硬件编写。FlagGems 在 Arm CPU 上就是这么做的:它的 W8 线性层有一条 Triton 路径,也有一条自己的 C++/Neon 实现(走 TLE Raw 直接调用,绕开 Triton 编译链),在一组 16×384×1024 的微基准上,普通 Triton 版本 2.38 ms,自有 Raw 版本 70.75 μs。
但这个数字不能当作整机性能,它是开发板 B 上的算子微基准,不是模型推理吞吐,这正是后面误区一要讲的问题:微基准的差距放大到整机往往只剩几个点。代价同样明确——手写内核不可移植,更换一个芯片架构,PTX 部分基本需要重写,因此它只适用于最热的那个算子,不能作为常规手段。

算子实现,自动调优之后的两条路:FlashAttention 结构改写与 PTX 手写内核
FlagGems:算子层的主角,换芯片时上层代码不用改
上面五层里,真正把收益兑现出来的,是算子层。算法层只是决定要算多少,精度层只是决定数字占几位,编译层只是决定计算怎么排布,只有算子层把每一段计算写成能在硬件上真正跑起来的 kernel,前面几层的账才落得了地,而这一层的主角就是 FlagGems。先说 FlagOS 本身:它是面向多种 AI 芯片的开放软件栈与社区,目标是让同一套模型与算子代码在不同芯片后端上一致运行,社区成员覆盖芯片厂商、框架团队与算子贡献者。在这套体系中,FlagGems 是算子层的开源算子库,定位是上接框架层(vLLM、Megatron)、下屏蔽异构硬件差异、中间提供融合算子与定制 Attention 等实现。框架调用的是 aten 那一套接口,FlagGems 把这套接口在异构硬件上重新实现一遍,因此模型代码不动,底层从 A 卡换到国产卡,走的是同一份调度逻辑。这个位置决定了它的价值不是算子数量多,而是换芯片的时候上层不用改。
落到具体实现上,它承担的工作都对应前面讲的几层:
-
FlashAttention 这类定制 Attention:把第四层那张 N² 矩阵彻底消掉,长上下文能不能跑,就看它。
-
融合算子:把第三层讲的"三次 DRAM 往返"收成一次,Decode 阶段收益最大的就是这类。
-
W8A8 / W8 线性层:把第二层的量化落到 kernel 上。前面说的 Arm CPU 那条 TLE Raw 路径,就是此处实现在继续压榨最后几个点。
一句话:本文前面所有层的结论,最终都是靠 FlagGems 这样的算子库在真实硬件上变现的。这也是后面那套协作机制存在的理由:算子库要覆盖十几个后端,靠的不是单人维护十几个版本,而是一套让十几家厂商各自提交的制度。收益越集中,越不能被一次疏漏的提交改坏。
六、第五层:调度层,PagedAttention 解决的是碎片
到了调度层,问题变成了:前面四层省下来的内存和计算,怎么变成真实的吞吐。
碎片是核心问题
传统做法给每条请求预分配一段连续的 KV Cache,长度按 max_model_len 留足,后果是三重浪费:预留了用不满(内部碎片)、请求结束才释放(外部碎片)、长度不确定只能保守估。vLLM 论文给过一个实测数字:这类系统里 60%–80% 的 KV Cache 显存实际被浪费掉了。
PagedAttention 借的是操作系统虚拟内存分页的思路:把缓存切成固定大小的块(vLLM 默认 block_size=16,即一块 16 个 token),每条请求持有一张块表,逻辑上连续的 token 可以映射到物理上不连续的块。
核心映射只有几行,并附带断言自检,可以直接运行:
BLOCK_SIZE = 16
class BlockTable:
def
init
(self):
self.table = []
逻辑块号 -> 物理块号
def append_block(self, physical_id: int):
self.table.append(physical_id)
def slot(self, token_idx: int) -> int:
"""token 在扁平化 KV Cache 中的物理槽位"""
logical_block = token_idx // BLOCK_SIZE
offset = token_idx % BLOCK_SIZE
return self.table[logical_block] * BLOCK_SIZE + offset
两个逻辑相邻的 token,可以落在物理上相隔很远的块里
bt = BlockTable()
bt.append_block(7)
逻辑块 0 -> 物理块 7
bt.append_block(2)
逻辑块 1 -> 物理块 2(不连续)
assert bt.slot(0) == 7 * 16 + 0
112
assert bt.slot(15) == 7 * 16 + 15
127
assert bt.slot(16) == 2 * 16 + 0
32 ← 逻辑连续,物理跳块
assert bt.slot(31) == 2 * 16 + 15
47
print("block table mapping OK")
这段代码跑出来是 block table mapping OK,它说明了 PagedAttention 的全部要点:逻辑连续不等于物理连续。正因为把逻辑映射与物理存储解耦,系统才能按需分配块、让块在不同请求间共享(相同前缀)、把碎片压缩到单块内部的最后几个 token,最坏情况浪费 15 个 token 的空间。block_size 是一个真实的工程权衡:块太小,块表本身占内存、查表开销上升;块太大,内部碎片回升,16 是 vLLM 长期沿用的默认值。

PagedAttention 的内存布局,逻辑连续的 KV 可以物理不连续地存放
连续批处理
静态批处理的假设是一批请求同时开始、同时结束,这在大模型推理里并不成立:有的请求生成 10 个 token 就遇到 EOS,有的要生成 500 个,前者结束后它那份算力就空转到整批结束。连续批处理(Continuous Batching)把调度粒度降到每一次迭代——某条请求一旦生成 EOS,立刻移出批次,同时插入排队的新请求,GPU 上始终维持满负荷。
vLLM 论文报告的结论是,PagedAttention 加连续批处理,相同延迟水平下吞吐相比当时的基线(FasterTransformer、Orca)提升 2–4 倍。
这个数字的口径必须说清楚:它是相对特定基线、特定模型和特定负载得到的,不是开了这个功能就一定快 2 到 4 倍。脱离基线谈加速比,是性能文章里最常见的失真来源。
七、FlagOS 分层设计的落地:五层如何对应到具体组件
这是全文最需要看清的一节:前面五层讲的都是"应该优化什么",而 FlagOS 真正可用的形态,是这五层各自对应到具体组件、再由这些组件拼成一条可跑通的链路。换句话说,分层设计不是一张示意图,而是一套已经落地到仓库里的职责划分。
把上面五层落到 FlagOS 的组件上,分工是清楚的:

这张表值得逐行对照前五层来读:FlagTree 对应编译层,把 Triton 代码生成到各家后端;FlagGems 对应算子层,提供真正跑在硬件上的 kernel;vLLM-Plugin-FL 对应调度层,管请求调度与 KV Cache 分块;FlagScale 则站在编排层,把训练、强化学习与推理串成一条链。算法层与精度层没有独立的组件,因为它们落在模型结构和启动参数上,由上层直接决定——这也是为什么本文把这两层放在最前面讲:它们的决策一旦定下,后面三层只能在其框架内做优化。
这里有一个直接的问题:已经有推理引擎,也有训练框架,为什么还需要 FlagTree 和 FlagScale 这一层?回答很直接——简单的推理引擎或训练框架,处理不了数十万个 GPU 级别的集群调度。这两个组件的分工是一条清晰的分界线:FlagTree 提供底层硬件抽象和调度,解决"同一个程序怎么在不同芯片上跑";FlagScale 提供模型级的高效分布式策略,解决"一个模型怎么摊到几万张卡上"。所以 FlagScale 面向的是从训练到推理的高效计算和可扩展性,不是某一个阶段的优化,本文这条推理链路是它下面的一条支线。
训练和推理正在被拉成一条线
有一件事容易被跳过:训练与推理的集成。FlagOS社区在训练端有两个组件——Megatron-LM-FL 提供针对超大规模集群优化的 3D 并行策略,TransformerEngine-FL 加速底层计算、尤其支持低精度。但真正值得记的是它给的判断:训练过程中积累的计算流程图和算子,可以平滑迁移到推理引擎。这句话解释了"一次开发、跨芯迁移"到底省的是什么——如果训练和推理是两套割裂的栈,前面所有优化都得做两遍;训练侧调好的低精度 kernel、验证过的并行切分,能直接拿到推理侧复用,那才是省下来的成本。
FlagOS社区在推理侧 vLLM-Plugin-FL 的设计理念可以用两个词形容:解耦、热插拔。解耦是把核心调度逻辑与底层硬件执行、算子库分开;热插拔是能快速接上自己开发的优化库,比如 FlagGems。这不是架构上的洁癖——推理引擎的核心价值在调度,而调度逻辑与芯片无关,真正因芯片而变的是 kernel 实现,把这两件事解耦之后,新增一个芯片后端就不需要改动调度器。
铁三角:大脑、肌肉、编译器
三个组件的分工可以用一组对应关系说明:
-
vLLM-Plugin-FL 是大脑:负责请求调度、KV Cache 管理、计算图分布。
-
FlagGems 是肌肉:提供高度优化的底层内核,FlashAttention 和各种融合算子。
-
FlagTree:把前端代码生成到各家芯片的机器指令上。
三个角色对应三种失败模式:调度层失效则吞吐上不去,算子层不够快则单位计算成本下不来,编译器无法生成则这颗芯片根本跑不起来。三者合起来的优势是在多个平台上实现开箱即用的高性能,而这个结论成立的前提,是三个角色各守边界——一旦职责越界,整体协同就会失效。
一条可复现的验证路径
验证 vLLM-Plugin-FL 在加速大模型推理是否有效。步骤就两步——快速启动 FlagScale 环境,然后配置硬件参数和插件环境变量。
这两步看似平淡,实际是端到端的落地方式:不在单个算子上跑 benchmark,而是在真实的框架组合里对比开插件与不开插件的差别。这也留下了后文要处理的问题——一旦结论依赖这套组合,这套组合本身就必须有人守着。
最后纠正两处常见的误读,因为它们直接影响对分层边界的理解。其一,FlagTree 是多 AI 芯片统一编译器,从 triton-lang/triton 分支而来,用 Triton 做统一前端,把同一份 kernel 代码编译到不同厂商的芯片后端,管的是代码生成和跨平台兼容,不是调度策略。这不是抠字眼——调度层决定什么时候算什么,编译层决定这段计算怎么变成目标硬件的指令,混在一起讲就解释不了为什么同一个模型换块芯片要重做后端适配。其二,VLA 不是超大型架构。VLA 是 Vision-Language-Action,视觉-语言-动作模型,跟超大型没有关系;FlagOS-Robo 面向具身智能推理,大模型要融进物理世界,对端到端延迟的要求极低,难点在于多模态输入(摄像头、传感器)和控制流输出要一起优化延迟,而不是只把语言模型跑快。
八、四个常见的认知误区
前面五层加组件落地,讲的是"该怎么做";下面四个误区讲的是"常见做法错在哪",实践价值更高。前三条是方法论层面的偏差,最后一条更重——它会推翻前文的一个隐含假设:那些收益并非普适。
误区一:把单算子微基准当作整机性能
端侧 CPU 推理有一组实测数据,结论与直觉相反。同一个模型,先换 W8A8 输出头,再把 Decode 线程从 8 降到 4,线程数是减少了,速度反而更快。原因在于:单 token 的 Decode 计算量过小,线程数越多,其创建与同步开销的占比就越高。算力尚未用满,开销已经先被占满,所以线程数越多越快这条直觉,在访存密集的场景里是反的。
误区二:把首次请求的 JIT 计入吞吐
上一条记录里还存在一处更隐蔽的问题:某次 HTTP 请求测出来的耗时,包含了首次的 shape JIT 编译,直接拿来当吞吐指标,结论会完全错。判断方法很直接——分别跑第一遍和第二遍,若差异显著,说明 JIT 编译被计入了耗时,报出指标之前必须先预热。性能数字必须和它的测试条件绑在一起看,否则它只是噪声。
误区三:认为参数叠加必然带来叠加收益
前面那个同一个预算池的问题,在工程实践中出现的频率很高。kv_cache_dtype=fp8 加 gpu_memory_utilization 拉高,预期是并发翻倍,实际往往达不到,因为激活、CUDA Graph、临时 buffer 都要从这个池子里出,缓存省下来的空间,一部分会被别的开销吃掉。
误区四:认为同一套优化换平台仍然有效
这一条需要重点强调,因为它动摇了整篇文章的一个隐含假设:前面五层讲的收益,全部是在这一套软硬件组合下测出来的;换个芯片,同一套算子优化的结论可能直接反转。
真实数据摆在这儿:FlagGems 的矩阵乘算子接入 vLLM 之后,在 NVIDIA H20 上六模型等权平均是 1.132×,在平头哥 ZW810E 上是 1.249×,到沐曦 C550 上变成 0.806×——比原生基线还慢,慢了将近两成。
同一份代码、同一套调优方法,三个平台三种结果,其中一个是负的。这并不是说那套优化做得不好——C550 上单看某些特化路径,仍有 1.200×、1.052× 的正收益,但把六个模型的形状集合按等权平均汇总之后,整体是负收益。局部占优、全局落后,在算子优化里是常见现象。前文每讲一层都强调边界与口径,原因就在这里:性能数字不是对象的固有属性,而是特定条件下的测量结果,任何不带平台、模型与基线的这个优化能提 X 倍的说法,都不可采信。
九、写在最后
回到端到端优化的本质:大模型推理的性能从不是单点调优的产物,而是算法、精度、编译、算子、调度五层协同、再由编排层串成整条链路的结果。前述五层的价值,正在于把"提了 X 倍"这类笼统结论,还原为可核算的算式、可运行的代码与明确的适用边界。
如果只保留一条结论,那就是:算法层决定需要算多少,精度层决定每个数字占几位,编译层决定计算如何排布,调度层决定这些计算以什么粒度、什么顺序填进硬件,编排层决定训练、强化学习与推理如何被串成一条可复现的链路。
同样值得记住的是这些收益的脆弱性。性能退化既不报错,也不让测试失败,它只是变慢。当同一份代码要同时支持十几种 AI 芯片、由十几个厂商的工程师共同维护时,依靠制度约束(保护分支、四道闸门、选择性触发)守住性能,与实现性能本身同等重要。
从更长的周期看,端到端优化的对象也在迁移。当 FP8 成为原生能力、当 MoE 把瓶颈从 GEMM 推向 All2All 通信、当同一份 kernel 要在多家芯片后端上保持等价,优化就不再是单点问题,而是一套需要持续维护的工程体系。FlagOS 的分层设计之所以重要,正因为它为这种可持续性提供了结构:算法、精度、编译、算子、调度各守边界,任何一层的变化都不会推翻其余几层。
FlagOS 的"一次开发,跨芯迁移",其含义并非代码无需改动,而是软硬件之间的协同关系无需重建。
关于众智FlagOS社区
为解决不同 AI 芯片大规模落地应用,北京智源研究院联合众多科研机构、芯片企业、系统厂商、算法和软件相关单位等国内外机构共同发起并创立了众智 FlagOS 社区,目前已经有 100多家成员单位
FlagOS 是一款专为异构 AI 芯片打造的开源、跨芯系统软件栈,支持 AI 模型一次开发即可无缝移植至各类硬件平台,大幅降低迁移与适配成本。它包括大型算子库、跨芯AI 编译器、并行训推框架、跨芯通信库等核心开源项目,致力于构建「模型-系统-芯片」三层贯通的开放技术生态,通过"一次开发跨芯迁移"释放硬件计算潜力,打破不同芯片软件栈之间生态隔离。
GitHub 项目地址:https://github.com/flagos-ai
GitCode 项目地址:https://gitcode.com/flagos-ai
SkillHub: https://skillhub.flagos.io
欢迎来到FlagOS开发社区,这里是一个汇聚了AI开发者、数据科学家、机器学习爱好者以及业界专家的活力平台。我们致力于成为业内领先的Triton技术交流与应用分享的殿堂,为推动人工智能技术的普及与深化应用贡献力量。
更多推荐




所有评论(0)