Prioritize scheduling to machines that are satisfied with current res…

…ources, and then consider machines that are satisfied with future resources

Signed-off-by: wangyang <wangyang8126@gmail.com>

pkg/scheduler/actions/allocate/allocate.go

@@ -195,28 +195,64 @@ func (alloc *Action) Execute(ssn *framework.Session) {
 				break
 			}
 
-			var candidateNodes []*api.NodeInfo
+			// When scheduling pods, gradient scoring is performed on all nodes that are successfully filtered.
+			// Divided into two gradients:
+			//   - The first gradient: the node that the current idle satisfies;
+			//   - The second gradient: the node (including the terminating pod) that the idle will satisfy in the future;
+			// Give priority to scoring the first gradient node. If the first gradiend can select a node, then directly schedule the pod.
+			// If there is no eligible node in the first echelon, then score the second gradient node to select the appropriate node.
+			var candidateNodes [][]*api.NodeInfo
+			var idleCandidateNodes []*api.NodeInfo
+			var futureIdleCandidateNodes []*api.NodeInfo
 			for _, n := range predicateNodes {
-				if task.InitResreq.LessEqual(n.Idle, api.Zero) || task.InitResreq.LessEqual(n.FutureIdle(), api.Zero) {
-					candidateNodes = append(candidateNodes, n)
+				if task.InitResreq.LessEqual(n.Idle, api.Zero) {
+					idleCandidateNodes = append(idleCandidateNodes, n)
+				} else if task.InitResreq.LessEqual(n.FutureIdle(), api.Zero) {
+					futureIdleCandidateNodes = append(futureIdleCandidateNodes, n)
+				} else {
+					klog.V(5).Infof("Predicate filtered node %v, idle: %v and future idle: %v do not meet the requirements of task: %v",
+						n.Name, n.Idle, n.FutureIdle(), task.Name)
 				}
 			}
+			candidateNodes = append(candidateNodes, idleCandidateNodes)
+			candidateNodes = append(candidateNodes, futureIdleCandidateNodes)
+
+			var bestNode *api.NodeInfo
+			for index, nodes := range candidateNodes {
+				if klog.V(5).Enabled() {
+					for _, node := range nodes {
+						klog.V(5).Infof("node %v, idle: %v, future idle: %v", node.Name, node.Idle, node.FutureIdle())
+					}
+				}
+				switch {
+				case len(nodes) == 0:
+					klog.V(3).Infof("Task: %v, no matching node is found in the nodes list."+
+						"candidateNodes index is %d ", task.Name, index)
+				case len(nodes) == 1: // If only one node after predicate, just use it.
+					bestNode = nodes[0]
+				case len(nodes) > 1: // If more than one node after predicate, using "the best" one
+					nodeScores := util.PrioritizeNodes(task, nodes, ssn.BatchNodeOrderFn, ssn.NodeOrderMapFn, ssn.NodeOrderReduceFn)
+
+					bestNode = ssn.BestNodeFn(task, nodeScores)
+					if bestNode == nil {
+						bestNode = util.SelectBestNode(nodeScores)
+					}
+				}
 
-			var node *api.NodeInfo
-			switch {
-			case len(candidateNodes) == 0: // If not candidate nodes for this task, skip it.
-				continue
-			case len(candidateNodes) == 1: // If only one node after predicate, just use it.
-				node = candidateNodes[0]
-			case len(candidateNodes) > 1: // If more than one node after predicate, using "the best" one
-				nodeScores := util.PrioritizeNodes(task, candidateNodes, ssn.BatchNodeOrderFn, ssn.NodeOrderMapFn, ssn.NodeOrderReduceFn)
-
-				node = ssn.BestNodeFn(task, nodeScores)
-				if node == nil {
-					node = util.SelectBestNode(nodeScores)
+				// If a proper node is found in idleCandidateNodes, skip futureIdleCandidateNodes and directly return the node information.
+				if bestNode != nil {
+					break
 				}
 			}
 
+			var node *api.NodeInfo
+			if bestNode != nil {
+				node = bestNode
+			} else {
+				klog.Errorf("task %s/%s allocate failed, bestNode is nil", task.Namespace, task.Name)
+				break
+			}
+
 			// Allocate idle resource to the task.
 			if task.InitResreq.LessEqual(node.Idle, api.Zero) {
 				klog.V(3).Infof("Binding Task <%v/%v> to node <%v>",