Add scheduling strategies in CA.

walidghallab · walidghallab · commit ad1637803b64 · 2026-02-10T19:20:23.000Z
To be more exact:
- An iterator to control the order of nodes to go through.
- An option to prefer the smallest number of iterations in case of
  multiple matches, even if parallelism is enabled.
diff --git a/cluster-autoscaler/core/podlistprocessor/filter_out_schedulable.go b/cluster-autoscaler/core/podlistprocessor/filter_out_schedulable.go
@@ -100,7 +100,7 @@ func (p *filterOutSchedulablePodListProcessor) filterOutSchedulableByPacking(uns
 		return corev1helpers.PodPriority(unschedulableCandidates[i]) > corev1helpers.PodPriority(unschedulableCandidates[j])
 	})
 
-	statuses, overflowingControllerCount, err := p.schedulingSimulator.TrySchedulePods(clusterSnapshot, unschedulableCandidates, p.nodeFilter, false)
+	statuses, overflowingControllerCount, err := p.schedulingSimulator.TrySchedulePods(clusterSnapshot, unschedulableCandidates, p.nodeFilter, false, clustersnapshot.SchedulingOptions{})
 	if err != nil {
 		return nil, err
 	}
diff --git a/cluster-autoscaler/core/scaledown/planner/planner.go b/cluster-autoscaler/core/scaledown/planner/planner.go
@@ -261,7 +261,7 @@ func (p *Planner) injectPods(pods []*apiv1.Pod) error {
 	pods = pod_util.ClearPodNodeNames(pods)
 	// Note: We're using ScheduleAnywhere, but the pods won't schedule back
 	// on the drained nodes due to taints.
-	statuses, _, err := p.actuationInjector.TrySchedulePods(p.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, true)
+	statuses, _, err := p.actuationInjector.TrySchedulePods(p.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, true, clustersnapshot.SchedulingOptions{})
 	if err != nil {
 		return fmt.Errorf("cannot scale down, an unexpected error occurred: %v", err)
 	}
diff --git a/cluster-autoscaler/estimator/binpacking_estimator.go b/cluster-autoscaler/estimator/binpacking_estimator.go
@@ -149,7 +149,7 @@ func (e *BinpackingNodeEstimator) tryToScheduleOnExistingNodes(
 		// Try to schedule the pod on all nodes created during simulation
 		nodeName, err := e.clusterSnapshot.SchedulePodOnAnyNodeMatching(pod, func(nodeInfo *framework.NodeInfo) bool {
 			return estimationState.newNodeNames[nodeInfo.Node().Name]
-		})
+		}, clustersnapshot.SchedulingOptions{})
 		if err != nil && err.Type() == clustersnapshot.SchedulingInternalError {
 			// Unexpected error.
 			return nil, err
@@ -192,7 +192,7 @@ func (e *BinpackingNodeEstimator) tryToScheduleOnNewNodes(
 				// The pod can't be scheduled on any new node either, because it has the same topology constraints.
 				nodeName, err := e.clusterSnapshot.SchedulePodOnAnyNodeMatching(pod, func(nodeInfo *framework.NodeInfo) bool {
 					return nodeInfo.Node().Name != estimationState.lastNodeName // only skip the last node that failed scheduling
-				})
+				}, clustersnapshot.SchedulingOptions{})
 				if err != nil && err.Type() == clustersnapshot.SchedulingInternalError {
 					// Unexpected error.
 					return false, err
diff --git a/cluster-autoscaler/processors/provreq/processor.go b/cluster-autoscaler/processors/provreq/processor.go
@@ -46,7 +46,7 @@ const (
 )
 
 type injector interface {
-	TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []*apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool) ([]scheduling.Status, int, error)
+	TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []*apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool, opts clustersnapshot.SchedulingOptions) ([]scheduling.Status, int, error)
 }
 
 type provReqProcessor struct {
@@ -165,7 +165,7 @@ func (p *provReqProcessor) bookCapacity(autoscalingCtx *ca_context.AutoscalingCo
 		return nil
 	}
 	// Scheduling the pods to reserve capacity for provisioning request.
-	if _, _, err = p.injector.TrySchedulePods(autoscalingCtx.ClusterSnapshot, podsToCreate, scheduling.ScheduleAnywhere, false); err != nil {
+	if _, _, err = p.injector.TrySchedulePods(autoscalingCtx.ClusterSnapshot, podsToCreate, scheduling.ScheduleAnywhere, false, clustersnapshot.SchedulingOptions{}); err != nil {
 		return err
 	}
 	return nil
diff --git a/cluster-autoscaler/processors/provreq/processor_test.go b/cluster-autoscaler/processors/provreq/processor_test.go
@@ -232,7 +232,7 @@ type fakeInjector struct {
 	pods []*apiv1.Pod
 }
 
-func (f *fakeInjector) TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []*apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool) ([]scheduling.Status, int, error) {
+func (f *fakeInjector) TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []*apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool, opts clustersnapshot.SchedulingOptions) ([]scheduling.Status, int, error) {
 	f.pods = pods
 	return nil, 0, nil
 }
diff --git a/cluster-autoscaler/provisioningrequest/besteffortatomic/provisioning_class.go b/cluster-autoscaler/provisioningrequest/besteffortatomic/provisioning_class.go
@@ -23,6 +23,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	ca_context "k8s.io/autoscaler/cluster-autoscaler/context"
 	"k8s.io/autoscaler/cluster-autoscaler/resourcequotas"
+	"k8s.io/autoscaler/cluster-autoscaler/simulator/clustersnapshot"
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/framework"
 	"k8s.io/klog/v2"
 
@@ -137,7 +138,7 @@ func (o *bestEffortAtomicProvClass) Provision(
 }
 
 func (o *bestEffortAtomicProvClass) filterOutSchedulable(pods []*apiv1.Pod) ([]*apiv1.Pod, error) {
-	statuses, _, err := o.injector.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, false)
+	statuses, _, err := o.injector.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, false, clustersnapshot.SchedulingOptions{})
 	if err != nil {
 		return nil, err
 	}
diff --git a/cluster-autoscaler/provisioningrequest/checkcapacity/provisioningclass.go b/cluster-autoscaler/provisioningrequest/checkcapacity/provisioningclass.go
@@ -36,6 +36,7 @@ import (
 	"k8s.io/autoscaler/cluster-autoscaler/provisioningrequest/provreqclient"
 	"k8s.io/autoscaler/cluster-autoscaler/provisioningrequest/provreqwrapper"
 	"k8s.io/autoscaler/cluster-autoscaler/resourcequotas"
+	"k8s.io/autoscaler/cluster-autoscaler/simulator/clustersnapshot"
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/framework"
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/scheduling"
 	"k8s.io/autoscaler/cluster-autoscaler/utils/errors"
@@ -177,7 +178,7 @@ func (o *checkCapacityProvClass) checkCapacity(unschedulablePods []*apiv1.Pod, p
 	o.autoscalingCtx.ClusterSnapshot.Fork()
 
 	// Case 1: Capacity fits.
-	scheduled, _, err := o.schedulingSimulator.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, unschedulablePods, scheduling.ScheduleAnywhere, true)
+	scheduled, _, err := o.schedulingSimulator.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, unschedulablePods, scheduling.ScheduleAnywhere, true, clustersnapshot.SchedulingOptions{})
 	if err == nil && len(scheduled) == len(unschedulablePods) {
 		commitError := o.autoscalingCtx.ClusterSnapshot.Commit()
 		if commitError != nil {
diff --git a/cluster-autoscaler/simulator/cluster.go b/cluster-autoscaler/simulator/cluster.go
@@ -205,7 +205,7 @@ func (r *RemovalSimulator) findPlaceFor(removedNode string, pods []*apiv1.Pod, n
 		newpods = append(newpods, &newpod)
 	}
 
-	statuses, _, err := r.schedulingSimulator.TrySchedulePods(r.clusterSnapshot, newpods, isCandidateNode, true)
+	statuses, _, err := r.schedulingSimulator.TrySchedulePods(r.clusterSnapshot, newpods, isCandidateNode, true, clustersnapshot.SchedulingOptions{})
 	if err != nil {
 		return err
 	}
diff --git a/cluster-autoscaler/simulator/clustersnapshot/clustersnapshot.go b/cluster-autoscaler/simulator/clustersnapshot/clustersnapshot.go
@@ -57,7 +57,7 @@ type ClusterSnapshot interface {
 	// Node its scheduled on and nil are returned. If the pod can't be scheduled on any Node, an empty string and a non-nil
 	// error explaining why are returned. The error Type() can be checked against SchedulingInternalError to distinguish
 	// failing predicates from unexpected errors.
-	SchedulePodOnAnyNodeMatching(pod *apiv1.Pod, nodeMatches func(*framework.NodeInfo) bool) (matchingNode string, err SchedulingError)
+	SchedulePodOnAnyNodeMatching(pod *apiv1.Pod, nodeMatches func(*framework.NodeInfo) bool, opts SchedulingOptions) (matchingNode string, err SchedulingError)
 	// UnschedulePod removes the given Pod from the given Node inside the snapshot, and modifies all relevant DRA objects
 	// to reflect the removal. The pod can then be scheduled on another Node in the snapshot using the Schedule methods.
 	UnschedulePod(namespace string, podName string, nodeName string) error
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/plugin_runner.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/plugin_runner.go
@@ -21,10 +21,12 @@ import (
 	"fmt"
 	"strings"
 	"sync"
+	"time"
 
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/clustersnapshot"
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/framework"
 	"k8s.io/client-go/util/workqueue"
+	"k8s.io/klog/v2"
 
 	apiv1 "k8s.io/api/core/v1"
 	schedulerframework "k8s.io/kubernetes/pkg/scheduler/framework"
@@ -47,12 +49,17 @@ func NewSchedulerPluginRunner(fwHandle *framework.Handle, snapshot clustersnapsh
 // function - until a Node where the Filters pass is found. Filters are only run for matching Nodes. If no matching Node with passing Filters is found, an error is returned.
 //
 // The node iteration always starts from the next Node from the last Node that was found by this method. TODO: Extract the iteration strategy out of SchedulerPluginRunner.
-func (p *SchedulerPluginRunner) RunFiltersUntilPassingNode(pod *apiv1.Pod, nodeMatches func(*framework.NodeInfo) bool) (*apiv1.Node, *schedulerframework.CycleState, clustersnapshot.SchedulingError) {
+func (p *SchedulerPluginRunner) RunFiltersUntilPassingNode(pod *apiv1.Pod, nodeMatches func(*framework.NodeInfo) bool, opts clustersnapshot.SchedulingOptions) (*apiv1.Node, *schedulerframework.CycleState, clustersnapshot.SchedulingError) {
 	nodeInfosList, err := p.snapshot.ListNodeInfos()
 	if err != nil {
 		return nil, nil, clustersnapshot.NewSchedulingInternalError(pod, fmt.Sprintf("error listing NodeInfos: %v", err))
 	}
 
+	nodeNameToIndex := make(map[string]int, len(nodeInfosList))
+	for i, ni := range nodeInfosList {
+		nodeNameToIndex[ni.Node().Name] = i
+	}
+
 	p.fwHandle.DelegatingLister.UpdateDelegate(p.snapshot)
 	defer p.fwHandle.DelegatingLister.ResetDelegate()
 
@@ -74,13 +81,41 @@ func (p *SchedulerPluginRunner) RunFiltersUntilPassingNode(pod *apiv1.Pod, nodeM
 		mu              sync.Mutex
 	)
 
+	var seqTracker *sequenceTracker
+	getNodeIndex := func(i int) int {
+		return (p.lastIndex + i + 1) % len(nodeInfosList)
+	}
+
+	if opts.PreferSmallestSteps {
+		seqTracker = newSequenceTracker()
+	}
+
+	if opts.Next != nil {
+		lastNode := nodeInfosList[p.lastIndex%len(nodeInfosList)].Node().Name
+		getNodeIndex = func(i int) int {
+			nodeName := opts.Next(lastNode, i)
+			if nodeIndex, ok := nodeNameToIndex[nodeName]; ok {
+				return nodeIndex
+			}
+			return -1
+		}
+	}
+
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	checkNode := func(i int) {
-		nodeIndex := (p.lastIndex + i) % len(nodeInfosList)
+		nodeIndex := getNodeIndex(i)
+		if nodeIndex < 0 {
+			return
+		}
+
 		nodeInfo := nodeInfosList[nodeIndex]
 
+		if seqTracker != nil {
+			defer seqTracker.Insert(i)
+		}
+
 		// Plugins can filter some Nodes out during the PreFilter phase, if they're sure the Nodes won't work for the Pod at that stage.
 		// Filters are only run for Nodes that haven't been filtered out during the PreFilter phase. Match that behavior here - skip such Nodes.
 		if !preFilterResult.AllNodes() && !preFilterResult.NodeNames.Has(nodeInfo.Node().Name) {
@@ -104,6 +139,13 @@ func (p *SchedulerPluginRunner) RunFiltersUntilPassingNode(pod *apiv1.Pod, nodeM
 		clonedState := state.Clone()
 		filterStatus := p.fwHandle.Framework.RunFilterPlugins(context.TODO(), clonedState, pod, nodeInfo.ToScheduler())
 		if filterStatus.IsSuccess() {
+			if seqTracker != nil {
+				waitTimeout := 10 * time.Second
+				err := seqTracker.WaitUntilAllUpToInserted(ctx, i-1, waitTimeout)
+				if err != nil {
+					klog.Warningf("Error while waiting for all previous nodes to be attempted scheduling, proceeding...: %v", err)
+				}
+			}
 			// Filter passed for all plugins, so this pod can be scheduled on this Node.
 			mu.Lock()
 			defer mu.Unlock()
@@ -120,7 +162,7 @@ func (p *SchedulerPluginRunner) RunFiltersUntilPassingNode(pod *apiv1.Pod, nodeM
 	workqueue.ParallelizeUntil(ctx, p.parallelism, len(nodeInfosList), checkNode)
 
 	if foundNode != nil {
-		p.lastIndex = (foundIndex + 1) % len(nodeInfosList)
+		p.lastIndex = foundIndex
 		return foundNode, foundCycleState, nil
 	}
 
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/plugin_runner_test.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/plugin_runner_test.go
@@ -279,7 +279,7 @@ func TestRunFilterUntilPassingNode(t *testing.T) {
 			err = snapshot.AddNodeInfo(framework.NewTestNodeInfo(n2000))
 			assert.NoError(t, err)
 
-			node, state, err := pluginRunner.RunFiltersUntilPassingNode(tc.pod, func(info *framework.NodeInfo) bool { return true })
+			node, state, err := pluginRunner.RunFiltersUntilPassingNode(tc.pod, func(info *framework.NodeInfo) bool { return true }, clustersnapshot.SchedulingOptions{})
 			if tc.expectError {
 				assert.Nil(t, node)
 				assert.Nil(t, state)
@@ -293,6 +293,101 @@ func TestRunFilterUntilPassingNode(t *testing.T) {
 	}
 }
 
+func TestRunFilterUntilPassingNode_NodeIterator(t *testing.T) {
+	p100 := BuildTestPod("p100", 100, 1000)
+
+	n1 := BuildTestNode("n1", 1000, 2000000)
+	n2 := BuildTestNode("n2", 1000, 2000000)
+	n3 := BuildTestNode("n3", 1000, 2000000)
+	n4 := BuildTestNode("n4", 1000, 2000000)
+
+	reverseOrderedIterator := func(lastNode string, i int) string {
+		nodes := []string{"n4", "n3", "n2", "n1"}
+		if i < len(nodes) {
+			return nodes[i]
+		}
+		return ""
+	}
+
+	pluginRunner, snapshot, err := newTestPluginRunnerAndSnapshot(nil)
+	pluginRunner.parallelism = 1 // Parallelism being 1 is essential in this test to make sure we go through nodes in order.
+	assert.NoError(t, err)
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n1)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n2)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n3)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n4)))
+
+	var visitOrder []string
+
+	_, _, err = pluginRunner.RunFiltersUntilPassingNode(p100, func(info *framework.NodeInfo) bool {
+		visitOrder = append(visitOrder, info.Node().Name)
+		return info.Node().Name == "n1" // This is the last node, we want to go through all the nodes.
+	}, clustersnapshot.SchedulingOptions{Next: reverseOrderedIterator})
+
+	assert.NoError(t, err)
+	assert.Equal(t, []string{"n4", "n3", "n2", "n1"}, visitOrder)
+
+}
+
+func TestRunFilterUntilPassingNode_PreferSmallestSteps(t *testing.T) {
+	p100 := BuildTestPod("p100", 100, 1000)
+
+	n1 := BuildTestNode("n1", 1000, 2000000)
+	n2 := BuildTestNode("n2", 1000, 2000000)
+	n3 := BuildTestNode("n3", 1000, 2000000)
+	n4 := BuildTestNode("n4", 1000, 2000000)
+
+	orderedIterator := func(lastNode string, i int) string {
+		nodes := []string{"n1", "n2", "n3", "n4"}
+		if i < len(nodes) {
+			return nodes[i]
+		}
+		return ""
+	}
+
+	pluginRunner, snapshot, err := newTestPluginRunnerAndSnapshot(nil)
+	pluginRunner.parallelism = 16
+	assert.NoError(t, err)
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n1)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n2)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n3)))
+	assert.NoError(t, snapshot.AddNodeInfo(framework.NewTestNodeInfo(n4)))
+
+	// We want to ensure that even if n2 is checked faster, n1 is preferred if it also passes.
+	// We use channels to block n1's evaluation until n2 has been visited, ensuring n2
+	// would finish first if not for the PreferSmallestSteps logic.
+	delayFirstNode := make(chan struct{})
+	secondNodeVisited := make(chan struct{})
+	schedulingFinished := make(chan struct{})
+
+	chosenNodeName := ""
+
+	go func() {
+		node, _, err := pluginRunner.RunFiltersUntilPassingNode(p100, func(info *framework.NodeInfo) bool {
+			if info.Node().Name == "n1" {
+				<-delayFirstNode
+			}
+			if info.Node().Name == "n2" {
+				close(secondNodeVisited)
+			}
+			return true // all nodes pass
+		}, clustersnapshot.SchedulingOptions{
+			Next:                orderedIterator, // Needed to make the test deterministic.
+			PreferSmallestSteps: true,
+		})
+		assert.NoError(t, err)
+		chosenNodeName = node.Name
+		close(schedulingFinished)
+	}()
+
+	<-secondNodeVisited
+	assert.Empty(t, chosenNodeName)
+
+	close(delayFirstNode)
+	<-schedulingFinished
+	assert.Equal(t, "n1", chosenNodeName)
+}
+
 func TestDebugInfo(t *testing.T) {
 	p1 := BuildTestPod("p1", 0, 0)
 	node1 := BuildTestNode("n1", 1000, 2000000)
@@ -399,22 +494,28 @@ func BenchmarkRunFiltersUntilPassingNode(b *testing.B) {
 	}
 
 	testCases := []struct {
-		parallelism int
+		parallelism            int
+		preferredSmallestSteps bool
 	}{
 		{parallelism: 1},
 		{parallelism: 2},
 		{parallelism: 4},
 		{parallelism: 8},
 		{parallelism: 16},
+		{parallelism: 1, preferredSmallestSteps: true},
+		{parallelism: 2, preferredSmallestSteps: true},
+		{parallelism: 4, preferredSmallestSteps: true},
+		{parallelism: 8, preferredSmallestSteps: true},
+		{parallelism: 16, preferredSmallestSteps: true},
 	}
 
 	for _, tc := range testCases {
-		b.Run(fmt.Sprintf("parallelism-%d", tc.parallelism), func(b *testing.B) {
+		b.Run(fmt.Sprintf("parallelism-%d_preferredSmallestSteps-%v", tc.parallelism, tc.preferredSmallestSteps), func(b *testing.B) {
 			pluginRunner.parallelism = tc.parallelism
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				pluginRunner.lastIndex = 0 // Reset state for each run
-				_, _, err := pluginRunner.RunFiltersUntilPassingNode(pod, func(info *framework.NodeInfo) bool { return true })
+				_, _, err := pluginRunner.RunFiltersUntilPassingNode(pod, func(info *framework.NodeInfo) bool { return true }, clustersnapshot.SchedulingOptions{PreferSmallestSteps: tc.preferredSmallestSteps})
 				assert.NoError(b, err)
 			}
 		})
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/predicate_snapshot.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/predicate_snapshot.go
@@ -189,8 +189,8 @@ func (s *PredicateSnapshot) SchedulePod(pod *apiv1.Pod, nodeName string) cluster
 }
 
 // SchedulePodOnAnyNodeMatching adds pod to the snapshot and schedules it to any node matching the provided function.
-func (s *PredicateSnapshot) SchedulePodOnAnyNodeMatching(pod *apiv1.Pod, anyNodeMatching func(*framework.NodeInfo) bool) (string, clustersnapshot.SchedulingError) {
-	node, cycleState, schedErr := s.pluginRunner.RunFiltersUntilPassingNode(pod, anyNodeMatching)
+func (s *PredicateSnapshot) SchedulePodOnAnyNodeMatching(pod *apiv1.Pod, anyNodeMatching func(*framework.NodeInfo) bool, opts clustersnapshot.SchedulingOptions) (string, clustersnapshot.SchedulingError) {
+	node, cycleState, schedErr := s.pluginRunner.RunFiltersUntilPassingNode(pod, anyNodeMatching, opts)
 	if schedErr != nil {
 		return "", schedErr
 	}
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/predicate_snapshot_test.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/predicate_snapshot_test.go
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/sequence_tracker.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/sequence_tracker.go
diff --git a/cluster-autoscaler/simulator/clustersnapshot/predicate/sequence_tracker_test.go b/cluster-autoscaler/simulator/clustersnapshot/predicate/sequence_tracker_test.go
diff --git a/cluster-autoscaler/simulator/clustersnapshot/scheduling_opts.go b/cluster-autoscaler/simulator/clustersnapshot/scheduling_opts.go
diff --git a/cluster-autoscaler/simulator/scheduling/hinting_simulator.go b/cluster-autoscaler/simulator/scheduling/hinting_simulator.go
diff --git a/cluster-autoscaler/simulator/scheduling/hinting_simulator_test.go b/cluster-autoscaler/simulator/scheduling/hinting_simulator_test.go

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ func (p *filterOutSchedulablePodListProcessor) filterOutSchedulableByPacking(uns`
`100`	`100`	`return corev1helpers.PodPriority(unschedulableCandidates[i]) > corev1helpers.PodPriority(unschedulableCandidates[j])`
`101`	`101`	`})`
`102`	`102`
`103`		`- statuses, overflowingControllerCount, err := p.schedulingSimulator.TrySchedulePods(clusterSnapshot, unschedulableCandidates, p.nodeFilter, false)`
	`103`	`+ statuses, overflowingControllerCount, err := p.schedulingSimulator.TrySchedulePods(clusterSnapshot, unschedulableCandidates, p.nodeFilter, false, clustersnapshot.SchedulingOptions{})`
`104`	`104`	`if err != nil {`
`105`	`105`	`return nil, err`
`106`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ func (p Planner) injectPods(pods []apiv1.Pod) error {`
`261`	`261`	`pods = pod_util.ClearPodNodeNames(pods)`
`262`	`262`	`// Note: We're using ScheduleAnywhere, but the pods won't schedule back`
`263`	`263`	`// on the drained nodes due to taints.`
`264`		`- statuses, _, err := p.actuationInjector.TrySchedulePods(p.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, true)`
	`264`	`+ statuses, _, err := p.actuationInjector.TrySchedulePods(p.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, true, clustersnapshot.SchedulingOptions{})`
`265`	`265`	`if err != nil {`
`266`	`266`	`return fmt.Errorf("cannot scale down, an unexpected error occurred: %v", err)`
`267`	`267`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ const (`
`46`	`46`	`)`
`47`	`47`
`48`	`48`	`type injector interface {`
`49`		`- TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []apiv1.Pod, isNodeAcceptable func(framework.NodeInfo) bool, breakOnFailure bool) ([]scheduling.Status, int, error)`
	`49`	`+ TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []apiv1.Pod, isNodeAcceptable func(framework.NodeInfo) bool, breakOnFailure bool, opts clustersnapshot.SchedulingOptions) ([]scheduling.Status, int, error)`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`type provReqProcessor struct {`
`@@ -165,7 +165,7 @@ func (p provReqProcessor) bookCapacity(autoscalingCtx ca_context.AutoscalingCo`
`165`	`165`	`return nil`
`166`	`166`	`}`
`167`	`167`	`// Scheduling the pods to reserve capacity for provisioning request.`
`168`		`- if _, _, err = p.injector.TrySchedulePods(autoscalingCtx.ClusterSnapshot, podsToCreate, scheduling.ScheduleAnywhere, false); err != nil {`
	`168`	`+ if _, _, err = p.injector.TrySchedulePods(autoscalingCtx.ClusterSnapshot, podsToCreate, scheduling.ScheduleAnywhere, false, clustersnapshot.SchedulingOptions{}); err != nil {`
`169`	`169`	`return err`
`170`	`170`	`}`
`171`	`171`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ type fakeInjector struct {`
`232`	`232`	`pods []*apiv1.Pod`
`233`	`233`	`}`
`234`	`234`
`235`		`-func (f fakeInjector) TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool) ([]scheduling.Status, int, error) {`
	`235`	`+func (f fakeInjector) TrySchedulePods(clusterSnapshot clustersnapshot.ClusterSnapshot, pods []apiv1.Pod, isNodeAcceptable func(*framework.NodeInfo) bool, breakOnFailure bool, opts clustersnapshot.SchedulingOptions) ([]scheduling.Status, int, error) {`
`236`	`236`	`f.pods = pods`
`237`	`237`	`return nil, 0, nil`
`238`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ import (`
`23`	`23`	`"k8s.io/apimachinery/pkg/types"`
`24`	`24`	`ca_context "k8s.io/autoscaler/cluster-autoscaler/context"`
`25`	`25`	`"k8s.io/autoscaler/cluster-autoscaler/resourcequotas"`
	`26`	`+ "k8s.io/autoscaler/cluster-autoscaler/simulator/clustersnapshot"`
`26`	`27`	`"k8s.io/autoscaler/cluster-autoscaler/simulator/framework"`
`27`	`28`	`"k8s.io/klog/v2"`
`28`	`29`
`@@ -137,7 +138,7 @@ func (o *bestEffortAtomicProvClass) Provision(`
`137`	`138`	`}`
`138`	`139`
`139`	`140`	`func (o bestEffortAtomicProvClass) filterOutSchedulable(pods []apiv1.Pod) ([]*apiv1.Pod, error) {`
`140`		`- statuses, _, err := o.injector.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, false)`
	`141`	`+ statuses, _, err := o.injector.TrySchedulePods(o.autoscalingCtx.ClusterSnapshot, pods, scheduling.ScheduleAnywhere, false, clustersnapshot.SchedulingOptions{})`
`141`	`142`	`if err != nil {`
`142`	`143`	`return nil, err`
`143`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -205,7 +205,7 @@ func (r RemovalSimulator) findPlaceFor(removedNode string, pods []apiv1.Pod, n`
`205`	`205`	`newpods = append(newpods, &newpod)`
`206`	`206`	`}`
`207`	`207`
`208`		`- statuses, _, err := r.schedulingSimulator.TrySchedulePods(r.clusterSnapshot, newpods, isCandidateNode, true)`
	`208`	`+ statuses, _, err := r.schedulingSimulator.TrySchedulePods(r.clusterSnapshot, newpods, isCandidateNode, true, clustersnapshot.SchedulingOptions{})`
`209`	`209`	`if err != nil {`
`210`	`210`	`return err`
`211`	`211`	`}`