Backport of Scheduler: Add configurable NodeLimitForFeasibilityChecks into release/2.0.x (#27884)

hc-github-team-nomad-core · lukepalmer · web-flow · commit d497773f9c89 · 2026-04-28T11:17:24.000-04:00
Co-authored-by: Luke Palmer &lt;luke@lukepalmer.net&gt;
diff --git a/.changelog/27650.txt b/.changelog/27650.txt
@@ -0,0 +1,3 @@
+```release-note:improvement
+scheduler: Add a configuration field for the number of nodes that the scheduler considers when spread or affinity is in use. This can improve scheduler performance for some cluster shapes.
+```
diff --git a/api/operator.go b/api/operator.go
@@ -185,6 +185,13 @@ type SchedulerConfiguration struct {
 	// until the configuration is updated and written to the Nomad servers.
 	PauseEvalBroker bool
 
+	// NodeLimitForFeasibilityChecks limits the number of feasible nodes to consider when
+	// scheduling a job that specifies spread and/or affinity. Defaults to 100 nodes if
+	// unset. Lower numbers result in better scheduler performance and more randomization
+	// of jobs across nodes. Higher numbers result in more deterministic application of
+	// spread and/or affinity.
+	NodeLimitForFeasibilityChecks uint
+
 	// CreateIndex/ModifyIndex store the create/modify indexes of this configuration.
 	CreateIndex uint64
 	ModifyIndex uint64
diff --git a/api/operator_test.go b/api/operator_test.go
@@ -64,6 +64,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 		MemoryOversubscriptionEnabled: true,
 		RejectJobRegistration:         true,
 		PauseEvalBroker:               true,
+		NodeLimitForFeasibilityChecks: 123,
 	}
 
 	schedulerConfigUpdateResp, _, err := c.Operator().SchedulerSetConfiguration(&newSchedulerConfig, nil)
@@ -78,6 +79,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 	must.True(t, schedulerConfig.SchedulerConfig.RejectJobRegistration)
 	must.True(t, schedulerConfig.SchedulerConfig.MemoryOversubscriptionEnabled)
 	must.Eq(t, schedulerConfig.SchedulerConfig.PreemptionConfig, newSchedulerConfig.PreemptionConfig)
+	must.Eq(t, schedulerConfig.SchedulerConfig.NodeLimitForFeasibilityChecks, newSchedulerConfig.NodeLimitForFeasibilityChecks)
 }
 
 func TestOperator_AutopilotState(t *testing.T) {
diff --git a/command/agent/operator_endpoint.go b/command/agent/operator_endpoint.go
@@ -311,6 +311,7 @@ func (s *HTTPServer) schedulerUpdateConfig(resp http.ResponseWriter, req *http.R
 		MemoryOversubscriptionEnabled: conf.MemoryOversubscriptionEnabled,
 		RejectJobRegistration:         conf.RejectJobRegistration,
 		PauseEvalBroker:               conf.PauseEvalBroker,
+		NodeLimitForFeasibilityChecks: conf.NodeLimitForFeasibilityChecks,
 		PreemptionConfig: structs.PreemptionConfig{
 			SystemSchedulerEnabled:   conf.PreemptionConfig.SystemSchedulerEnabled,
 			SysBatchSchedulerEnabled: conf.PreemptionConfig.SysBatchSchedulerEnabled,
diff --git a/command/agent/operator_endpoint_test.go b/command/agent/operator_endpoint_test.go
@@ -496,6 +496,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 {
   "MemoryOversubscriptionEnabled": true,
   "PauseEvalBroker": true,
+  "NodeLimitForFeasibilityChecks": 123,
   "PreemptionConfig": {
     "SystemSchedulerEnabled": true,
     "ServiceSchedulerEnabled": true
@@ -525,6 +526,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 		require.True(t, reply.SchedulerConfig.PreemptionConfig.ServiceSchedulerEnabled)
 		require.True(t, reply.SchedulerConfig.MemoryOversubscriptionEnabled)
 		require.True(t, reply.SchedulerConfig.PauseEvalBroker)
+		require.Equal(t, reply.SchedulerConfig.GetNodeLimitForFeasibilityChecks(), uint(123))
 	})
 }
 
diff --git a/command/operator_scheduler_get_config.go b/command/operator_scheduler_get_config.go
@@ -86,6 +86,7 @@ func (o *OperatorSchedulerGetConfig) Run(args []string) int {
 		fmt.Sprintf("Preemption Service Scheduler|%v", schedConfig.PreemptionConfig.ServiceSchedulerEnabled),
 		fmt.Sprintf("Preemption Batch Scheduler|%v", schedConfig.PreemptionConfig.BatchSchedulerEnabled),
 		fmt.Sprintf("Preemption SysBatch Scheduler|%v", schedConfig.PreemptionConfig.SysBatchSchedulerEnabled),
+		fmt.Sprintf("Node Limit For Feasibility Checks|%v", schedConfig.NodeLimitForFeasibilityChecks),
 		fmt.Sprintf("Modify Index|%v", resp.SchedulerConfig.ModifyIndex),
 	}))
 	return 0
diff --git a/command/operator_scheduler_get_config_test.go b/command/operator_scheduler_get_config_test.go
@@ -25,8 +25,8 @@ func TestOperatorSchedulerGetConfig_Run(t *testing.T) {
 	// Run the command, so we get the default output and test this.
 	must.Zero(t, c.Run([]string{"-address=" + addr}))
 	s := ui.OutputWriter.String()
-	must.StrContains(t, s, "Scheduler Algorithm           = binpack")
-	must.StrContains(t, s, "Preemption SysBatch Scheduler = false")
+	must.StrContains(t, s, "Scheduler Algorithm               = binpack")
+	must.StrContains(t, s, "Preemption SysBatch Scheduler     = false")
 	ui.ErrorWriter.Reset()
 	ui.OutputWriter.Reset()
 
diff --git a/command/operator_scheduler_set_config.go b/command/operator_scheduler_set_config.go
@@ -22,15 +22,16 @@ type OperatorSchedulerSetConfig struct {
 	// The scheduler configuration flags allow us to tell whether the user set
 	// a value or not. This means we can safely merge the current configuration
 	// with user supplied, selective updates.
-	checkIndex               string
-	schedulerAlgorithm       string
-	memoryOversubscription   flagHelper.BoolValue
-	rejectJobRegistration    flagHelper.BoolValue
-	pauseEvalBroker          flagHelper.BoolValue
-	preemptBatchScheduler    flagHelper.BoolValue
-	preemptServiceScheduler  flagHelper.BoolValue
-	preemptSysBatchScheduler flagHelper.BoolValue
-	preemptSystemScheduler   flagHelper.BoolValue
+	checkIndex                    string
+	schedulerAlgorithm            string
+	memoryOversubscription        flagHelper.BoolValue
+	rejectJobRegistration         flagHelper.BoolValue
+	pauseEvalBroker               flagHelper.BoolValue
+	preemptBatchScheduler         flagHelper.BoolValue
+	preemptServiceScheduler       flagHelper.BoolValue
+	preemptSysBatchScheduler      flagHelper.BoolValue
+	preemptSystemScheduler        flagHelper.BoolValue
+	nodeLimitForFeasibilityChecks flagHelper.UintValue
 }
 
 func (o *OperatorSchedulerSetConfig) AutocompleteFlags() complete.Flags {
@@ -41,13 +42,14 @@ func (o *OperatorSchedulerSetConfig) AutocompleteFlags() complete.Flags {
 				string(api.SchedulerAlgorithmBinpack),
 				string(api.SchedulerAlgorithmSpread),
 			),
-			"-memory-oversubscription":    complete.PredictSet("true", "false"),
-			"-reject-job-registration":    complete.PredictSet("true", "false"),
-			"-pause-eval-broker":          complete.PredictSet("true", "false"),
-			"-preempt-batch-scheduler":    complete.PredictSet("true", "false"),
-			"-preempt-service-scheduler":  complete.PredictSet("true", "false"),
-			"-preempt-sysbatch-scheduler": complete.PredictSet("true", "false"),
-			"-preempt-system-scheduler":   complete.PredictSet("true", "false"),
+			"-memory-oversubscription":           complete.PredictSet("true", "false"),
+			"-reject-job-registration":           complete.PredictSet("true", "false"),
+			"-pause-eval-broker":                 complete.PredictSet("true", "false"),
+			"-preempt-batch-scheduler":           complete.PredictSet("true", "false"),
+			"-preempt-service-scheduler":         complete.PredictSet("true", "false"),
+			"-preempt-sysbatch-scheduler":        complete.PredictSet("true", "false"),
+			"-preempt-system-scheduler":          complete.PredictSet("true", "false"),
+			"-node-limit-for-feasibility-checks": complete.PredictAnything,
 		},
 	)
 }
@@ -72,6 +74,7 @@ func (o *OperatorSchedulerSetConfig) Run(args []string) int {
 	flags.Var(&o.preemptServiceScheduler, "preempt-service-scheduler", "")
 	flags.Var(&o.preemptSysBatchScheduler, "preempt-sysbatch-scheduler", "")
 	flags.Var(&o.preemptSystemScheduler, "preempt-system-scheduler", "")
+	flags.Var(&o.nodeLimitForFeasibilityChecks, "node-limit-for-feasibility-checks", "")
 
 	if err := flags.Parse(args); err != nil {
 		return 1
@@ -134,6 +137,7 @@ func (o *OperatorSchedulerSetConfig) Run(args []string) int {
 	o.preemptServiceScheduler.Merge(&schedulerConfig.PreemptionConfig.ServiceSchedulerEnabled)
 	o.preemptSysBatchScheduler.Merge(&schedulerConfig.PreemptionConfig.SysBatchSchedulerEnabled)
 	o.preemptSystemScheduler.Merge(&schedulerConfig.PreemptionConfig.SystemSchedulerEnabled)
+	o.nodeLimitForFeasibilityChecks.Merge(&schedulerConfig.NodeLimitForFeasibilityChecks)
 
 	// Check-and-set the new configuration.
 	result, _, err := client.Operator().SchedulerCASConfiguration(schedulerConfig, nil)
@@ -208,6 +212,13 @@ Scheduler Set Config Options:
   -preempt-system-scheduler=[true|false]
     Specifies whether preemption for system jobs is enabled. Note that if this
     is set to true, then system jobs can preempt any other jobs.
+
+  -node-limit-for-feasibility-checks=<count>
+    Limits the number of feasible nodes to consider when scheduling a job that
+	specifies spread and/or affinity. Defaults to 100 nodes if unset. Lower
+	numbers result in better scheduler performance and more randomization of jobs
+	across nodes. Higher numbers result in more deterministic application of
+	feasibility checks.
 `
 	return strings.TrimSpace(helpText)
 }
diff --git a/command/operator_scheduler_set_config_test.go b/command/operator_scheduler_set_config_test.go
@@ -51,6 +51,7 @@ func TestOperatorSchedulerSetConfig_Run(t *testing.T) {
 		"-preempt-service-scheduler=true",
 		"-preempt-sysbatch-scheduler=true",
 		"-preempt-system-scheduler=false",
+		"-node-limit-for-feasibility-checks=200",
 	}
 	must.Zero(t, c.Run(modifyingArgs))
 	s := ui.OutputWriter.String()
@@ -69,6 +70,7 @@ func TestOperatorSchedulerSetConfig_Run(t *testing.T) {
 		MemoryOversubscriptionEnabled: true,
 		RejectJobRegistration:         true,
 		PauseEvalBroker:               true,
+		NodeLimitForFeasibilityChecks: 200,
 	}, modifiedConfig.SchedulerConfig)
 
 	ui.ErrorWriter.Reset()
@@ -108,4 +110,5 @@ func schedulerConfigEquals(t *testing.T, expected, actual *api.SchedulerConfigur
 	must.Eq(t, expected.MemoryOversubscriptionEnabled, actual.MemoryOversubscriptionEnabled)
 	must.Eq(t, expected.PauseEvalBroker, actual.PauseEvalBroker)
 	must.Eq(t, expected.PreemptionConfig, actual.PreemptionConfig)
+	must.Eq(t, expected.NodeLimitForFeasibilityChecks, actual.NodeLimitForFeasibilityChecks)
 }
diff --git a/nomad/operator_endpoint_test.go b/nomad/operator_endpoint_test.go
@@ -551,13 +551,14 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 	rpcCodec := rpcClient(t, s1)
 	testutil.WaitForLeader(t, s1.RPC)
 
-	// Disable preemption and pause the eval broker.
+	// Disable preemption, pause the eval broker, and set a custom node limit.
 	arg := structs.SchedulerSetConfigRequest{
 		Config: structs.SchedulerConfiguration{
 			PreemptionConfig: structs.PreemptionConfig{
 				SystemSchedulerEnabled: false,
 			},
-			PauseEvalBroker: true,
+			PauseEvalBroker:               true,
+			NodeLimitForFeasibilityChecks: 200,
 		},
 	}
 	arg.Region = s1.config.Region
@@ -581,6 +582,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {
 	require.NotZero(t, reply.Index)
 	require.False(t, reply.SchedulerConfig.PreemptionConfig.SystemSchedulerEnabled)
 	require.True(t, reply.SchedulerConfig.PauseEvalBroker)
+	require.Equal(t, uint(200), reply.SchedulerConfig.GetNodeLimitForFeasibilityChecks())
 
 	require.False(t, s1.evalBroker.Enabled())
 	require.False(t, s1.blockedEvals.Enabled())
diff --git a/nomad/structs/operator.go b/nomad/structs/operator.go
@@ -209,6 +209,10 @@ const (
 	// SchedulerAlgorithmSpread indicates that the scheduler should spread
 	// allocations as evenly as possible over the available hardware.
 	SchedulerAlgorithmSpread SchedulerAlgorithm = "spread"
+
+	// DefaultNodeLimitForFeasibilityChecks is the default value of
+	// NodeLimitForFeasibilityChecks if not specified
+	DefaultNodeLimitForFeasibilityChecks = 100
 )
 
 // SchedulerConfiguration is the config for controlling scheduler behavior
@@ -233,6 +237,13 @@ type SchedulerConfiguration struct {
 	// during leadership transitions.
 	PauseEvalBroker bool `hcl:"pause_eval_broker"`
 
+	// NodeLimitForFeasibilityChecks limits the number of randomly selected feasible nodes
+	// to consider when scheduling a job that specifies spread and/or affinity. Defaults
+	// to 100 nodes if unset. Lower numbers result in better scheduler performance and
+	// more randomization of jobs across nodes. Higher numbers result in more
+	// deterministic application of spread and/or affinity.
+	NodeLimitForFeasibilityChecks uint `hcl:"node_limit_for_feasibility_checks"`
+
 	// CreateIndex/ModifyIndex store the create/modify indexes of this configuration.
 	CreateIndex uint64
 	ModifyIndex uint64
@@ -255,6 +266,13 @@ func (s *SchedulerConfiguration) EffectiveSchedulerAlgorithm() SchedulerAlgorith
 	return s.SchedulerAlgorithm
 }
 
+func (s *SchedulerConfiguration) GetNodeLimitForFeasibilityChecks() uint {
+	if s == nil || s.NodeLimitForFeasibilityChecks == 0 {
+		return DefaultNodeLimitForFeasibilityChecks
+	}
+	return s.NodeLimitForFeasibilityChecks
+}
+
 // WithNodePool returns a new SchedulerConfiguration with the node pool
 // scheduler configuration applied.
 func (s *SchedulerConfiguration) WithNodePool(pool *NodePool) *SchedulerConfiguration {
diff --git a/nomad/structs/operator_test.go b/nomad/structs/operator_test.go
@@ -11,6 +11,40 @@ import (
 	"github.com/shoenig/test/must"
 )
 
+func TestSchedulerConfiguration_GetNodeLimitForFeasibilityChecks(t *testing.T) {
+	ci.Parallel(t)
+
+	testCases := []struct {
+		name     string
+		config   *SchedulerConfiguration
+		expected uint
+	}{
+		{
+			name:     "nil config returns default",
+			config:   nil,
+			expected: DefaultNodeLimitForFeasibilityChecks,
+		},
+		{
+			name:     "zero value returns default",
+			config:   &SchedulerConfiguration{},
+			expected: DefaultNodeLimitForFeasibilityChecks,
+		},
+		{
+			name: "positive value is returned",
+			config: &SchedulerConfiguration{
+				NodeLimitForFeasibilityChecks: 42,
+			},
+			expected: 42,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			must.Eq(t, tc.expected, tc.config.GetNodeLimitForFeasibilityChecks())
+		})
+	}
+}
+
 func TestSchedulerConfiguration_WithNodePool(t *testing.T) {
 	ci.Parallel(t)
 
diff --git a/scheduler/feasible/stack.go b/scheduler/feasible/stack.go
@@ -63,16 +63,17 @@ type GenericStack struct {
 	taskGroupNetwork     *NetworkChecker
 	taskGroupSecrets     *SecretsProviderChecker
 
-	distinctHostsConstraint    *DistinctHostsIterator
-	distinctPropertyConstraint *DistinctPropertyIterator
-	binPack                    *BinPackIterator
-	jobAntiAff                 *JobAntiAffinityIterator
-	nodeReschedulingPenalty    *NodeReschedulingPenaltyIterator
-	limit                      *LimitIterator
-	maxScore                   *MaxScoreIterator
-	nodeAffinity               *NodeAffinityIterator
-	spread                     *SpreadIterator
-	scoreNorm                  *ScoreNormalizationIterator
+	distinctHostsConstraint       *DistinctHostsIterator
+	distinctPropertyConstraint    *DistinctPropertyIterator
+	binPack                       *BinPackIterator
+	jobAntiAff                    *JobAntiAffinityIterator
+	nodeReschedulingPenalty       *NodeReschedulingPenaltyIterator
+	limit                         *LimitIterator
+	maxScore                      *MaxScoreIterator
+	nodeAffinity                  *NodeAffinityIterator
+	spread                        *SpreadIterator
+	scoreNorm                     *ScoreNormalizationIterator
+	nodeLimitForFeasibilityChecks int
 }
 
 func (s *GenericStack) SetNodes(baseNodes []*structs.Node) {
@@ -129,6 +130,7 @@ func (s *GenericStack) SetJob(job *structs.Job) {
 // on the node pool being used.
 func (s *GenericStack) SetSchedulerConfiguration(schedConfig *structs.SchedulerConfiguration) {
 	s.binPack.SetSchedulerConfiguration(schedConfig)
+	s.nodeLimitForFeasibilityChecks = int(schedConfig.GetNodeLimitForFeasibilityChecks())
 }
 
 func (s *GenericStack) Select(tg *structs.TaskGroup, options *SelectOptions) *RankedNode {
@@ -183,11 +185,11 @@ func (s *GenericStack) Select(tg *structs.TaskGroup, options *SelectOptions) *Ra
 	if s.nodeAffinity.hasAffinities() || s.spread.hasSpreads() {
 		// scoring spread across all nodes has quadratic behavior, so
 		// we need to consider a subset of nodes to keep evaluaton times
-		// reasonable but enough to ensure spread is correct. this
-		// value was empirically determined.
-		s.limit.SetLimit(tg.Count)
-		if tg.Count < 100 {
-			s.limit.SetLimit(100)
+		// reasonable but enough to ensure spread is statistically correct.
+		if tg.Count < s.nodeLimitForFeasibilityChecks {
+			s.limit.SetLimit(s.nodeLimitForFeasibilityChecks)
+		} else {
+			s.limit.SetLimit(tg.Count)
 		}
 	}
 
diff --git a/scheduler/generic_sched_test.go b/scheduler/generic_sched_test.go
@@ -997,6 +997,49 @@ func TestServiceSched_Spread(t *testing.T) {
 	}
 }
 
+// TestServiceSched_Spread_NodeLimitForFeasibilityChecks verifies that the
+// NodeLimitForFeasibilityChecks scheduler configuration limits the number of
+// nodes evaluated when scheduling a job with spreads.
+func TestServiceSched_Spread_NodeLimitForFeasibilityChecks(t *testing.T) {
+	ci.Parallel(t)
+
+	h := tests.NewHarness(t)
+
+	const nodeLimit uint = 5
+	h.State.SchedulerSetConfig(h.NextIndex(), &structs.SchedulerConfiguration{
+		NodeLimitForFeasibilityChecks: nodeLimit,
+	})
+
+	job := mock.Job()
+	job.TaskGroups[0].Count = 1
+	job.TaskGroups[0].Spreads = append(job.TaskGroups[0].Spreads,
+		&structs.Spread{Attribute: "${node.datacenter}", Weight: 100})
+	must.NoError(t, h.State.UpsertJob(structs.MsgTypeTestSetup, h.NextIndex(), nil, job))
+
+	for i := 0; i < 20; i++ {
+		must.NoError(t, h.State.UpsertNode(structs.MsgTypeTestSetup, h.NextIndex(), mock.Node()))
+	}
+
+	eval := &structs.Evaluation{
+		Namespace:   structs.DefaultNamespace,
+		ID:          uuid.Generate(),
+		Priority:    job.Priority,
+		TriggeredBy: structs.EvalTriggerJobRegister,
+		JobID:       job.ID,
+		Status:      structs.EvalStatusPending,
+	}
+	must.NoError(t, h.State.UpsertEvals(structs.MsgTypeTestSetup, h.NextIndex(), []*structs.Evaluation{eval}))
+	must.NoError(t, h.Process(NewServiceScheduler, eval))
+
+	// With 20 feasible nodes but a limit of 5, only 5 should be evaluated.
+	var planned []*structs.Allocation
+	for _, allocList := range h.Plans[0].NodeAllocation {
+		planned = append(planned, allocList...)
+	}
+	must.Len(t, 1, planned)
+	must.Eq(t, int(nodeLimit), planned[0].Metrics.NodesEvaluated)
+}
+
 // TestServiceSched_JobRegister_Datacenter_Downgrade tests the case where an
 // allocation fails during a deployment with canaries, an the job changes its
 // datacenter. The replacement for the failed alloc should be placed in the

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+```release-note:improvement
	`2`	`+scheduler: Add a configuration field for the number of nodes that the scheduler considers when spread or affinity is in use. This can improve scheduler performance for some cluster shapes.`
	`3`	+```
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {`
`64`	`64`	`MemoryOversubscriptionEnabled: true,`
`65`	`65`	`RejectJobRegistration: true,`
`66`	`66`	`PauseEvalBroker: true,`
	`67`	`+ NodeLimitForFeasibilityChecks: 123,`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`schedulerConfigUpdateResp, _, err := c.Operator().SchedulerSetConfiguration(&newSchedulerConfig, nil)`
`@@ -78,6 +79,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {`
`78`	`79`	`must.True(t, schedulerConfig.SchedulerConfig.RejectJobRegistration)`
`79`	`80`	`must.True(t, schedulerConfig.SchedulerConfig.MemoryOversubscriptionEnabled)`
`80`	`81`	`must.Eq(t, schedulerConfig.SchedulerConfig.PreemptionConfig, newSchedulerConfig.PreemptionConfig)`
	`82`	`+ must.Eq(t, schedulerConfig.SchedulerConfig.NodeLimitForFeasibilityChecks, newSchedulerConfig.NodeLimitForFeasibilityChecks)`
`81`	`83`	`}`
`82`	`84`
`83`	`85`	`func TestOperator_AutopilotState(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -496,6 +496,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {`
`496`	`496`	`{`
`497`	`497`	`"MemoryOversubscriptionEnabled": true,`
`498`	`498`	`"PauseEvalBroker": true,`
	`499`	`+ "NodeLimitForFeasibilityChecks": 123,`
`499`	`500`	`"PreemptionConfig": {`
`500`	`501`	`"SystemSchedulerEnabled": true,`
`501`	`502`	`"ServiceSchedulerEnabled": true`
`@@ -525,6 +526,7 @@ func TestOperator_SchedulerSetConfiguration(t *testing.T) {`
`525`	`526`	`require.True(t, reply.SchedulerConfig.PreemptionConfig.ServiceSchedulerEnabled)`
`526`	`527`	`require.True(t, reply.SchedulerConfig.MemoryOversubscriptionEnabled)`
`527`	`528`	`require.True(t, reply.SchedulerConfig.PauseEvalBroker)`
	`529`	`+ require.Equal(t, reply.SchedulerConfig.GetNodeLimitForFeasibilityChecks(), uint(123))`
`528`	`530`	`})`
`529`	`531`	`}`
`530`	`532`