GPU集群调度公平性

可视化演示

动态演示GPU集群调度公平性的核心机制，通过入门/进阶/实战/优化四种模式展示关键概念与交互流程。

多租户资源竞争

把GPU集群想象成一家24小时营业的自助餐厅，几个AI团队是常客。自然语言组的餐盘上堆满GPU“牛排”，却几乎不碰内存“米饭”；视觉组恰好相反，显存“甜点”拿了一盘又一盘；推荐组则是每样都来一点。餐厅经理很快发现，如果按人头平均分配食材——每人一份完全相同——那自然语言组的牛排不够吃，视觉组的甜点被浪费，推荐组看着盘子里用不上的东西干瞪眼。这就是多租户GPU集群的第一课：用户的需求是异构的，平均分配并不等于公平分配。

在多租户GPU集群中，多个团队共享同一批物理GPU，有的跑大模型训练（吃GPU算力），有的做推理服务（吃显存和内存），有的做数据预处理（吃CPU和I/O）。如果调度器不考虑需求的差异，简单按比例分配资源，就会出现两种恶果：一是需要大量GPU的团队长期排队，二是某些节点的显存被低效占用，整体利用率上不去。更棘手的是，用户会为了“抢到”资源而虚报需求，进一步加剧分配不均。

因此，调度器的核心目标不是让每个用户拿到相同数量的资源，而是让每个用户感受到公平。什么叫“感受到公平”？一位用户最看重GPU，他评判公平的标准是“我拿到的GPU占我需求的占比”；另一位用户最看重内存，他则盯着内存份额。好的调度算法要同时照顾这些不同的“满意标尺”。这就是现代集群调度中“多资源公平”思想的起点——在餐厅里，让每个人都按自己真正爱吃的菜来计量“我吃没吃饱”。

DRF多资源公平

为了给自助餐厅设计一套公平分菜流程，我们引入一位“AI分菜师”，它采用的策略叫 DRF（Dominant Resource Fairness，主导资源公平）。分菜师有个独特的观察习惯：它不看每个用户拿了多少总量，而是先判断每个用户“最离不开哪种资源”——这种资源就叫他的主导资源。

假设集群总共有 100 块 GPU、200 GB 内存。用户A的训练任务每跑一个样本要 2 块 GPU 和 1 GB 内存，那么在总容量中，A对GPU的需求占比是 \(2 \div 100 = 2\%\)，对内存的需求占比是 \(1 \div 200 = 0.5\%\)。GPU 占比更大，所以 GPU 就是 A 的主导资源。用户B的推理服务每路要 1 块 GPU 和 4 GB 内存，那么B对内存的需求占比是 \(4 \div 200 = 2\%\)，内存是他的主导资源。DRF 的分菜逻辑很简洁：每一轮，把资源分配给当前主导份额最小的用户。它追求的是让所有用户的主导份额尽量相等。

DRF 在GPU集群中的应用特别直观。假设有三支团队：大模型训练组、视觉推理组、离线批处理组。大模型组要大量GPU，视觉组要大量显存，批处理组要内存。如果只按GPU数量平均分，视觉组和批处理组都会不满；如果只按内存平均分，大模型组会饿死。DRF 则分别计算每支团队的主导份额，然后让三者趋近相等。你会发现，大模型组拿到的GPU数量可能确实更多，但这正是因为GPU在他眼里“最珍贵”——这恰恰是公平。

回到自助餐厅的比喻：DRF 分菜师不再给每人一样的餐盘，而是先问每个客人“你最想吃什么”，然后让每个人“最想要的那种菜拿到手的比例”尽量接近。爱吃牛排的客人多吃牛排，爱吃甜点的客人多吃甜点，大家比较的不是“分量一样”，而是“我最想吃的东西，我得到了它应有的比例”。

max-min公平算法

在 DRF 诞生之前，调度界最朴素的一条公平准则是 max-min 公平：让资源最少的人，尽可能多地获得资源。用餐厅的话说，就是“最饿的人先夹菜”。这条准则源自一个基本直觉——如果你要保证所有人的最小满足度都能尽量大，就应该优先照顾那些目前获得最少的人。它是“公平”二字最原初的数学形态。

max-min 算法的执行过程很像流水线分餐：第一轮，先把资源分给当前需求量最小的用户，满足他后，剩余资源再分给需求量第二小的用户……以此类推。这样，即使某个用户的需求特别小，他也能先被满足，不会被大胃王挤掉；而那些需求极大的用户，在所有人被满足到同一水平后，剩下的资源继续按需追加。核心原则可以写成一句话：任何用户 i 获得的资源，不能因为其他用户想要更多就被剥夺。

在单资源场景——比如只看GPU张数——max-min 是最直观、也最容易实现的公平策略。许多集群调度器（比如Hadoop YARN 的 Capacity Scheduler）都内置了类似逻辑：短小的低优先级任务先完成，大任务后启动；所有队列都保证一个最小容量，不会出现某个队列永远抢不到资源的情况。当资源变成多维度时，max-min 就直接推广为 DRF——DRF 本质上就是“把每类资源换算成份额后，在份额层做 max-min”。

用餐厅的话说：max-min 策略是“让最饿的人先夹菜，等他吃上了，再让第二饿的人夹，最后还有剩，再给能吃的多加一些”。它保护的底线是——任何时候，都不会有一个人被晾在餐桌角落，连一口汤都喝不上。

权重资源分配

自助餐厅营业一段时间后，经理发现：有些客人是 VIP——比如正在跑线上推荐服务的用户，服务断了要赔钱；有些客人是普通食客——比如离线实验团队，晚跑几小时也无所谓。如果一视同仁地公平，VIP 客人会急得跳脚。于是，公平的定义需要引入一个修正项：权重。

在 GPU 集群调度中，权重是个贴切的“优先级刻度”。某团队权重为 \(w_i=2\)，另一团队权重为 \(w_j=1\)，那么在公平分配时，前者分到的份额比例应该是后者的 2 倍。权重化之后，DRF 的公平目标从“主导份额相等”变成“主导份额与权重之比相等”。这样既能体现业务优先级，又不至于让低权重团队完全饿死——因为算法仍然保证每个人至少获得与权重相匹配的一个下限。

在工程实践中，权重配置要小心。比如 K8s 的 ResourceQuota 可以为每个命名空间设置请求上限；YARN 的 Capacity Scheduler 支持队列权重分配；Slurm 的 PriorityWeight 系列参数则综合了年龄、QOS、公平因子。如果你的平台有在线推理和离线训练两类任务，常见的做法是给在线推理设置更高的权重，同时给离线任务一个最低保障配额，避免高权重任务永久霸占集群。

回到餐厅：权重就是“VIP 卡”。持有 VIP 卡的客人，分菜师会优先给他端上主菜；但普通客人也永远不会被赶出门——餐厅会给每个层次都预留最基本的座位和食物。这就是现代调度器里“加权公平 + 最小保证”的智慧：让公平拥有弹性，让优先级有边界。

公平性度量方法

分菜师到底做得好不好，不能只靠感觉。就像餐厅会用“顾客满意度问卷”来打分，集群调度也需要一把尺子来度量公平。最常用的尺子叫 Jain 公平指数（Jain's Fairness Index）。假设我们有 \(n\) 个用户，每人获得了 \(x_i\) 份资源，那么 Jain 指数定义为：

这个指数有一个极好的性质：当所有用户获得完全相同的份额时，\(J = 1\)，表示绝对公平；反之，若某个用户独占所有资源，\(J \to 1/n\)，接近 0，表示严重不公平。它是调度器调参时最直观的仪表盘。

除了 Jain 指数，另一个常见的度量是基尼系数——经济学里衡量收入分配不均的经典指标。基尼系数为 0 表示绝对平均，为 1 表示绝对不平均。在集群场景中，基尼系数可以用来衡量不同队列获得资源量的离散程度。此外，分布式系统里还经常关注两个动态指标：饥饿时间（某个任务等待资源超过阈值的时间）和队列延迟公平（不同租户的平均排队耗时差距）。一个系统即使 Jain 指数很高，如果个别短任务被无限期饿死，也算不上真公平。

用餐厅的话说：Jain 指数就是“满意度分数卡”，基尼系数是“贫富差距曲线”，饥饿时间是“有没有客人饿晕的记录”。一个好的分菜师，三张表都要好看。这样管理者打开监控面板，一眼就能看出哪桌客人在挨饿、哪桌在被过度投喂，进而优化下一轮的配菜策略。

公平效率权衡

看到这里，你可能会想：只要把公平算法调到完美，世界就太平了。但现实中的分菜师面临一个尴尬：绝对公平可能带来巨大的浪费。设想一下，餐厅为了“绝对公平”，把整块牛排切成细丝，平均分给每一位客人——每个人只吃到一口，主厨的锅却因为切了太多次而累坏了。这在计算集群中叫资源碎片化：为了维持公平，把一批 GPU 拆得七零八落，结果谁也跑不成大任务。

反过来，如果一味追求效率——谁的任务先来，就把全部空闲 GPU 都给他——那么后来的高优任务会被饿死，长此以往，低优任务永远找不到资源，整体体验崩塌。公平与效率，就像天平的两端：压低了公平，效率曲线上升但长尾恶化；压低了效率，公平指数高但资源空转。现代调度器的解法不是二选一，而是引入弹性配额与抢占回收机制。所谓弹性配额，就是允许用户突破下限去使用闲置资源，但一旦资源紧张，超出部分会被回收（preemption），低优任务可能需要被挂起或迁移，把资源让给高优任务。

一个典型的调度循环是：首先按加权公平算法给每个用户设定“保障配额”；然后如果资源有剩余，允许用户超用（即使用空闲资源）；当新的高优任务到达时，系统从超用用户那里回收资源，必要时 kill 掉低优任务。这样在大多数时候保障高利用率，在竞争时刻保障公平底线。K8s 的 PriorityClass 配合 Preemption，以及 Slurm 的抢占与回填（backfill）就是这个思路的落地。

对照自助餐厅：最高级的私厨不会强求每桌分量完全一致，而是“平时随意加菜，名人到访时临时借位”。他用预约制度（配额）和“蹭座”机制（抢占）保证了黄金时段的高翻台率，也保证每位预订客人都能有位子。公平与效率从来不是单项选择题，而是一道动态平衡的配菜艺术。

AI 应用场景

Python 演示

"""DRF 多资源公平调度模拟器（简化版）"""import copy class DRFAllocator:    def __init__(self, total_res, users):        self.total = total_res              # dict: {'gpu': float, 'mem': float}        self.users = users                  # list of {'name','demand','weight'}        self.alloc = []                     # list of dict: {'gpu':..,'mem':..}        for _ in users:            self.alloc.append({'gpu': 0.0, 'mem': 0.0})        self._cur_iter = 0     def _shares(self, idx):        alloc = self.alloc[idx]        capacity = self.total        user = self.users[idx]        gpu_share = alloc['gpu'] / capacity['gpu']        mem_share = alloc['mem'] / capacity['mem']        return gpu_share, mem_share     def find_target(self):        target = -1        best = float('inf')        for i in range(len(self.users)):            u = self.users[i]            gs, ms = self._shares(i)            dom = max(gs, ms) / u['weight']            if dom < best:                best = dom                target = i        return target     def step(self, amount=0.02):        idx = self.find_target()        user = self.users[idx]        demand = user['demand']        for res in self.total:            need = demand[res]            total_res = self.total[res]            avail = (need / sum(u['demand'][res] for u in self.users)) * amount            take = min(avail, total_res * 0.2)            self.alloc[idx][res] += take        self._cur_iter += 1        return idx     def metrics(self):        samples = [max(self._shares(i)) for i in range(len(self.users))]        n = len(samples)        jain = (sum(samples) ** 2) / (n * sum(s ** 2 for s in samples))        return jain, samples  def main():    cluster = {'gpu': 100.0, 'mem': 200.0}    users = [        {'name': 'nlp',   'demand': {'gpu': 2.0, 'mem': 1.0}, 'weight': 1.0},        {'name': 'cv',    'demand': {'gpu': 1.0, 'mem': 4.0}, 'weight': 1.0},        {'name': 'rec',   'demand': {'gpu': 1.0, 'mem': 2.0}, 'weight': 2.0},    ]    allocator = DRFAllocator(cluster, users)    for _ in range(200):        allocator.step(amount=0.03)    jain, samples = allocator.metrics()    print('DRF allocation:')    for i, u in enumerate(users):        a = allocator.alloc[i]        print('%s -> gpu=%.1f mem=%.1f dom=%.3f' % (            u['name'], a['gpu'], a['mem'], samples[i]))    print('Jain fairness: %.3f' % jain)  if __name__ == '__main__':    main()

1. demand = user['demand']取出当前用户的资源需求向量，GPU 和内存是两种独立资源。
2. dom = max(gs, ms) / u['weight']计算主导份额并除以权重，这是 DRF 选择目标的“打分函数”。
3. avail = (need / sum(need_all)) * amount按用户需求占总需求的比例，估算本次应分配的资源量。
4. take = min(avail, total_res * 0.2)防止一次性分配过多，模拟调度器逐步推进的节奏。
5. jain = (sum(samples) ** 2) / (n * sum(...))计算 Jain 公平指数，评估最终分配是否均衡。

常见误区

面试题