NodeOrder Plugin 详解

type NodeOrderPlugin struct {
    pluginArguments       framework.Arguments   // 用户配置的权重参数
    weight                priorityWeight         // 解析后的权重结构
    Handle                k8sframework.Handle    // K8s 调度框架 Handle
    ScorePlugins          map[string]nodescore.BaseScorePlugin     // 批量评分插件（需要 PreScore）
    NodeOrderScorePlugins map[string]ScorePluginWithWeight         // 简单评分插件（仅需 Score）
}

type priorityWeight struct {
    leastReqWeight          int  // 默认: 1
    mostReqWeight           int  // 默认: 0（禁用）
    nodeAffinityWeight      int  // 默认: 2
    podAffinityWeight       int  // 默认: 2
    balancedResourceWeight  int  // 默认: 1
    taintTolerationWeight   int  // 默认: 3
    imageLocalityWeight     int  // 默认: 1
    podTopologySpreadWeight int  // 默认: 2
}

type ScorePluginWithWeight struct {
    plugin k8sframework.ScorePlugin  // K8s 原生 ScorePlugin 接口
    weight int                        // 该插件的权重系数
}

func (pp *NodeOrderPlugin) InitPlugin() {
    scorePlugins := map[string]nodescore.BaseScorePlugin{}
    nodeOrderScorePlugins := map[string]ScorePluginWithWeight{}

    // 只有权重 != 0 时才初始化对应插件
    if pp.weight.leastReqWeight != 0 {
        // 创建 LeastAllocated 实例...
        nodeOrderScorePlugins[name+"_LeastAllocated"] = ScorePluginWithWeight{plugin, weight}
    }
    // ... 其余 7 个插件同理

    pp.NodeOrderScorePlugins = nodeOrderScorePlugins
    pp.ScorePlugins = scorePlugins
}

func (pp *NodeOrderPlugin) NodeOrderFn(task *api.TaskInfo, node *api.NodeInfo,
    k8sNodeInfo fwk.NodeInfo, state *k8sframework.CycleState) (float64, error) {
    var nodeScore = 0.0
    for name, p := range pp.NodeOrderScorePlugins {
        score, status := p.plugin.Score(context.TODO(), state, task.Pod, k8sNodeInfo)
        if !status.IsSuccess() {
            return 0, status.AsError()
        }
        // 每个插件的原始分数乘以其权重
        nodeScore += float64(score) * float64(p.weight)
    }
    return nodeScore, nil
}

func CalculatePluginScore(pluginName string, plugin BaseScorePlugin,
    normalizer k8sframework.ScoreExtensions, ...) (map[string]float64, error) {

    // 阶段一：PreScore - 构建全局状态
    preScoreStatus := plugin.PreScore(ctx, cycleState, pod, nodeInfos)
    if preScoreStatus.IsSkip() {
        return map[string]float64{}, nil  // 跳过该插件
    }

    // 阶段二：Score - 并行计算各节点分数
    workqueue.ParallelizeUntil(ctx, 16, len(nodeInfos), func(index int) {
        s, status := plugin.Score(ctx, cycleState, pod, nodeInfos[index])
        nodeScoreList[index] = NodeScore{Name: nodeName, Score: s}
    })

    // 阶段三：NormalizeScore - 归一化
    normalizer.NormalizeScore(ctx, cycleState, pod, nodeScoreList)

    // 阶段四：应用权重
    for i, nodeScore := range nodeScoreList {
        nodeScore.Score *= int64(weight)
    }
}

for _, node := range nodes {
    score := 0.0
    if reduceScore, ok := reduceScores[node.Name]; ok {
        score += reduceScore      // 来自 NodeOrderReduceFn
    }
    if orderScore, ok := nodeOrderScoreMap[node.Name]; ok {
        score += orderScore       // 来自 NodeOrderFn（简单评分路径）
    }
    if batchScore, ok := batchNodeScore[node.Name]; ok {
        score += batchScore       // 来自 BatchNodeOrderFn（批量评分路径）
    }
    nodeScores[score] = append(nodeScores[score], node)
}

actions: "enqueue, allocate, backfill, preempt"
tiers:
- plugins:
  - name: gang
  - name: predicates
  - name: proportion
  - name: nodeorder
    arguments:
      leastrequested.weight: 1
      mostrequested.weight: 0
      nodeaffinity.weight: 2
      podaffinity.weight: 2
      balancedresource.weight: 1
      tainttoleration.weight: 3
      imagelocality.weight: 1
      podtopologyspread.weight: 2

arguments:
  leastrequested.weight: 2
  mostrequested.weight: 0
  balancedresource.weight: 1
  tainttoleration.weight: 3

arguments:
  leastrequested.weight: 0
  mostrequested.weight: 2
  balancedresource.weight: 0
  tainttoleration.weight: 3

arguments:
  podaffinity.weight: 5
  nodeaffinity.weight: 3
  tainttoleration.weight: 2
  leastrequested.weight: 1

arguments:
  podtopologyspread.weight: 5
  leastrequested.weight: 1
  tainttoleration.weight: 3

func (pp *NodeOrderPlugin) OnSessionOpen(ssn *framework.Session) {
    // 初始化 K8s 调度框架 Handle
    handle := k8s.NewFramework(nodeMap,
        k8s.WithClientSet(ssn.KubeClient()),
        k8s.WithInformerFactory(ssn.InformerFactory()),
    )
    pp.Handle = handle
    pp.InitPlugin()

    // 注册扩展点一：逐节点评分
    ssn.AddNodeOrderFn(pp.Name(), func(task *api.TaskInfo, node *api.NodeInfo) (float64, error) {
        nodeInfo := nodeMap[node.Name]
        state := k8sframework.NewCycleState()
        return pp.NodeOrderFn(task, node, nodeInfo, state)
    })

    // 注册扩展点二：批量评分
    ssn.AddBatchNodeOrderFn(pp.Name(), func(task *api.TaskInfo, nodeInfo []*api.NodeInfo) (map[string]float64, error) {
        state := k8sframework.NewCycleState()
        return pp.BatchNodeOrderFn(task, nodeInfo, state)
    })
}

type Framework struct {
    snapshot         *Snapshot              // 节点快照
    kubeClient       kubernetes.Interface   // K8s API 客户端
    informerFactory  informers.SharedInformerFactory  // Informer 工厂
    sharedDRAManager framework.SharedDRAManager       // DRA 管理器
}

tiers:
- plugins:
  - name: predicates
  - name: nodeorder