其他调度插件合集

// JobOrderFn: 高优先级 Job 排在前面
if lv.Priority > rv.Priority {
    return -1
}
if lv.Priority < rv.Priority {
    return 1
}
return 0

func jobStarvingFn(obj interface{}) bool {
    ji := obj.(*api.JobInfo)
    return ji.ReadyTaskNum()+ji.WaitingTaskNum() < int32(len(ji.Tasks))
}

actions: "enqueue, allocate, backfill, preempt"
tiers:
- plugins:
  - name: priority
  - name: gang

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 1000
globalDefault: false
description: "High priority for critical jobs"

for _, evictee := range evictees {
    className := evictee.Pod.Spec.PriorityClassName
    if className == scheduling.SystemClusterCritical ||
        className == scheduling.SystemNodeCritical ||
        evictee.Namespace == v1.NamespaceSystem {
        continue
    }
    victims = append(victims, evictee)
}

actions: "reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: priority
  - name: gang
  - name: conformance
- plugins:
  - name: drf
  - name: predicates
  - name: proportion

// Inqueue 状态的 Job
if job.PodGroup.Status.Phase == scheduling.PodGroupInqueue &&
    job.PodGroup.Spec.MinResources != nil {
    op.inqueueResource.Add(job.DeductSchGatedResources(job.GetMinResources()))
}
// Running 状态且满足 MinMember 的 Job
if job.PodGroup.Status.Phase == scheduling.PodGroupRunning &&
    int32(util.CalculateAllocatedTaskNum(job)) >= job.PodGroup.Spec.MinMember {
    inqueued := util.GetInqueueResource(job, job.Allocated)
    op.inqueueResource.Add(job.DeductSchGatedResources(inqueued))
}

actions: "enqueue, allocate, backfill"
tiers:
- plugins:
  - name: overcommit
    arguments:
      overcommit-factor: 1.5  # 允许超卖 50% 的资源

actions: "reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: pdb
  - name: conformance

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: my-app

func (q queueGroupAffinity) score(group string) float64 {
    nodeScore := 0.0
    if q.queueGroupAffinityRequired.Has(group) {
        nodeScore += BaseScore          // +100
    }
    if q.queueGroupAffinityPreferred.Has(group) {
        nodeScore += 0.5 * BaseScore    // +50
    }
    if q.queueGroupAntiAffinityPreferred.Has(group) {
        nodeScore = -1                  // -1 (软反亲和)
    }
    return nodeScore
}

actions: "reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: nodegroup
    #enableHierarchy: true
    arguments:
      strict: true   # 默认 true，严格模式

apiVersion: scheduling.volcano.sh/v1beta1
kind: Queue
metadata:
  name: gpu-queue
spec:
  affinity:
    nodeGroupAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - gpu-pool
      preferredDuringSchedulingIgnoredDuringExecution:
        - high-memory-pool
    nodeGroupAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - cpu-only-pool

actions: "enqueue, allocate, backfill"
tiers:
- plugins:
  - name: usage
    enablePredicate: true   # 是否开启负载过滤
    arguments:
      usage.weight: 5       # 插件在 NodeOrder 中的权重
      cpu.weight: 1         # CPU 评分权重
      memory.weight: 1      # 内存评分权重
      thresholds:
        cpu: 80             # CPU 使用率阈值 (%)
        mem: 80             # 内存使用率阈值 (%)

// 累加同一 Namespace 中已通过检查的 pending 资源
if pendingUse, found := pendingResources[job.Namespace]; found {
    resourcesUsed = quotav1.Add(pendingUse, resourcesUsed)
}
newUsage := quotav1.Add(resourcesUsed, requestedUsage)

// 检查是否超出 Hard 限制
if allowed, exceeded := quotav1.LessThanOrEqual(maskedNewUsage, resourceQuota.Hard); !allowed {
    // Reject 并记录详细的超限信息
    return util.Reject
}

// 通过检查后累加到 pendingResources
pendingResources[job.Namespace] = quotav1.Add(pendingResources[job.Namespace], *resourcesRequests)

actions: "enqueue, allocate, backfill"
tiers:
- plugins:
  - name: resourcequota
  - name: overcommit

apiVersion: v1
kind: ResourceQuota
metadata:
  name: team-quota
  namespace: team-a
spec:
  hard:
    cpu: "100"
    memory: "200Gi"
    nvidia.com/gpu: "8"

// 基础分: 同 Bucket 中已绑定到该节点的 Task 数量
score := bucket.node[node.Name]
// 反亲和扣分
if affinityScore < 0 {
    score += affinityScore
}
// 同 Bucket 未绑定的 Task 数量
score += len(bucket.tasks)
// 归一化
fScore = float64(score * weight) * MaxNodeScore / float64(bucketMaxSize)

actions: "enqueue, reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: task-topology
    arguments:
      task-topology.weight: 10

apiVersion: scheduling.volcano.sh/v1beta1
kind: PodGroup
metadata:
  name: distributed-training
  annotations:
    volcano.sh/task-topology-affinity: "worker,ps"
    volcano.sh/task-topology-anti-affinity: "worker"
    volcano.sh/task-topology-task-order: "ps,worker"
spec:
  minMember: 5

func (ep *extenderPlugin) IsInterested(task *api.TaskInfo) bool {
    if ep.config.managedResources.Len() == 0 {
        return true  // 未配置则关注所有 Task
    }
    // 检查 containers 和 initContainers 的 Requests/Limits
    return ep.hasManagedResources(task.Pod.Spec.Containers) ||
           ep.hasManagedResources(task.Pod.Spec.InitContainers)
}

func (ep *extenderPlugin) send(action string, args interface{}, result interface{}) error {
    out, _ := json.Marshal(args)
    url := strings.TrimRight(ep.config.urlPrefix, "/") + "/" + action
    req, _ := http.NewRequest("POST", url, bytes.NewReader(out))
    req.Header.Set("Content-Type", "application/json")
    resp, _ := ep.client.Do(req)
    resp.Body = http.MaxBytesReader(nil, resp.Body, 10<<20) // 10MB limit
    return json.NewDecoder(resp.Body).Decode(result)
}

actions: "reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: extender
    arguments:
      extender.urlPrefix: http://my-extender-service:8080
      extender.httpTimeout: 100ms
      extender.onSessionOpenVerb: onSessionOpen
      extender.onSessionCloseVerb: onSessionClose
      extender.predicateVerb: predicate
      extender.prioritizeVerb: prioritize
      extender.preemptableVerb: preemptable
      extender.reclaimableVerb: reclaimable
      extender.queueOverusedVerb: queueOverused
      extender.jobEnqueueableVerb: jobEnqueueable
      extender.jobReadyVerb: jobReady
      extender.allocateFuncVerb: allocate
      extender.deallocateFuncVerb: deallocate
      extender.ignorable: true
      extender.managedResources:
        - nvidia.com/gpu
        - nvidia.com/gpumem

func (sp *CooldownProtectionPlugin) podCooldownTime(pod *v1.Pod) (time.Duration, bool) {
    v, ok := pod.Labels[v1beta1.CooldownTime]      // 先检查 label
    if !ok {
        v, ok = pod.Annotations[v1beta1.CooldownTime]  // 再检查 annotation
    }
    return time.ParseDuration(v)  // 支持 "600s", "10m" 等格式
}

for _, c := range pod.Status.Conditions {
    if c.Type == v1.PodScheduled && c.Status == v1.ConditionTrue {
        if c.LastTransitionTime.Add(cooldownTime).After(time.Now()) {
            stableFiltered = true  // 仍在冷却期内
        }
        break
    }
}

actions: "reclaim, allocate, backfill, preempt"
tiers:
- plugins:
  - name: cdp
  - name: conformance
  - name: priority

apiVersion: v1
kind: Pod
metadata:
  labels:
    volcano.sh/cooldown-time: "10m"   # 10 分钟冷却保护
spec:
  containers:
  - name: worker
    image: training:latest

apiVersion: batch.volcano.sh/v1alpha1
kind: Job
metadata:
  name: elastic-training
spec:
  tasks:
  - replicas: 4
    name: worker
    template:
      metadata:
        labels:
          volcano.sh/cooldown-time: "5m"
      spec:
        containers:
        - name: worker
          image: training:latest

// MostAllocated: 使用率越高分越高 -> 装箱效果
func mostRequestedScore(requested, used, capacity, weight) float64 {
    usedFinally := requested + used
    return usedFinally * weight / capacity
}

// LeastAllocated: 使用率越低分越高 -> 分散效果
func leastRequestedScore(requested, used, capacity, weight) float64 {
    usedFinally := requested + used
    return (capacity - usedFinally) * weight / capacity
}

// 精确匹配优先级 > 通配符匹配
// 通配符匹配选择最长前缀
"nvidia.com/gpu"  -> 先精确匹配 "nvidia.com/gpu"
                  -> 再匹配 "nvidia.com/*"
                  -> 再匹配 "nvidia.*" (不支持，非尾部通配)

annotations:
  volcano.sh/resource-strategy-scoring-type: "MostAllocated"
  volcano.sh/resource-strategy-weight: '{"cpu": 2, "memory": 1}'

// 例如: 每张 GPU 预留 4 核 CPU 和 8Gi 内存
// 配置: nvidia.com/gpu.cpu = 4, nvidia.com/gpu.memory = 8
// 节点有 2 张空闲 GPU，则预留: 8 CPU, 16Gi Memory
cpuReserved := idleGPU * 4     // 2 * 4 = 8 CPU
memReserved := idleGPU * 8 * 1M  // 2 * 8 * 1M = 16Gi Memory

// 如果调度后剩余 CPU/Memory 不足预留量，则拒绝调度
if node.Idle.CPU - task.CPU < cpuReserved {
    return Reject  // 会破坏 GPU:CPU 的比例约束
}

actions: "enqueue, allocate, backfill, reclaim, preempt"
tiers:
- plugins:
  - name: resource-strategy-fit
    arguments:
      resourceStrategyFitWeight: 10
      resources:
        nvidia.com/gpu:
          type: MostAllocated      # GPU 使用装箱策略
          weight: 2
        cpu:
          type: LeastAllocated     # CPU 使用分散策略
          weight: 1
        memory:
          type: LeastAllocated
          weight: 1
      sra:
        enable: true
        resources: nvidia.com/gpu
        weight: 10
        resourceWeight:
          nvidia.com/gpu: 1
      proportional:
        enable: true
        resources: nvidia.com/gpu
        resourceProportion:
          nvidia.com/gpu.cpu: 4       # 每张 GPU 预留 4 核 CPU
          nvidia.com/gpu.memory: 8    # 每张 GPU 预留 8Gi Memory

tiers:
- plugins:
  - name: priority
  - name: gang
  - name: conformance
- plugins:
  - name: overcommit
  - name: drf
  - name: predicates
  - name: proportion

tiers:
- plugins:
  - name: priority
  - name: gang
  - name: conformance
  - name: pdb
  - name: cdp
- plugins:
  - name: overcommit
  - name: predicates
  - name: nodegroup
  - name: resource-strategy-fit
    arguments:
      resources:
        nvidia.com/gpu:
          type: MostAllocated
          weight: 5
      sra:
        enable: true
        resources: nvidia.com/gpu
        weight: 10
      proportional:
        enable: true
        resources: nvidia.com/gpu
        resourceProportion:
          nvidia.com/gpu.cpu: 8
          nvidia.com/gpu.memory: 32
  - name: task-topology
    arguments:
      task-topology.weight: 10

tiers:
- plugins:
  - name: priority
  - name: gang
  - name: conformance
  - name: pdb
- plugins:
  - name: overcommit
  - name: resourcequota
  - name: predicates
  - name: usage
    arguments:
      usage.weight: 5
      thresholds:
        cpu: 75
        mem: 80
  - name: nodegroup
  - name: extender
    arguments:
      extender.urlPrefix: http://custom-scheduler:8080
      extender.predicateVerb: filter
      extender.prioritizeVerb: score
      extender.ignorable: true
  - name: proportion