小胖鱼@Think· 调度器系列 博客首页
END-TO-END SCHEDULING FLOW

Volcano 完整调度流程图

从用户提交 Job Manifest 开始,到 Pod 真正 Running 于目标节点为止 —— 覆盖对象模型、Session 快照、插件扩展点、五大 Action、 gang 全有全无、Statement 事务、异步 Bind / Evict 写回的完整链路。基于 Volcano master 分支源码核实整理。
8个主阶段
5个调度 Action
20+扩展点
2条写回路径
1s默认调度周期
提交 / 控制层
Controller 展开
快照 / 主循环
Session / 插件
Actions / Gang / 驱逐
提交 / 异步写回
贯穿机制

端到端全景图

下面两张全景图与正文 8 阶段一一对应:横版以泳道呈现多组件如何并行决策与异步写回(可左右拖动); 纵版沿主干自上而下逐阶段展开。为避免与正文样式互相影响,两图在独立画框中渲染。

① 横版泳道全景(左右拖动查看完整流水线)
② 纵版全景(自上而下的完整链路)
0
提交层 · Manifest
管理员建队列与打标,用户提交作业声明
SUBMIT
🗂️0.1 管理员预建 Queue(CRD)

安装后内置 root(根队列)与 default(默认队列,weight=1),均不可删改。其余按业务自建。核心是三级配额模型:guarantee ≤ deserved/weight ≤ capability。

# scheduling.volcano.sh/v1beta1
apiVersion: scheduling.volcano.sh/v1beta1
kind: Queue
metadata: {name: training}
spec:
  deserved:            # 软基准(capacity 插件用)
    cpu: "16"; nvidia.com/gpu: "8"
  guarantee:           # 硬下限,独占预留
    resource: {cpu: "8", nvidia.com/gpu: "2"}
  capability:          # 硬上限,绝对封顶
    cpu: "32"; nvidia.com/gpu: "16"
  weight: 1            # 比例权重(proportion 插件用)
  priority: 100
  reclaimable: true
  state: Open
注意:capacity(配 deserved)与 proportion(配 weight)二选一,不能同时用;只有 state=Open 才能接收任务。
📦0.2 用户提交 VCJob(作业,不是散装 Pod)

提交类型是作业 Job,层级在提交时就定义好。顶层 spec.queue 声明归属(不写则进 default)。

# batch.volcano.sh/v1alpha1
apiVersion: batch.volcano.sh/v1alpha1
kind: Job
metadata: {name: pytorch-ddp}
spec:
  queue: training        # ← 归属队列(声明式)
  minAvailable: 4        # ← gang 门槛 → PodGroup.MinMember
  tasks:
    - name: worker
      replicas: 4        # ← 生成 4 个 Pod
      template:
        spec:
          schedulerName: volcano   # ← 交给 volcano
          containers: [...]
其他框架(PyTorchJob / MPIJob 等)无 spec.queue,改用注解: metadata.annotations.scheduling.volcano.sh/queue-name: training + spec.schedulingPolicy.{queue,minAvailable}。
🏷️0.3 节点硬件打标(插件数据基础)

机柜 / 电源等硬件信息先落到 Node 的 label / annotation,自定义插件才能在 NodeInfo.Node 上读到。

kubectl label node node-01 \
  topology.kubernetes.io/rack=rack-A-01
kubectl annotate node node-01 \
  hardware.example.com/power-capacity-watts=8000
kubectl annotate node node-01 \
  hardware.example.com/power-feed=dual
kubectl label node node-01 \
  hardware.example.com/cooling-tier=high
⚙️0.4 调度器配置(ConfigMap)

定义 Action 执行顺序与插件分层(tier)。同一扩展点被多插件注册时,靠 tier 顺序组合结果。

actions: "enqueue, allocate, preempt, reclaim, backfill"
tiers:
  - plugins:            # 第一层:排序 / 准入
      - {name: priority}
      - {name: gang}
      - {name: hwtopology}   # 自定义硬件插件
  - plugins:            # 第二层:过滤 / 打分
      - {name: drf}
      - {name: predicates}
      - {name: nodeorder}
      - {name: binpack}
默认配置常为 enqueue,allocate,backfill;enqueue 与 preempt/reclaim 通常不同时启用(见阶段 4)。
✅ 准入校验:提交后准入组件检查队列是否存在、state 是否 Open;启用分层队列时还要求是叶子节点。校验不过直接拒绝。
API Server 持久化对象,触发 Controller reconcile
1
Controller 展开 · 对象模型
vc-controller 把 Job 展开成 PodGroup + N 个 Pod
EXPAND
① VCJob
用户提交的作业对象
→
② PodGroup
MinMember = minAvailable
gang 全有全无的载体
→
③ N 个 Pod
按 replicas 展开
Pending,nodeName 空
→
④ 打 annotation
group-name / queue-name
三层关联写死
🔗三层是"定义"的,不是"聚合"的

正确因果:提交 Job(声明 queue/replicas/minAvailable)→ controller 按 replicas 展开成 N 个 Pod,并建 PodGroup 绑成 gang 单元。不是"提交散装 Pod 再由调度器聚合"。

🏷️关联写进每个 Pod

createJobPod 给每个 Pod 打上指向 PodGroup 与 Queue 的 annotation。这三层的关联在 Pod 创建那一刻就固定了。

✂️scheduler / controller 分离

volcano-scheduler 从不创建 workload。它的全部职责是给这些已存在的 Pending Pod 挑节点并绑定。

层级K8s 对象谁创建提交里如何指定
队列 QueueQueue CRD管理员预建spec.queue: training(声明归属)
作业 JobVCJob + PodGroup用户提交 Job;controller 造 PodGroupminAvailable: 4 → PodGroup.MinMember
任务 TaskPodcontroller 按 replicas 展开replicas: 4 → 生成 4 个 Pod
informer watch 到新 Pod,进入调度器待调度队列
2
调度主循环 · 周期驱动
单 goroutine 串行,默认 1 秒一个周期
LOOP
go wait.Until(pc.runOnce, pc.schedulePeriod, stopCh)
// defaultSchedulerPeriod = time.Second   →   --schedule-period=1s
🚦严格串行

wait.Until 在单个 goroutine 同步调用 runOnce:不会有两个 Session 并发。Session 内部也是串行执行各 Action,全程共用同一个 ssn。

⏱️跑完再等 1 秒(sliding)

计时从 runOnce 执行完之后才开始。真实周期 ≈ 本轮调度耗时 + 1s。调度慢了不追赶、不并发补跑,周期自然拉长。

👑全局单实例

生产部署通过 leader election 选主,多副本只有一个 active 实例在调度,避免重复分配。

🔀数据同步是并发的

Cache 的 informer、NodeWorkerThreads=20、JobUpdaterWorker=16 都并发,但它们只更新快照,不参与调度决策。

每一轮 runOnce = openSession → 依次执行 Actions → closeSession。上一轮在 CloseSession 统一提交后,下一轮快照才看得到结果 —— 这是"一致性"的保证。
runOnce 开始:openSession()
3
Session 快照 + 插件注册
拍一份全量一致性快照,插件挂载决策算法
SESSION
📸3.1 openSession:schedulerCache.Snapshot()

拍一份集群快照整体赋值给 Session,大多是引用而非深拷贝;周期内不再刷新 —— 调度中新来的 Pod 这轮不考虑,等下个周期。

JobsNodesQueues HyperNodesNamespaceInfoTotalResource
⚠️ Session 没有独立 Tasks 字段 —— Task 嵌在 JobInfo(job.Tasks)里,从数据结构上说明"任务从属于作业"。
另含客户端与状态:kubeClient / vcClient / cache / recorder / DirtyJobs。
🧩3.2 插件 OnSessionOpen 注册算法

插件接口三方法:Name()、OnSessionOpen(ssn)、OnSessionClose(ssn)。插件在 Open 时通过 AddXxxFn 把函数注册进 Session 内部的 30+ 个 Fn map,Action 执行时统一回调。

queueOrderFnsjobOrderFnspredicateFnsjobReadyFns…30+
同一扩展点可被多插件注册,依 tier 分层决定组合顺序。自定义插件用 RegisterPluginBuilder 注册后编译进调度器。
本轮所有 Action 都基于这同一份快照、在这些内存对象上顺序操作、状态逐层累积 —— 这就是"全量快照 + 逐层决策"模型。
进入 Actions 执行(详见附录 A 扩展点清单)
4
Actions 流水线 · 核心决策
代价递增:能温和就不激进,最后兜底
ACTIONS
enqueue
配额准入
pending→inqueue
→
allocate
空闲资源分配
gang 全有全无
→
preempt
同队列
高抢低
→
reclaim
跨队列
按权重回收
→
backfill
碎片填缝
兜底
顺序按配置中 actions 字段执行,Volcano 自身不校验顺序合理性。默认只有 enqueue,allocate,backfill;enqueue 若判定 Job 达不到最小资源就不让它入队、不建 Pending Pod,则 preempt/reclaim 无可抢占对象 —— 这就是二者冲突的原因。
🚪4.1 enqueue 入队

过滤任务,状态 pending → inqueue。用 jobEnqueueableFn 检查队列配额与 gang 最小资源,不满足的 Job 不生成 Pending Pod。

⚡4.3 preempt 抢占

输入 = allocate 后仍饥饿的 Job(JobStarving)。限定同队列内选低优先级 victim,Evict + Pipeline 放同一 Statement 事务,达到 JobPipelined 才整体 Commit。

🔄4.4 reclaim 回收

与 preempt 同构,区别在于 victim 来自其他队列(按权重收回借出的份额),涉及租户边界,是更重的操作故后置。

🧠4.2 allocate —— 核心中的核心(展开)

用空闲资源、按「队列 → 作业 → 任务」层级做预选 + 优选,gang 满足才 Commit,否则整体 Discard —— 全程不驱逐任何 Pod。

① 准备:buildAllocateContext(筛选谁有资格)

跳过 pending / JobValid 不通过 / 被 unschedulable 抑制 / 队列不存在的 Job;organizeJobWorksheet 分 nominated(上轮抢占锁定)与 regular 两阶段;无资源请求的 task 直接跳过,留给 backfill。

② 三层决策循环(从粗到细逐层 Pop)
L1 队列 Queue
QueueOrderFn
查 Overused(配额)
租户公平
→
L2 作业 Job
JobOrderFn
JobReady(minAvail)
gang 原子性
→
L3 任务 Task
TaskOrderFn
predicate + nodeOrder
放置效率
③ 单个 task 六步流水线
选队列 QueueOrderFn → 选作业 JobOrderFn → 选任务 TaskOrderFn
   → predicate 预选(resourcefit + predicates:亲和性/污点/端口)
   → nodeOrderFn 优选(prioritizeNodes:两梯度打分)
   → Allocate / Pipeline 落决策到 Statement

优选两梯度:① Idle 就够用的节点优先打分,有结果就不看第二梯度;② FutureIdle(Idle+Releasing−Pipelined)才够用的节点作为后备。
空闲够 → stmt.Allocate()(可绑定);只有 FutureIdle 够 → stmt.Pipeline()(占坑,等资源释放再绑)。

💾扣资源 ≈ Reserve(但非扩展点)

node.AddTask() 改 NodeInfo 记账:Idle.sub() / Used.Add();Pipeline 则加 Pipelined 使 FutureIdle 变小。仅内存记账,防本轮重复占用,Session 结束即丢弃;gang 不过则 Discard 反向回滚。K8s 的 Reserve 是独立 stage,Volcano 直接改字段更内聚。

🎯决策单位 = PodGroup

一轮 allocate 处理多个 PodGroup(training 的 A、B,default 的 C…逐个),但每次决策的单位是一个组:组内逐个 Pod 选节点(执行单位)却不立即绑定,整组记入同一 Statement,整组 Commit / Discard。整体判定保 gang,逐 task 记账保执行粒度。

◆ 判定:ssn.JobReady(job) ? 该 Job 是否满足 minAvailable(全有 or 全无)
✅ 满足 → stmt.Commit()

整组 Operation 一起提交 → 进入阶段 5 转为 BindTask。8 个 Pod 全部分配。

❌ 不满足 → Discard

整组回滚,一个都不占 —— 这正是 Gang 死锁不再发生的机制。饥饿 Job 留给 preempt/reclaim。

allocate 不做什么同样重要:不写 API Server(只内存决策 + 记账);不驱逐任何 Pod(Statement 只有 Pipeline/Allocate)。高级细节:NominatedNodeName 优先、HyperNode 拓扑、shard 分片、FitErrors 追踪。
🧩4.5 backfill 回填(必须垫底)

pickUpPendingTasks() 多重过滤:if job.IsPending() continue / JobValid 不通过跳过 / if task.HasSchedulingResourceRequests() continue(只留无资源请求的 BestEffort)/ scheduling gate 跳过。它用的是前面 Action 更新后的剩余碎片资源。

为什么垫底:它跳过 gang 与配额核算,若放前面会先占住节点、把正经作业挤掉,破坏公平与 gang 整体性。放最后才能"只利用别人不要的边角料"。
Actions 全部执行完 → closeSession() 提交决策
5
Statement 提交 · 决策转请求
Commit 把每条操作转成入队请求,Session 到此结束
COMMIT
Statement.Commit()
遍历 operations[]
每条 = {name, task}
→
case Allocate
ssn.allocate(task)
CreateBindContext
状态 → Binding
→
cache.AddBindTask
丢进 BindFlowChannel
(容量 5000)
📝operations 三种操作,单位都是单个 task

Evict / Pipeline / Allocate。Commit() 逐条遍历:Allocate 转 BindTask 入队;Evict 走 cache.Evict()(改 Releasing 记账 + 起 goroutine)。

🚧此刻仍未碰 API Server

Session 内设的 Pod.Spec.NodeName 只是内存对象。Commit 只是把绑定请求入队 —— 真正的 API 调用在下一个阶段的后台 goroutine 里完成。

这样设计的好处:bind 这种慢 I/O 不阻塞调度主循环(还记得 1 秒一个周期吗),并支持批量(BATCH_BIND_NUM 默认 1)。
⚡ 异步边界 · 以下由 Cache 后台 goroutine 执行,已不在 Session 内
6
异步写回 · 两条路径
绑定创建 Binding 对象 / 驱逐 Delete Pod
WRITEBACK
┌──────────┴──────────┐
🟢 路径 A · 绑定(正常调度成功)
processBindTask() 后台每 20ms 消费一次
BindTask → PreBind 插件 → Binder.Bind()
核心:Pods(ns).Bind(&v1.Binding{...})
创建 Binding 子资源对象(非 Update nodeName)

与 kube-scheduler 做法一致:API Server 收到 Binding 后才把 nodeName 落到 Pod。Bind 失败会回滚 PreBind 并重新入队重调。

🔴 路径 B · 驱逐(preempt / reclaim 的 victim)
go sc.Evictor.Evict(p, reason)
defaultEvictor 先 UpdateStatus:
PodReady=False/Evict · DisruptionTarget=True/PreemptionByScheduler
核心:Pods().Delete(p.Name)
真正删除集群里的 Pod(直接删,不过 PDB)

改 cache 的 Releasing 只是内部记账(保证本轮决策一致);这次 Delete 才是让驱逐落到真实集群的动作。失败会 resyncTask 重新入队。

⚠️ 两个易错点:① Pod 不是 Volcano 创建的,写回是对已存在的 Pod 创建 Binding;② 默认 evictor 是直接 Delete,没有走 policy/v1 的 Eviction subresource,所以不做 PodDisruptionBudget 校验。
API Server 持久化变更,kubelet / controller watch 到
7
落地与闭环 · Pod Running
真实 Pod 起来,资源占用持久化,进入下一周期
DONE
🚀绑定路径落地

API Server 把 nodeName 写入 Pod → kubelet watch 到 nodeName → 拉取镜像、启动容器 → Pod Running。资源占用从此持久化,下一轮 Session 快照能从 Cache 看到它。

♻️驱逐路径落地

被驱逐的 victim Pod 被删 → ReplicaSet / vc-controller 发现副本不足 → 重建新 Pod → 新 Pod Pending → 下一轮 Session 重新调度,此时资源已被高优先级任务占用。Volcano 自己不重建 Pod。

🔁 闭环:CloseSession 收尾(更新 PodGroup status / DirtyJobs flush)→ 本份快照丢弃 → wait.Until 跑完等 1 秒 → 回到阶段 2,开启下一个调度周期。整条链路:提交 Job → Controller 展开 → 周期快照 → 插件注册 → 五大 Action gang 决策 → Statement 提交 → 异步 Bind/Evict 写回 → kubelet 落地。
🧩附录 A · 扩展点四大类与内置插件
① 排序类 Ordering

queueOrderFn · jobOrderFn · taskOrderFn · nodeOrderFn · batchNodeOrderFn · namespaceOrderFn

代表插件:drf / gang / priority / nodeorder / binpack
② 过滤与准入 Validation

predicateFn · jobValidFn · jobReadyFn · jobStarvingFn · jobEnqueueableFn · jobEnqueuedFn

代表插件:gang(jobValid/Ready/Starving 近乎专属)/ predicates / proportion / extender
③ 抢占与回收 Preempt / Reclaim

preemptableFn(被 5 插件注册)· reclaimableFn · overusedFn · allocatableFn · reclaimFn

代表插件:priority / conformance / drf / proportion / extender
④ 状态与预留 State / Reserve

targetJobFn · reservedNodesFn · jobPipelineFn

代表插件:reservation / gang
三种扩展方式:① 零代码——配置内置插件(gang/drf/proportion/capacity/priority/conformance/predicates/nodeorder/binpack/numaaware/overcommit/reservation/extender);② 免重编译——extender 用 HTTP 回调外部服务,覆盖过滤/打分/抢占/回收全套钩子;③ 深度定制——实现 Plugin 接口 + RegisterPluginBuilder 后重编译。
⚖️附录 B · 与 K8s 官方调度器对比
维度Kube-scheduler(线性流水线)Volcano(多级决策回调)
扩展点数量约 12~13 个(PreEnqueue→QueueSort→…→Bind→PostBind)20+ 个 Fn
调度对象一次一个 Pod一次一整个 Job / 队列
对象层级只围绕 Pod 一层Queue → Job → Task → Node 四层
对应关系Filter↔predicateFn · Score↔nodeOrderFn · Permit(gang)↔jobReadyFn · PostFilter↔preemptableFn · QueueingHint↔eventHandler
为什么扩展点多:① 对象层级不同(一个 QueueSort 拆成 jobOrder/queueOrder/taskOrder);② 模型粒度不同(阶段卡槽 vs 决策回调);③ 内建范围不同(gang/DRF/配额/抢占回收都是 Volcano 原生,各需专属钩子)。一句话:K8s 用少而固定的阶段换简洁,Volcano 用多而细的回调换批处理可控性。
🍽️附录 C · Gang 通俗理解与决策单位小结
Gang 三招("8 人聚餐订位")

① 绑成一单:PodGroup + minAvailable:8,调度器眼里是一个整体。
② 先看全貌:拍资源快照,看清总共剩几张卡。
③ 凑不齐全撤回:内存试算,JobReady 通过才 Commit;不够 Discard 全撤回,一个不占。因在内存里,撤回不留痕迹。

对比 K8s:先起的 4 个占卡死等同伴 → 后 4 个永远起不来 → 全体卡死、GPU 白占。Volcano 从根上杜绝"半组卡死"。
allocate 决策单位 = PodGroup

一轮 allocate 会处理多个 PodGroup,但每次拿出来决策的单位是一个组:
• 决策判定 → 一个 PodGroup(JobReady)
• 节点选点 → 单个 Pod(predicate + nodeOrder)
• 结果提交 → 一个 PodGroup(同一 Statement 一起提交)

"一次遍历多组、逐个组决策" —— 组 A 凑不齐就回滚 A,不影响组 B。
🔄附录 D · 一次调度全景(纵向流程 + 横向泳道)

以「3 队列 / 6 作业」为背景,展示一次 Session 内部如何完成调度。上面 8 阶段讲「从提交到落地的生命周期」,这里两张图讲「单次调度内部怎么转」。

附图 D-1 · 纵向流程:多队列多作业下的一次 Session
training weight=5 · 未超用
job-A8 Pod · minAvail=8
job-B4 Pod · minAvail=4
default weight=1 · 未超用
job-C2 Pod · minAvail=2
job-D1 Pod · 无资源请求
research weight=2 · 已超用
job-E4 Pod · 超配额
job-F2 Pod · 饥饿
↓ openSession 快照 → enqueue 准入 → allocate(放大如下)→ preempt → reclaim → backfill ↓
allocate · while 循环(逐层 Pop,一轮处理多个 Queue / Job)
① queues.Pop() 选队列(QueueOrderFn / Overused)→ 本轮 Pop training
↓
② jobs.Pop() 选作业(JobOrderFn)→ 本轮 Pop job-A(gang,minAvailable=8)
↓
③ 遍历 8 个 task:PrePredicate → predicate 预选 → nodeOrder 优选 → Allocate/Pipeline → AddTask 扣资源(Idle−/Used+)
↓
◆ ④ ssn.JobReady(job-A) ?凑齐 8 个了吗(gang 全有 or 全无)
✅ 满足 8/8 → Commit,整组转 BindTask
❌ 不满足 4/8 → Discard,全回滚、一个不占
⑤ queues.Push / jobs.Push 重新入队,下一轮按最新资源重算优先级(跨租户轮转公平)。⟲ 回到 ①。
附图 D-2 · 横向泳道:队列为行、阶段为从左到右的时间轴
队列/阶段
① 快照
② 入队
③ alloc①
④ alloc②
⑤ alloc③
⑥ 补救兜底
⑦ 写回
trainingw=5 未超用
job-A 8Pod
job-B 4Pod
job-A/B
→ inqueue
Pop job-A
8/8 ✅
Pop job-B
不足 ❌
job-B 饥饿
转抢占
同队列抢占
无 victim
job-A 8
→ BindTask ✅
defaultw=1 未超用
job-C 2Pod
job-D 1Pod·BE
job-C 入队
job-D 留回填
等待轮转
Pop job-C
2/2 ✅
job-D 跳过
backfill
调度 job-D ✅
C2+D1
→ BindTask ✅
researchw=2 已超用
job-E 超配额
job-F 饥饿
job-E 受限
job-F 入队
排序靠后
等待轮转
Pop job-F
无空闲 ❌
reclaim
本轮未满足
无 Binding
下周期重排
读法:纵向图沿主干看每一步判定(Pop→选点→JobReady→Commit/Discard→Push 轮转);横向图以队列为行、阶段为横轴,看多队列如何并行轮转。本轮结果:job-A(8)+job-C(2)+job-D(1) 共 11 个 task 生成 BindTask,其余 Push 回堆等下轮。
← 返回调度器系列目录 Volcano 原理详解 →
参考来源:Volcano 官方文档 · Volcano master 源码(scheduler.go / allocate.go / session.go / statement.go / cache.go / node_info.go / job_controller_util.go)· K8s Scheduling Framework · 本文档由对话内容整理生成 · 2026-11-18 · 小胖鱼@Think · 调度器系列