前面的文章提到过,提升集群的GPU利用率可以有效地降低 Token 工厂的成本。这句话说起来容易,落到 Kubernetes 上却有个硬约束:Kubernetes 只会按整数分配 GPU。一个申请 nvidia.com/gpu: 1 的 Pod 拿到整张卡,哪怕它的模型只需要 2 GiB 显存。而智能体常用的 rerank、embedding 模型都是这样的小模型,如果每个小模型都独占一张卡的话,GPU利用率肯定上不去。

本文讨论我们怎么把 HAMi 接进 Go TaaS,把一张物理卡切成几份分配给几个小模型,并且用一套可复现的基准测出真实收益——包括收益没有想象中大的地方。


1. HAMi 是什么

HAMi 全称 Heterogeneous AI Computing Virtualization Middleware(异构 AI 计算虚拟化中间件),前身是 k8s-vGPU-scheduler,目前是 CNCF 孵化项目。它解决的核心问题:让 Kubernetes 能把一张物理加速卡切开,分给多个容器,并且各自有边界。

工作原理

HAMi 由四个部分组成:

组件形态作用
MutatingWebhookhami-scheduler Deployment 的一部分发现 Pod 申请了 HAMi 资源,把 schedulerName 改成 hami-scheduler
HAMi 调度器hami-scheduler Deployment(内嵌 kube-scheduler + extender)维护每张卡的余量视图,选节点、选卡,把结果写进 Pod 注解
device plugin每个 GPU 节点一个 DaemonSet向 kubelet 上报设备,Pod 启动时把卡和 libvgpu.so 挂进容器
HAMi-Core(libvgpu.so)容器内 preload 的库拦截 CUDA/NVML 调用,执行显存与算力限额

一个申请 nvidia.com/gpumem: 3000 的 Pod 的调度流程如下:

关键是第 4 步:只有 HAMi 调度器知道哪张卡还有余量,也只有它会写 hami.io/vgpu-devices-allocated 这个注解。device plugin 完全依赖这个注解来分配设备。把切片 Pod 交给 kube-scheduler 或 Volcano,Pod 会一直 Pending——这一点我们在集成时踩过一次。

资源模型

资源名含义
nvidia.com/gpu申请的 vGPU 个数(必须带,它是设备插件注册的计数资源)
nvidia.com/gpumem每个 vGPU 的显存,单位 MiB 的整数
nvidia.com/gpumem-percentage显存按卡容量百分比申请
nvidia.com/gpucores算力占比,5–100
nvidia.com/priority同卡容器的优先级,影响算力限速策略

这里得提一下容易踩坑的两个细节:

  • gpumem 是纯 MiB 数值。写成 6Gi 会被当成 60 亿 MiB,等价于不限制。我们第一次就写成了 6Gi,容器里 nvidia-smi 照样显示整卡的显存容量,但 Pod 看起来是成功的——这种”静默失效”最难查。
  • gpucores 不是硬隔离。HAMi-Core 用令牌桶控制 kernel 提交速率,后台线程采样 GPU 利用率来补令牌。官方文档明确了三种策略:default 只在同卡有同/高优先级容器跑 kernel 时限速,force 始终按配额限速,disable 不限速。HAMi 不为 Pod 预留 SM,所以算力隔离是尽力而为。

隔离边界

维度是否硬隔离说明
显存是超出限额的分配返回 CUDA_ERROR_OUT_OF_MEMORY,只影响该容器
显存可见性是容器内 NVML 返回限额,nvidia-smi 的 total 就是切片大小
算力否,尽力而为令牌桶 + 采样,不预留 SM
故障域否同卡容器共享同一个 CUDA 上下文与驱动

所以 HAMi 的缺点很明确:**它适合”多个小模型共享一张卡”,不适合”强 SLA 的多租户混部”**。后者应该上 MIG(硬件分区),代价是粒度固定、卡型受限。但是对于 Token 工厂而言,多租户隔离的是 Token 的使用,加速卡由厂商或者管理员统一调度,我们只需要在集群中划分出几个节点专门给 HAMi 使用即可。


2. 为什么 Token 工厂需要集成 HAMi

小模型的整卡浪费

我们在实验集群上跑了一个 Qwen2.5-0.5B(bf16,权重 954 MB)和一个 Qwen2.5-1.5B(2.0 GiB)。整卡部署时,vLLM 的日志是这样的:

1
2
3
Model loading took 0.93 GiB memory and 3.80 seconds
Available KV cache memory: 19.89 GiB
GPU KV cache size: 1,737,840 tokens, Maximum concurrency for 4,096 tokens per request: 424.28x

0.93 GiB 权重,却占了 19.89 GiB 的 KV cache。这不是浪费——vLLM 默认 gpu_memory_utilization=0.92,它会把可见显存的 92% 一次性预占成 KV cache,用更大的 batch 换更高的吞吐。这是对的做法。

问题在于 Kubernetes 的视角:这张卡”已分配”,第二个模型无论多小都排不上。从集群指标看,DCGM_FI_DEV_FB_USED 是 23299 / 24564 MiB,看起来”卡用满了”;从业务看,这张卡只服务一个 0.5B 模型。显存被预占,不等于算力被用满——实测这两张卡的 DCGM 利用率是 76.3% 和 84.8%(第 4 节)。

对一个按 token 计费的平台,这直接决定了单位卡能提供多少个可售模型。整卡模式下,2 张卡 = 2 个模型;每个新增的小模型都要一张新卡。

为什么不是 MIG,也不是 MPS

方案为什么不用
NVIDIA MIG卡型有限制;支持的数据中心卡也只有固定的几种切法(如 1g.5gb),切法由硬件枚举,不能按业务自定义
CUDA MPS只做算力并行,不做显存隔离。一个进程 OOM 会拖垮同卡的其他进程

HAMi 是这三者之外的一层:显存硬限制 + 算力软限制 + 对应用零改动 + K8s 原生资源模型。对 Go TaaS 这种把”部署一个模型”做成表单操作的产品,应用无感知很重要 —— 我们不需要为了适配 HAMi 而改 YAML,更不需要改推理框架。


3. Go TaaS 是如何集成 HAMi 的

抽象设计

运营者的词汇是”池 + 模板”,不是注解,因此我们没有把 nvidia.com/gpumem / nvidia.com/gpucores 暴露给用户。让用户自己填显存和算力,容量规划就失效了。取而代之的是两层抽象:

  • vGPU 池(pool):一组由节点标签指定的节点,例如 go-taas.com/vgpu-pool=pool-a。只有池里的节点才会被切片。
  • 切片模板(template):池上允许用户(管理员)定义模板,例如 quarter = 6 GiB + 25%、half = 10 GiB + 50%。启动推理服务时选择模板即可。

Controller 实际生成的东西

一个 quarter 模板(6 GiB / 25%)的服务,Pod 变成这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
spec:
schedulerName: hami-scheduler # 必须:只有它选卡并写分配注解
nodeSelector:
go-taas.com/vgpu-pool: pool-a # 池的标签选择器(部署时从池解析)
...
containers:
- name: engine
resources:
limits:
nvidia.com/gpu: "1" # vGPU 个数
nvidia.com/gpumem: "6144" # MiB 整数,不能带单位
nvidia.com/gpucores: "25"
args:
- --gpu-memory-utilization
- "0.88" # 切片内 12% 余量

Pod 上的注解 hami.io/gpu-scheduler-policy: binpack 来自池的放置策略——这个注解现在真的生效了,因为切片 Pod 走的是 HAMi 调度器。

集成时遇到的问题

集成并不是一次就通的,这里记录一下遇到的问题:

问题 1:只请求 gpumem / gpucores,没有请求 nvidia.com/gpu。
nvidia.com/gpumem 不是节点的 allocatable 资源,它只是 device plugin 读取的请求字段。少写 nvidia.com/gpu: 1,调度器看到的就是”这个 Pod 没申请任何 GPU 设备”,或者”申请了不存在的资源”,两种情况都不会绑定到正确的卡。

问题 2:gpumem 写成了 6Gi。
resource.MustParse("6144Mi") 再序列化会变成 6Gi,而 HAMi 用 AsInt64() 取 MiB 数值。6Gi 被解析成约 6×10⁹ MiB,远大于卡容量,等于没有任何限制。容器里 nvidia-smi 仍然显示 24564 MiB,CUDA_DEVICE_MEMORY_LIMIT_0=0m:

1
2
3
4
$ nvidia-smi --query-gpu=memory.total --format=csv,noheader
24564 MiB
$ echo $CUDA_DEVICE_MEMORY_LIMIT_0
0m

改成不带单位的整数后正确切分:

1
2
6144 MiB
LIMIT=6144m SM=25

问题 3:切片 Pod 没有交给 HAMi 调度器。
原实现沿用平台的 Volcano 调度器。Volcano 不认识 nvidia.com/gpumem,也不会写 hami.io/vgpu-devices-allocated,结果是 Pod 一直 Pending,事件里什么都没有。

这个问题还有第二层,比第一层更容易误判:装完 HAMi 之后,整卡 Pod 也必须交给 HAMi 调度器。因为 nvidia.com/gpu 已经由 HAMi 的 device plugin 接管,而它的 Allocate() 只从 Pod 注解里读设备列表(pkg/device-plugin/nvidiadevice/nvinternal/plugin/server.go):

1
2
3
4
5
6
7
currentCtr, devreq, err := GetNextDeviceRequest(nvidia.NvidiaGPUDevice, *current)
klog.Infoln("deviceAllocateFromAnnotation=", devreq)
// ...
if len(devreq) != len(reqs.ContainerRequests[idx].DevicesIds) {
PodAllocationFailed(nodename, current, NodeLockNvidia)
return &kubeletdevicepluginv1beta1.AllocateResponse{}, errors.New("device number not matched")
}

Pod 由 Volcano 绑定时,devreq 是空的(没有 HAMi 选卡的记录),设备数对不上,分配直接失败;kubelet 反复重试,Pod 在 Scheduled 与 Pending 之间循环,上游控制器则不断重建它。实测现象很容易误判:Volcano 的日志里是 bind ok,Pod 却永远不 Running。

所以正确的规则是:HAMi 接管设备资源的节点上,所有申请加速器的 Pod 都由 hami-scheduler 放置,整卡也一样。修复后切片 Pod 与整卡 Pod 都走 hami-scheduler,并验证整卡服务正常启动。

代价要说清楚:这些 Pod 就没有 gang 调度了——Pod 的 schedulerName 是 hami-scheduler,Volcano 永远不会读它的 PodGroup,所以我们把 PodGroup 的写入限定在”没有 HAMi”的情况下。如果既要 HAMi 切分、又要 gang 调度,需要改用 HAMi 的 Volcano 集成(Volcano 自己的 vGPU device plugin),那是另一套安装形态。

问题 4:vLLM 的默认 gpu_memory_utilization=0.92 在切片里必然 OOM。
HAMi 把 nvidia-smi 的 total 改成了切片大小,但 CUDA 的 mem_get_info 仍按切片算,于是引擎按 92% 预占、只留 8% 余量,而激活峰值和 CUDA graph 需要的不止 8%。实测 6144 MiB 的切片:

1
2
3
Free memory on device (5.62/6.0 GiB) on startup. Desired GPU memory utilization is (0.92, 5.52 GiB).
[HAMI-core ERROR] Device 0 OOM 6471943168 / 6442450944
torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 54.00 MiB.

切片比整卡小得多,8% 的绝对余量也更小。我们把启用切片的推理服务的默认值降到 0.88(12% 余量),并保留运营者覆盖的能力。修复后同一个切片的日志:

1
2
3
Free memory on device (5.62/6.0 GiB) on startup.
Available KV cache memory: 3.86 GiB
GPU KV cache size: 337,184 tokens, Maximum concurrency for 4,096 tokens per request: 82.32x

问题 5:管理面看不到池成员。
accelerator inventory 只上报加速器相关标签(go-taas.com/accelerator、驱动版本、卡型号),把运营者自己打的 go-taas.com/vgpu-pool 过滤掉了。结果池的 nodeCount 是 1,但 nodes 是空数组,容量核算无从谈起。同时每张卡的清单也是空的——切片之后节点的 nvidia.com/gpu 是 vGPU 个数(20),不是物理卡数(2)。修复方式是上报所有 go-taas.com/* 标签,并从 HAMi 的节点注册注解 hami.io/node-nvidia-register 读每张卡的 index / 型号 / 显存。

修复后的验证

两个服务(0.5B quarter、1.5B half)被 HAMi 的 binpack 策略放到了同一张物理卡上:

1
2
3
$ kubectl get pod -o jsonpath='{...annotations.hami\.io/vgpu-devices-allocated}'
GPU-e447a90d-67d7-9381-7201-f803ffc43179,NVIDIA,6144,25:;
GPU-e447a90d-67d7-9381-7201-f803ffc43179,NVIDIA,10240,50:;

同一个 GPU UUID,6144 MiB/25% 与 10240 MiB/50%,都是从 hami-scheduler 拿到的。两个容器内的 nvidia-smi 分别只看到 6144 MiB 和 10240 MiB:

1
2
3
4
5
$ kubectl exec <0.5B pod> -- nvidia-smi --query-gpu=memory.total --format=csv,noheader
6144 MiB # LIMIT=6144m SM=25

$ kubectl exec <1.5B pod> -- nvidia-smi --query-gpu=memory.total --format=csv,noheader
10240 MiB # LIMIT=10240m SM=50

到这里,显存与算力的边界是真实存在的,而不是配置里的一个数字。


4. 集成 HAMi 之后 GPU 利用率的提升

测试环境与方法

项值
集群RKE2 v1.36.2,Ubuntu 22.04.5,2 节点
切分池节点2 × NVIDIA GeForce RTX 4090,24564 MiB/卡,驱动 595.91.07,CUDA 13.2
HAMiv2.9.0(chart 2.9.0),deviceSplitCount: 10
平台Go TaaS 1.118.1
推理引擎vLLM 0.28.0(vllm.entrypoints.openai.api_server)
模型Qwen2.5-0.5B-Instruct(954 MB)、Qwen2.5-1.5B-Instruct(2.0 GiB),bf16
模型参数--max-model-len 4096

负载:固定的中文 prompt(89 token),max_tokens=128、temperature=0、ignore_eos=true,每个服务 N 并发,持续 60 s;先发一轮预热,不计入统计。

计量:

  • 客户端统计 completion tokens/s、请求数、p50/p95/p99 延迟(httpx 异步压测脚本,跑在集群内的 Pod 里,直连 Service);
  • GPU 侧用集群已有的 DCGM exporter,DCGM_FI_DEV_GPU_UTIL(有 kernel 运行的时间占比)与 DCGM_FI_DEV_FB_USED(显存占用),2 s 采样,取压测窗口内均值。

为什么按”每卡并发”对齐:整卡方案是 1 个服务 8 并发/卡;切片方案是 2 个服务各 4 并发 = 8 并发/卡。这样比较的是”同一张卡、同样的请求压力,能产出多少 token”,而不是拿低并发和高并发对比。

基线:整卡独占

服务模型卡数tokens/sreq/sp50 (ms)p95 (ms)p99 (ms)
whole-05bQwen2.5-0.5B13372.126.34300.7324.7355.0
whole-15bQwen2.5-1.5B11513.811.83674.5691.8706.1

DCGM(60 s 窗口均值):卡 0 利用率 **76.3%**,卡 1 **84.8%**;显存占用 23299 / 23019 MiB。

值的注意的是:**显存占用 94%,但算力只用了 76–85%**。这就是”整卡分配”的真实问题——显存被 vLLM 预占满,算力仍有 15–24% 的空隙无法利用。

切片:一张卡两个模型(25% + 50%)

切分池策略 binpack,每卡放一个 quarter(0.5B)和一个 half(1.5B),每个推理服务 4 并发。

服务模板物理卡tokens/sreq/sp50 (ms)p95 (ms)p99 (ms)
slice-05b-1quarter 6 GiB/25%GPU-e447…663.55.18777.9794.3803.0
slice-15b-1half 10 GiB/50%GPU-e447…238.31.862190.42232.62565.8
slice-05b-2quarter 6 GiB/25%GPU-8b2f…661.75.17775.3797.8877.5
slice-15b-2half 10 GiB/50%GPU-8b2f…746.75.83679.7694.01004.6

合计 2310 tokens/s(2 张卡,4 个推理服务);DCGM指标:卡 1 **100%**,卡 0 **76.6%**。

需要解释如下两个现象:

第一,总吞吐低于整卡。 整卡双服务是 4886 tokens/s,切片双服务是 2310 tokens/s。原因是:25% + 50% = 75% 加速卡的算力配额先砍掉 1/4;两个引擎在同一张卡上时间片轮转,KV cache 反复换入换出,再损失一部分。HAMi 不为切片预留 SM,这个代价是必然的。

第二,同规格的两个服务吞吐差 3 倍(238 对 747)。它们配额相同、邻居规格相同,差异来自 HAMi 的算力限制实现:令牌桶按采样窗口补令牌,default 策略下只有”同卡有同/高优先级容器在跑 kernel”时才限速。采样与调度的时序决定了谁在什么时刻被限流,不保证按配额严格成比例。所以 238 这个数字不是”1.5B 只需要 238 tokens/s”,而是”这一轮它被限得更狠”。要拿延迟做 SLO,得靠保守配额、独立池,或把关键服务放到整卡上。

切片:一张卡三个同规格模型(3 × 25%)

为了看”密度”的极限,我们在一张卡上放了 3 个 0.5B、都是 quarter(6 GiB/25%),每个 3 并发(合计 9 并发/卡,与基线的 8 并发基本对齐)。

服务物理卡tokens/sp50 (ms)p95 (ms)
dense-1GPU-e447…481.4797.4814.4
dense-2GPU-e447…486.7786.7809.1
dense-3GPU-e447…479.2797.5812.7
合计1447.3

DCGM:该卡利用率 **100%**,显存峰值 19165 MiB。

对照组:同一个 25% 切片独占一张卡(邻居空闲)时是 1318.7 tokens/s、p50 287.7 ms、利用率 54.9%、显存 6391 MiB。

把两组放在一起,结论就出来了:

1
2
1 个 25% 切片独占卡:  1318.7 tok/s   利用率 54.9%   1 个模型
3 个 25% 切片同卡: 1447.3 tok/s 利用率 100% 3 个模型

同一张卡的 token 产出基本不变(+9.7%),可跑的推理服务数变成 3 倍,GPU 利用率从 55% 变成 100%。 这 9.7% 的增量来自三个引擎的请求互相填补了对方的批处理空隙——单引擎在 3 并发下等请求,三引擎叠加后 GPU 很少空转。

结果对比

维度整卡切片(25%+50%)切片(3×25%)
每卡模型数123
2 张卡可上线模型数246(按同规格推算)
每卡 tokens/s(同并发)244311551447
单模型 p50300–675 ms680–2190 ms~790 ms
GPU 利用率(DCGM)76–85%76–100%100%
显存边界无6 / 10 GiB 硬限制6 GiB 硬限制

结论如下:

  1. 收益在”密度”和”边界”,不在”同一负载跑得更快”。 如果负载不变、模型不变,切片只会更慢——多出来的上下文切换和算力配额就是成本。切片的价值出现在”卡不够、模型很多”的场景:4 个小模型 2 张卡,整卡方案根本部署不了,只能加卡。
  2. GPU 利用率提升 整卡方案的显存占用是 94%,看起来”用满了”;DCGM 利用率只有 76–85%。切片后显存占用反而降到 19 GiB,利用率却到 100%。按显存做容量规划会得出完全相反的结论。
  3. 单位 token 的算力成本不一定下降

当利用率提升所带来的“固定成本摊薄效应”,大于 HAMi 软件切分所引入的“有效吞吐量损失”时,单位 token 的成本才会真实下降。

如果 HAMi 把一张原本大量闲置的卡切分后,填充了大量原本无法被服务的小任务,使得总有效 token 产出显著增加,那么成本下降是成立的。但如果切分后,多个任务在软件层竞争同一张卡的计算资源,导致整体 MFU 下降,吞吐量的损失就可能抵消甚至超过利用率提升带来的好处。

因此,衡量 HAMi 经济性的最终指标,不应是简单的“GPU 利用率”,而应是在给定延迟 SLA 下,每卡每小时能产出的有效 token 数(tokens/GPU-hour)。只有这个指标上升,单位 token 的成本才真正下降。

部署问题

  • **DEVICE_DISCOVERY_STRATEGY=nvml**:默认的 auto 依赖 ResolvePlatform() 探测,在 RKE2 + GPU Operator 的节点上会落到 Incompatible strategy detected auto。显式指定可以跳过探测。
  • **nvidiaDriverRoot: "/"**:驱动装在宿主机 /usr/lib/x86_64-linux-gnu,/run/nvidia/driver 是个空目录(GPU Operator 只建了骨架)。指到 /run/nvidia/driver 会导致 NVML ERROR_LIBRARY_NOT_FOUND。

另外要关掉 GPU Operator 的 device plugin,否则它会和 HAMi 抢着向 kubelet 注册 nvidia.com/gpu:

1
2
kubectl patch clusterpolicy cluster-policy --type merge \
-p '{"spec":{"devicePlugin":{"enabled":false}}}'

5. 小结

HAMi 是什么:Kubernetes 上的 GPU 切分层。它把”一张卡”变成”若干个有显存与算力边界的 vGPU”,靠 webhook + 调度器 + device plugin + 容器内 libvgpu.so 四段协作完成,对应用零改动。

为什么 Token 工厂需要它:小模型占不满卡,是推理负载的结构性特征。整卡分配下,0.5B 模型会把 24 GB 卡的 94% 显存预占成 KV cache,第二个模型无处安放;而卡的算力只用了 76–85%。

Go TaaS 怎么集成:把运营者的”池 + 模板”翻译成 HAMi 的资源请求与注解。

实测收益(2 × RTX 4090,Qwen2.5-0.5B / 1.5B):

整卡切片
每卡模型数12–3
2 卡可上线模型数24–6
GPU 利用率(DCGM)76–85%100%(3 切片同卡)
每卡 tokens/s(同并发)24431155–1447

HAMi 不会让一张卡产出更多 token。但它让一张卡能同时服务更多模型,并且给每个模型划出硬边界。对 Token 工厂,这解决的是”卡不够、小模型很多”这个具体问题——把 2 张卡的供给从 2 个模型变成 4–6 个模型,扩容粒度从一张卡变成 6 GiB 显存 + 25% 算力。

什么时候不该用:模型的权重加 KV cache 本身就接近吃满一张卡,或者对延迟有硬 SLO 的场景。前者是因为没有切分的空间,后者是因为 HAMi 的算力隔离是尽力而为,无法承诺。这种情况下,整卡 + 独占仍是正确选择——HAMi 只是多了一个可选项,不是所有场景的更优解。