Repository: kubernetes-sigs/kueue
Pull request #509 (2023-01-11 14:00:31)

Move version/commint logs after the logging is fully set up
#### What type of PR is this?

/kind bug

#### What this PR does / why we need it:

Currently the version and commit information is not printed due to wrong placement of the log (before init). This PR moves it after the init.

Before:
```
Version/commit is NOT printed
```

After:
```
{"level":"info","ts":"2023-01-11T14:53:15.204052+01:00","logger":"setup","caller":"kueue/main.go:85","msg":"Initializing","gitVersion":"v0.3.0-devel-168-gc326046-dirty","gitCommit":"c326046d8e41b57bf242fba021bedaa12613abf9"}
```



Patch:
diff --git a/Makefile b/Makefile
index 7ef1e00c9..c49afb56e 100644
--- a/Makefile
+++ b/Makefile
@@ -232,7 +232,6 @@ artifacts: kustomize
 	if [ -d artifacts ]; then rm -rf artifacts; fi
 	mkdir -p artifacts
 	$(KUSTOMIZE) build config/default -o artifacts/manifests.yaml
-	$(KUSTOMIZE) build config/dev -o artifacts/manifests-dev.yaml
 	$(KUSTOMIZE) build config/prometheus -o artifacts/prometheus.yaml
 	@$(call clean-manifests)
 
diff --git a/apis/kueue/webhooks/clusterqueue_webhook.go b/apis/kueue/webhooks/clusterqueue_webhook.go
index 797ecae8b..345c9553d 100644
--- a/apis/kueue/webhooks/clusterqueue_webhook.go
+++ b/apis/kueue/webhooks/clusterqueue_webhook.go
@@ -22,6 +22,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/resource"
 	apivalidation "k8s.io/apimachinery/pkg/api/validation"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/validation"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -100,8 +101,7 @@ func ValidateClusterQueue(cq *kueue.ClusterQueue) field.ErrorList {
 		allErrs = append(allErrs, validateNameReference(cq.Spec.Cohort, path.Child("cohort"))...)
 	}
 	allErrs = append(allErrs, validateResources(cq.Spec.Resources, path.Child("resources"))...)
-	allErrs = append(allErrs,
-		validation.ValidateLabelSelector(cq.Spec.NamespaceSelector, validation.LabelSelectorValidationOptions{}, path.Child("namespaceSelector"))...)
+	allErrs = append(allErrs, validateNamespaceSelector(cq.Spec.NamespaceSelector, path.Child("namespaceSelector"))...)
 
 	return allErrs
 }
@@ -119,13 +119,13 @@ func ValidateClusterQueueUpdate(newObj, oldObj *kueue.ClusterQueue) field.ErrorL
 
 func validateResources(resources []kueue.Resource, path *field.Path) field.ErrorList {
 	var allErrs field.ErrorList
-	flavorsPerRes := make([]sets.Set[string], len(resources))
+	flavorsPerRes := make([]sets.String, len(resources))
 
 	for i, resource := range resources {
 		path := path.Index(i)
 		allErrs = append(allErrs, validateResourceName(resource.Name, path.Child("name"))...)
 
-		flavorsPerRes[i] = make(sets.Set[string], len(resource.Flavors))
+		flavorsPerRes[i] = make(sets.String, len(resource.Flavors))
 		for j, flavor := range resource.Flavors {
 			path := path.Child("flavors").Index(j)
 			allErrs = append(allErrs, validateNameReference(string(flavor.Name), path.Child("name"))...)
@@ -176,3 +176,7 @@ func validateResourceQuantity(value resource.Quantity, fldPath *field.Path) fiel
 	}
 	return allErrs
 }
+
+func validateNamespaceSelector(selector *metav1.LabelSelector, path *field.Path) field.ErrorList {
+	return validation.ValidateLabelSelector(selector, path)
+}
diff --git a/apis/kueue/webhooks/resourceflavor_webhook.go b/apis/kueue/webhooks/resourceflavor_webhook.go
index b0a09512d..617c4ec5a 100644
--- a/apis/kueue/webhooks/resourceflavor_webhook.go
+++ b/apis/kueue/webhooks/resourceflavor_webhook.go
@@ -100,7 +100,7 @@ func ValidateResourceFlavor(rf *kueue.ResourceFlavor) field.ErrorList {
 func validateNodeTaints(taints []corev1.Taint, fldPath *field.Path) field.ErrorList {
 	allErrors := field.ErrorList{}
 
-	uniqueTaints := make(map[corev1.TaintEffect]sets.Set[string])
+	uniqueTaints := map[corev1.TaintEffect]sets.String{}
 
 	for i, currTaint := range taints {
 		idxPath := fldPath.Index(i)
@@ -123,7 +123,7 @@ func validateNodeTaints(taints []corev1.Taint, fldPath *field.Path) field.ErrorL
 
 		// add taint to existingTaints for uniqueness check
 		if len(uniqueTaints[currTaint.Effect]) == 0 {
-			uniqueTaints[currTaint.Effect] = sets.New[string]()
+			uniqueTaints[currTaint.Effect] = sets.String{}
 		}
 		uniqueTaints[currTaint.Effect].Insert(currTaint.Key)
 	}
diff --git a/config/dev/kustomization.yaml b/config/dev/kustomization.yaml
deleted file mode 100644
index 5bed948ee..000000000
--- a/config/dev/kustomization.yaml
+++ /dev/null
@@ -1,10 +0,0 @@
-# Dev/testing friendly settings for Kueue.
-
-# Use default settings as a base.
-bases:
-- ../default
-
-patchesStrategicMerge:
-# Modify logging for better user experience. 
-- manager_config_patch.yaml
-
diff --git a/config/dev/manager_config_patch.yaml b/config/dev/manager_config_patch.yaml
deleted file mode 100644
index 797db315e..000000000
--- a/config/dev/manager_config_patch.yaml
+++ /dev/null
@@ -1,14 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: controller-manager
-  namespace: system
-spec:
-  template:
-    spec:
-      containers:
-      - name: manager
-        args:
-        - "--config=controller_manager_config.yaml"
-        - "--zap-devel"
-        - "--zap-log-level=3"
diff --git a/docs/setup/install.md b/docs/setup/install.md
index ac117780d..c68a61005 100644
--- a/docs/setup/install.md
+++ b/docs/setup/install.md
@@ -10,7 +10,7 @@ Make sure the following conditions are met:
   In Kubernetes 1.23 or newer, the feature gate is enabled by default.
 - The kubectl command-line tool has communication with your cluster.
 
-Kueue publishes [metrics](/docs/reference/metrics.md) to monitor its operators.
+Kueue publishes [metrics](/docs/reference/metrics) to monitor its operators.
 You can scrape these metrics with Prometheus.
 Use [kube-prometheus](https://github.com/prometheus-operator/kube-prometheus)
 if you don't have your own monitoring system.
diff --git a/go.mod b/go.mod
index 7c422e44b..936adea6c 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module sigs.k8s.io/kueue
 
-go 1.19
+go 1.18
 
 require (
 	github.com/go-logr/logr v1.2.3
@@ -11,12 +11,12 @@ require (
 	github.com/prometheus/client_golang v1.14.0
 	go.uber.org/zap v1.24.0
 	k8s.io/api v0.25.5
-	k8s.io/apimachinery v0.26.0
+	k8s.io/apimachinery v0.25.5
 	k8s.io/client-go v0.25.5
 	k8s.io/component-base v0.25.5
 	k8s.io/component-helpers v0.25.5
-	k8s.io/klog/v2 v2.80.1
-	k8s.io/utils v0.0.0-20221107191617-1a15be271d1d
+	k8s.io/klog/v2 v2.70.1
+	k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed
 	sigs.k8s.io/controller-runtime v0.13.1
 )
 
@@ -78,7 +78,7 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/apiextensions-apiserver v0.25.0 // indirect
-	k8s.io/kube-openapi v0.0.0-20221012153701-172d655c2280 // indirect
+	k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1 // indirect
 	sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
diff --git a/go.sum b/go.sum
index d6fecb2f3..d5e4fdf48 100644
--- a/go.sum
+++ b/go.sum
@@ -132,6 +132,7 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
@@ -333,6 +334,7 @@ github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPx
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8=
@@ -808,21 +810,22 @@ k8s.io/api v0.25.5 h1:mqyHf7aoaYMpdvO87mqpol+Qnsmo+y09S0PMIXwiZKo=
 k8s.io/api v0.25.5/go.mod h1:RzplZX0Z8rV/WhSTfEvnyd91bBhBQTRWo85qBQwRmb8=
 k8s.io/apiextensions-apiserver v0.25.0 h1:CJ9zlyXAbq0FIW8CD7HHyozCMBpDSiH7EdrSTCZcZFY=
 k8s.io/apiextensions-apiserver v0.25.0/go.mod h1:3pAjZiN4zw7R8aZC5gR0y3/vCkGlAjCazcg1me8iB/E=
-k8s.io/apimachinery v0.26.0 h1:1feANjElT7MvPqp0JT6F3Ss6TWDwmcjLypwoPpEf7zg=
-k8s.io/apimachinery v0.26.0/go.mod h1:tnPmbONNJ7ByJNz9+n9kMjNP8ON+1qoAIIC70lztu74=
+k8s.io/apimachinery v0.25.5 h1:SQomYHvv+aO43qdu3QKRf9YuI0oI8w3RrOQ1qPbAUGY=
+k8s.io/apimachinery v0.25.5/go.mod h1:1S2i1QHkmxc8+EZCIxe/fX5hpldVXk4gvnJInMEb8D4=
 k8s.io/client-go v0.25.5 h1:7QWVK0Ph4bLn0UwotPTc2FTgm8shreQXyvXnnHDd8rE=
 k8s.io/client-go v0.25.5/go.mod h1:bOeoaUUdpyz3WDFGo+Xm3nOQFh2KuYXRDwrvbAPtFQA=
 k8s.io/component-base v0.25.5 h1:tVni0kgpceq71MDMBSixp8Y621YGvTS/1zq3RABgX9A=
 k8s.io/component-base v0.25.5/go.mod h1:9J+e9uIUwUOG2x5q5+aaOR0b8QI5OIqwqPAbeODkYpc=
 k8s.io/component-helpers v0.25.5 h1:9lzSVcNmysgBIVFkdauELnDOrd3iJBBqilDeexpF7Wk=
 k8s.io/component-helpers v0.25.5/go.mod h1:K5wb7vW1QVzCRfKE6Fe0tLv4LOQLz/Yj51MSTLoQBOI=
-k8s.io/klog/v2 v2.80.1 h1:atnLQ121W371wYYFawwYx1aEY2eUfs4l3J72wtgAwV4=
-k8s.io/klog/v2 v2.80.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
+k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE=
+k8s.io/klog/v2 v2.70.1 h1:7aaoSdahviPmR+XkS7FyxlkkXs6tHISSG03RxleQAVQ=
+k8s.io/klog/v2 v2.70.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
 k8s.io/kube-aggregator v0.23.2 h1:6CoZZqNdFc9benrgSJJ0GQGgFtKjI0y3UwlBbioXtc8=
-k8s.io/kube-openapi v0.0.0-20221012153701-172d655c2280 h1:+70TFaan3hfJzs+7VK2o+OGxg8HsuBr/5f6tVAjDu6E=
-k8s.io/kube-openapi v0.0.0-20221012153701-172d655c2280/go.mod h1:+Axhij7bCpeqhklhUTe3xmOn6bWxolyZEeyaFpjGtl4=
-k8s.io/utils v0.0.0-20221107191617-1a15be271d1d h1:0Smp/HP1OH4Rvhe+4B8nWGERtlqAGSftbSbbmm45oFs=
-k8s.io/utils v0.0.0-20221107191617-1a15be271d1d/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
+k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1 h1:MQ8BAZPZlWk3S9K4a9NCkIFQtZShWqoha7snGixVgEA=
+k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1/go.mod h1:C/N6wCaBHeBHkHUesQOQy2/MZqGgMAFPqGsGQLdbZBU=
+k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed h1:jAne/RjBTyawwAy0utX5eqigAwz/lQhTmy+Hr/Cpue4=
+k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/main.go b/main.go
index 5ac651cfa..1fac264d9 100644
--- a/main.go
+++ b/main.go
@@ -69,8 +69,6 @@ func init() {
 }
 
 func main() {
-	setupLog.Info("Initializing", "gitVersion", version.GitVersion, "gitCommit", version.GitCommit)
-
 	var configFile string
 	flag.StringVar(&configFile, "config", "",
 		"The controller will load its initial configuration from this file. "+
@@ -84,6 +82,7 @@ func main() {
 	flag.Parse()
 
 	ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))
+	setupLog.Info("Initializing", "gitVersion", version.GitVersion, "gitCommit", version.GitCommit)
 
 	options, cfg := apply(configFile)
 
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
index 6de2e3d4b..ea7948cc9 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -27,7 +27,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -101,7 +100,7 @@ type ResourceQuantities map[corev1.ResourceName]map[string]int64
 // Cohort is a set of ClusterQueues that can borrow resources from each other.
 type Cohort struct {
 	Name    string
-	Members sets.Set[*ClusterQueue]
+	members map[*ClusterQueue]struct{}
 
 	// These fields are only populated for a snapshot.
 	RequestableResources ResourceQuantities
@@ -111,7 +110,7 @@ type Cohort struct {
 func newCohort(name string, size int) *Cohort {
 	return &Cohort{
 		Name:    name,
-		Members: make(sets.Set[*ClusterQueue], size),
+		members: make(map[*ClusterQueue]struct{}, size),
 	}
 }
 
@@ -129,12 +128,12 @@ type ClusterQueue struct {
 	RequestableResources map[corev1.ResourceName]*Resource
 	UsedResources        ResourceQuantities
 	Workloads            map[string]*workload.Info
-	WorkloadsNotReady    sets.Set[string]
+	WorkloadsNotReady    sets.String
 	NamespaceSelector    labels.Selector
 	// The set of key labels from all flavors of a resource.
 	// Those keys define the affinity terms of a workload
 	// that can be matched against the flavors.
-	LabelKeys map[corev1.ResourceName]sets.Set[string]
+	LabelKeys map[corev1.ResourceName]sets.String
 	Status    metrics.ClusterQueueStatus
 
 	// The following fields are not populated in a snapshot.
@@ -144,7 +143,7 @@ type ClusterQueue struct {
 }
 
 type Resource struct {
-	CodependentResources sets.Set[corev1.ResourceName]
+	CodependentResources sets.String
 	Flavors              []FlavorLimits
 }
 
@@ -171,7 +170,7 @@ func (c *Cache) newClusterQueue(cq *kueue.ClusterQueue) (*ClusterQueue, error) {
 	cqImpl := &ClusterQueue{
 		Name:                      cq.Name,
 		Workloads:                 make(map[string]*workload.Info),
-		WorkloadsNotReady:         sets.New[string](),
+		WorkloadsNotReady:         sets.NewString(),
 		admittedWorkloadsPerQueue: make(map[string]int),
 		podsReadyTracking:         c.podsReadyTracking,
 	}
@@ -219,7 +218,7 @@ func (c *Cache) podsReadyForAllAdmittedWorkloads(ctx context.Context) bool {
 	log := ctrl.LoggerFrom(ctx)
 	for _, cq := range c.clusterQueues {
 		if len(cq.WorkloadsNotReady) > 0 {
-			log.V(3).Info("There is a ClusterQueue with not ready workloads", "clusterQueue", klog.KRef("", cq.Name))
+			log.V(3).Info("There is a ClusterQueue with not ready workloads", "clusterQueue", cq.Name)
 			return false
 		}
 	}
@@ -283,10 +282,10 @@ func (c *ClusterQueue) UpdateCodependentResources() {
 			// Already matched with other resources.
 			continue
 		}
-		codep := sets.New[corev1.ResourceName]()
+		codep := sets.NewString()
 		for jName, jRes := range c.RequestableResources {
 			if iName == jName || iRes.matchesFlavors(jRes) {
-				codep.Insert(jName)
+				codep.Insert(string(jName))
 			}
 		}
 		if len(codep) > 1 {
@@ -313,12 +312,12 @@ func (c *ClusterQueue) UpdateWithFlavors(flavors map[string]*kueue.ResourceFlavo
 
 func (c *ClusterQueue) updateLabelKeys(flavors map[string]*kueue.ResourceFlavor) bool {
 	var flavorNotFound bool
-	labelKeys := make(map[corev1.ResourceName]sets.Set[string])
+	labelKeys := map[corev1.ResourceName]sets.String{}
 	for rName, res := range c.RequestableResources {
 		if len(res.Flavors) == 0 {
 			continue
 		}
-		resKeys := sets.New[string]()
+		resKeys := sets.NewString()
 		for _, rf := range res.Flavors {
 			if flv, exist := flavors[rf.Name]; exist {
 				for k := range flv.NodeSelector {
@@ -422,8 +421,8 @@ func (c *ClusterQueue) flavorInUse(flavor string) bool {
 	return false
 }
 
-func (c *Cache) updateClusterQueues() sets.Set[string] {
-	cqs := sets.New[string]()
+func (c *Cache) updateClusterQueues() sets.String {
+	cqs := sets.NewString()
 
 	for _, cq := range c.clusterQueues {
 		prevStatus := cq.Status
@@ -439,14 +438,14 @@ func (c *Cache) updateClusterQueues() sets.Set[string] {
 	return cqs
 }
 
-func (c *Cache) AddOrUpdateResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[string] {
+func (c *Cache) AddOrUpdateResourceFlavor(rf *kueue.ResourceFlavor) sets.String {
 	c.Lock()
 	defer c.Unlock()
 	c.resourceFlavors[rf.Name] = rf
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) DeleteResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[string] {
+func (c *Cache) DeleteResourceFlavor(rf *kueue.ResourceFlavor) sets.String {
 	c.Lock()
 	defer c.Unlock()
 	delete(c.resourceFlavors, rf.Name)
@@ -789,7 +788,7 @@ func (c *Cache) addClusterQueueToCohort(cq *ClusterQueue, cohortName string) {
 		cohort = newCohort(cohortName, 1)
 		c.cohorts[cohortName] = cohort
 	}
-	cohort.Members.Insert(cq)
+	cohort.members[cq] = struct{}{}
 	cq.Cohort = cohort
 }
 
@@ -797,8 +796,8 @@ func (c *Cache) deleteClusterQueueFromCohort(cq *ClusterQueue) {
 	if cq.Cohort == nil {
 		return
 	}
-	cq.Cohort.Members.Delete(cq)
-	if cq.Cohort.Members.Len() == 0 {
+	delete(cq.Cohort.members, cq)
+	if len(cq.Cohort.members) == 0 {
 		delete(c.cohorts, cq.Cohort.Name)
 	}
 	cq.Cohort = nil
@@ -817,11 +816,11 @@ func (c *Cache) ClusterQueuesUsingFlavor(flavor string) []string {
 	return cqs
 }
 
-func (c *Cache) MatchingClusterQueues(nsLabels map[string]string) sets.Set[string] {
+func (c *Cache) MatchingClusterQueues(nsLabels map[string]string) sets.String {
 	c.RLock()
 	defer c.RUnlock()
 
-	cqs := sets.New[string]()
+	cqs := sets.NewString()
 	for _, cq := range c.clusterQueues {
 		if cq.NamespaceSelector.Matches(labels.Set(nsLabels)) {
 			cqs.Insert(cq.Name)
diff --git a/pkg/cache/snapshot.go b/pkg/cache/snapshot.go
index 958e99dd8..bb564d6bd 100644
--- a/pkg/cache/snapshot.go
+++ b/pkg/cache/snapshot.go
@@ -26,7 +26,7 @@ import (
 type Snapshot struct {
 	ClusterQueues            map[string]*ClusterQueue
 	ResourceFlavors          map[string]*kueue.ResourceFlavor
-	InactiveClusterQueueSets sets.Set[string]
+	InactiveClusterQueueSets sets.String
 }
 
 func (c *Cache) Snapshot() Snapshot {
@@ -36,7 +36,7 @@ func (c *Cache) Snapshot() Snapshot {
 	snap := Snapshot{
 		ClusterQueues:            make(map[string]*ClusterQueue, len(c.clusterQueues)),
 		ResourceFlavors:          make(map[string]*kueue.ResourceFlavor, len(c.resourceFlavors)),
-		InactiveClusterQueueSets: sets.New[string](),
+		InactiveClusterQueueSets: sets.NewString(),
 	}
 	for _, cq := range c.clusterQueues {
 		if !cq.Active() {
@@ -50,13 +50,13 @@ func (c *Cache) Snapshot() Snapshot {
 		snap.ResourceFlavors[rf.Name] = rf
 	}
 	for _, cohort := range c.cohorts {
-		cohortCopy := newCohort(cohort.Name, cohort.Members.Len())
-		for cq := range cohort.Members {
+		cohortCopy := newCohort(cohort.Name, len(cohort.members))
+		for cq := range cohort.members {
 			if cq.Active() {
 				cqCopy := snap.ClusterQueues[cq.Name]
 				cqCopy.accumulateResources(cohortCopy)
 				cqCopy.Cohort = cohortCopy
-				cohortCopy.Members.Insert(cqCopy)
+				cohortCopy.members[cqCopy] = struct{}{}
 			}
 		}
 	}
diff --git a/pkg/controller/core/clusterqueue_controller.go b/pkg/controller/core/clusterqueue_controller.go
index 2cc739fdd..c841393d4 100644
--- a/pkg/controller/core/clusterqueue_controller.go
+++ b/pkg/controller/core/clusterqueue_controller.go
@@ -278,7 +278,7 @@ func (h *cqNamespaceHandler) Update(e event.UpdateEvent, q workqueue.RateLimitin
 	oldMatchingCqs := h.cache.MatchingClusterQueues(oldNs.Labels)
 	newNs := e.ObjectNew.(*corev1.Namespace)
 	newMatchingCqs := h.cache.MatchingClusterQueues(newNs.Labels)
-	cqs := sets.New[string]()
+	cqs := sets.NewString()
 	for cq := range newMatchingCqs {
 		if !oldMatchingCqs.Has(cq) {
 			cqs.Insert(cq)
diff --git a/pkg/controller/core/resourceflavor_controller.go b/pkg/controller/core/resourceflavor_controller.go
index b6ab24a59..9e87485e7 100644
--- a/pkg/controller/core/resourceflavor_controller.go
+++ b/pkg/controller/core/resourceflavor_controller.go
@@ -255,11 +255,11 @@ func (r *ResourceFlavorReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		Complete(r)
 }
 
-func resourceFlavors(cq *kueue.ClusterQueue) sets.Set[kueue.ResourceFlavorReference] {
-	flavors := sets.New[kueue.ResourceFlavorReference]()
+func resourceFlavors(cq *kueue.ClusterQueue) sets.String {
+	flavors := sets.NewString()
 	for _, resource := range cq.Spec.Resources {
 		for _, flavor := range resource.Flavors {
-			flavors.Insert(flavor.Name)
+			flavors.Insert(string(flavor.Name))
 		}
 	}
 	return flavors
diff --git a/pkg/controller/workload/job/job_controller.go b/pkg/controller/workload/job/job_controller.go
index 00af25dfa..77912ad8a 100644
--- a/pkg/controller/workload/job/job_controller.go
+++ b/pkg/controller/workload/job/job_controller.go
@@ -262,7 +262,7 @@ func podsReady(job *batchv1.Job) bool {
 // the workload (which should include the original affinities that the job had).
 func (r *JobReconciler) stopJob(ctx context.Context, w *kueue.Workload,
 	job *batchv1.Job, eventMsg string) error {
-	job.Spec.Suspend = pointer.Bool(true)
+	job.Spec.Suspend = pointer.BoolPtr(true)
 	if err := r.client.Update(ctx, job); err != nil {
 		return err
 	}
@@ -311,7 +311,7 @@ func (r *JobReconciler) startJob(ctx context.Context, w *kueue.Workload, job *ba
 		log.V(3).Info("no nodeSelectors to inject")
 	}
 
-	job.Spec.Suspend = pointer.Bool(false)
+	job.Spec.Suspend = pointer.BoolPtr(false)
 	if err := r.client.Update(ctx, job); err != nil {
 		return err
 	}
diff --git a/pkg/queue/cluster_queue_impl.go b/pkg/queue/cluster_queue_impl.go
index 58b35859f..b4b372572 100644
--- a/pkg/queue/cluster_queue_impl.go
+++ b/pkg/queue/cluster_queue_impl.go
@@ -194,11 +194,11 @@ func (c *clusterQueueBase) Pop() *workload.Info {
 	return info.(*workload.Info)
 }
 
-func (c *clusterQueueBase) Dump() (sets.Set[string], bool) {
+func (c *clusterQueueBase) Dump() (sets.String, bool) {
 	if c.heap.Len() == 0 {
 		return nil, false
 	}
-	elements := make(sets.Set[string], c.heap.Len())
+	elements := make(sets.String, c.heap.Len())
 	for _, e := range c.heap.List() {
 		info := e.(*workload.Info)
 		elements.Insert(workload.Key(info.Obj))
@@ -206,11 +206,11 @@ func (c *clusterQueueBase) Dump() (sets.Set[string], bool) {
 	return elements, true
 }
 
-func (c *clusterQueueBase) DumpInadmissible() (sets.Set[string], bool) {
+func (c *clusterQueueBase) DumpInadmissible() (sets.String, bool) {
 	if len(c.inadmissibleWorkloads) == 0 {
-		return nil, false
+		return sets.NewString(), false
 	}
-	elements := make(sets.Set[string], len(c.inadmissibleWorkloads))
+	elements := make(sets.String, len(c.inadmissibleWorkloads))
 	for _, info := range c.inadmissibleWorkloads {
 		elements.Insert(workload.Key(info.Obj))
 	}
diff --git a/pkg/queue/cluster_queue_interface.go b/pkg/queue/cluster_queue_interface.go
index f793283cc..18131d5f9 100644
--- a/pkg/queue/cluster_queue_interface.go
+++ b/pkg/queue/cluster_queue_interface.go
@@ -89,8 +89,8 @@ type ClusterQueue interface {
 	// Dump produces a dump of the current workloads in the heap of
 	// this ClusterQueue. It returns false if the queue is empty.
 	// Otherwise returns true.
-	Dump() (sets.Set[string], bool)
-	DumpInadmissible() (sets.Set[string], bool)
+	Dump() (sets.String, bool)
+	DumpInadmissible() (sets.String, bool)
 	// Info returns workload.Info for the workload key.
 	// Users of this method should not modify the returned object.
 	Info(string) *workload.Info
diff --git a/pkg/queue/manager.go b/pkg/queue/manager.go
index c2528bbad..e4a5a56c3 100644
--- a/pkg/queue/manager.go
+++ b/pkg/queue/manager.go
@@ -53,7 +53,7 @@ type Manager struct {
 	localQueues   map[string]*LocalQueue
 
 	// Key is cohort's name. Value is a set of associated ClusterQueue names.
-	cohorts map[string]sets.Set[string]
+	cohorts map[string]sets.String
 }
 
 func NewManager(client client.Client, checker StatusChecker) *Manager {
@@ -62,7 +62,7 @@ func NewManager(client client.Client, checker StatusChecker) *Manager {
 		statusChecker: checker,
 		localQueues:   make(map[string]*LocalQueue),
 		clusterQueues: make(map[string]ClusterQueue),
-		cohorts:       make(map[string]sets.Set[string]),
+		cohorts:       make(map[string]sets.String),
 	}
 	m.cond.L = &m.RWMutex
 	return m
@@ -366,7 +366,7 @@ func (m *Manager) QueueAssociatedInadmissibleWorkloads(ctx context.Context, w *k
 // QueueInadmissibleWorkloads moves all inadmissibleWorkloads in
 // corresponding ClusterQueues to heap. If at least one workload queued,
 // we will broadcast the event.
-func (m *Manager) QueueInadmissibleWorkloads(ctx context.Context, cqNames sets.Set[string]) {
+func (m *Manager) QueueInadmissibleWorkloads(ctx context.Context, cqNames sets.String) {
 	m.Lock()
 	defer m.Unlock()
 	if len(cqNames) == 0 {
@@ -456,13 +456,13 @@ func (m *Manager) Heads(ctx context.Context) []workload.Info {
 
 // Dump is a dump of the queues and it's elements (unordered).
 // Only use for testing purposes.
-func (m *Manager) Dump() map[string]sets.Set[string] {
+func (m *Manager) Dump() map[string]sets.String {
 	m.Lock()
 	defer m.Unlock()
 	if len(m.clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[string]sets.Set[string], len(m.clusterQueues))
+	dump := make(map[string]sets.String, len(m.clusterQueues))
 	for key, cq := range m.clusterQueues {
 		if elements, ok := cq.Dump(); ok {
 			dump[key] = elements
@@ -476,13 +476,13 @@ func (m *Manager) Dump() map[string]sets.Set[string] {
 
 // DumpInadmissible is a dump of the inadmissible workloads list.
 // Only use for testing purposes.
-func (m *Manager) DumpInadmissible() map[string]sets.Set[string] {
+func (m *Manager) DumpInadmissible() map[string]sets.String {
 	m.Lock()
 	defer m.Unlock()
 	if len(m.clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[string]sets.Set[string], len(m.clusterQueues))
+	dump := make(map[string]sets.String, len(m.clusterQueues))
 	for key, cq := range m.clusterQueues {
 		if elements, ok := cq.DumpInadmissible(); ok {
 			dump[key] = elements
@@ -517,7 +517,7 @@ func (m *Manager) heads() []workload.Info {
 
 func (m *Manager) addCohort(cohort string, cqName string) {
 	if m.cohorts[cohort] == nil {
-		m.cohorts[cohort] = make(sets.Set[string])
+		m.cohorts[cohort] = make(sets.String)
 	}
 	m.cohorts[cohort].Insert(cqName)
 }
diff --git a/pkg/scheduler/flavorassigner/flavorassigner.go b/pkg/scheduler/flavorassigner/flavorassigner.go
index 4e538c9d4..1bfdc5354 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner.go
@@ -254,7 +254,7 @@ func AssignFlavors(log logr.Logger, wl *workload.Info, resourceFlavors map[strin
 			}
 			codepResources := cq.RequestableResources[resName].CodependentResources
 			if codepResources.Len() == 0 {
-				codepResources = sets.New(resName)
+				codepResources = sets.NewString(string(resName))
 			}
 			codepReq := filterRequestedResources(podSet.Requests, codepResources)
 			flavors, status := assignment.findFlavorForCodepResources(log, codepReq, resourceFlavors, cq, &wl.Obj.Spec.PodSets[i].Spec)
@@ -391,7 +391,7 @@ func (a *Assignment) findFlavorForCodepResources(
 	return bestAssignment, status
 }
 
-func flavorSelector(spec *corev1.PodSpec, allowedKeys sets.Set[string]) nodeaffinity.RequiredNodeAffinity {
+func flavorSelector(spec *corev1.PodSpec, allowedKeys sets.String) nodeaffinity.RequiredNodeAffinity {
 	// This function generally replicates the implementation of kube-scheduler's NodeAffintiy
 	// Filter plugin as of v1.24.
 	var specCopy corev1.PodSpec
@@ -490,10 +490,10 @@ func fitsFlavorLimits(rName corev1.ResourceName, val int64, cq *cache.ClusterQue
 	return mode, 0, &status
 }
 
-func filterRequestedResources(req workload.Requests, allowList sets.Set[corev1.ResourceName]) workload.Requests {
+func filterRequestedResources(req workload.Requests, allowList sets.String) workload.Requests {
 	filtered := make(workload.Requests)
 	for n, v := range req {
-		if allowList.Has(n) {
+		if allowList.Has(string(n)) {
 			filtered[n] = v
 		}
 	}
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
index 38d8aeac1..32c3e8d86 100644
--- a/pkg/scheduler/scheduler.go
+++ b/pkg/scheduler/scheduler.go
@@ -132,7 +132,7 @@ func (s *Scheduler) schedule(ctx context.Context) {
 	// This is because there can be other workloads deeper in a clusterQueue whose
 	// head got admitted that should be scheduled in the cohort before the heads
 	// of other clusterQueues.
-	usedCohorts := sets.New[string]()
+	usedCohorts := sets.NewString()
 	for i := range entries {
 		e := &entries[i]
 		if e.assignment.RepresentativeMode() == flavorassigner.NoFit {
@@ -342,7 +342,7 @@ func (s *Scheduler) requeueAndUpdate(log logr.Logger, ctx context.Context, e ent
 		e.requeueReason = queue.RequeueReasonFailedAfterNomination
 	}
 	added := s.queues.RequeueWorkload(ctx, &e.Info, e.requeueReason)
-	log.V(2).Info("Workload re-queued", "workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue), "queue", klog.KRef(e.Obj.Namespace, e.Obj.Spec.QueueName), "requeueReason", e.requeueReason, "added", added)
+	log.V(2).Info("Workload re-queued", "workload", klog.KObj(e.Obj), "clusterQueue", e.ClusterQueue, "queue", klog.KRef(e.Obj.Namespace, e.Obj.Spec.QueueName), "requeueReason", e.requeueReason, "added", added)
 
 	if e.status == notNominated {
 		err := workload.UpdateStatus(ctx, s.client, e.Obj, kueue.WorkloadAdmitted, metav1.ConditionFalse, "Pending", e.inadmissibleMsg)


Test patch:
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index 13a8fd1fe..345f50a0b 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -123,7 +123,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 		name              string
 		operation         func(*Cache)
 		wantClusterQueues map[string]*ClusterQueue
-		wantCohorts       map[string]sets.Set[string]
+		wantCohorts       map[string]sets.String
 	}{
 		{
 			name: "add",
@@ -139,7 +139,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						},
 					},
 					NamespaceSelector: labels.Nothing(),
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
 					Status:            active,
 				},
@@ -150,7 +150,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 					NamespaceSelector: labels.Nothing(),
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					Status:            active,
 				},
 				"c": {
@@ -178,9 +178,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:            pending,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e"),
+			wantCohorts: map[string]sets.String{
+				"one": sets.NewString("a", "b"),
+				"two": sets.NewString("c", "e"),
 			},
 		},
 		{
@@ -205,7 +205,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						corev1.ResourceCPU: {Flavors: []FlavorLimits{{Name: "default", Min: 10000, Max: pointer.Int64(20000)}}},
 					},
 					NamespaceSelector: labels.Nothing(),
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
 					Status:            active,
 				},
@@ -216,7 +216,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 					NamespaceSelector: labels.Nothing(),
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					Status:            active,
 				},
 				"c": {
@@ -244,9 +244,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:            pending,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e"),
+			wantCohorts: map[string]sets.String{
+				"one": sets.NewString("a", "b"),
+				"two": sets.NewString("c", "e"),
 			},
 		},
 		{
@@ -320,7 +320,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						corev1.ResourceCPU: {Flavors: []FlavorLimits{{Name: "default", Min: 5000, Max: pointer.Int64(10000)}}},
 					},
 					NamespaceSelector: labels.Nothing(),
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType", "region")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType", "region")},
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
 					Status:            active,
 				},
@@ -352,13 +352,13 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 					NamespaceSelector: labels.Nothing(),
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType", "region")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType", "region")},
 					Status:            active,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("b"),
-				"two": sets.New("a", "c", "e"),
+			wantCohorts: map[string]sets.String{
+				"one": sets.NewString("b"),
+				"two": sets.NewString("a", "c", "e"),
 			},
 		},
 		{
@@ -381,7 +381,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 					NamespaceSelector: labels.Nothing(),
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					Status:            active,
 				},
 				"c": {
@@ -402,9 +402,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:            pending,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("b"),
-				"two": sets.New("c", "e"),
+			wantCohorts: map[string]sets.String{
+				"one": sets.NewString("b"),
+				"two": sets.NewString("c", "e"),
 			},
 		},
 		{
@@ -422,7 +422,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						corev1.ResourceCPU: {Flavors: []FlavorLimits{{Name: "default", Min: 10000, Max: pointer.Int64(20000)}}},
 					},
 					NamespaceSelector: labels.Nothing(),
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
 					Status:            active,
 				},
@@ -433,7 +433,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 					NamespaceSelector: labels.Nothing(),
 					UsedResources:     ResourceQuantities{corev1.ResourceCPU: {"default": 0}},
-					LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+					LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 					Status:            active,
 				},
 				"c": {
@@ -461,9 +461,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:            active,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e"),
+			wantCohorts: map[string]sets.String{
+				"one": sets.NewString("a", "b"),
+				"two": sets.NewString("c", "e"),
 			},
 		},
 		{
@@ -514,14 +514,14 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 								{Name: "foo"},
 								{Name: "bar"},
 							},
-							CodependentResources: sets.New[corev1.ResourceName]("cpu", "memory"),
+							CodependentResources: sets.NewString("cpu", "memory"),
 						},
 						"memory": {
 							Flavors: []FlavorLimits{
 								{Name: "foo"},
 								{Name: "bar"},
 							},
-							CodependentResources: sets.New[corev1.ResourceName]("cpu", "memory"),
+							CodependentResources: sets.NewString("cpu", "memory"),
 						},
 						"example.com/gpu": {
 							Flavors: []FlavorLimits{
@@ -558,10 +558,10 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				t.Errorf("Unexpected clusterQueues (-want,+got):\n%s", diff)
 			}
 
-			gotCohorts := make(map[string]sets.Set[string], len(cache.cohorts))
+			gotCohorts := map[string]sets.String{}
 			for name, cohort := range cache.cohorts {
-				gotCohort := sets.New[string]()
-				for cq := range cohort.Members {
+				gotCohort := sets.NewString()
+				for cq := range cohort.members {
 					gotCohort.Insert(cq.Name)
 				}
 				gotCohorts[name] = gotCohort
@@ -654,7 +654,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 	).Build()
 
 	type result struct {
-		Workloads     sets.Set[string]
+		Workloads     sets.String
 		UsedResources ResourceQuantities
 	}
 
@@ -685,11 +685,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c", "/d"),
+					Workloads:     sets.NewString("c", "d"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -708,11 +708,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "failed to add workload",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -730,11 +730,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -753,11 +753,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/b"),
+					Workloads:     sets.NewString("b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 				"two": {
-					Workloads:     sets.New("/a", "/c"),
+					Workloads:     sets.NewString("a", "c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 			},
@@ -776,11 +776,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "old ClusterQueue doesn't exist",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -799,11 +799,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "new ClusterQueue doesn't exist",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -821,11 +821,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c", "/d"),
+					Workloads:     sets.NewString("c", "d"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -840,11 +840,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/b"),
+					Workloads:     sets.NewString("b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -860,11 +860,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -879,11 +879,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -910,11 +910,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b", "/d"),
+					Workloads:     sets.NewString("a", "b", "d"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 20, "spot": 30}},
 				},
 				"two": {
-					Workloads:     sets.New("/c", "/e"),
+					Workloads:     sets.NewString("c", "e"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 			},
@@ -937,11 +937,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -971,11 +971,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c", "/e"),
+					Workloads:     sets.NewString("c", "e"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 			},
@@ -997,11 +997,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "the workload is not assumed",
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b"),
+					Workloads:     sets.NewString("a", "b"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 				"two": {
-					Workloads:     sets.New("/c"),
+					Workloads:     sets.NewString("c"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 0, "spot": 0}},
 				},
 			},
@@ -1033,11 +1033,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[string]result{
 				"one": {
-					Workloads:     sets.New("/a", "/b", "/d"),
+					Workloads:     sets.NewString("a", "b", "d"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 20, "spot": 30}},
 				},
 				"two": {
-					Workloads:     sets.New("/c", "/e"),
+					Workloads:     sets.NewString("c", "e"),
 					UsedResources: ResourceQuantities{"cpu": {"on-demand": 10, "spot": 15}},
 				},
 			},
@@ -1062,7 +1062,11 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			}
 			gotWorkloads := make(map[string]result)
 			for name, cq := range cache.clusterQueues {
-				gotWorkloads[name] = result{Workloads: sets.KeySet(cq.Workloads), UsedResources: cq.UsedResources}
+				c := sets.NewString()
+				for k := range cq.Workloads {
+					c.Insert(cq.Workloads[k].Obj.Name)
+				}
+				gotWorkloads[name] = result{Workloads: c, UsedResources: cq.UsedResources}
 			}
 			if diff := cmp.Diff(step.wantResults, gotWorkloads); diff != "" {
 				t.Errorf("Unexpected clusterQueues (-want,+got):\n%s", diff)
@@ -1697,14 +1701,14 @@ func TestClusterQueueUpdateCodependentResources(t *testing.T) {
 							{Name: "alpha"},
 							{Name: "beta"},
 						},
-						CodependentResources: sets.New[corev1.ResourceName]("cpu", "memory"),
+						CodependentResources: sets.NewString("cpu", "memory"),
 					},
 					"memory": {
 						Flavors: []FlavorLimits{
 							{Name: "alpha"},
 							{Name: "beta"},
 						},
-						CodependentResources: sets.New[corev1.ResourceName]("cpu", "memory"),
+						CodependentResources: sets.NewString("cpu", "memory"),
 					},
 					"example.com/gpu": {
 						Flavors: []FlavorLimits{
@@ -1716,13 +1720,13 @@ func TestClusterQueueUpdateCodependentResources(t *testing.T) {
 						Flavors: []FlavorLimits{
 							{Name: "default"},
 						},
-						CodependentResources: sets.New[corev1.ResourceName]("example.com/foo", "example.com/bar"),
+						CodependentResources: sets.NewString("example.com/foo", "example.com/bar"),
 					},
 					"example.com/bar": {
 						Flavors: []FlavorLimits{
 							{Name: "default"},
 						},
-						CodependentResources: sets.New[corev1.ResourceName]("example.com/foo", "example.com/bar"),
+						CodependentResources: sets.NewString("example.com/foo", "example.com/bar"),
 					},
 				},
 			},
@@ -1755,7 +1759,7 @@ func TestMatchingClusterQueues(t *testing.T) {
 				},
 			}).Obj(),
 	}
-	wantCQs := sets.New("matching1", "matching2")
+	wantCQs := sets.NewString("matching1", "matching2")
 
 	ctx := context.Background()
 	scheme := runtime.NewScheme()
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/snapshot_test.go
index 5ce61d52a..a928b6554 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/snapshot_test.go
@@ -320,7 +320,7 @@ func TestSnapshot(t *testing.T) {
 				Workloads: map[string]*workload.Info{
 					"/alpha": workload.NewInfo(&workloads[0]),
 				},
-				LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("baz", "foo", "instance")},
+				LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: {"baz": {}, "foo": {}, "instance": {}}},
 				NamespaceSelector: labels.Nothing(),
 				Status:            active,
 			},
@@ -358,7 +358,7 @@ func TestSnapshot(t *testing.T) {
 					"/gamma": workload.NewInfo(&workloads[2]),
 				},
 				NamespaceSelector: labels.Nothing(),
-				LabelKeys:         map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("baz", "instance")},
+				LabelKeys:         map[corev1.ResourceName]sets.String{corev1.ResourceCPU: {"baz": {}, "instance": {}}},
 				Status:            active,
 			},
 			"bar": {
@@ -398,9 +398,9 @@ func TestSnapshot(t *testing.T) {
 				NodeSelector: map[string]string{"baz": "bar", "instance": "spot"},
 			},
 		},
-		InactiveClusterQueueSets: sets.New("flavor-nonexistent-cq"),
+		InactiveClusterQueueSets: sets.String{"flavor-nonexistent-cq": {}},
 	}
-	if diff := cmp.Diff(wantSnapshot, snapshot, cmpopts.IgnoreUnexported(ClusterQueue{}), cmpopts.IgnoreFields(Cohort{}, "Members")); diff != "" {
+	if diff := cmp.Diff(wantSnapshot, snapshot, cmpopts.IgnoreUnexported(Cohort{}, ClusterQueue{})); diff != "" {
 		t.Errorf("Unexpected Snapshot (-want,+got):\n%s", diff)
 	}
 }
diff --git a/pkg/queue/cluster_queue_impl_test.go b/pkg/queue/cluster_queue_impl_test.go
index e4ce9d473..5754354bf 100644
--- a/pkg/queue/cluster_queue_impl_test.go
+++ b/pkg/queue/cluster_queue_impl_test.go
@@ -201,7 +201,7 @@ func TestClusterQueueImpl(t *testing.T) {
 		workloadsToUpdate                 []*kueue.Workload
 		workloadsToDelete                 []*kueue.Workload
 		queueInadmissibleWorkloads        bool
-		wantActiveWorkloads               sets.Set[string]
+		wantActiveWorkloads               sets.String
 		wantPending                       int
 		wantInadmissibleWorkloadsRequeued bool
 	}{
@@ -210,27 +210,27 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{},
 			workloadsToUpdate:              []*kueue.Workload{updatedWorkloads[0]},
 			workloadsToDelete:              []*kueue.Workload{workloads[0]},
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[1])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[1])),
 			wantPending:                    1,
 		},
 		"re-queue inadmissible workload": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[0])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[0])),
 			wantPending:                    2,
 		},
 		"re-queue admissible workload that was inadmissible": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			admissibleWorkloadsToRequeue:   []*workload.Info{workload.NewInfo(workloads[1])},
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[0]), workload.Key(workloads[1])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[0]), workload.Key(workloads[1])),
 			wantPending:                    2,
 		},
 		"re-queue inadmissible workload and flush": {
 			workloadsToAdd:                    []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue:    []*workload.Info{workload.NewInfo(workloads[1])},
 			queueInadmissibleWorkloads:        true,
-			wantActiveWorkloads:               sets.New(workload.Key(workloads[0]), workload.Key(workloads[1])),
+			wantActiveWorkloads:               sets.NewString(workload.Key(workloads[0]), workload.Key(workloads[1])),
 			wantPending:                       2,
 			wantInadmissibleWorkloadsRequeued: true,
 		},
@@ -238,14 +238,14 @@ func TestClusterQueueImpl(t *testing.T) {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[2])},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[0])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[0])),
 			wantPending:                    2,
 		},
 		"update inadmissible workload": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			workloadsToUpdate:              []*kueue.Workload{updatedWorkloads[1]},
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[0]), workload.Key(workloads[1])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[0]), workload.Key(workloads[1])),
 			wantPending:                    2,
 		},
 		"delete inadmissible workload": {
@@ -253,7 +253,7 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			workloadsToDelete:              []*kueue.Workload{workloads[1]},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            sets.New(workload.Key(workloads[0])),
+			wantActiveWorkloads:            sets.NewString(workload.Key(workloads[0])),
 			wantPending:                    1,
 		},
 		"update inadmissible workload without changes": {
@@ -336,7 +336,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	ctx := context.Background()
 	cq.PushOrUpdate(workload.NewInfo(wl))
 
-	wantActiveWorkloads := sets.New(workload.Key(wl))
+	wantActiveWorkloads := sets.NewString(workload.Key(wl))
 
 	activeWorkloads, _ := cq.Dump()
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads); diff != "" {
@@ -349,7 +349,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	cq.requeueIfNotPresent(head, false)
 
 	activeWorkloads, _ = cq.Dump()
-	wantActiveWorkloads = sets.New(workload.Key(wl))
+	wantActiveWorkloads = sets.NewString(workload.Key(wl))
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads); diff != "" {
 		t.Errorf("Unexpected active workloads after scheduling with requeueing (-want,+got):\n%s", diff)
 	}
diff --git a/pkg/queue/manager_test.go b/pkg/queue/manager_test.go
index 5a77c4798..f1ea7a166 100644
--- a/pkg/queue/manager_test.go
+++ b/pkg/queue/manager_test.go
@@ -60,7 +60,7 @@ func TestAddLocalQueueOrphans(t *testing.T) {
 	}
 	qImpl := manager.localQueues[Key(q)]
 	workloadNames := workloadNamesFromLQ(qImpl)
-	if diff := cmp.Diff(sets.New("earth/a", "earth/c"), workloadNames); diff != "" {
+	if diff := cmp.Diff(sets.NewString("earth/a", "earth/c"), workloadNames); diff != "" {
 		t.Errorf("Unexpected items in queue foo (-want,+got):\n%s", diff)
 	}
 }
@@ -98,8 +98,8 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		}
 	}
 
-	wantActiveWorkloads := map[string]sets.Set[string]{
-		"cq": sets.New("/a", "/b"),
+	wantActiveWorkloads := map[string]sets.String{
+		"cq": sets.NewString("/a", "/b"),
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump()); diff != "" {
 		t.Errorf("Unexpected active workloads after creating all objects (-want,+got):\n%s", diff)
@@ -169,8 +169,8 @@ func TestUpdateClusterQueue(t *testing.T) {
 		t.Fatalf("Failed to update ClusterQueue: %v", err)
 	}
 
-	wantCohorts := map[string]sets.Set[string]{
-		"alpha": sets.New("cq1", "cq2"),
+	wantCohorts := map[string]sets.String{
+		"alpha": sets.NewString("cq1", "cq2"),
 	}
 	if diff := cmp.Diff(manager.cohorts, wantCohorts); diff != "" {
 		t.Errorf("Unexpected ClusterQueues in cohorts (-want,+got):\n%s", diff)
@@ -178,9 +178,9 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify all workloads are active after the update.
 	activeWorkloads := manager.Dump()
-	wantActiveWorkloads := map[string]sets.Set[string]{
-		"cq1": sets.New("default/a"),
-		"cq2": sets.New("default/b"),
+	wantActiveWorkloads := map[string]sets.String{
+		"cq1": sets.NewString("default/a"),
+		"cq2": sets.NewString("default/b"),
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads); diff != "" {
 		t.Errorf("Unexpected active workloads (-want +got):\n%s", diff)
@@ -263,8 +263,8 @@ func TestDeleteLocalQueue(t *testing.T) {
 		t.Fatalf("Could not create LocalQueue: %v", err)
 	}
 
-	wantActiveWorkloads := map[string]sets.Set[string]{
-		"cq": sets.New("/a"),
+	wantActiveWorkloads := map[string]sets.String{
+		"cq": sets.NewString("/a"),
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump()); diff != "" {
 		t.Errorf("Unexpected workloads after setup (-want,+got):\n%s", diff)
@@ -553,7 +553,7 @@ func TestUpdateWorkload(t *testing.T) {
 		update           func(*kueue.Workload)
 		wantUpdated      bool
 		wantQueueOrder   map[string][]string
-		wantQueueMembers map[string]sets.Set[string]
+		wantQueueMembers map[string]sets.String
 	}{
 		"in queue": {
 			clusterQueues: []*kueue.ClusterQueue{
@@ -573,8 +573,8 @@ func TestUpdateWorkload(t *testing.T) {
 			wantQueueOrder: map[string][]string{
 				"cq": {"/b", "/a"},
 			},
-			wantQueueMembers: map[string]sets.Set[string]{
-				"/foo": sets.New("/a", "/b"),
+			wantQueueMembers: map[string]sets.String{
+				"/foo": sets.NewString("/a", "/b"),
 			},
 		},
 		"between queues": {
@@ -595,9 +595,9 @@ func TestUpdateWorkload(t *testing.T) {
 			wantQueueOrder: map[string][]string{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[string]sets.Set[string]{
-				"/foo": nil,
-				"/bar": sets.New("/a"),
+			wantQueueMembers: map[string]sets.String{
+				"/foo": sets.NewString(),
+				"/bar": sets.NewString("/a"),
 			},
 		},
 		"between cluster queues": {
@@ -620,9 +620,9 @@ func TestUpdateWorkload(t *testing.T) {
 				"cq1": nil,
 				"cq2": {"/a"},
 			},
-			wantQueueMembers: map[string]sets.Set[string]{
-				"/foo": nil,
-				"/bar": sets.New("/a"),
+			wantQueueMembers: map[string]sets.String{
+				"/foo": sets.NewString(),
+				"/bar": sets.NewString("/a"),
 			},
 		},
 		"to non existent queue": {
@@ -641,8 +641,8 @@ func TestUpdateWorkload(t *testing.T) {
 			wantQueueOrder: map[string][]string{
 				"cq": nil,
 			},
-			wantQueueMembers: map[string]sets.Set[string]{
-				"/foo": nil,
+			wantQueueMembers: map[string]sets.String{
+				"/foo": sets.NewString(),
 			},
 		},
 		"from non existing queue": {
@@ -662,8 +662,8 @@ func TestUpdateWorkload(t *testing.T) {
 			wantQueueOrder: map[string][]string{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[string]sets.Set[string]{
-				"/foo": sets.New("/a"),
+			wantQueueMembers: map[string]sets.String{
+				"/foo": sets.NewString("/a"),
 			},
 		},
 	}
@@ -715,7 +715,7 @@ func TestUpdateWorkload(t *testing.T) {
 			if diff := cmp.Diff(tc.wantQueueOrder, queueOrder); diff != "" {
 				t.Errorf("Elements popped in the wrong order from clusterQueues (-want,+got):\n%s", diff)
 			}
-			queueMembers := make(map[string]sets.Set[string])
+			queueMembers := make(map[string]sets.String)
 			for name, q := range manager.localQueues {
 				queueMembers[name] = workloadNamesFromLQ(q)
 			}
@@ -746,12 +746,12 @@ func TestHeads(t *testing.T) {
 	tests := []struct {
 		name          string
 		workloads     []*kueue.Workload
-		wantWorkloads sets.Set[string]
+		wantWorkloads sets.String
 	}{
 		{
 			name:          "empty clusterQueues",
 			workloads:     []*kueue.Workload{},
-			wantWorkloads: sets.Set[string]{},
+			wantWorkloads: sets.String{},
 		},
 		{
 			name: "active clusterQueues",
@@ -759,7 +759,7 @@ func TestHeads(t *testing.T) {
 				utiltesting.MakeWorkload("a", "").Creation(now).Queue("foo").Obj(),
 				utiltesting.MakeWorkload("b", "").Creation(now).Queue("bar").Obj(),
 			},
-			wantWorkloads: sets.New("a", "b"),
+			wantWorkloads: sets.NewString("a", "b"),
 		},
 		{
 			name: "active clusterQueues with multiple workloads",
@@ -768,7 +768,7 @@ func TestHeads(t *testing.T) {
 				utiltesting.MakeWorkload("a2", "").Creation(now.Add(time.Hour)).Queue("foo").Obj(),
 				utiltesting.MakeWorkload("b", "").Creation(now).Queue("bar").Obj(),
 			},
-			wantWorkloads: sets.New("a1", "b"),
+			wantWorkloads: sets.NewString("a1", "b"),
 		},
 		{
 			name: "inactive clusterQueues",
@@ -777,7 +777,7 @@ func TestHeads(t *testing.T) {
 				utiltesting.MakeWorkload("b", "").Creation(now).Queue("bar").Obj(),
 				utiltesting.MakeWorkload("c", "").Creation(now.Add(time.Hour)).Queue("baz").Obj(),
 			},
-			wantWorkloads: sets.New("a", "b"),
+			wantWorkloads: sets.NewString("a", "b"),
 		},
 	}
 	for _, tc := range tests {
@@ -802,7 +802,7 @@ func TestHeads(t *testing.T) {
 				manager.AddOrUpdateWorkload(wl)
 			}
 
-			wlNames := sets.New[string]()
+			wlNames := sets.NewString()
 			heads := manager.Heads(ctx)
 			for _, h := range heads {
 				wlNames.Insert(h.Obj.Name)
@@ -1058,8 +1058,8 @@ func popNamesFromCQ(cq ClusterQueue) []string {
 }
 
 // workloadNamesFromLQ returns all the names of the workloads in a localQueue.
-func workloadNamesFromLQ(q *LocalQueue) sets.Set[string] {
-	names := sets.New[string]()
+func workloadNamesFromLQ(q *LocalQueue) sets.String {
+	names := sets.NewString()
 	for k := range q.items {
 		names.Insert(k)
 	}
diff --git a/pkg/scheduler/flavorassigner/flavorassigner_test.go b/pkg/scheduler/flavorassigner/flavorassigner_test.go
index abf248ef7..58f76761b 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner_test.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner_test.go
@@ -527,7 +527,7 @@ func TestAssignFlavors(t *testing.T) {
 						},
 					},
 				},
-				LabelKeys: map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+				LabelKeys: map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 			},
 			wantRepMode: Fit,
 			wantAssignment: Assignment{
@@ -705,7 +705,7 @@ func TestAssignFlavors(t *testing.T) {
 						},
 					},
 				},
-				LabelKeys: map[corev1.ResourceName]sets.Set[string]{corev1.ResourceCPU: sets.New("cpuType")},
+				LabelKeys: map[corev1.ResourceName]sets.String{corev1.ResourceCPU: sets.NewString("cpuType")},
 			},
 			wantAssignment: Assignment{
 				PodSets: []PodSetAssignment{{
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index eae0df2cb..03e63e43a 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -259,9 +259,9 @@ func TestSchedule(t *testing.T) {
 		// wantScheduled is the subset of workloads that got scheduled/admitted in this cycle.
 		wantScheduled []string
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[string]sets.Set[string]
+		wantLeft map[string]sets.String
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[string]sets.Set[string]
+		wantInadmissibleLeft map[string]sets.String
 	}{
 		"workload fits in single clusterQueue": {
 			workloads: []kueue.Workload{
@@ -321,8 +321,8 @@ func TestSchedule(t *testing.T) {
 				},
 			},
 			admissionError: errors.New("admission"),
-			wantLeft: map[string]sets.Set[string]{
-				"sales": sets.New("sales/foo"),
+			wantLeft: map[string]sets.String{
+				"sales": sets.NewString("sales/foo"),
 			},
 		},
 		"single clusterQueue full": {
@@ -387,8 +387,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[string]sets.Set[string]{
-				"sales": sets.New("sales/new"),
+			wantLeft: map[string]sets.String{
+				"sales": sets.NewString("sales/new"),
 			},
 		},
 		"failed to match clusterQueue selector": {
@@ -412,8 +412,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantInadmissibleLeft: map[string]sets.Set[string]{
-				"eng-alpha": sets.New("sales/new"),
+			wantInadmissibleLeft: map[string]sets.String{
+				"eng-alpha": sets.NewString("sales/new"),
 			},
 		},
 		"assign to different cohorts": {
@@ -650,8 +650,8 @@ func TestSchedule(t *testing.T) {
 				},
 			},
 			wantScheduled: []string{"eng-alpha/new"},
-			wantLeft: map[string]sets.Set[string]{
-				"eng-beta": sets.New("eng-beta/new"),
+			wantLeft: map[string]sets.String{
+				"eng-beta": sets.NewString("eng-beta/new"),
 			},
 		},
 		"cannot borrow if needs reclaim from cohort": {
@@ -673,9 +673,9 @@ func TestSchedule(t *testing.T) {
 					Admit(utiltesting.MakeAdmission("eng-beta").Flavor(corev1.ResourceCPU, "spot").Obj()).
 					Obj(),
 			},
-			wantLeft: map[string]sets.Set[string]{
-				"eng-alpha": sets.New("eng-alpha/can-reclaim"),
-				"eng-beta":  sets.New("eng-beta/needs-to-borrow"),
+			wantLeft: map[string]sets.String{
+				"eng-alpha": sets.NewString("eng-alpha/can-reclaim"),
+				"eng-beta":  sets.NewString("eng-beta/needs-to-borrow"),
 			},
 			wantAssignments: map[string]kueue.Admission{
 				"eng-beta/user-spot":      *utiltesting.MakeAdmission("eng-beta").Flavor(corev1.ResourceCPU, "spot").Obj(),
@@ -703,8 +703,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[string]sets.Set[string]{
-				"eng-alpha": sets.New("eng-alpha/new"),
+			wantLeft: map[string]sets.String{
+				"eng-alpha": sets.NewString("eng-alpha/new"),
 			},
 		},
 		"not enough resources to borrow, fallback to next flavor": {
@@ -825,8 +825,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[string]sets.Set[string]{
-				"flavor-nonexistent-cq": sets.New("sales/foo"),
+			wantLeft: map[string]sets.String{
+				"flavor-nonexistent-cq": sets.NewString("sales/foo"),
 			},
 		},
 	}
@@ -1005,8 +1005,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 	cases := []struct {
 		name             string
 		e                entry
-		wantWorkloads    map[string]sets.Set[string]
-		wantInadmissible map[string]sets.Set[string]
+		wantWorkloads    map[string]sets.String
+		wantInadmissible map[string]sets.String
 		wantStatus       kueue.WorkloadStatus
 	}{
 		{
@@ -1024,8 +1024,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 					},
 				},
 			},
-			wantInadmissible: map[string]sets.Set[string]{
-				"cq": sets.New(workload.Key(w1)),
+			wantInadmissible: map[string]sets.String{
+				"cq": sets.NewString(workload.Key(w1)),
 			},
 		},
 		{
@@ -1034,8 +1034,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          assumed,
 				inadmissibleMsg: "",
 			},
-			wantWorkloads: map[string]sets.Set[string]{
-				"cq": sets.New(workload.Key(w1)),
+			wantWorkloads: map[string]sets.String{
+				"cq": sets.NewString(workload.Key(w1)),
 			},
 		},
 		{
@@ -1044,8 +1044,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          nominated,
 				inadmissibleMsg: "failed to admit workload",
 			},
-			wantWorkloads: map[string]sets.Set[string]{
-				"cq": sets.New(workload.Key(w1)),
+			wantWorkloads: map[string]sets.String{
+				"cq": sets.NewString(workload.Key(w1)),
 			},
 		},
 		{
@@ -1054,8 +1054,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          skipped,
 				inadmissibleMsg: "cohort used in this cycle",
 			},
-			wantWorkloads: map[string]sets.Set[string]{
-				"cq": sets.New(workload.Key(w1)),
+			wantWorkloads: map[string]sets.String{
+				"cq": sets.NewString(workload.Key(w1)),
 			},
 		},
 	}