我把 HAMi 摆回一台双卡机器上跑了一遍:GPU 编排的性能账,到底记在谁头上

我把 HAMi 摆回一台双卡机器上跑了一遍:GPU 编排的性能账,到底记在谁头上

作 者:吴佳浩Alben

撰稿时间:2026.11.18


引言:

上一篇写 Run:ai 开源的时候,很多筒子都在问一个问题:GPU 编排到底值不值?

这个问题其实不好回答。

光看架构图,看不出来;光讲原理,也说服不了人。

更重要的是,这两年国产算力越来越多,企业机房里已经很难做到只有一种 GPU。从 NVIDIA,到昇腾、寒武纪、摩尔线程、壁仞、沐曦、海光......异构已经不是未来,而是很多企业的现状。

**HAMi 恰好就是国内目前最成熟的开源 GPU 编排项目之一,也是少数一开始就把多厂商异构支持作为核心目标来设计的方案。**它的意义已经不仅仅是给 NVIDIA 做 GPU Sharing,而是希望让不同厂商的 GPU 能在 Kubernetes 里使用统一的资源模型和调度方式。

所以这次我没有继续分析,而是把一台双卡机器腾空,把 HAMi 装起来,把八个真实业务搬进去重新跑了一遍。

结果和我原来想的不太一样。


🔸 一、先说结论

先把三件事摆在前面:

  1. 性能成本不在"切分",在"限核"。八个实例同卡,容器化加 vGPU 切分的差异是 0.2% ,在噪声范围内。但一加 gpucores 限核,吞吐掉了 48%,p95 从 1.34 秒涨到 4.77 秒。
  2. 控制面真正难的不是"能不能切",而是"切完以后谁看得见谁"。我踩到最狠的一个坑:调度器看不见不归它管的显存占用,把 Pod 派到了一张已经快满的卡上,直接 OOM。
  3. 异构已经是现状,谈不上选不选。这一层要开放,不是因为理念,是因为你手里已经不太可能只有一种卡了。

上一篇我说控制面决定算力值不值钱。这一篇算是把这句话换成了能验证的数字。验证出来的结果,比我预期的好一些,也比我预期的乱一些。


🔸 二、先把实验台搭起来

机器长这样

一台双卡机,两张卡不是同一代:

图里有个不对称,是我故意留的:5090 上压着 30.4 GB 的生产负载,4090 是空的。

我要的就是"一张卡在跑生产,另一张可以随便折腾"这种环境,因为真实集群里的混部现场基本就长这样。

"停服务"到底怎么停

第一步是把 4090 上所有东西停掉。

做的时候我发现,这件事的重点不是杀进程,而是把入口掐掉,不然进程停了又会被拉起来。

顺手记一个判定上的坑:有个容器 strata 带着 NVIDIA_VISIBLE_DEVICES=all,看上去像是要占 4090,但它的 DeviceRequests 明确只给了 ["1"],实际只用 5090。判断一个容器到底用哪张卡,要看 DeviceRequests,环境变量往往是历史残留,会误导人。

九项验证

入口掐完之后,我跑了九项验收:

# 检查项 判据 结果
1 计算进程(30 秒 10 次采样) 峰值 = 0 ✅
2 显存占用 < 1024 MiB(实测 0) ✅
3 利用率 == 0% ✅
4 /dev/nvidia0 句柄 仅 HAMi 自身组件 ✅
5-7 容器 / 自动拉起 / k8s Pod 均无占用 4090 的 ✅
8 系统服务自启 已 disabled ✅
9 对照组:5090 30408 MiB → 30408 MiB ✅

第 9 项是我特意加的。做资源回收这类操作,最容易出的事故就是顺手把生产也动了。所以全程我都盯着 5090 的数字,它没变,才算这次操作是干净的。


🔸 三、切分这件事,硬不硬

节点上的 HAMi 是 v2.11.0 ,hami-core 模式,两张卡各切 10 份:

json 复制代码
[{"id":"GPU-86d14e75...","count":10,"devmem":49140,"devcore":100,
  "type":"NVIDIA GeForce RTX 4090","mode":"hami-core","health":true},
 {"id":"GPU-6b12533d...","index":1,"count":10,"devmem":32607,"devcore":100,
  "type":"NVIDIA GeForce RTX 5090","mode":"hami-core","health":true}]

节点 allocatable: nvidia.com/gpu = 20。

先验一个最小的:4 GiB 切片

我给一个 Pod 申请 nvidia.com/gpumem: 4096,让它自己去问 CUDA"这块卡有多大":

csharp 复制代码
[1] cuInit            -> 0
[2] cuDeviceGetCount  -> 1
[3] 设备               -> NVIDIA GeForce RTX 4090
[4] cuCtxCreate       -> 0
[5] 容器看到的显存     -> total 4.00 GiB / free 4.00 GiB   ← 物理 48 GiB 被抹掉
[6] 申请 2 GiB        -> 0 成功
[7] 申请 6 GiB        -> 2 CUDA_ERROR_OUT_OF_MEMORY

HAMi 侧同时打出了拦截日志:

markdown 复制代码
[HAMI-core ERROR (allocator.c:40)]: Device 0 OOM 6442450944 / 4294967296

6 GiB 是 6442450944,配额是 4294967296,限额精确到字节,而且是在 CUDA 分配器这一层拦下来的。

这是控制面最基础的一件事:应用问"我有多大显存",答案由编排层说了算,不由硬件说了算。这一步成立之后,一张 24 GB 的卡才能被当成四张 6 GB 的卡来用,GPU 也才算从"设备"变成了"资源"。

再验一次共享:两个租户同卡

两个 Pod 各要 8 GiB,同时钉在 4090 上:

Pod 分配到的卡 切片 内部视角 实际占用
hami-share-1 GPU-86d14e75... 8192 MiB total 8.00 GiB 3458 MiB
hami-share-2 GPU-86d14e75... 8192 MiB total 8.00 GiB 3458 MiB

宿主机这边看到的是:

yaml 复制代码
index  name          used        util
0      RTX 4090      6930 MiB    0 %      ← 两个租户叠加
1      RTX 5090      30408 MiB   0 %      ← 全程未变

GPU-86d14e75..., 1731329, python3, 3458 MiB
GPU-86d14e75..., 1731626, python3, 3458 MiB   ← 同一张卡两个进程

两个 Pod 各自看到的都是自己的 8 GiB,而不是共享的 48 GiB。

所以隔离的含义不只是"你用不了我的",还包括"你根本看不见我的"。


🔸 四、把八个真实业务搬进去

切分能跑通,只是及格线。我真正关心的是:把生产负载搬进来,会不会变慢。

对照组设计

我找了八个同构的容器,是同一套 VL 的 Embedding + Reranker 服务(FastAPI,内部端口 8004,2B 模型),八个实例各自处理自己的分片。

对照是这样设的:

三组都跑在同一张 4090 上,网络路径都是"宿主机端口 → 容器 8004",工作负载完全一致。

先看单实例独占。这种情况干扰最少,能直接看出容器化本身的开销:

指标 docker 原生 HAMi pod 差异
串行 mean 560.3 ms 560.8 ms +0.09%
串行 rps 1.78 1.78 0
并发 4 mean 2102.2 ms 2070.1 ms −1.5%(pod 略快)
并发 4 rps 1.82 1.84 +1.1%

再看八实例同卡,也就是真实的生产形态:

指标 8 × docker 容器 8 × HAMi pod(只切显存) 差异
聚合吞吐 5.97 req/s 5.98 req/s +0.2%
单实例 mean 1333.0 ms 1330.5 ms −0.2%
p50 1334.1 ms 1329.7 ms −0.3%
p95 1340.7 ms 1343.0 ms +0.2%
显存占用 36432 MiB 36432 MiB 完全一致
失败请求 0 / 96 0 / 96 ---

我怕样本太少,又加厚到 320 个请求 重跑了一遍,结果几乎没动:5.95 req/s,p95 1341 ms,0 失败。

同时我也抓了 GPU 侧的遥测:

matlab 复制代码
采样点 55 个 / 55 秒
GPU 利用率 : mean 96%   max 100%
显存       : mean 36463 MiB
功耗       : mean 254 W  max 269 W
温度       : mean 46 C   max 53 C
SM 频率    : mean 2614 MHz  max 2715 MHz

这组里最值得看的是利用率 96%。

它说明 5.95 req/s 不是被编排层拖出来的,而是这张卡本身已经被压满了。八个实例如果线性叠加,理论上应该是 1.78 × 8 ≈ 14.2 req/s,实际只有 5.95,差的那部分是 GPU 上的争抢,和容器化没有关系。

那损失到底在哪

看第三组。还是这八个 Pod,只多加一条 nvidia.com/gpucores: 12:

指标 不限核 gpucores=12 变化
聚合吞吐 5.98 req/s 3.10 req/s −48%
单实例 mean 1330.5 ms 1874.8 ms +41%
p50 1329.7 ms 1443.2 ms +8.5%
p95 1343.0 ms 4773.6 ms +255%

隔离是有代价的,但这个代价记在 SM 配额上,不记在容器化上。

以前大家常担心"上 Kubernetes 之后 GPU 会变慢",从这次的数据看,这个担心基本不成立:K8s 沙箱、vGPU 拦截、hostPath 挂载,三样加起来是 0.2%,在统计上都站不住。真正会让你变慢的,是你自己在 gpucores 里填的那个数。

三个顺带的发现

① 冷启动多了 2.6 秒。 Pod 从创建到 API 可用要 8.5 s ,docker 从 run 到 API 可用是 5.9 s。多出来的时间花在调度、沙箱创建和 hostPath 挂载上。小规模弹性场景里,这笔开销是实打实的,别指望 Pod 能秒级扩容。

② 这个服务本身是串行的。 单实例并发 4 时吞吐 1.82 rps,串行时 1.78 rps,并发基本没提速,延迟反而从 560 ms 涨到了 2100 ms。原因是代码里给模型加载加了互斥锁。

所以这个服务的扩容只能堆实例,没法靠堆并发,这恰好就是 GPU 切分的适用场景。八个 Pod 的 5.95 rps,就是八个独立实例叠出来的。

③ 文档数基本是线性放大的。 同一实例串行:

文档数 mean
5 171 ms
20 551 ms
50 1377 ms
100 2755 ms

每多一个文档大约 +27 ms。这条曲线平不平,直接决定一张卡上能塞几个实例。


🔸 五、三个必须说的问题

好的部分放后面讲,先说问题,都是我实测里踩出来的。

问题一:看不见的显存,是混部的杀手

这是这次踩得最狠的坑。

第一次做多租户测试时,调度器把第二个 Pod 派到了 5090 上,然后直接 OOM。

原因是 5090 上有 30408 MiB 被两个普通 docker 容器占着(strata 21.5 GB,加一个 python 8.7 GB)。这两个容器不归 HAMi 管,HAMi 对它们一无所知。

在 HAMi 的台账里,5090 的 32607 MiB 是满的、全新的、随便切的,于是它很大方地批了一个 8 GiB 的切片,容器一申请就爆了。

这不算配置错误,是架构上天然的观测盲区。HAMi 统计的只是它自己调度出去的 Pod,直接 docker run 起来的容器它管不到,也看不到。

规避办法有,但得自己主动去做:

yaml 复制代码
metadata:
  annotations:
    nvidia.com/nouse-gpuuuid: "GPU-6b12533d-..."   # 把混部卡排除出切片池

也可以在 device-config 里用 filterdevices 按 uuid 或 index 过滤。我最后是用 use-gpuuuid 把八个 Pod 全部钉在 4090 上,问题就没再出现。

但这个坑我觉得做混部的人都该记一下:编排层看到的世界,和机器真实的世界,可以差出 30 GB。

问题二:gpucores 是硬节流,不是软配额

12% × 8 = 96%,看着像是给每个实例分了一小份。实际表现是 p95 从 1343 ms 直接跳到了 4773 ms,尾部放大了三倍半,均值却只涨了 41%。

这说明 SM 配额是硬切的:配额用完,请求就停在那里等,不会"稍微超一点"。所以:

  • 平均延迟会骗人(只涨了 41%)
  • p95 才反映真实情况(涨了 255%)
  • 如果面向用户的 SLA 是按 p95 定的,gpucores 这一栏就得填得很小心

我的建议是:没有强隔离需求,就别填 gpucores,上面那张表已经把代价列清楚了。

问题三:device-config 的默认值是个占位符

hami-device-plugin 的 ConfigMap 里,nodeconfig 的节点名默认值是:

json 复制代码
{"nodeconfig": [{"name": "your-node-name", "operatingmode": "hami-core", ...}]}

而我的节点叫 node1。

名字对不上的时候,它不会报错,只会悄悄走默认配置。这次碰巧默认值就合理(devicesplitcount: 10),所以结果是对的。但如果有人给某个节点改了特殊参数,改完发现没生效,就会很懵。

这种"静默降级",比直接报错难查得多。


🔸 六、异构:这一层为什么必须开放

回到上一篇的那个判断。

我当时说,Run:ai 开源的意义,在于 NVIDIA 认可了 GPU 编排是一个必须开放的公共层。这篇我想补一句更实际的:这一层非开放不可,不是因为理念,是因为供给。

供给已经不只是技术问题

这两年算力方面最大的变量不在技术,在供给。

一张卡能不能按时到,到的是什么型号,下一批还是不是同一个型号,这些问题的答案越来越不确定。

结果就是,一家公司的 GPU 库存,正在从"一种卡若干张"变成"几种卡各若干张"。

异构不是谁选出来的架构,它就是现状。

同一套调度语义能不能同时覆盖这几种架构,决定了这些卡是资产,还是躺在机房里的库存。

HAMi 在这一层的价值

HAMi 的做法是把这件事当成第一性问题来设计:不是先做好 NVIDIA,再去兼容别人,而是一开始就把设备抽象单独拉出来,让调度器面对的是"设备"这个统一概念,而不是某一家厂商的 API。

它列出的国产卡覆盖了昇腾、寒武纪、海光、沐曦、天数、壁仞、摩尔线程这一批,并且共用同一个 hami-scheduler、nvidia.com/gpu 之外同一套资源名语义、同一个 quota 模型。

这件事的分量,做过混部的人才体会得到:统一的意义不在于"支持了多少卡",而在于不用为每种卡重写一遍调度策略。

nvidia.com/gpumem 的语义在异构池里保持一致,运维才有可能只维护一套 SLO。

但"无损适配"要拆开看

这里我得说句实话,不然就成吹了。

HAMi 说的"无损",准确含义是"应用不用改":同一份代码、同一个镜像、同一个 cudaMalloc 调用,换一张卡还能跑。这个价值很大,不要小看。

但它不等于"能力对齐"。我这次实测的是 NVIDIA 这条线,能做到显存加算力双维度切分,能做到字节级硬上限,能给出 Pod 级指标。换成别的架构,不同厂商、不同驱动版本能提供的切分粒度并不一样:有的能到显存加算力,有的只能到整卡,有的指标精度差一截。

所以比较合适的心态是,把 HAMi 当成"统一的最小公约数",而不是指望所有卡都变成 H100。

这个差距不能算 HAMi 的问题,是硬件和驱动能力本来就不同。但用的人得清楚自己是在最小公约数上做设计,别默认每家都能给你同样的切分能力。


🔸 七、两条路线:驱动强制 vs 运行时拦截

这次实测还让我看清了一件事:Run:ai 和 HAMi 在"怎么切"上,走的是两条不同的路。

我上一篇提到,Run:ai 已经把原来的专有分片实现退役,改用 CUDA 13.4 原生的 GPU fractioning,由驱动强制执行每个负载的显存硬上限。当时我写了一句"能力下沉到了 CUDA"。

这次在 HAMi 上,我看到的日志是这样的:

markdown 复制代码
[HAMI-core ERROR (allocator.c:40)]: Device 0 OOM 6442450944 / 4294967296

文件名是 allocator.c,说明是在 CUDA 分配器这一层拦截的,靠 libvgpu.so 通过 LD_PRELOAD 注入实现。

两条路对照起来是这样:

驱动层强制(CUDA 原生) 运行时拦截(HAMi-core)
强制位置 驱动,应用绕不过 用户态,拦截 API 调用
对旧卡/旧驱动 需要新驱动 通吃,这正是它的价值
对异构 每家的驱动得各自实现 一套拦截逻辑覆盖所有
强度 硬边界(安全级) 软边界(管理级)

我觉得两条路各有道理,短期内也会并存。

驱动层强制更硬、更安全,但前提是驱动要跟得上,而在异构池里,你没法要求每张卡的驱动版本都同步到最新。

运行时拦截要软一些,但它是"老驱动加多厂商"这个现实约束下,唯一能立刻落地的方案。

这对国产卡这条线尤其合适:不用等驱动升级,先把卡管起来再说。

顺便说一句,这个差异也解释了前面问题一的性质。用户态拦截只能看见经过它的调用,没走 libvgpu.so 的容器,对 HAMi 来说就是透明的,所以才会有那个 30 GB 的观测盲区。这两件事是同一个设计选择的两面。


🔸 八、把两张表放一起看

上一篇我给过一张分工表,这次可以把实测数字补进去了:

层 关注点 优化什么 本次实测
Runtime(vLLM / SGLang) 如何让 Token 更快出来 执行效率 双侧一致,560 ms
Scheduler(HAMi / Run:ai) 如何让 GPU 不浪费 资源效率 切分 0.2% 开销;限核 −48%
Cluster(Kubernetes) 如何让机器不浪费 机器效率 冷启动 +2.6 s

上一篇我写过这么一句:

Runtime 优化的是执行效率(Execution Efficiency);Scheduler 优化的是资源效率(Resource Efficiency)。

当时这还只是个概念,现在它有数了:

  • 执行效率:单个请求多快。560 ms,编排层不碰它。
  • 资源效率:一张卡能同时服务几个。从 1 个到 8 个,这是编排层给的。

把这两个数放在一起,价值就很直观:

一个实例 1.78 rps,八个实例 5.95 rps。 你多花的不是延迟,是三层楼的机柜。

还有那个 96% 的利用率,也提醒我这张卡已经被榨干了,剩下的提升空间不在编排层,在服务本身(那个串行的互斥锁)。

编排层的贡献是"让八个一起跑",不是"让一个跑得更快",这也基本就是这一层的边界。


🔸 九、落到工程师身上

上一篇我写过"你可能只有一张 5090,明天要管几十张 H100"。

现在我想换个说法:你可能已经有三张不同架构的卡了。

那么这次实测里,有几条可以直接拿去用:

  1. 别怕把 GPU 负载搬进 K8s。 容器化本身只有 0.2% 的开销,不是 20%。真正会变慢的,是你自己填的 gpucores。
  2. gpucores 慎填。 平均延迟只涨 41%,p95 涨了 255%,如果你按均值做容量规划,会被打脸。
  3. 混部之前,先查"看不见的显存"。 nvidia-smi 和 HAMi 台账对不上的时候,信 nvidia-smi。
  4. 扩容靠堆实例,别指望堆并发。 前提是服务本身是串行的,很多推理服务都是这样。
  5. 冷启动按秒算,不按毫秒算。 建一个 Pod 要 8.5 秒,弹性策略得按这个量级来设计。

理解 Runtime,能让一张卡跑得更快;理解 Scheduler,才能让一堆卡跑得更值。这句话我上一篇写过,这一篇算是把它从判断变成了测量结果。而且结果是站在 Scheduler 这边的,我挺高兴。


🔸 十、最后

回到开头的问题:GPU 编排到底该不该单独成一章。

我的答案没变,但理由换了。

上一篇的理由是"它同时管钱和管卡"。这一篇的理由是:它管的那部分,是唯一有 8 倍空间的那部分。

一个实例 1.78 rps,八个实例 5.95 rps。Runtime 再怎么优化,也给不了 8 倍,因为它优化的是一张卡的内部。只有编排层,才能把"一张卡"变成"八份可以卖的东西"。

这一层正在从闭源走向开放,从单一厂商走向异构。这个方向不是哪一家公司决定的,是供给结构推着走的。

开源不等于胜利。但当一个池子里必然同时存在好几种架构时,"能统一管理"本身就已经是刚需了。

差点忘了说:这次实测的脚本、配置和原始数据都在我本地,包括那个 30 GB 观测盲区的复现步骤,感兴趣的可以留言,一起看。


【一句话总结】把八个真实业务从 docker 搬进 HAMi Pod,容器化加 vGPU 切分只带来 0.2% 的差异,基本等于无损;真正的性能代价记在你填的 gpucores 上,限核 12% 换来吞吐 −48%、p95 +255%。所以 GPU 编排这一层的价值,不在让一张卡跑得更快,而在让一张卡变成八份能卖的东西;它之所以必须开放、必须支持异构,不是因为理念先进,而是因为你下一个算力池里大概率不会只有一种卡。

最近阿里的PPU很火你听说了么?


相关推荐
forest_094 小时前
《AI 编程 Harness 实战手册》04|审批这道门:点了一百次“允许”,还剩多少作用?
人工智能·算法·prompt·agi
火山引擎开发者社区5 小时前
当 RPA 遇上 Agent:MUA 混合执行 Workflow 深度拆解
人工智能
严肃小白兔5 小时前
第 10/24 期:深度神经网络的自动求导机制与梯度验证
人工智能·神经网络·dnn
火山引擎开发者社区6 小时前
定档12.16-12.18!FORCE原动力大会上海见!
人工智能
努力的MM1236 小时前
CAIE 二级和阿里云大模型 ACP 怎么选?企业 AI 工程与云平台开发能力对比
人工智能
老金带你玩AI6 小时前
Kling Image 4.0来了!8K和组图直出,电商人的提效神器?
人工智能
孟健6 小时前
用 unslop 拯救 AI 生成网页的塑料感,7 分钟重构落地实测
前端·人工智能·ai编程
stormzhangV7 小时前
Google 重返第一梯队
人工智能·google·aigc