Graduate PrioritySortingWithinCohort feature gate to GA

Set PrioritySortingWithinCohort to GA with LockToDefault: true at version
0.17. Remove all conditional code paths guarded by the feature gate since
priority sorting within cohorts is now always enabled. Remove associated
disabled-feature test cases and update documentation to no longer reference
the ability to disable the feature.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kannon92

pkg/features/kube_features.go

@@ -269,6 +269,7 @@ var defaultVersionedFeatureGates = map[featuregate.Feature]featuregate.Versioned
 	},
 	PrioritySortingWithinCohort: {
 		{Version: version.MustParse("0.6"), Default: true, PreRelease: featuregate.Beta},
+		{Version: version.MustParse("0.17"), Default: true, PreRelease: featuregate.GA, LockToDefault: true}, // remove in 0.19
 	},
 	MultiKueue: {
 		{Version: version.MustParse("0.6"), Default: false, PreRelease: featuregate.Alpha},

pkg/scheduler/fair_sharing_iterator.go

@@ -25,7 +25,6 @@ import (
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta2"
 	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
-	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/util/priority"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
@@ -173,12 +172,10 @@ func (e *entryComparer) less(a, b *entry, parentCohort kueue.CohortReference) bo
 	}
 
 	// 2: Priority
-	if features.Enabled(features.PrioritySortingWithinCohort) {
-		p1 := priority.Priority(a.Obj)
-		p2 := priority.Priority(b.Obj)
-		if p1 != p2 {
-			return p1 > p2
-		}
+	p1 := priority.Priority(a.Obj)
+	p2 := priority.Priority(b.Obj)
+	if p1 != p2 {
+		return p1 > p2
 	}
 
 	// 3: FIFO

pkg/scheduler/scheduler.go

@@ -737,13 +737,11 @@ func (e entryOrdering) Less(i, j int) bool {
 		return aBorrows < bBorrows
 	}
 
-	// 2. Higher priority first if not disabled.
-	if features.Enabled(features.PrioritySortingWithinCohort) {
-		p1 := priority.Priority(a.Obj)
-		p2 := priority.Priority(b.Obj)
-		if p1 != p2 {
-			return p1 > p2
-		}
+	// 2. Higher priority first.
+	p1 := priority.Priority(a.Obj)
+	p2 := priority.Priority(b.Obj)
+	if p1 != p2 {
+		return p1 > p2
 	}
 
 	// 3. FIFO.

pkg/scheduler/scheduler_test.go

@@ -7826,54 +7826,24 @@ func TestEntryOrdering(t *testing.T) {
 	for _, tc := range []struct {
 		name             string
 		input            []entry
-		prioritySorting  bool
 		workloadOrdering workload.Ordering
 		wantOrder        []string
 	}{
 		{
-			name:             "Priority sorting is enabled (default) using pods-ready Eviction timestamp (default)",
+			name:             "Priority sorting using pods-ready Eviction timestamp (default)",
 			input:            input,
-			prioritySorting:  true,
 			workloadOrdering: workload.Ordering{PodsReadyRequeuingTimestamp: config.EvictionTimestamp},
 			wantOrder:        []string{"new_high_pri", "old", "recently_evicted", "new", "high_pri_borrowing", "old_borrowing", "evicted_borrowing", "new_borrowing", "high_pri_borrowing_more"},
 		},
 		{
-			name:             "Priority sorting is enabled (default) using pods-ready Creation timestamp",
+			name:             "Priority sorting using pods-ready Creation timestamp",
 			input:            input,
-			prioritySorting:  true,
 			workloadOrdering: workload.Ordering{PodsReadyRequeuingTimestamp: config.CreationTimestamp},
 			wantOrder:        []string{"new_high_pri", "recently_evicted", "old", "new", "high_pri_borrowing", "old_borrowing", "evicted_borrowing", "new_borrowing", "high_pri_borrowing_more"},
 		},
 		{
-			name:             "Priority sorting is disabled using pods-ready Eviction timestamp",
-			input:            input,
-			prioritySorting:  false,
-			workloadOrdering: workload.Ordering{PodsReadyRequeuingTimestamp: config.EvictionTimestamp},
-			wantOrder:        []string{"old", "recently_evicted", "new", "new_high_pri", "old_borrowing", "evicted_borrowing", "high_pri_borrowing", "new_borrowing", "high_pri_borrowing_more"},
-		},
-		{
-			name:             "Priority sorting is disabled using pods-ready Creation timestamp",
-			input:            input,
-			prioritySorting:  false,
-			workloadOrdering: workload.Ordering{PodsReadyRequeuingTimestamp: config.CreationTimestamp},
-			wantOrder:        []string{"recently_evicted", "old", "new", "new_high_pri", "old_borrowing", "evicted_borrowing", "high_pri_borrowing", "new_borrowing", "high_pri_borrowing_more"},
-		},
-		{
-			name:            "Some workloads are preempted; Priority sorting is disabled",
-			input:           inputForOrderingPreemptedWorkloads,
-			prioritySorting: false,
-			wantOrder: []string{
-				"old-mid-recently-preempted-in-queue",
-				"old-mid-not-preempted-yet",
-				"old-mid-recently-reclaimed-while-borrowing",
-				"preemptor",
-				"old-mid-more-recently-reclaimed-while-borrowing",
-			},
-		},
-		{
-			name:            "Some workloads are preempted; Priority sorting is enabled",
-			input:           inputForOrderingPreemptedWorkloads,
-			prioritySorting: true,
+			name:  "Some workloads are preempted",
+			input: inputForOrderingPreemptedWorkloads,
 			wantOrder: []string{
 				"preemptor",
 				"old-mid-recently-preempted-in-queue",
@@ -7884,7 +7854,6 @@ func TestEntryOrdering(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			features.SetFeatureGateDuringTest(t, features.PrioritySortingWithinCohort, tc.prioritySorting)
 			ctx, _ := utiltesting.ContextWithLog(t)
 			iter := makeIterator(ctx, tc.input, tc.workloadOrdering, false)
 			order := make([]string, len(tc.input))

pkg/workload/workload.go

@@ -1116,15 +1116,6 @@ func (o Ordering) GetQueueOrderTimestamp(w *kueue.Workload) *metav1.Time {
 	if evictedCond, evictedByCheck := IsEvictedByAdmissionCheck(w); evictedByCheck {
 		return &evictedCond.LastTransitionTime
 	}
-	if !features.Enabled(features.PrioritySortingWithinCohort) {
-		if preemptedCond := apimeta.FindStatusCondition(w.Status.Conditions, kueue.WorkloadPreempted); preemptedCond != nil &&
-			preemptedCond.Status == metav1.ConditionTrue &&
-			preemptedCond.Reason == kueue.InCohortReclaimWhileBorrowingReason {
-			// We add an epsilon to make sure the timestamp of the preempted
-			// workload is strictly greater that the preemptor's
-			return &metav1.Time{Time: preemptedCond.LastTransitionTime.Add(time.Millisecond)}
-		}
-	}
 	return &w.CreationTimestamp
 }
 

site/content/en/docs/concepts/cluster_queue.md

@@ -240,8 +240,7 @@ semantics:
 
 {{% alert title="Note" color="primary" %}}
 Within a Cohort, Kueue prioritizes scheduling workloads that will fit under `nominalQuota`.
-By default, if multiple workloads require `borrowing`, Kueue will try to schedule workloads with higher [priority](/docs/concepts/workload#priority) first.
-If the feature gate `PrioritySortingWithinCohort=false` is set, Kueue will try to schedule workloads with the earliest `.metadata.creationTimestamp`.
+If multiple workloads require `borrowing`, Kueue will try to schedule workloads with higher [priority](/docs/concepts/workload#priority) first.
 {{% /alert %}}
 
 You can influence some semantics of flavor selection and borrowing

site/content/zh-CN/docs/concepts/cluster_queue.md

@@ -219,9 +219,8 @@ ClusterQueue 借用配额。
 
 {{% alert title="注意" color="primary" %}}
 在 cohort 中，Kueue 优先安排将适合 under `nominalQuota` 的工作负载。
-默认情况下，如果多个工作负载需要 `borrowing`，Kueue 将尝试安排优先级更高的工作负载
+如果多个工作负载需要 `borrowing`，Kueue 将尝试安排优先级更高的工作负载
 [priority](/docs/concepts/workload#priority) 首先。
-如果 feature gate `PrioritySortingWithinCohort=false` 设置，Kueue 将尝试安排最早的 `.metadata.creationTimestamp` 的工作负载。
 {{% /alert %}}
 
 你可以设置一个 [`flavorFungibility`](/docs/concepts/cluster_queue#flavorfungibility) 来影响一些规格选择和借用的语义。

site/data/featuregates/versioned_feature_list.yaml

@@ -161,6 +161,10 @@
     lockToDefault: false
     preRelease: Beta
     version: "0.6"
+  - default: true
+    lockToDefault: true
+    preRelease: GA
+    version: "0.17"
 - name: PropagateBatchJobLabelsToWorkload
   versionedSpecs:
   - default: true

test/compatibility_lifecycle/reference/versioned_feature_list.yaml

@@ -161,6 +161,10 @@
     lockToDefault: false
     preRelease: Beta
     version: "0.6"
+  - default: true
+    lockToDefault: true
+    preRelease: GA
+    version: "0.17"
 - name: PropagateBatchJobLabelsToWorkload
   versionedSpecs:
   - default: true

test/integration/singlecluster/scheduler/preemption_test.go

@@ -857,123 +857,6 @@ var _ = ginkgo.Describe("Preemption", func() {
 		})
 	})
 
-	ginkgo.Context("When borrowWithinCohort is used and PrioritySortingWithinCohort disabled", func() {
-		var (
-			aCQ, bCQ, cCQ *kueue.ClusterQueue
-			aLQ, bLQ      *kueue.LocalQueue
-			defaultFlavor *kueue.ResourceFlavor
-		)
-
-		ginkgo.BeforeEach(func() {
-			features.SetFeatureGateDuringTest(ginkgo.GinkgoTB(), features.PrioritySortingWithinCohort, false)
-			defaultFlavor = utiltestingapi.MakeResourceFlavor("default").Obj()
-			util.MustCreate(ctx, k8sClient, defaultFlavor)
-
-			aCQ = utiltestingapi.MakeClusterQueue("a-cq").
-				Cohort("all").
-				ResourceGroup(
-					*utiltestingapi.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "0", "10").Obj(),
-				).
-				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.MayStopSearch,
-					WhenCanPreempt: kueue.MayStopSearch,
-				}).
-				Preemption(kueue.ClusterQueuePreemption{
-					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
-					WithinClusterQueue:  kueue.PreemptionPolicyLowerPriority,
-				}).
-				Obj()
-			util.MustCreate(ctx, k8sClient, aCQ)
-			aLQ = utiltestingapi.MakeLocalQueue("a-lq", ns.Name).ClusterQueue(aCQ.Name).Obj()
-			util.MustCreate(ctx, k8sClient, aLQ)
-
-			bCQ = utiltestingapi.MakeClusterQueue("b-cq").
-				Cohort("all").
-				ResourceGroup(
-					*utiltestingapi.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "5", "5").Obj(),
-				).
-				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.MayStopSearch,
-					WhenCanPreempt: kueue.MayStopSearch,
-				}).
-				Preemption(kueue.ClusterQueuePreemption{
-					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
-					WithinClusterQueue:  kueue.PreemptionPolicyLowerPriority,
-					BorrowWithinCohort: &kueue.BorrowWithinCohort{
-						Policy:               kueue.BorrowWithinCohortPolicyLowerPriority,
-						MaxPriorityThreshold: ptr.To(veryHighPriority),
-					},
-				}).
-				Obj()
-			util.MustCreate(ctx, k8sClient, bCQ)
-			bLQ = utiltestingapi.MakeLocalQueue("b-lq", ns.Name).ClusterQueue(bCQ.Name).Obj()
-			util.MustCreate(ctx, k8sClient, bLQ)
-
-			cCQ = utiltestingapi.MakeClusterQueue("c-cq").
-				Cohort("all").
-				ResourceGroup(
-					*utiltestingapi.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "5").Obj(),
-				).
-				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.MayStopSearch,
-					WhenCanPreempt: kueue.MayStopSearch,
-				}).
-				Preemption(kueue.ClusterQueuePreemption{
-					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
-					WithinClusterQueue:  kueue.PreemptionPolicyLowerPriority,
-				}).
-				Obj()
-			util.MustCreate(ctx, k8sClient, cCQ)
-		})
-
-		ginkgo.AfterEach(func() {
-			gomega.Expect(util.DeleteWorkloadsInNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
-			util.ExpectObjectToBeDeleted(ctx, k8sClient, aCQ, true)
-			util.ExpectObjectToBeDeleted(ctx, k8sClient, bCQ, true)
-			util.ExpectObjectToBeDeleted(ctx, k8sClient, cCQ, true)
-			util.ExpectObjectToBeDeleted(ctx, k8sClient, defaultFlavor, true)
-		})
-
-		ginkgo.It("should allow preempting workloads while borrowing", func() {
-			var aWl, b1Wl, b2Wl *kueue.Workload
-
-			ginkgo.By("Create a mid priority workload in aCQ and await for admission", func() {
-				aWl = utiltestingapi.MakeWorkload("a-low", ns.Name).
-					Queue(kueue.LocalQueueName(aLQ.Name)).
-					Priority(midPriority).
-					Request(corev1.ResourceCPU, "4").
-					Obj()
-				util.MustCreate(ctx, k8sClient, aWl)
-				util.ExpectWorkloadsToBeAdmitted(ctx, k8sClient, aWl)
-			})
-
-			ginkgo.By("Create a high priority workload b1 in bCQ and await for admission", func() {
-				b1Wl = utiltestingapi.MakeWorkload("b1-high", ns.Name).
-					Queue(kueue.LocalQueueName(bLQ.Name)).
-					Priority(highPriority).
-					Request(corev1.ResourceCPU, "4").
-					Obj()
-				util.MustCreate(ctx, k8sClient, b1Wl)
-				util.ExpectWorkloadsToBeAdmitted(ctx, k8sClient, b1Wl)
-			})
-
-			ginkgo.By("Create a high priority workload b2 in bCQ", func() {
-				b2Wl = utiltestingapi.MakeWorkload("b2-high", ns.Name).
-					Queue(kueue.LocalQueueName(bLQ.Name)).
-					Priority(highPriority).
-					Request(corev1.ResourceCPU, "4").
-					Obj()
-				util.MustCreate(ctx, k8sClient, b2Wl)
-			})
-
-			ginkgo.By("Await for preemption of the workload in aCQ and admission of b2", func() {
-				util.FinishEvictionForWorkloads(ctx, k8sClient, aWl)
-				util.ExpectWorkloadsToBePending(ctx, k8sClient, aWl)
-				util.ExpectWorkloadsToBeAdmitted(ctx, k8sClient, b2Wl)
-			})
-		})
-	})
-
 	ginkgo.Context("In a multi-level cohort", func() {
 		var rootCohort, guaranteedCohort *kueue.Cohort
 		var bestEffortCQ, guaranteedCQ *kueue.ClusterQueue