Slurm/K8s调度：队列与优先级管理

可视化演示

展示网络拓扑中数据包从源节点S到目标节点T的多路径路由过程，数据包沿不同路径传输，路由器转发数据包，支持自动发送和路径切换。

调度器总览：挂号的病人与分诊的护士

走进一家大型综合医院，第一步不是找医生，而是到分诊台挂号。护士快速评估病情：心跳骤停的进抢救室，高烧的挂急诊，慢病复查挂普通门诊，开药则安排到低峰时段。算力集群的入口同样是“分诊台”——调度器。用户提交的作业就是病人，调度器决定它进哪个队列、排什么位置、何时轮到它“看病”。

这个流程在 Slurm 中由 slurmctld 主守护进程完成，在 K8s 中由 kube-scheduler 完成。两者的职责高度一致：接收作业（挂号）、评估优先级（分诊）、放入队列（候诊）、分配合适节点（叫号就诊）。把这三个动作连起来，就是一套完整的调度流水线。

集群通常由多个课题组或业务线共享，就像病房分属不同科室。调度器最核心的挑战，是在“公平”和“效率”之间找平衡：既要让每个租户都能分到资源，又不能让任何节点闲置。衡量效率的关键指标是资源利用率，它直接反映“病床”有没有空转。

调度员心里永远有两本账：危重病人要及时抢救，普通诊室不能空转。队列与优先级管理，正是这两本账共同遵守的记账规则。

队列设计：分诊后的候诊区

分诊之后，病人被引导到不同候诊区：急诊区、普通门诊区、慢病区。这些候诊区就是队列。Slurm 用 partition（分区）来划分队列，每个分区对应一组节点和调度策略；K8s 则用 namespace（命名空间）做租户隔离，不同业务跑在不同“候诊室”里互不干扰。

大医院还有多级结构：院区、住院楼、科室层层嵌套。Slurm 中 partition、account、QOS 可以组合出树状多级队列，让资源配额按层级继承；K8s 生态中的 Kueue 项目也提供 ClusterQueue 层级队列，支持父队列把配额分给子队列。多级队列解决的是“大组织如何分级治理”的问题。

队列设计要回答三个问题：分几类（分区维度）、上限多少（配额）、如何隔离（防互相挤占）。Slurm 用 GrpTRES、MaxJobs 等参数约束队列配额，K8s 用 ResourceQuota 限制 namespace 的资源总量。配额就像候诊区的座位数——座位满了，新来的病人只能等下一波。

候诊区划得好，医院才不混乱；队列设计得好，集群才不会出现“急诊区人满为患、慢病区空无一人”的资源冰火两重天。

优先级机制：彩色标签与权重天平

分诊护士会给病人贴彩色标签：红色危重、黄色较重、绿色轻症。标签决定排队的先后顺序，这就是优先级。Slurm 中每个作业都有一套优先级分数，K8s 中每个 Pod 则有一个 PriorityClass 数值，两者都是“标签”的具体形态。

优先级不是拍脑袋得出的单一数字，而是多个因子加权求和的结果。Slurm 的常见因子包括：年龄因子（等待时长）、公平份额因子（fairshare）、QOS 因子、分区因子和作业规模因子。其中年龄因子正是“优先级衰减”的原理——排队越久分数越高，防止低优先级作业永远轮不上。

公平份额因子负责多租户间的长期公平：某用户或课题组用量超出公平份额后，他后续作业的优先级会被压低，把机会让给用量不足的租户。权重则由管理员配置，相当于医院规定“心跳骤停权重 100、普通感冒权重 1”。

分诊标签不是一成不变的——病人等久了，护士会重新评估。调度器同样动态调整年龄因子，让久等的“绿标病人”自动升级，这是优先级管理中最温暖的设计。

Slurm QOS：急诊绿色通道

大医院都有绿色通道：胸痛、卒中患者凭卡免排队直接进抢救室。Slurm 的 QOS（Quality of Service，服务质量）就是算力集群的“绿色通道卡”，它可以绑定到用户、账户或分区，决定作业享受的“待遇等级”。

QOS 能管三件事：资源限额（同时运行作业数、CPU 时长、节点数上限）、优先级加成（Priority 值注入优先级计算）、抢占权限（允许该 QOS 的作业抢占低优先级作业）。它既像通行证又像紧箍咒——给特权的同时必配上限。

管理员用 sacctmgr 命令创建和绑定 QOS：先执行 sacctmgr add qos name=express 定义，再执行 sacctmgr modify user=zhangsan set qos+=express 关联用户。生产环境常见做法是配置 normal、high、express 三级 QOS，分别对应不同优先级与限额，实现多租户精细治理。

绿色通道卡不能乱发——人人都插队，通道就瘫痪了。QOS 的精髓是限额与加成并举：既给特权，又设上界，确保特权作业不会吞噬整座医院。

K8s优先级：手术臂环的秩序

急诊室靠“手术臂环”决定上台顺序：红色臂环先做，黄色次之，绿色最后。K8s 的 PriorityClass 就是这种臂环——它是一个集群级对象，通过 value 字段定义 0 到 10 亿的数值，Pod 声明 priorityClassName 来佩戴属于自己的臂环。

调度器按数值降序逐个调度 Pod：数值越大越先被安排。当高优先级 Pod 在集群中找不到足够资源的节点时，会触发抢占（Preemption）：从候选节点上驱逐优先级较低的 Pod，腾出“床位”给新来的重症病人，被驱逐的 Pod 会被重新排队。

与 Slurm QOS 对照可以看到两种设计思路：QOS 是用户或作业级的绿色通道，管的是限额、加成与排队秩序；PriorityClass 是 Pod 级的个人臂环，管的是调度顺序与驱逐。一个管“通道”，一个管“臂环”，作用维度不同，却共同服务优先级管理。

臂环规则的设计核心是“克制”：只有新臂环严格更高且资源确实不足时才触发驱逐，就像手术室不会因为来了 VIP 就把缝合到一半的病人赶下台。

回填调度：手术室的插缝艺术

排期表上写着一台明天上午开台的 5 小时大手术，今天下午手术室却空着。聪明的护士长会把割阑尾、清创这些小手术插进空隙，只要保证大手术开台前结束。这就是回填调度（backfill）的日常画面。

Slurm 默认加载 sched/backfill 插件：当高优先级作业因资源不足而排队时，调度器为它“预约”未来资源，同时允许低优先级短作业利用当前空闲资源先行运行，前提是小作业能在预约时刻之前完成。预约像大手术的排期，回填像见缝插针的小手术。

回填的前提是“时长估计”：调度器按用户申报或历史数据预估作业运行时间。如果小作业超时，就可能耽误大作业，所以需要配套超时强杀等兜底机制。K8s 原生调度器没有经典回填，需要借助 Volcano、Kueue 等调度组件实现类似能力。

回填的精髓是“用确定性换效率”：大手术的时间表雷打不动，小手术见缝插针。调度系统正是靠预约与插缝的组合，让每一张手术台都不闲着。

AI 应用场景

Python 演示

class BackfillScheduler:    """回填调度模拟: 高优大作业未来才集齐资源, 低优短作业利用眼前缝隙先跑"""     def __init__(self, node_count=4):        self.node_count = node_count        self.plan = []          # [(名称, 开始, 结束, 节点列表)]        self.placed_count = 0   # 已放置作业数     def _free_at(self, node, start, end):        for _, s, e, nodes in self.plan:            if node in nodes and s < end and e > start:                return False        return True     def earliest_start(self, need, duration):        """找出最早能让 need 个节点连续空闲 duration 的时刻(找缝隙)"""        t = 0        while True:            free = sum(1 for n in range(self.node_count)                       if self._free_at(n, t, t + duration))            if free >= need:                return t            nxt = min((e for _, s, e, _ in self.plan if e > t), default=t + 1)            t = nxt     def schedule(self, jobs):        """jobs: [(名称, 时长, 节点数, 优先级)], 按优先级降序依次放置"""        result = []        for name, dur, need, prio in sorted(jobs, key=lambda x: -x[3]):            start = self.earliest_start(need, dur)            nodes = [n for n in range(self.node_count)                     if self._free_at(n, start, start + dur)][:need]            self.plan.append((name, start, start + dur, nodes))            result.append((name, start, start + dur))            self.placed_count += 1        return result  def main():    jobs = [        ("h1", 30, 1, 10),      # 高优小作业: 先用 1 节点跑 30 小时        ("big", 300, 4, 10),    # 高优大作业: 30 小时才能集齐 4 节点        ("small1", 20, 1, 1),   # 低优短作业: 回填进 0-20 的缝隙        ("small2", 10, 2, 1),   # 低优短作业: 回填进 0-10 的缝隙    ]    sch = BackfillScheduler()    plan = sch.schedule(jobs)    for name, start, end in plan:        kind = "回填" if name.startswith("small") else "预约"        print("%s: %3d -> %3d [%s]" % (name, start, end, kind))    big_start = [s for n, s, _ in plan if n == "big"][0]    assert all(e <= big_start for n, _, e in plan if n.startswith("small"))    print("小作业都在 big 启动前完成, 大作业不被推迟 - 这就是回填")  if __name__ == "__main__":    main()

1. def earliest_start(self, need, duration):回填的核心方法：为作业找最早能容纳 need 个节点连续空闲 duration 的窗口，相当于护士长寻找手术室的空档。
2. free = sum(1 for n in range(self.node_count) if self._free_at(n, t, t + duration))数出当前时刻空闲的节点数，凑不够 need 说明窗口不够大。
3. nxt = min((e for _, s, e, _ in self.plan if e > t), default=t + 1)窗口不够时快进到下一个作业的结束时刻，避免逐秒扫描浪费时间。
4. for name, dur, need, prio in sorted(jobs, key=lambda x: -x[3]):按优先级降序处理作业，高优大作业先“占坑”，低优小作业随后见缝插针。
5. nodes = [n for n in range(self.node_count) if self._free_at(n, start, start + dur)][:need]选取窗口内真正空闲的节点，而不是默认从 0 号节点开始，避免与已有预约冲突。
6. assert all(e <= big_start for n, _, e in plan if n.startswith("small"))校验小作业都在大作业启动前完成，验证回填“不误事”的核心承诺。

常见误区

面试题