Repository: kubernetes-sigs/kueue

Issue:
TAS: Two-level JobSet scheduling
<!-- Please only use this template for submitting enhancement requests -->

**What would you like to be added**:
A possibility to define topology for each Job in ReplicatedJob to co-locate the whole ReplicatedJob in one domain and each Job in that ReplicatedJob in lower-level domain within that domain.

In more generic terms - an API to define required sub PodSet topology and allow for two-level scheduling for the whole PodSet and lower-level topology domain for each chunk within that PodSet.

An example is a JobSet in which user can define topology for all Jobs resulting from a single ReplicatedJob. We want to allow user to define topology for each such Job and possibly co-locate all such Jobs in higher-level topology.

**Why is this needed**:
Currently Topology-Aware Scheduling considers the whole PodSet as a single unit for which Kueue looks for a matching domain. For JobSet PodSet covers all pods resulting from the whole ReplicatedJob. However, there are use-cases in which user would like to co-locate each Job in a lower-level domains and co-locate all those Jobs in higher-level domain.

Additionally, user would like to define a topology only for each Job without any expectations for a topology of the whole ReplicatedJob.

**Completion requirements**:

This enhancement requires the following artifacts:

- [ ] Design doc
- [x] API change
- [ ] Docs update

The artifacts should be linked in subsequent comments.


Discussion:
@mimowo: /retitle TAS: Two-level JobSet scheduling@lchrzaszcz: TAS KEP update to reflect two-level scheduling and podset chunk topology: https://github.com/kubernetes-sigs/kueue/pull/5449@kerthcet: One quick question: can this solve the https://github.com/kubernetes-sigs/kueue/pull/3941? E.g. co-locate the master and worker jobs in pytorchjob.
Thanks!@kerthcet: I'll read the KEP in detail later.@kerthcet: This focused on podSet chunks, not between multi-podsets. @lchrzaszcz: I will be looking into cross-podsets scheduling in few following weeks. I'll do it mostly for LeaderWorkerSet though, but I think the underlying mechanism will be universal, so probably it'll be easy to add pytorchjob support afterwards.@kerthcet: Thanks @lchrzaszcz for your response, I think leaderworkerset pytorchjob are just two different workload types, the mechanism should be universal to them all I believe. Glad to jump into the discussion.@tenzen-y: /assign @lchrzaszcz 

Solution patch:
diff --git a/.gitignore b/.gitignore
index e487f4005..da528897b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,4 +34,7 @@ build_logs
 dep-crds
 
 kueue.yaml
+
 node_modules
+test/e2e/kueueviz/cypress/screenshots
+test/e2e/kueueviz/cypress/videos
diff --git a/Makefile-test.mk b/Makefile-test.mk
index 165154a6e..3b903a95d 100644
--- a/Makefile-test.mk
+++ b/Makefile-test.mk
@@ -246,12 +246,14 @@ setup-e2e-env: kustomize yq gomod-download dep-crds kind ginkgo ginkgo-top ## Se
 
 .PHONY: test-e2e-kueueviz-local
 test-e2e-kueueviz-local: setup-e2e-env ## Run end-to-end tests for kueueviz without running kueue tests.
+	CYPRESS_SCREENSHOTS_FOLDER=$(ARTIFACTS)/cypress/screenshots CYPRESS_VIDEOS_FOLDER=$(ARTIFACTS)/cypress/videos \
 	ARTIFACTS=$(ARTIFACTS) KIND_CLUSTER_NAME=$(KIND_CLUSTER_NAME) PROJECT_DIR=$(PROJECT_DIR)/ \
 	KIND_CLUSTER_FILE="kind-cluster.yaml" IMAGE_TAG=$(IMAGE_TAG) ${PROJECT_DIR}/hack/e2e-kueueviz-local.sh
 
 .PHONY: test-e2e-kueueviz
 test-e2e-kueueviz: setup-e2e-env ## Run end-to-end tests for kueueviz without running kueue tests.
 	@echo Starting kueueviz end to end test in containers
+	CYPRESS_SCREENSHOTS_FOLDER=$(ARTIFACTS)/cypress/screenshots CYPRESS_VIDEOS_FOLDER=$(ARTIFACTS)/cypress/videos \
 	ARTIFACTS=$(ARTIFACTS) KIND_CLUSTER_NAME=$(KIND_CLUSTER_NAME) PROJECT_DIR=$(PROJECT_DIR)/ \
 	KIND_CLUSTER_FILE="kind-cluster.yaml" IMAGE_TAG=$(IMAGE_TAG) \
 	${PROJECT_DIR}/hack/e2e-kueueviz-backend.sh
diff --git a/cmd/kueuectl/app/list/list_workload.go b/cmd/kueuectl/app/list/list_workload.go
index a46918e8d..322f0f9e8 100644
--- a/cmd/kueuectl/app/list/list_workload.go
+++ b/cmd/kueuectl/app/list/list_workload.go
@@ -430,10 +430,10 @@ func (o *WorkloadOptions) localQueues(ctx context.Context, list *v1beta1.Workloa
 	return localQueues, nil
 }
 
-func (o *WorkloadOptions) pendingWorkloads(ctx context.Context, list *v1beta1.WorkloadList, localQueues map[string]*v1beta1.LocalQueue) (map[workload.WorkloadReference]*visibility.PendingWorkload, error) {
+func (o *WorkloadOptions) pendingWorkloads(ctx context.Context, list *v1beta1.WorkloadList, localQueues map[string]*v1beta1.LocalQueue) (map[workload.Reference]*visibility.PendingWorkload, error) {
 	var err error
 
-	pendingWorkloads := make(map[workload.WorkloadReference]*visibility.PendingWorkload)
+	pendingWorkloads := make(map[workload.Reference]*visibility.PendingWorkload)
 	pendingWorkloadsSummaries := make(map[v1beta1.ClusterQueueReference]*visibility.PendingWorkloadsSummary)
 
 	for _, wl := range list.Items {
diff --git a/cmd/kueuectl/app/list/list_workload_printer.go b/cmd/kueuectl/app/list/list_workload_printer.go
index 0731f15f0..e2bd8dc8e 100644
--- a/cmd/kueuectl/app/list/list_workload_printer.go
+++ b/cmd/kueuectl/app/list/list_workload_printer.go
@@ -39,14 +39,14 @@ const crdTypeMaxLength = 20
 
 type listWorkloadResources struct {
 	localQueues      map[string]*v1beta1.LocalQueue
-	pendingWorkloads map[workload.WorkloadReference]*visibility.PendingWorkload
+	pendingWorkloads map[workload.Reference]*visibility.PendingWorkload
 	apiResourceLists map[string]*metav1.APIResourceList
 }
 
 func newListWorkloadResources() *listWorkloadResources {
 	return &listWorkloadResources{
 		localQueues:      make(map[string]*v1beta1.LocalQueue),
-		pendingWorkloads: make(map[workload.WorkloadReference]*visibility.PendingWorkload),
+		pendingWorkloads: make(map[workload.Reference]*visibility.PendingWorkload),
 		apiResourceLists: make(map[string]*metav1.APIResourceList),
 	}
 }
diff --git a/cmd/kueueviz/frontend/.gitignore b/cmd/kueueviz/frontend/.gitignore
index 21b7f9b0f..ba6441571 100644
--- a/cmd/kueueviz/frontend/.gitignore
+++ b/cmd/kueueviz/frontend/.gitignore
@@ -1,5 +1,4 @@
 node_modules/
 build/
-cypress/screenshots
 yarn.lock
 
diff --git a/hack/e2e-kueueviz-backend.sh b/hack/e2e-kueueviz-backend.sh
index 78cedc5c4..5d32ff77c 100755
--- a/hack/e2e-kueueviz-backend.sh
+++ b/hack/e2e-kueueviz-backend.sh
@@ -84,8 +84,12 @@ fi
 # Start KueueViz frontend and cypress in a container
 echo "Current container information: CONTAINER_ID=${CONTAINER_ID} WORKSPACE_VOLUME=${WORKSPACE_VOLUME}"
 docker run -i --entrypoint /workspace/hack/e2e-kueueviz-frontend.sh \
+           -e CYPRESS_SCREENSHOTS_FOLDER="${CYPRESS_SCREENSHOTS_FOLDER}" \
+           -e CYPRESS_VIDEOS_FOLDER="${CYPRESS_VIDEOS_FOLDER}" \
            -e PROJECT_DIR="/workspace" -w /workspace --network host \
            -v "${WORKSPACE_VOLUME}":/workspace:rw \
+           -v "${CYPRESS_SCREENSHOTS_FOLDER}":"${CYPRESS_SCREENSHOTS_FOLDER}" \
+           -v "${CYPRESS_VIDEOS_FOLDER}":"${CYPRESS_VIDEOS_FOLDER}" \
            -v /var/run/docker.sock:/var/run/docker.sock "${CYPRESS_IMAGE_NAME}"
 
 set +x  # Disable debug mode
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
index 552504607..8d4ed39ed 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -104,7 +104,7 @@ type Cache struct {
 	podsReadyCond sync.Cond
 
 	client              client.Client
-	assumedWorkloads    map[workload.WorkloadReference]kueue.ClusterQueueReference
+	assumedWorkloads    map[workload.Reference]kueue.ClusterQueueReference
 	resourceFlavors     map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor
 	podsReadyTracking   bool
 	admissionChecks     map[kueue.AdmissionCheckReference]AdmissionCheck
@@ -123,7 +123,7 @@ func New(client client.Client, opts ...Option) *Cache {
 	}
 	c := &Cache{
 		client:              client,
-		assumedWorkloads:    make(map[workload.WorkloadReference]kueue.ClusterQueueReference),
+		assumedWorkloads:    make(map[workload.Reference]kueue.ClusterQueueReference),
 		resourceFlavors:     make(map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor),
 		admissionChecks:     make(map[kueue.AdmissionCheckReference]AdmissionCheck),
 		podsReadyTracking:   options.podsReadyTracking,
@@ -139,8 +139,8 @@ func New(client client.Client, opts ...Option) *Cache {
 func (c *Cache) newClusterQueue(log logr.Logger, cq *kueue.ClusterQueue) (*clusterQueue, error) {
 	cqImpl := &clusterQueue{
 		Name:                kueue.ClusterQueueReference(cq.Name),
-		Workloads:           make(map[workload.WorkloadReference]*workload.Info),
-		WorkloadsNotReady:   sets.New[workload.WorkloadReference](),
+		Workloads:           make(map[workload.Reference]*workload.Info),
+		WorkloadsNotReady:   sets.New[workload.Reference](),
 		localQueues:         make(map[queue.LocalQueueReference]*LocalQueue),
 		podsReadyTracking:   c.podsReadyTracking,
 		workloadInfoOptions: c.workloadInfoOptions,
@@ -148,7 +148,7 @@ func (c *Cache) newClusterQueue(log logr.Logger, cq *kueue.ClusterQueue) (*clust
 		resourceNode:        NewResourceNode(),
 		tasCache:            &c.tasCache,
 
-		workloadsNotAccountedForTAS: sets.New[workload.WorkloadReference](),
+		workloadsNotAccountedForTAS: sets.New[workload.Reference](),
 	}
 	c.hm.AddClusterQueue(cqImpl)
 	c.hm.UpdateClusterQueueEdge(kueue.ClusterQueueReference(cq.Name), cq.Spec.Cohort)
diff --git a/pkg/cache/clusterqueue.go b/pkg/cache/clusterqueue.go
index 12379cfed..eaf99d820 100644
--- a/pkg/cache/clusterqueue.go
+++ b/pkg/cache/clusterqueue.go
@@ -53,8 +53,8 @@ var (
 type clusterQueue struct {
 	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
-	Workloads         map[workload.WorkloadReference]*workload.Info
-	WorkloadsNotReady sets.Set[workload.WorkloadReference]
+	Workloads         map[workload.Reference]*workload.Info
+	WorkloadsNotReady sets.Set[workload.Reference]
 	NamespaceSelector labels.Selector
 	Preemption        kueue.ClusterQueuePreemption
 	FairWeight        resource.Quantity
@@ -88,7 +88,7 @@ type clusterQueue struct {
 
 	tasCache *tasCache
 
-	workloadsNotAccountedForTAS sets.Set[workload.WorkloadReference]
+	workloadsNotAccountedForTAS sets.Set[workload.Reference]
 }
 
 func (c *clusterQueue) GetName() kueue.ClusterQueueReference {
diff --git a/pkg/cache/clusterqueue_snapshot.go b/pkg/cache/clusterqueue_snapshot.go
index 5cff48d73..18f34fcca 100644
--- a/pkg/cache/clusterqueue_snapshot.go
+++ b/pkg/cache/clusterqueue_snapshot.go
@@ -37,8 +37,8 @@ import (
 type ClusterQueueSnapshot struct {
 	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
-	Workloads         map[workload.WorkloadReference]*workload.Info
-	WorkloadsNotReady sets.Set[workload.WorkloadReference]
+	Workloads         map[workload.Reference]*workload.Info
+	WorkloadsNotReady sets.Set[workload.Reference]
 	NamespaceSelector labels.Selector
 	Preemption        kueue.ClusterQueuePreemption
 	FairWeight        resource.Quantity
diff --git a/pkg/cache/tas_flavor_snapshot.go b/pkg/cache/tas_flavor_snapshot.go
index b3f1a63ec..572e2e979 100644
--- a/pkg/cache/tas_flavor_snapshot.go
+++ b/pkg/cache/tas_flavor_snapshot.go
@@ -185,6 +185,10 @@ func (s *TASFlavorSnapshot) lowestLevel() string {
 	return s.levelKeys[len(s.levelKeys)-1]
 }
 
+func (s *TASFlavorSnapshot) highestLevel() string {
+	return s.levelKeys[0]
+}
+
 // initialize prepares the topology tree structure. This structure holds
 // for a given the list of topology domains with additional static and dynamic
 // information. This function initializes the static information which
@@ -726,6 +730,9 @@ func isRequired(tr *kueue.PodSetTopologyRequest) bool {
 }
 
 func (s *TASFlavorSnapshot) levelKeyWithImpliedFallback(tasRequests *TASPodSetRequests) *string {
+	if isSliceTopologyOnlyRequest(tasRequests.PodSet.TopologyRequest) {
+		return ptr.To(s.highestLevel())
+	}
 	if key := s.levelKey(tasRequests.PodSet.TopologyRequest); key != nil {
 		return key
 	}
@@ -759,7 +766,11 @@ func (s *TASFlavorSnapshot) sliceLevelKeyWithDefault(tasRequests *TASPodSetReque
 }
 
 func isUnconstrained(tr *kueue.PodSetTopologyRequest, tasRequests *TASPodSetRequests) bool {
-	return (tr != nil && tr.Unconstrained != nil && *tr.Unconstrained) || tasRequests.Implied
+	return (tr != nil && tr.Unconstrained != nil && *tr.Unconstrained) || tasRequests.Implied || isSliceTopologyOnlyRequest(tr)
+}
+
+func isSliceTopologyOnlyRequest(tr *kueue.PodSetTopologyRequest) bool {
+	return tr != nil && tr.Required == nil && tr.Preferred == nil && tr.PodSetSliceRequiredTopology != nil
 }
 
 // findBestFitDomain finds an index of the first domain with the lowest
diff --git a/pkg/controller/admissionchecks/multikueue/multikueuecluster.go b/pkg/controller/admissionchecks/multikueue/multikueuecluster.go
index eb8dab41f..f58b0b0ab 100644
--- a/pkg/controller/admissionchecks/multikueue/multikueuecluster.go
+++ b/pkg/controller/admissionchecks/multikueue/multikueuecluster.go
@@ -260,14 +260,14 @@ func (rc *remoteClient) runGC(ctx context.Context) {
 		return
 	}
 
-	lst := &kueue.WorkloadList{}
-	err := rc.client.List(ctx, lst, client.MatchingLabels{kueue.MultiKueueOriginLabel: rc.origin})
+	wls := &kueue.WorkloadList{}
+	err := rc.client.List(ctx, wls, client.MatchingLabels{kueue.MultiKueueOriginLabel: rc.origin})
 	if err != nil {
 		log.Error(err, "Listing remote workloads")
 		return
 	}
 
-	for _, remoteWl := range lst.Items {
+	for _, remoteWl := range wls.Items {
 		localWl := &kueue.Workload{}
 		wlLog := log.WithValues("remoteWl", klog.KObj(&remoteWl))
 		err := rc.localClient.Get(ctx, client.ObjectKeyFromObject(&remoteWl), localWl)
diff --git a/pkg/controller/admissionchecks/provisioning/controller.go b/pkg/controller/admissionchecks/provisioning/controller.go
index a3ceb8d4d..69b0a5608 100644
--- a/pkg/controller/admissionchecks/provisioning/controller.go
+++ b/pkg/controller/admissionchecks/provisioning/controller.go
@@ -128,8 +128,8 @@ func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reco
 		return reconcile.Result{}, nil
 	}
 
-	provisioningRequestList := &autoscaling.ProvisioningRequestList{}
-	if err := c.client.List(ctx, provisioningRequestList, client.InNamespace(wl.Namespace), client.MatchingFields{RequestsOwnedByWorkloadKey: wl.Name}); client.IgnoreNotFound(err) != nil {
+	provReqs := &autoscaling.ProvisioningRequestList{}
+	if err := c.client.List(ctx, provReqs, client.InNamespace(wl.Namespace), client.MatchingFields{RequestsOwnedByWorkloadKey: wl.Name}); client.IgnoreNotFound(err) != nil {
 		return reconcile.Result{}, err
 	}
 
@@ -148,7 +148,7 @@ func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reco
 		checkConfig[checkName] = prc
 	}
 
-	activeOrLastPRForChecks := c.activeOrLastPRForChecks(ctx, wl, checkConfig, provisioningRequestList.Items)
+	activeOrLastPRForChecks := c.activeOrLastPRForChecks(ctx, wl, checkConfig, provReqs.Items)
 
 	wlInfo := workloadInfo{
 		checkStates: make([]kueue.AdmissionCheckState, 0),
@@ -158,7 +158,7 @@ func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reco
 		return reconcile.Result{}, err
 	}
 
-	err = c.deleteUnusedProvisioningRequests(ctx, provisioningRequestList.Items, activeOrLastPRForChecks)
+	err = c.deleteUnusedProvisioningRequests(ctx, provReqs.Items, activeOrLastPRForChecks)
 	if err != nil {
 		log.V(2).Error(err, "syncOwnedProvisionRequest failed to delete unused provisioning requests")
 		return reconcile.Result{}, err
@@ -697,13 +697,13 @@ func (a *acHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueue
 }
 
 func (a *acHandler) reconcileWorkloadsUsing(ctx context.Context, check string, q workqueue.TypedRateLimitingInterface[reconcile.Request]) error {
-	list := &kueue.WorkloadList{}
-	if err := a.client.List(ctx, list, client.MatchingFields{WorkloadsWithAdmissionCheckKey: check}); client.IgnoreNotFound(err) != nil {
+	wls := &kueue.WorkloadList{}
+	if err := a.client.List(ctx, wls, client.MatchingFields{WorkloadsWithAdmissionCheckKey: check}); client.IgnoreNotFound(err) != nil {
 		return err
 	}
 
-	for i := range list.Items {
-		wl := &list.Items[i]
+	for i := range wls.Items {
+		wl := &wls.Items[i]
 		req := reconcile.Request{
 			NamespacedName: types.NamespacedName{
 				Name:      wl.Name,
@@ -765,11 +765,11 @@ func (p *prcHandler) Generic(_ context.Context, _ event.GenericEvent, _ workqueu
 }
 
 func (p *prcHandler) reconcileWorkloadsUsing(ctx context.Context, config string, q workqueue.TypedRateLimitingInterface[reconcile.Request]) error {
-	list := &kueue.AdmissionCheckList{}
-	if err := p.client.List(ctx, list, client.MatchingFields{AdmissionCheckUsingConfigKey: config}); client.IgnoreNotFound(err) != nil {
+	acs := &kueue.AdmissionCheckList{}
+	if err := p.client.List(ctx, acs, client.MatchingFields{AdmissionCheckUsingConfigKey: config}); client.IgnoreNotFound(err) != nil {
 		return err
 	}
-	users := slices.Map(list.Items, func(ac *kueue.AdmissionCheck) string { return ac.Name })
+	users := slices.Map(acs.Items, func(ac *kueue.AdmissionCheck) string { return ac.Name })
 	for _, user := range users {
 		if p.acHandlerOverride != nil {
 			if err := p.acHandlerOverride(ctx, user, q); err != nil {
diff --git a/pkg/controller/jobframework/reconciler.go b/pkg/controller/jobframework/reconciler.go
index c6621e628..ce9365e40 100644
--- a/pkg/controller/jobframework/reconciler.go
+++ b/pkg/controller/jobframework/reconciler.go
@@ -662,25 +662,25 @@ func (r *JobReconciler) recordAdmissionCheckUpdate(wl *kueue.Workload, job Gener
 
 // getWorkloadForObject returns the Workload associated with the given job.
 func (r *JobReconciler) getWorkloadForObject(ctx context.Context, jobObj client.Object) (*kueue.Workload, error) {
-	wlList := kueue.WorkloadList{}
-	if err := r.client.List(ctx, &wlList, client.InNamespace(jobObj.GetNamespace()), client.MatchingFields{indexer.OwnerReferenceUID: string(jobObj.GetUID())}); client.IgnoreNotFound(err) != nil {
+	wls := kueue.WorkloadList{}
+	if err := r.client.List(ctx, &wls, client.InNamespace(jobObj.GetNamespace()), client.MatchingFields{indexer.OwnerReferenceUID: string(jobObj.GetUID())}); client.IgnoreNotFound(err) != nil {
 		return nil, err
 	}
 
-	if len(wlList.Items) == 0 {
+	if len(wls.Items) == 0 {
 		return nil, nil
 	}
 
 	// In theory the job can own multiple Workloads, we cannot do too much about it, maybe log it.
-	if len(wlList.Items) > 1 {
+	if len(wls.Items) > 1 {
 		ctrl.LoggerFrom(ctx).V(2).Info(
 			"WARNING: The job has multiple associated Workloads",
 			"job", klog.KObj(jobObj),
-			"workloads", klog.KObjSlice(wlList.Items),
+			"workloads", klog.KObjSlice(wls.Items),
 		)
 	}
 
-	return &wlList.Items[0], nil
+	return &wls.Items[0], nil
 }
 
 // FindAncestorJobManagedByKueue traverses controllerRefs to find the top-level ancestor Job managed by Kueue.
@@ -712,7 +712,7 @@ func FindAncestorJobManagedByKueue(ctx context.Context, c client.Client, jobObj
 		if seen.Has(currentObj.GetUID()) {
 			log.Error(ErrCyclicOwnership,
 				"Terminated search for Kueue-managed Job because of cyclic ownership",
-				"owner", currentObj,
+				"currentObj", currentObj,
 			)
 			return nil, ErrCyclicOwnership
 		}
@@ -720,12 +720,16 @@ func FindAncestorJobManagedByKueue(ctx context.Context, c client.Client, jobObj
 
 		owner := metav1.GetControllerOf(currentObj)
 		if owner == nil {
-			log.V(3).Info("stop walking up as the owner is not found", "owner", klog.KObj(currentObj))
+			log.V(3).Info("stop walking up as the owner is not found", "currentObj", klog.KObj(currentObj))
 			return topLevelJob, nil
 		}
 
 		if !manager.isKnownOwner(owner) {
-			log.V(3).Info("stop walking up as the owner is not known", "owner", klog.KObj(currentObj))
+			log.V(3).Info(
+				"stop walking up as the owner is not known",
+				"currentObj", klog.KObj(currentObj),
+				"owner", klog.KRef(jobObj.GetNamespace(), owner.Name),
+			)
 			return topLevelJob, nil
 		}
 		parentObj := getEmptyOwnerObject(owner)
diff --git a/pkg/controller/jobframework/tas.go b/pkg/controller/jobframework/tas.go
index dedf11ca7..e921df89f 100644
--- a/pkg/controller/jobframework/tas.go
+++ b/pkg/controller/jobframework/tas.go
@@ -27,36 +27,37 @@ import (
 )
 
 type podSetTopologyRequestBuilder struct {
-	request *kueue.PodSetTopologyRequest
-}
-
-func (p *podSetTopologyRequestBuilder) Build() *kueue.PodSetTopologyRequest {
-	return p.request
+	podIndexLabel      *string
+	subGroupIndexLabel *string
+	subGroupCount      *int32
+	meta               *metav1.ObjectMeta
 }
 
 func (p *podSetTopologyRequestBuilder) PodIndexLabel(podIndexLabel *string) *podSetTopologyRequestBuilder {
-	if p.request != nil {
-		p.request.PodIndexLabel = podIndexLabel
-	}
+	p.podIndexLabel = podIndexLabel
 	return p
 }
 
 func (p *podSetTopologyRequestBuilder) SubGroup(subGroupIndexLabel *string, subGroupCount *int32) *podSetTopologyRequestBuilder {
-	if p.request != nil {
-		p.request.SubGroupIndexLabel = subGroupIndexLabel
-		p.request.SubGroupCount = subGroupCount
-	}
+	p.subGroupIndexLabel = subGroupIndexLabel
+	p.subGroupCount = subGroupCount
 	return p
 }
 
 func NewPodSetTopologyRequest(meta *metav1.ObjectMeta) *podSetTopologyRequestBuilder {
-	psTopologyReq := &kueue.PodSetTopologyRequest{}
-	requiredValue, requiredFound := meta.Annotations[kueuealpha.PodSetRequiredTopologyAnnotation]
-	preferredValue, preferredFound := meta.Annotations[kueuealpha.PodSetPreferredTopologyAnnotation]
-	unconstrained, unconstrainedFound := meta.Annotations[kueuealpha.PodSetUnconstrainedTopologyAnnotation]
+	return &podSetTopologyRequestBuilder{
+		meta: meta,
+	}
+}
+
+func (p *podSetTopologyRequestBuilder) Build() (*kueue.PodSetTopologyRequest, error) {
+	psTopologyReq := kueue.PodSetTopologyRequest{}
+	requiredValue, requiredFound := p.meta.Annotations[kueuealpha.PodSetRequiredTopologyAnnotation]
+	preferredValue, preferredFound := p.meta.Annotations[kueuealpha.PodSetPreferredTopologyAnnotation]
+	unconstrained, unconstrainedFound := p.meta.Annotations[kueuealpha.PodSetUnconstrainedTopologyAnnotation]
 
-	sliceRequiredTopologyValue, sliceRequiredTopologyFound := meta.Annotations[kueuealpha.PodSetSliceRequiredTopologyAnnotation]
-	sliceSizeValue, sliceSizeFound := meta.Annotations[kueuealpha.PodSetSliceSizeAnnotation]
+	sliceRequiredTopologyValue, sliceRequiredTopologyFound := p.meta.Annotations[kueuealpha.PodSetSliceRequiredTopologyAnnotation]
+	sliceSizeValue, sliceSizeFound := p.meta.Annotations[kueuealpha.PodSetSliceSizeAnnotation]
 
 	switch {
 	case requiredFound:
@@ -64,22 +65,28 @@ func NewPodSetTopologyRequest(meta *metav1.ObjectMeta) *podSetTopologyRequestBui
 	case preferredFound:
 		psTopologyReq.Preferred = &preferredValue
 	case unconstrainedFound:
-		unconstrained, _ := strconv.ParseBool(unconstrained)
+		unconstrained, err := strconv.ParseBool(unconstrained)
+		if err != nil {
+			return nil, err
+		}
 		psTopologyReq.Unconstrained = &unconstrained
 	default:
-		psTopologyReq = nil
+		return nil, nil
 	}
 
 	if sliceRequiredTopologyFound && sliceSizeFound {
 		sliceSizeIntValue, err := strconv.ParseInt(sliceSizeValue, 10, 32)
 		if err != nil {
-			// silently ignore as it should not happen due to earlier validation in a webhook
+			return nil, err
 		} else {
 			psTopologyReq.PodSetSliceRequiredTopology = &sliceRequiredTopologyValue
 			psTopologyReq.PodSetSliceSize = ptr.To(int32(sliceSizeIntValue))
 		}
 	}
 
-	builder := &podSetTopologyRequestBuilder{request: psTopologyReq}
-	return builder
+	psTopologyReq.PodIndexLabel = p.podIndexLabel
+	psTopologyReq.SubGroupCount = p.subGroupCount
+	psTopologyReq.SubGroupIndexLabel = p.subGroupIndexLabel
+
+	return &psTopologyReq, nil
 }
diff --git a/pkg/controller/jobframework/tas_validation.go b/pkg/controller/jobframework/tas_validation.go
index 0a2ce57a6..e54a8b01d 100644
--- a/pkg/controller/jobframework/tas_validation.go
+++ b/pkg/controller/jobframework/tas_validation.go
@@ -76,9 +76,6 @@ func ValidateTASPodSetRequest(replicaPath *field.Path, replicaMetadata *metav1.O
 
 	// validate slice annotations
 	if sliceRequiredFound {
-		if !requiredFound && !preferredFound {
-			allErrs = append(allErrs, field.Forbidden(annotationsPath.Key(kueuealpha.PodSetSliceRequiredTopologyAnnotation), "can be used with required or preferred topology only"))
-		}
 		if !sliceSizeFound {
 			allErrs = append(allErrs, field.Required(annotationsPath.Key(kueuealpha.PodSetSliceSizeAnnotation), "slice size is required if slice topology is requested"))
 		}
diff --git a/pkg/controller/jobs/appwrapper/appwrapper_controller.go b/pkg/controller/jobs/appwrapper/appwrapper_controller.go
index 2c6300673..c3c7c6fc7 100644
--- a/pkg/controller/jobs/appwrapper/appwrapper_controller.go
+++ b/pkg/controller/jobs/appwrapper/appwrapper_controller.go
@@ -147,9 +147,13 @@ func (j *AppWrapper) PodSets() ([]kueue.PodSet, error) {
 			Count:    awutils.Replicas(awPodSets[psIndex]),
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSets[psIndex].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&(podSpecTemplates[psIndex].ObjectMeta)).
 				PodIndexLabel(podIndexLabel).SubGroup(subGroupIndexLabel, subGroupCount).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSets[psIndex].TopologyRequest = topologyRequest
 		}
 	}
 	return podSets, nil
diff --git a/pkg/controller/jobs/job/job_controller.go b/pkg/controller/jobs/job/job_controller.go
index 30a0704d9..c8cc26495 100644
--- a/pkg/controller/jobs/job/job_controller.go
+++ b/pkg/controller/jobs/job/job_controller.go
@@ -251,9 +251,13 @@ func (j *Job) PodSets() ([]kueue.PodSet, error) {
 		MinCount: j.minPodsCount(),
 	}
 	if features.Enabled(features.TopologyAwareScheduling) {
-		podSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(
+		topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 			&j.Spec.Template.ObjectMeta).PodIndexLabel(
 			ptr.To(batchv1.JobCompletionIndexAnnotation)).Build()
+		if err != nil {
+			return nil, err
+		}
+		podSet.TopologyRequest = topologyRequest
 	}
 	return []kueue.PodSet{
 		podSet,
diff --git a/pkg/controller/jobs/jobset/jobset_controller.go b/pkg/controller/jobs/jobset/jobset_controller.go
index b84cad3a0..57a44a929 100644
--- a/pkg/controller/jobs/jobset/jobset_controller.go
+++ b/pkg/controller/jobs/jobset/jobset_controller.go
@@ -120,11 +120,15 @@ func (j *JobSet) PodSets() ([]kueue.PodSet, error) {
 			Count:    podsCount(&replicatedJob),
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSets[index].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&replicatedJob.Template.Spec.Template.ObjectMeta).PodIndexLabel(
 				ptr.To(batchv1.JobCompletionIndexAnnotation)).SubGroup(
 				ptr.To(jobsetapi.JobIndexKey),
 				ptr.To(replicatedJob.Replicas)).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSets[index].TopologyRequest = topologyRequest
 		}
 	}
 	return podSets, nil
diff --git a/pkg/controller/jobs/kubeflow/kubeflowjob/kubeflowjob_controller.go b/pkg/controller/jobs/kubeflow/kubeflowjob/kubeflowjob_controller.go
index 2cbe58dab..1e2885068 100644
--- a/pkg/controller/jobs/kubeflow/kubeflowjob/kubeflowjob_controller.go
+++ b/pkg/controller/jobs/kubeflow/kubeflowjob/kubeflowjob_controller.go
@@ -108,9 +108,13 @@ func (j *KubeflowJob) PodSets() ([]kueue.PodSet, error) {
 			Count:    podsCount(j.KFJobControl.ReplicaSpecs(), replicaType),
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSets[index].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&j.KFJobControl.ReplicaSpecs()[replicaType].Template.ObjectMeta).PodIndexLabel(
 				ptr.To(kftraining.ReplicaIndexLabel)).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSets[index].TopologyRequest = topologyRequest
 		}
 	}
 	return podSets, nil
diff --git a/pkg/controller/jobs/leaderworkerset/leaderworkerset_reconciler.go b/pkg/controller/jobs/leaderworkerset/leaderworkerset_reconciler.go
index cce69b451..872f55287 100644
--- a/pkg/controller/jobs/leaderworkerset/leaderworkerset_reconciler.go
+++ b/pkg/controller/jobs/leaderworkerset/leaderworkerset_reconciler.go
@@ -184,14 +184,18 @@ func (r *Reconciler) createPrebuiltWorkload(ctx context.Context, lws *leaderwork
 }
 
 func (r *Reconciler) constructWorkload(lws *leaderworkersetv1.LeaderWorkerSet, workloadName string) (*kueue.Workload, error) {
-	createdWorkload := podcontroller.NewGroupWorkload(workloadName, lws, r.podSets(lws), r.labelKeysToCopy)
+	podSets, err := r.podSets(lws)
+	if err != nil {
+		return nil, err
+	}
+	createdWorkload := podcontroller.NewGroupWorkload(workloadName, lws, podSets, r.labelKeysToCopy)
 	if err := controllerutil.SetOwnerReference(lws, createdWorkload, r.client.Scheme()); err != nil {
 		return nil, err
 	}
 	return createdWorkload, nil
 }
 
-func (r *Reconciler) podSets(lws *leaderworkersetv1.LeaderWorkerSet) []kueue.PodSet {
+func (r *Reconciler) podSets(lws *leaderworkersetv1.LeaderWorkerSet) ([]kueue.PodSet, error) {
 	podSets := make([]kueue.PodSet, 0, 2)
 
 	if lws.Spec.LeaderWorkerTemplate.LeaderTemplate != nil {
@@ -203,8 +207,12 @@ func (r *Reconciler) podSets(lws *leaderworkersetv1.LeaderWorkerSet) []kueue.Pod
 			},
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&lws.Spec.LeaderWorkerTemplate.LeaderTemplate.ObjectMeta).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSet.TopologyRequest = topologyRequest
 		}
 		podSets = append(podSets, podSet)
 	}
@@ -228,14 +236,18 @@ func (r *Reconciler) podSets(lws *leaderworkersetv1.LeaderWorkerSet) []kueue.Pod
 	}
 
 	if features.Enabled(features.TopologyAwareScheduling) {
-		podSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(
+		topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 			&lws.Spec.LeaderWorkerTemplate.WorkerTemplate.ObjectMeta).PodIndexLabel(
 			ptr.To(leaderworkersetv1.WorkerIndexLabelKey)).Build()
+		if err != nil {
+			return nil, err
+		}
+		podSet.TopologyRequest = topologyRequest
 	}
 
 	podSets = append(podSets, podSet)
 
-	return podSets
+	return podSets, nil
 }
 
 func (r *Reconciler) removeOwnerReference(ctx context.Context, lws *leaderworkersetv1.LeaderWorkerSet, wl *kueue.Workload) error {
diff --git a/pkg/controller/jobs/mpijob/mpijob_controller.go b/pkg/controller/jobs/mpijob/mpijob_controller.go
index be604d498..c752c310d 100644
--- a/pkg/controller/jobs/mpijob/mpijob_controller.go
+++ b/pkg/controller/jobs/mpijob/mpijob_controller.go
@@ -119,9 +119,13 @@ func (j *MPIJob) PodSets() ([]kueue.PodSet, error) {
 			Count:    podsCount(&j.Spec, mpiReplicaType),
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSets[index].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&j.Spec.MPIReplicaSpecs[mpiReplicaType].Template.ObjectMeta).PodIndexLabel(
 				ptr.To(kfmpi.ReplicaIndexLabel)).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSets[index].TopologyRequest = topologyRequest
 		}
 	}
 	return podSets, nil
diff --git a/pkg/controller/jobs/pod/pod_controller.go b/pkg/controller/jobs/pod/pod_controller.go
index 3133daa0c..b3857a2f6 100644
--- a/pkg/controller/jobs/pod/pod_controller.go
+++ b/pkg/controller/jobs/pod/pod_controller.go
@@ -385,7 +385,7 @@ func (p *Pod) Finished() (message string, success, finished bool) {
 // PodSets will build workload podSets corresponding to the job.
 func (p *Pod) PodSets() ([]kueue.PodSet, error) {
 	if !p.isGroup {
-		return constructPodSets(&p.pod), nil
+		return constructPodSets(&p.pod)
 	} else {
 		return p.constructGroupPodSets()
 	}
@@ -642,13 +642,17 @@ func (p *Pod) constructGroupPodSets() ([]kueue.PodSet, error) {
 	return constructGroupPodSets(p.list.Items)
 }
 
-func constructPodSets(p *corev1.Pod) []kueue.PodSet {
-	return []kueue.PodSet{
-		constructPodSet(p),
+func constructPodSets(p *corev1.Pod) ([]kueue.PodSet, error) {
+	podSet, err := constructPodSet(p)
+	if err != nil {
+		return nil, err
 	}
+	return []kueue.PodSet{
+		podSet,
+	}, nil
 }
 
-func constructPodSet(p *corev1.Pod) kueue.PodSet {
+func constructPodSet(p *corev1.Pod) (kueue.PodSet, error) {
 	podSet := kueue.PodSet{
 		Name:  kueue.DefaultPodSetName,
 		Count: 1,
@@ -657,11 +661,15 @@ func constructPodSet(p *corev1.Pod) kueue.PodSet {
 		},
 	}
 	if features.Enabled(features.TopologyAwareScheduling) {
-		podSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(
+		topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 			&p.ObjectMeta).PodIndexLabel(
 			ptr.To(kueuealpha.PodGroupPodIndexLabel)).Build()
+		if err != nil {
+			return kueue.PodSet{}, err
+		}
+		podSet.TopologyRequest = topologyRequest
 	}
-	return podSet
+	return podSet, nil
 }
 
 func constructGroupPodSetsFast(pods []corev1.Pod, groupTotalCount int) ([]kueue.PodSet, error) {
@@ -673,7 +681,10 @@ func constructGroupPodSetsFast(pods []corev1.Pod, groupTotalCount int) ([]kueue.
 		if err != nil {
 			return nil, fmt.Errorf("failed to calculate pod role hash: %w", err)
 		}
-		podSets := constructPodSets(&podInGroup)
+		podSets, err := constructPodSets(&podInGroup)
+		if err != nil {
+			return nil, err
+		}
 		podSets[0].Name = kueue.NewPodSetReference(roleHash)
 		podSets[0].Count = int32(groupTotalCount)
 		return podSets, nil
@@ -705,7 +716,10 @@ func constructGroupPodSets(pods []corev1.Pod) ([]kueue.PodSet, error) {
 		}
 
 		if !podRoleFound {
-			podSet := constructPodSet(&podInGroup)
+			podSet, err := constructPodSet(&podInGroup)
+			if err != nil {
+				return nil, err
+			}
 			podSet.Name = kueue.NewPodSetReference(roleHash)
 
 			resultPodSets = append(resultPodSets, podSet)
diff --git a/pkg/controller/jobs/raycluster/raycluster_controller.go b/pkg/controller/jobs/raycluster/raycluster_controller.go
index 3a7dde7b1..baf700805 100644
--- a/pkg/controller/jobs/raycluster/raycluster_controller.go
+++ b/pkg/controller/jobs/raycluster/raycluster_controller.go
@@ -113,8 +113,12 @@ func (j *RayCluster) PodSets() ([]kueue.PodSet, error) {
 	}
 
 	if features.Enabled(features.TopologyAwareScheduling) {
-		podSets[0].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+		topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 			&j.Spec.HeadGroupSpec.Template.ObjectMeta).Build()
+		if err != nil {
+			return nil, err
+		}
+		podSets[0].TopologyRequest = topologyRequest
 	}
 
 	// workers
@@ -133,8 +137,12 @@ func (j *RayCluster) PodSets() ([]kueue.PodSet, error) {
 			Count:    count,
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			podSets[index+1].TopologyRequest = jobframework.NewPodSetTopologyRequest(
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 				&wgs.Template.ObjectMeta).Build()
+			if err != nil {
+				return nil, err
+			}
+			podSets[index+1].TopologyRequest = topologyRequest
 		}
 	}
 	return podSets, nil
diff --git a/pkg/controller/jobs/rayjob/rayjob_controller.go b/pkg/controller/jobs/rayjob/rayjob_controller.go
index 38cf765cb..2c2f39fd0 100644
--- a/pkg/controller/jobs/rayjob/rayjob_controller.go
+++ b/pkg/controller/jobs/rayjob/rayjob_controller.go
@@ -121,8 +121,12 @@ func (j *RayJob) PodSets() ([]kueue.PodSet, error) {
 		Count:    1,
 	}
 	if features.Enabled(features.TopologyAwareScheduling) {
-		headPodSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(
+		topologyRequest, err := jobframework.NewPodSetTopologyRequest(
 			&j.Spec.RayClusterSpec.HeadGroupSpec.Template.ObjectMeta).Build()
+		if err != nil {
+			return nil, err
+		}
+		headPodSet.TopologyRequest = topologyRequest
 	}
 	podSets = append(podSets, headPodSet)
 
@@ -142,7 +146,11 @@ func (j *RayJob) PodSets() ([]kueue.PodSet, error) {
 			Count:    count,
 		}
 		if features.Enabled(features.TopologyAwareScheduling) {
-			workerPodSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(&wgs.Template.ObjectMeta).Build()
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(&wgs.Template.ObjectMeta).Build()
+			if err != nil {
+				return nil, err
+			}
+			workerPodSet.TopologyRequest = topologyRequest
 		}
 		podSets = append(podSets, workerPodSet)
 	}
@@ -158,7 +166,11 @@ func (j *RayJob) PodSets() ([]kueue.PodSet, error) {
 		// Create the TopologyRequest for the Submitter Job PodSet, based on the annotations
 		// in rayJob.Spec.SubmitterPodTemplate, which can be specified by the user.
 		if features.Enabled(features.TopologyAwareScheduling) {
-			submitterJobPodSet.TopologyRequest = jobframework.NewPodSetTopologyRequest(&submitterJobPodSet.Template.ObjectMeta).Build()
+			topologyRequest, err := jobframework.NewPodSetTopologyRequest(&submitterJobPodSet.Template.ObjectMeta).Build()
+			if err != nil {
+				return nil, err
+			}
+			submitterJobPodSet.TopologyRequest = topologyRequest
 		}
 		podSets = append(podSets, submitterJobPodSet)
 	}
diff --git a/pkg/queue/cluster_queue.go b/pkg/queue/cluster_queue.go
index a5cd1eb32..a02040636 100644
--- a/pkg/queue/cluster_queue.go
+++ b/pkg/queue/cluster_queue.go
@@ -56,12 +56,12 @@ var (
 type ClusterQueue struct {
 	hierarchy.ClusterQueue[*cohort]
 	name              kueue.ClusterQueueReference
-	heap              heap.Heap[workload.Info, workload.WorkloadReference]
+	heap              heap.Heap[workload.Info, workload.Reference]
 	namespaceSelector labels.Selector
 	active            bool
 
 	// inadmissibleWorkloads are workloads that have been tried at least once and couldn't be admitted.
-	inadmissibleWorkloads map[workload.WorkloadReference]*workload.Info
+	inadmissibleWorkloads map[workload.Reference]*workload.Info
 
 	// popCycle identifies the last call to Pop. It's incremented when calling Pop.
 	// popCycle and queueInadmissibleCycle are used to track when there is a requeuing
@@ -88,7 +88,7 @@ func (c *ClusterQueue) GetName() kueue.ClusterQueueReference {
 	return c.name
 }
 
-func workloadKey(i *workload.Info) workload.WorkloadReference {
+func workloadKey(i *workload.Info) workload.Reference {
 	return workload.Key(i.Obj)
 }
 
@@ -115,7 +115,7 @@ func newClusterQueueImpl(ctx context.Context, client client.Client, wo workload.
 	lessFunc := queueOrderingFunc(ctx, client, wo, fsResWeights, enableAdmissionFs)
 	return &ClusterQueue{
 		heap:                   *heap.New(workloadKey, lessFunc),
-		inadmissibleWorkloads:  make(map[workload.WorkloadReference]*workload.Info),
+		inadmissibleWorkloads:  make(map[workload.Reference]*workload.Info),
 		queueInadmissibleCycle: -1,
 		lessFunc:               lessFunc,
 		rwm:                    sync.RWMutex{},
@@ -274,7 +274,7 @@ func (c *ClusterQueue) requeueIfNotPresent(wInfo *workload.Info, immediate bool)
 	return true
 }
 
-func (c *ClusterQueue) forgetInflightByKey(key workload.WorkloadReference) {
+func (c *ClusterQueue) forgetInflightByKey(key workload.Reference) {
 	if c.inflight != nil && workload.Key(c.inflight.Obj) == key {
 		c.inflight = nil
 	}
@@ -290,7 +290,7 @@ func (c *ClusterQueue) QueueInadmissibleWorkloads(ctx context.Context, client cl
 		return false
 	}
 
-	inadmissibleWorkloads := make(map[workload.WorkloadReference]*workload.Info)
+	inadmissibleWorkloads := make(map[workload.Reference]*workload.Info)
 	moved := false
 	for key, wInfo := range c.inadmissibleWorkloads {
 		ns := corev1.Namespace{}
@@ -347,26 +347,26 @@ func (c *ClusterQueue) Pop() *workload.Info {
 // 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.
-func (c *ClusterQueue) Dump() ([]workload.WorkloadReference, bool) {
+func (c *ClusterQueue) Dump() ([]workload.Reference, bool) {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	if c.heap.Len() == 0 {
 		return nil, false
 	}
-	elements := make([]workload.WorkloadReference, c.heap.Len())
+	elements := make([]workload.Reference, c.heap.Len())
 	for i, info := range c.heap.List() {
 		elements[i] = workload.Key(info.Obj)
 	}
 	return elements, true
 }
 
-func (c *ClusterQueue) DumpInadmissible() ([]workload.WorkloadReference, bool) {
+func (c *ClusterQueue) DumpInadmissible() ([]workload.Reference, bool) {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	if len(c.inadmissibleWorkloads) == 0 {
 		return nil, false
 	}
-	elements := make([]workload.WorkloadReference, 0, len(c.inadmissibleWorkloads))
+	elements := make([]workload.Reference, 0, len(c.inadmissibleWorkloads))
 	for _, info := range c.inadmissibleWorkloads {
 		elements = append(elements, workload.Key(info.Obj))
 	}
@@ -385,7 +385,7 @@ func (c *ClusterQueue) Snapshot() []*workload.Info {
 
 // Info returns workload.Info for the workload key.
 // Users of this method should not modify the returned object.
-func (c *ClusterQueue) Info(key workload.WorkloadReference) *workload.Info {
+func (c *ClusterQueue) Info(key workload.Reference) *workload.Info {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	return c.heap.GetByKey(key)
diff --git a/pkg/queue/dumper.go b/pkg/queue/dumper.go
index 647003e64..bda4bf4e6 100644
--- a/pkg/queue/dumper.go
+++ b/pkg/queue/dumper.go
@@ -41,14 +41,14 @@ func (m *Manager) LogDump(log logr.Logger) {
 
 // Dump is a dump of the queues and it's elements (unordered).
 // Only use for testing purposes.
-func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.WorkloadReference {
+func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.Reference {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]workload.Reference, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.Dump(); ok {
 			dump[key] = elements
@@ -62,14 +62,14 @@ func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.WorkloadRefe
 
 // DumpInadmissible is a dump of the inadmissible workloads list.
 // Only use for testing purposes.
-func (m *Manager) DumpInadmissible() map[kueue.ClusterQueueReference][]workload.WorkloadReference {
+func (m *Manager) DumpInadmissible() map[kueue.ClusterQueueReference][]workload.Reference {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]workload.Reference, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.DumpInadmissible(); ok {
 			dump[key] = elements
diff --git a/pkg/queue/local_queue.go b/pkg/queue/local_queue.go
index fecb283e6..315a62ee8 100644
--- a/pkg/queue/local_queue.go
+++ b/pkg/queue/local_queue.go
@@ -66,13 +66,13 @@ type LocalQueue struct {
 	Key          LocalQueueReference
 	ClusterQueue kueue.ClusterQueueReference
 
-	items map[workload.WorkloadReference]*workload.Info
+	items map[workload.Reference]*workload.Info
 }
 
 func newLocalQueue(q *kueue.LocalQueue) *LocalQueue {
 	qImpl := &LocalQueue{
 		Key:   Key(q),
-		items: make(map[workload.WorkloadReference]*workload.Info),
+		items: make(map[workload.Reference]*workload.Info),
 	}
 	qImpl.update(q)
 	return qImpl
diff --git a/pkg/queue/second_pass_queue.go b/pkg/queue/second_pass_queue.go
index abb2dc71d..c783a92eb 100644
--- a/pkg/queue/second_pass_queue.go
+++ b/pkg/queue/second_pass_queue.go
@@ -28,14 +28,14 @@ import (
 type secondPassQueue struct {
 	sync.RWMutex
 
-	prequeued sets.Set[workload.WorkloadReference]
-	queued    map[workload.WorkloadReference]*workload.Info
+	prequeued sets.Set[workload.Reference]
+	queued    map[workload.Reference]*workload.Info
 }
 
 func newSecondPassQueue() *secondPassQueue {
 	return &secondPassQueue{
-		prequeued: sets.New[workload.WorkloadReference](),
-		queued:    make(map[workload.WorkloadReference]*workload.Info),
+		prequeued: sets.New[workload.Reference](),
+		queued:    make(map[workload.Reference]*workload.Info),
 	}
 }
 
@@ -47,7 +47,7 @@ func (q *secondPassQueue) takeAllReady() []workload.Info {
 	for _, v := range q.queued {
 		result = append(result, *v)
 	}
-	q.queued = make(map[workload.WorkloadReference]*workload.Info)
+	q.queued = make(map[workload.Reference]*workload.Info)
 	return result
 }
 
@@ -71,7 +71,7 @@ func (q *secondPassQueue) queue(w *workload.Info) bool {
 	return enqueued
 }
 
-func (q *secondPassQueue) deleteByKey(key workload.WorkloadReference) {
+func (q *secondPassQueue) deleteByKey(key workload.Reference) {
 	q.Lock()
 	defer q.Unlock()
 
diff --git a/pkg/scheduler/fair_sharing_iterator.go b/pkg/scheduler/fair_sharing_iterator.go
index 56f257954..799e4f386 100644
--- a/pkg/scheduler/fair_sharing_iterator.go
+++ b/pkg/scheduler/fair_sharing_iterator.go
@@ -156,7 +156,7 @@ func runTournament(cohort *cache.CohortSnapshot, ec entryComparer, cqToEntry map
 
 type drsKey struct {
 	parentCohort kueue.CohortReference
-	workloadKey  workload.WorkloadReference
+	workloadKey  workload.Reference
 }
 
 type entryComparer struct {
diff --git a/pkg/scheduler/flavorassigner/flavorassigner.go b/pkg/scheduler/flavorassigner/flavorassigner.go
index 556d5a960..2f42c0b33 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner.go
@@ -746,7 +746,7 @@ func (a *FlavorAssigner) fitsResourceQuota(log logr.Logger, fr resources.FlavorR
 		if preemptionPossibility == preemptioncommon.Reclaim {
 			mode = reclaim
 		}
-	} else if a.canPreemptWhileBorrowing() && (preemptionPossibility != preemptioncommon.None) {
+	} else if a.canPreemptWhileBorrowing() && (preemptionPossibility != preemptioncommon.NoCandidates) {
 		mode = preempt
 	}
 
diff --git a/pkg/scheduler/preemption/preempted_workloads.go b/pkg/scheduler/preemption/preempted_workloads.go
index 666fd163b..5d9ab2b8c 100644
--- a/pkg/scheduler/preemption/preempted_workloads.go
+++ b/pkg/scheduler/preemption/preempted_workloads.go
@@ -20,7 +20,7 @@ import (
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
-type PreemptedWorkloads map[workload.WorkloadReference]*workload.Info
+type PreemptedWorkloads map[workload.Reference]*workload.Info
 
 func (p PreemptedWorkloads) HasAny(newTargets []*Target) bool {
 	for _, target := range newTargets {
diff --git a/pkg/scheduler/preemption/preemption_oracle.go b/pkg/scheduler/preemption/preemption_oracle.go
index 8514672c8..0ba55690f 100644
--- a/pkg/scheduler/preemption/preemption_oracle.go
+++ b/pkg/scheduler/preemption/preemption_oracle.go
@@ -47,11 +47,11 @@ func (p *PreemptionOracle) SimulatePreemption(log logr.Logger, cq *cache.Cluster
 		workloadUsage:     workload.Usage{Quota: resources.FlavorResourceQuantities{fr: quantity}},
 	})
 	if len(candidates) == 0 {
-		return preemptioncommon.None
+		return preemptioncommon.NoCandidates
 	}
 	for _, candidate := range candidates {
 		if candidate.WorkloadInfo.ClusterQueue == cq.Name {
-			return preemptioncommon.PriorityBased
+			return preemptioncommon.Preempt
 		}
 	}
 	return preemptioncommon.Reclaim
diff --git a/pkg/scheduler/preemption/preemptioncommon/types.go b/pkg/scheduler/preemption/preemptioncommon/types.go
index e34a0bd32..1dfa93097 100644
--- a/pkg/scheduler/preemption/preemptioncommon/types.go
+++ b/pkg/scheduler/preemption/preemptioncommon/types.go
@@ -16,17 +16,17 @@ limitations under the License.
 
 package preemptioncommon
 
+// PreemptionPossibility represents the result
+// of a preemption simulation.
 type PreemptionPossibility int
 
-// Preemption Oracle returns one of three possible
-// results of the preemption simulation.
 const (
-	// Preemption in the given resource flavor is
-	// impossible
-	None PreemptionPossibility = iota
-	// Priority-based preemption may be possible
-	// but reclaim is impossible
-	PriorityBased
-	// Reclaim may be possible
+	// NoCandidates were found.
+	NoCandidates PreemptionPossibility = iota
+	// Preemption targets were found.
+	Preempt
+	// Preemption targets were found, and
+	// all of them are outside of preempting
+	// ClusterQueue.
 	Reclaim
 )
diff --git a/pkg/workload/workload.go b/pkg/workload/workload.go
index 164e38014..953dc2c90 100644
--- a/pkg/workload/workload.go
+++ b/pkg/workload/workload.go
@@ -69,11 +69,11 @@ var (
 	}
 )
 
-// WorkloadReference is the full reference to Workload formed as <namespace>/< kueue.WorkloadName >.
-type WorkloadReference string
+// Reference is the full reference to Workload formed as <namespace>/< kueue.WorkloadName >.
+type Reference string
 
-func NewWorkloadReference(namespace, name string) WorkloadReference {
-	return WorkloadReference(namespace + "/" + name)
+func NewReference(namespace, name string) Reference {
+	return Reference(namespace + "/" + name)
 }
 
 func Status(w *kueue.Workload) string {
@@ -393,8 +393,8 @@ func CanBePartiallyAdmitted(wl *kueue.Workload) bool {
 	return false
 }
 
-func Key(w *kueue.Workload) WorkloadReference {
-	return NewWorkloadReference(w.Namespace, w.Name)
+func Key(w *kueue.Workload) Reference {
+	return NewReference(w.Namespace, w.Name)
 }
 
 func reclaimableCounts(wl *kueue.Workload) map[kueue.PodSetReference]int32 {



Test patch:
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index 102f96553..3d2c7de9c 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -460,7 +460,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:     active,
 					Preemption: defaultPreemption,
 					FairWeight: oneQuantity,
-					Workloads: map[workload.WorkloadReference]*workload.Info{
+					Workloads: map[workload.Reference]*workload.Info{
 						"/one": {
 							Obj: utiltesting.MakeWorkload("one", "").
 								Request(corev1.ResourceCPU, "5").
@@ -895,7 +895,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 							{Flavor: "f1", Resource: corev1.ResourceCPU}: 2000,
 						},
 					},
-					Workloads: map[workload.WorkloadReference]*workload.Info{
+					Workloads: map[workload.Reference]*workload.Info{
 						"ns/reserving": {
 							ClusterQueue: "cq1",
 							TotalRequests: []workload.PodSetResources{
@@ -1195,7 +1195,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		}).Obj())
 
 	type result struct {
-		Workloads     sets.Set[workload.WorkloadReference]
+		Workloads     sets.Set[workload.Reference]
 		UsedResources resources.FlavorResourceQuantities
 	}
 
@@ -1203,7 +1203,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		name                 string
 		operation            func(log logr.Logger, cache *Cache) error
 		wantResults          map[kueue.ClusterQueueReference]result
-		wantAssumedWorkloads map[workload.WorkloadReference]kueue.ClusterQueueReference
+		wantAssumedWorkloads map[workload.Reference]kueue.ClusterQueueReference
 		wantError            string
 		wantLocalQueue       queue.LocalQueueReference
 	}{
@@ -1227,14 +1227,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/d"),
+					Workloads: sets.New[workload.Reference]("/c", "/d"),
 				},
 			},
 		},
@@ -1252,14 +1252,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "failed to add workload",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1276,14 +1276,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1301,14 +1301,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/c"),
+					Workloads: sets.New[workload.Reference]("/a", "/c"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
@@ -1330,14 +1330,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "old ClusterQueue doesn't exist",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1355,14 +1355,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "new ClusterQueue doesn't exist",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1379,14 +1379,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/d"),
+					Workloads: sets.New[workload.Reference]("/c", "/d"),
 				},
 			},
 		},
@@ -1400,14 +1400,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1419,14 +1419,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1439,14 +1439,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1461,14 +1461,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1482,14 +1482,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1515,21 +1515,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b", "/d"),
+					Workloads: sets.New[workload.Reference]("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 20,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      30,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/d": "one",
 				"/e": "two",
 			},
@@ -1548,17 +1548,17 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{},
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{},
 		},
 		{
 			name: "forget",
@@ -1584,21 +1584,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1616,14 +1616,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "the workload is not assumed",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1654,21 +1654,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b", "/d"),
+					Workloads: sets.New[workload.Reference]("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 20,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      30,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1699,7 +1699,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				t.Errorf("Unexpected clusterQueues (-want,+got):\n%s", diff)
 			}
 			if step.wantAssumedWorkloads == nil {
-				step.wantAssumedWorkloads = map[workload.WorkloadReference]kueue.ClusterQueueReference{}
+				step.wantAssumedWorkloads = map[workload.Reference]kueue.ClusterQueueReference{}
 			}
 			if diff := cmp.Diff(step.wantAssumedWorkloads, cache.assumedWorkloads); diff != "" {
 				t.Errorf("Unexpected assumed workloads (-want,+got):\n%s", diff)
@@ -3204,13 +3204,13 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 	tests := []struct {
 		name             string
 		clusterQueues    map[string]*clusterQueue
-		assumedWorkloads map[workload.WorkloadReference]kueue.ClusterQueueReference
+		assumedWorkloads map[workload.Reference]kueue.ClusterQueueReference
 		workload         workload.Info
 		expected         bool
 	}{
 		{
 			name:             "Workload Is Assumed and not Admitted",
-			assumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3227,7 +3227,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace/workload_name": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace/workload_name": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name",
@@ -3253,7 +3253,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace/workload_name": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace/workload_name": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name",
@@ -3262,7 +3262,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 						},
 					}},
 				}},
-			assumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3279,7 +3279,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace2/workload_name2": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace2/workload_name2": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name2",
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/snapshot_test.go
index 16ea5fab5..637dcfee1 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/snapshot_test.go
@@ -76,7 +76,7 @@ func TestSnapshot(t *testing.T) {
 							Status:                        active,
 							FlavorFungibility:             defaultFlavorFungibility,
 							AllocatableResourceGeneration: 1,
-							Workloads: map[workload.WorkloadReference]*workload.Info{
+							Workloads: map[workload.Reference]*workload.Info{
 								"/alpha": workload.NewInfo(
 									utiltesting.MakeWorkload("alpha", "").
 										ReserveQuota(&kueue.Admission{ClusterQueue: "a"}).Obj()),
@@ -90,7 +90,7 @@ func TestSnapshot(t *testing.T) {
 							Status:                        active,
 							FlavorFungibility:             defaultFlavorFungibility,
 							AllocatableResourceGeneration: 1,
-							Workloads: map[workload.WorkloadReference]*workload.Info{
+							Workloads: map[workload.Reference]*workload.Info{
 								"/beta": workload.NewInfo(
 									utiltesting.MakeWorkload("beta", "").
 										ReserveQuota(&kueue.Admission{ClusterQueue: "b"}).Obj()),
@@ -255,7 +255,7 @@ func TestSnapshot(t *testing.T) {
 									},
 								},
 								FlavorFungibility: defaultFlavorFungibility,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -299,7 +299,7 @@ func TestSnapshot(t *testing.T) {
 									},
 								},
 								FlavorFungibility: defaultFlavorFungibility,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/beta": workload.NewInfo(utiltesting.MakeWorkload("beta", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "1").
@@ -380,7 +380,7 @@ func TestSnapshot(t *testing.T) {
 							NamespaceSelector:             labels.Everything(),
 							AllocatableResourceGeneration: 1,
 							Status:                        active,
-							Workloads:                     map[workload.WorkloadReference]*workload.Info{},
+							Workloads:                     map[workload.Reference]*workload.Info{},
 							FlavorFungibility:             defaultFlavorFungibility,
 							Preemption: kueue.ClusterQueuePreemption{
 								ReclaimWithinCohort: kueue.PreemptionPolicyAny,
@@ -405,7 +405,7 @@ func TestSnapshot(t *testing.T) {
 							NamespaceSelector:             labels.Everything(),
 							AllocatableResourceGeneration: 1,
 							Status:                        active,
-							Workloads:                     map[workload.WorkloadReference]*workload.Info{},
+							Workloads:                     map[workload.Reference]*workload.Info{},
 							FlavorFungibility:             defaultFlavorFungibility,
 							Preemption:                    defaultPreemption,
 							FairWeight:                    resource.MustParse("3"),
@@ -504,7 +504,7 @@ func TestSnapshot(t *testing.T) {
 								},
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -659,7 +659,7 @@ func TestSnapshot(t *testing.T) {
 								},
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -999,7 +999,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			t.Fatalf("Couldn't add ClusterQueue to cache: %v", err)
 		}
 	}
-	wlInfos := make(map[workload.WorkloadReference]*workload.Info, len(workloads))
+	wlInfos := make(map[workload.Reference]*workload.Info, len(workloads))
 	for _, cq := range cqCache.hm.ClusterQueues() {
 		for _, wl := range cq.Workloads {
 			wlInfos[workload.Key(wl.Obj)] = wl
@@ -1011,17 +1011,17 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 	}
 	initialCohortResources := initialSnapshot.ClusterQueue("c1").Parent().ResourceNode.SubtreeQuota
 	cases := map[string]struct {
-		remove []workload.WorkloadReference
-		add    []workload.WorkloadReference
+		remove []workload.Reference
+		add    []workload.Reference
 		want   Snapshot
 	}{
 		"no-op remove add": {
-			remove: []workload.WorkloadReference{"/c1-cpu", "/c2-cpu-1"},
-			add:    []workload.WorkloadReference{"/c1-cpu", "/c2-cpu-1"},
+			remove: []workload.Reference{"/c1-cpu", "/c2-cpu-1"},
+			add:    []workload.Reference{"/c1-cpu", "/c2-cpu-1"},
 			want:   *initialSnapshot,
 		},
 		"remove all": {
-			remove: []workload.WorkloadReference{"/c1-cpu", "/c1-memory-alpha", "/c1-memory-beta", "/c2-cpu-1", "/c2-cpu-2"},
+			remove: []workload.Reference{"/c1-cpu", "/c1-memory-alpha", "/c1-memory-beta", "/c2-cpu-1", "/c2-cpu-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1042,7 +1042,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name:              "c1",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("c1").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1061,7 +1061,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name:                          "c2",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("c2").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1081,7 +1081,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			}(),
 		},
 		"remove c1-cpu": {
-			remove: []workload.WorkloadReference{"/c1-cpu"},
+			remove: []workload.Reference{"/c1-cpu"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1102,7 +1102,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c1-memory-alpha": nil,
 									"/c1-memory-beta":  nil,
 								},
@@ -1124,7 +1124,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name: "c2",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c2-cpu-1": nil,
 									"/c2-cpu-2": nil,
 								},
@@ -1147,7 +1147,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			}(),
 		},
 		"remove c1-memory-alpha": {
-			remove: []workload.WorkloadReference{"/c1-memory-alpha"},
+			remove: []workload.Reference{"/c1-memory-alpha"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1168,7 +1168,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c1-memory-alpha": nil,
 									"/c1-memory-beta":  nil,
 								},
@@ -1190,7 +1190,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name: "c2",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c2-cpu-1": nil,
 									"/c2-cpu-2": nil,
 								},
@@ -1293,7 +1293,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			t.Fatalf("Couldn't add ClusterQueue to cache: %v", err)
 		}
 	}
-	wlInfos := make(map[workload.WorkloadReference]*workload.Info, len(workloads))
+	wlInfos := make(map[workload.Reference]*workload.Info, len(workloads))
 	for _, cq := range cqCache.hm.ClusterQueues() {
 		for _, wl := range cq.Workloads {
 			wlInfos[workload.Key(wl.Obj)] = wl
@@ -1305,17 +1305,17 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 	}
 	initialCohortResources := initialSnapshot.ClusterQueue("lend-a").Parent().ResourceNode.SubtreeQuota
 	cases := map[string]struct {
-		remove []workload.WorkloadReference
-		add    []workload.WorkloadReference
+		remove []workload.Reference
+		add    []workload.Reference
 		want   Snapshot
 	}{
 		"remove all then add all": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
 			want:   *initialSnapshot,
 		},
 		"remove all": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1334,7 +1334,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1349,7 +1349,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:              "lend-b",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1368,7 +1368,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove workload, but still using quota over GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1387,7 +1387,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1402,7 +1402,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1422,7 +1422,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove wokload, using same quota as GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1441,7 +1441,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1456,7 +1456,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1476,7 +1476,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove workload, using less quota than GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-2", "/lend-a-3"},
+			remove: []workload.Reference{"/lend-a-2", "/lend-a-3"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1495,7 +1495,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1510,7 +1510,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1530,8 +1530,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using less quota than GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-1"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1550,7 +1550,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1565,7 +1565,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1585,8 +1585,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using same quota as GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-3"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-3"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1605,7 +1605,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1620,7 +1620,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:              "lend-b",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1639,8 +1639,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using quota over GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1659,7 +1659,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1674,7 +1674,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
diff --git a/pkg/cache/tas_cache_test.go b/pkg/cache/tas_cache_test.go
index 186d6e503..e9fd9f133 100644
--- a/pkg/cache/tas_cache_test.go
+++ b/pkg/cache/tas_cache_test.go
@@ -2798,6 +2798,142 @@ func TestFindTopologyAssignment(t *testing.T) {
 			count:      1,
 			wantReason: "no requested topology level for slices: not-existing-topology-level",
 		},
+		"no topology for podset; host required for slices; BestFit": {
+			//        b1
+			//         |
+			//        r1
+			//    /    |    \
+			// x1:3, x2:3, x3:3
+			//
+			nodes: []corev1.Node{
+				*testingnode.MakeNode("b1-r1-x1").
+					Label(tasBlockLabel, "b1").
+					Label(tasRackLabel, "r1").
+					Label(corev1.LabelHostname, "x1").
+					StatusAllocatable(corev1.ResourceList{
+						corev1.ResourceCPU:  resource.MustParse("3"),
+						corev1.ResourcePods: resource.MustParse("10"),
+					}).
+					Ready().
+					Obj(),
+				*testingnode.MakeNode("b1-r1-x2").
+					Label(tasBlockLabel, "b1").
+					Label(tasRackLabel, "r1").
+					Label(corev1.LabelHostname, "x2").
+					StatusAllocatable(corev1.ResourceList{
+						corev1.ResourceCPU:  resource.MustParse("3"),
+						corev1.ResourcePods: resource.MustParse("10"),
+					}).
+					Ready().
+					Obj(),
+				*testingnode.MakeNode("b1-r1-x3").
+					Label(tasBlockLabel, "b1").
+					Label(tasRackLabel, "r1").
+					Label(corev1.LabelHostname, "x3").
+					StatusAllocatable(corev1.ResourceList{
+						corev1.ResourceCPU:  resource.MustParse("3"),
+						corev1.ResourcePods: resource.MustParse("10"),
+					}).
+					Ready().
+					Obj(),
+			},
+			topologyRequest: &kueue.PodSetTopologyRequest{
+				PodSetSliceRequiredTopology: ptr.To(corev1.LabelHostname),
+				PodSetSliceSize:             ptr.To(int32(2)),
+			},
+			levels: defaultThreeLevels,
+			requests: resources.Requests{
+				corev1.ResourceCPU: 1000,
+			},
+			count: 6,
+			wantAssignment: &kueue.TopologyAssignment{
+				Levels: defaultOneLevel,
+				Domains: []kueue.TopologyDomainAssignment{
+					{
+						Count: 2,
+						Values: []string{
+							"x3",
+						},
+					},
+					{
+						Count: 2,
+						Values: []string{
+							"x2",
+						},
+					},
+					{
+						Count: 2,
+						Values: []string{
+							"x1",
+						},
+					},
+				},
+			},
+		},
+		"no topology for podset; host required for slices; multiple blocks; BestFit": {
+			nodes: scatteredNodes,
+			topologyRequest: &kueue.PodSetTopologyRequest{
+				PodSetSliceRequiredTopology: ptr.To(corev1.LabelHostname),
+				PodSetSliceSize:             ptr.To(int32(2)),
+			},
+			levels: defaultThreeLevels,
+			requests: resources.Requests{
+				corev1.ResourceCPU: 1000,
+			},
+			count: 6,
+			wantAssignment: &kueue.TopologyAssignment{
+				Levels: defaultOneLevel,
+				Domains: []kueue.TopologyDomainAssignment{
+					{
+						Count: 4,
+						Values: []string{
+							"x1",
+						},
+					},
+					{
+						Count: 2,
+						Values: []string{
+							"x4",
+						},
+					},
+				},
+			},
+		},
+		"no topology for podset; rack required for slices; multiple blocks; BestFit": {
+			nodes: defaultNodes,
+			topologyRequest: &kueue.PodSetTopologyRequest{
+				PodSetSliceRequiredTopology: ptr.To(tasRackLabel),
+				PodSetSliceSize:             ptr.To(int32(2)),
+			},
+			levels: defaultThreeLevels,
+			requests: resources.Requests{
+				corev1.ResourceCPU: 1000,
+			},
+			count: 4,
+			wantAssignment: &kueue.TopologyAssignment{
+				Levels: defaultOneLevel,
+				Domains: []kueue.TopologyDomainAssignment{
+					{
+						Count: 1,
+						Values: []string{
+							"x2",
+						},
+					},
+					{
+						Count: 1,
+						Values: []string{
+							"x3",
+						},
+					},
+					{
+						Count: 2,
+						Values: []string{
+							"x6",
+						},
+					},
+				},
+			},
+		},
 	}
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
diff --git a/pkg/controller/jobs/job/job_webhook_test.go b/pkg/controller/jobs/job/job_webhook_test.go
index 0ee068168..3faf19d42 100644
--- a/pkg/controller/jobs/job/job_webhook_test.go
+++ b/pkg/controller/jobs/job/job_webhook_test.go
@@ -287,15 +287,13 @@ func TestValidateCreate(t *testing.T) {
 			wantErr: nil,
 		},
 		{
-			name: "invalid topology request - unconstrained with slices defined",
+			name: "valid topology request - slice-only topology - unconstrained with slices defined",
 			job: testingutil.MakeJob("job", "default").
 				PodAnnotation(kueuealpha.PodSetUnconstrainedTopologyAnnotation, "true").
 				PodAnnotation(kueuealpha.PodSetSliceRequiredTopologyAnnotation, "cloud.com/block").
 				PodAnnotation(kueuealpha.PodSetSliceSizeAnnotation, "1").
 				Obj(),
-			wantErr: field.ErrorList{
-				field.Forbidden(replicaMetaPath.Child("annotations").Key("kueue.x-k8s.io/podset-slice-required-topology"), "can be used with required or preferred topology only"),
-			},
+			wantErr: nil,
 		},
 		{
 			name: "invalid topology request - slice requested without slice size",
@@ -351,14 +349,12 @@ func TestValidateCreate(t *testing.T) {
 			},
 		},
 		{
-			name: "invalid topology request - slice topology requested without podset topology",
+			name: "valid topology request - slice-only topology",
 			job: testingutil.MakeJob("job", "default").
 				PodAnnotation(kueuealpha.PodSetSliceRequiredTopologyAnnotation, "cloud.com/block").
 				PodAnnotation(kueuealpha.PodSetSliceSizeAnnotation, "1").
 				Obj(),
-			wantErr: field.ErrorList{
-				field.Forbidden(replicaMetaPath.Child("annotations").Key("kueue.x-k8s.io/podset-slice-required-topology"), "can be used with required or preferred topology only"),
-			},
+			wantErr: nil,
 		},
 	}
 
@@ -639,12 +635,11 @@ func TestValidateUpdate(t *testing.T) {
 			oldJob: testingutil.MakeJob("job", "default").
 				Obj(),
 			newJob: testingutil.MakeJob("job", "default").
-				PodAnnotation(kueuealpha.PodSetUnconstrainedTopologyAnnotation, "true").
+				PodAnnotation(kueuealpha.PodSetRequiredTopologyAnnotation, "cloud.com/block").
 				PodAnnotation(kueuealpha.PodSetSliceRequiredTopologyAnnotation, "cloud.com/block").
-				PodAnnotation(kueuealpha.PodSetSliceSizeAnnotation, "1").
 				Obj(),
 			wantErr: field.ErrorList{
-				field.Forbidden(replicaMetaPath.Child("annotations").Key("kueue.x-k8s.io/podset-slice-required-topology"), "can be used with required or preferred topology only"),
+				field.Required(replicaMetaPath.Child("annotations").Key("kueue.x-k8s.io/podset-slice-size"), "slice size is required if slice topology is requested"),
 			},
 		},
 	}
diff --git a/pkg/queue/cluster_queue_test.go b/pkg/queue/cluster_queue_test.go
index 55f51dca2..1051c38e6 100644
--- a/pkg/queue/cluster_queue_test.go
+++ b/pkg/queue/cluster_queue_test.go
@@ -69,7 +69,7 @@ func Test_PushOrUpdate(t *testing.T) {
 	cases := map[string]struct {
 		workload                  *utiltesting.WorkloadWrapper
 		wantWorkload              *workload.Info
-		wantInAdmissibleWorkloads map[workload.WorkloadReference]*workload.Info
+		wantInAdmissibleWorkloads map[workload.Reference]*workload.Info
 	}{
 		"workload doesn't have re-queue state": {
 			workload:     wlBase.Clone(),
@@ -87,7 +87,7 @@ func Test_PushOrUpdate(t *testing.T) {
 					Type:   kueue.WorkloadRequeued,
 					Status: metav1.ConditionFalse,
 				}),
-			wantInAdmissibleWorkloads: map[workload.WorkloadReference]*workload.Info{
+			wantInAdmissibleWorkloads: map[workload.Reference]*workload.Info{
 				"default/workload-1": workload.NewInfo(wlBase.Clone().
 					ResourceVersion("1").
 					RequeueState(ptr.To[int32](10), ptr.To(metav1.NewTime(minuteLater))).
@@ -114,7 +114,7 @@ func Test_PushOrUpdate(t *testing.T) {
 					Type:   kueue.WorkloadRequeued,
 					Status: metav1.ConditionFalse,
 				}),
-			wantInAdmissibleWorkloads: map[workload.WorkloadReference]*workload.Info{
+			wantInAdmissibleWorkloads: map[workload.Reference]*workload.Info{
 				"default/workload-1": workload.NewInfo(wlBase.Clone().
 					ResourceVersion("1").
 					Condition(metav1.Condition{
@@ -243,8 +243,8 @@ func Test_AddFromLocalQueue(t *testing.T) {
 	cq := newClusterQueueImpl(t.Context(), nil, defaultOrdering, testingclock.NewFakeClock(time.Now()), nil, false)
 	wl := utiltesting.MakeWorkload("workload-1", defaultNamespace).Obj()
 	queue := &LocalQueue{
-		items: map[workload.WorkloadReference]*workload.Info{
-			workload.WorkloadReference(wl.Name): workload.NewInfo(wl),
+		items: map[workload.Reference]*workload.Info{
+			workload.Reference(wl.Name): workload.NewInfo(wl),
 		},
 	}
 	cq.PushOrUpdate(workload.NewInfo(wl))
@@ -333,7 +333,7 @@ func TestClusterQueueImpl(t *testing.T) {
 		workloadsToUpdate                 []*kueue.Workload
 		workloadsToDelete                 []*kueue.Workload
 		queueInadmissibleWorkloads        bool
-		wantActiveWorkloads               []workload.WorkloadReference
+		wantActiveWorkloads               []workload.Reference
 		wantPending                       int
 		wantInadmissibleWorkloadsRequeued bool
 	}{
@@ -342,27 +342,27 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{},
 			workloadsToUpdate:              []*kueue.Workload{updatedWorkloads[0]},
 			workloadsToDelete:              []*kueue.Workload{workloads[0]},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[1])},
 			wantPending:                    2,
 		},
 		"re-queue inadmissible workload; workloads with requeueState can't re-queue": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0])},
 			wantPending:                    3,
 		},
 		"re-queue admissible workload that was inadmissible": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
 			admissibleWorkloadsToRequeue:   []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                    3,
 		},
 		"re-queue inadmissible workload and flush": {
 			workloadsToAdd:                    []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue:    []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
 			queueInadmissibleWorkloads:        true,
-			wantActiveWorkloads:               []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:               []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                       3,
 			wantInadmissibleWorkloadsRequeued: true,
 		},
@@ -370,14 +370,14 @@ func TestClusterQueueImpl(t *testing.T) {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[2])},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{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:            []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                    2,
 		},
 		"delete inadmissible workload": {
@@ -385,7 +385,7 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			workloadsToDelete:              []*kueue.Workload{workloads[1]},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0])},
 			wantPending:                    1,
 		},
 		"update inadmissible workload without changes": {
@@ -406,7 +406,7 @@ func TestClusterQueueImpl(t *testing.T) {
 					ReclaimablePods(kueue.ReclaimablePod{Name: kueue.DefaultPodSetName, Count: 1}).
 					Obj(),
 			},
-			wantActiveWorkloads: []workload.WorkloadReference{"/w"},
+			wantActiveWorkloads: []workload.Reference{"/w"},
 			wantPending:         1,
 		},
 	}
@@ -473,7 +473,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	ctx := t.Context()
 	cq.PushOrUpdate(workload.NewInfo(wl))
 
-	wantActiveWorkloads := []workload.WorkloadReference{workload.Key(wl)}
+	wantActiveWorkloads := []workload.Reference{workload.Key(wl)}
 
 	activeWorkloads, _ := cq.Dump()
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads, cmpDump...); diff != "" {
@@ -486,7 +486,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	cq.requeueIfNotPresent(head, false)
 
 	activeWorkloads, _ = cq.Dump()
-	wantActiveWorkloads = []workload.WorkloadReference{workload.Key(wl)}
+	wantActiveWorkloads = []workload.Reference{workload.Key(wl)}
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads, cmpDump...); diff != "" {
 		t.Errorf("Unexpected active workloads after scheduling with requeuing (-want,+got):\n%s", diff)
 	}
diff --git a/pkg/queue/manager_test.go b/pkg/queue/manager_test.go
index a582da955..c4d77e408 100644
--- a/pkg/queue/manager_test.go
+++ b/pkg/queue/manager_test.go
@@ -41,7 +41,7 @@ import (
 const headsTimeout = 3 * time.Second
 
 var cmpDump = cmp.Options{
-	cmpopts.SortSlices(func(a, b workload.WorkloadReference) bool { return a < b }),
+	cmpopts.SortSlices(func(a, b workload.Reference) bool { return a < b }),
 	cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime"),
 }
 
@@ -63,7 +63,7 @@ func TestAddLocalQueueOrphans(t *testing.T) {
 	}
 	qImpl := manager.localQueues[Key(q)]
 	workloadNames := workloadNamesFromLQ(qImpl)
-	if diff := cmp.Diff(sets.New[workload.WorkloadReference]("earth/a", "earth/c"), workloadNames); diff != "" {
+	if diff := cmp.Diff(sets.New[workload.Reference]("earth/a", "earth/c"), workloadNames); diff != "" {
 		t.Errorf("Unexpected items in queue foo (-want,+got):\n%s", diff)
 	}
 }
@@ -97,7 +97,7 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		}
 	}
 
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq": {"/a", "/b"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -115,7 +115,7 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		t.Fatalf("Could not re-add ClusterQueue: %v", err)
 	}
 	workloads := popNamesFromCQ(manager.hm.ClusterQueue("cq"))
-	wantWorkloads := []workload.WorkloadReference{"/b", "/a"}
+	wantWorkloads := []workload.Reference{"/b", "/a"}
 	if diff := cmp.Diff(wantWorkloads, workloads); diff != "" {
 		t.Errorf("Workloads popped in the wrong order from clusterQueue:\n%s", diff)
 	}
@@ -163,7 +163,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are marked as inadmissible after creation.
 	inadmissibleWorkloads := manager.DumpInadmissible()
-	wantInadmissibleWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantInadmissibleWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -171,7 +171,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads := manager.Dump()
-	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.WorkloadReference(nil), activeWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.Reference(nil), activeWorkloads); diff != "" {
 		t.Errorf("Unexpected active workloads (-want +got):\n%s", diff)
 	}
 
@@ -197,11 +197,11 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are active after the update.
 	inadmissibleWorkloads = manager.DumpInadmissible()
-	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.WorkloadReference(nil), inadmissibleWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.Reference(nil), inadmissibleWorkloads); diff != "" {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads = manager.Dump()
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -343,11 +343,11 @@ func TestUpdateLocalQueue(t *testing.T) {
 	}
 
 	// Verification.
-	workloadOrders := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference)
+	workloadOrders := make(map[kueue.ClusterQueueReference][]workload.Reference)
 	for name, cq := range manager.hm.ClusterQueues() {
 		workloadOrders[name] = popNamesFromCQ(cq)
 	}
-	wantWorkloadOrders := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantWorkloadOrders := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": nil,
 		"cq2": {"/b", "/a"},
 	}
@@ -374,7 +374,7 @@ func TestDeleteLocalQueue(t *testing.T) {
 		t.Fatalf("Could not create LocalQueue: %v", err)
 	}
 
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq": {"/a"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -655,8 +655,8 @@ func TestUpdateWorkload(t *testing.T) {
 		workloads        []*kueue.Workload
 		update           func(*kueue.Workload)
 		wantUpdated      bool
-		wantQueueOrder   map[kueue.ClusterQueueReference][]workload.WorkloadReference
-		wantQueueMembers map[LocalQueueReference]sets.Set[workload.WorkloadReference]
+		wantQueueOrder   map[kueue.ClusterQueueReference][]workload.Reference
+		wantQueueMembers map[LocalQueueReference]sets.Set[workload.Reference]
 		wantErr          error
 	}{
 		"in queue": {
@@ -674,11 +674,11 @@ func TestUpdateWorkload(t *testing.T) {
 				w.CreationTimestamp = metav1.NewTime(now.Add(time.Minute))
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/b", "/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
-				"/foo": sets.New[workload.WorkloadReference]("/a", "/b"),
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
+				"/foo": sets.New[workload.Reference]("/a", "/b"),
 			},
 		},
 		"between queues": {
@@ -696,12 +696,12 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
-				"/bar": sets.New[workload.WorkloadReference]("/a"),
+				"/bar": sets.New[workload.Reference]("/a"),
 			},
 		},
 		"between cluster queues": {
@@ -720,13 +720,13 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq1": nil,
 				"cq2": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
-				"/bar": sets.New[workload.WorkloadReference]("/a"),
+				"/bar": sets.New[workload.Reference]("/a"),
 			},
 		},
 		"to non existent queue": {
@@ -742,10 +742,10 @@ func TestUpdateWorkload(t *testing.T) {
 			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": nil,
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
 			},
 			wantErr: ErrLocalQueueDoesNotExistOrInactive,
@@ -764,11 +764,11 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "foo"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
-				"/foo": sets.New[workload.WorkloadReference]("/a"),
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
+				"/foo": sets.New[workload.Reference]("/a"),
 			},
 		},
 	}
@@ -814,14 +814,14 @@ func TestUpdateWorkload(t *testing.T) {
 					}
 				}
 			}
-			queueOrder := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference)
+			queueOrder := make(map[kueue.ClusterQueueReference][]workload.Reference)
 			for name, cq := range manager.hm.ClusterQueues() {
 				queueOrder[name] = popNamesFromCQ(cq)
 			}
 			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[LocalQueueReference]sets.Set[workload.WorkloadReference])
+			queueMembers := make(map[LocalQueueReference]sets.Set[workload.Reference])
 			for name, q := range manager.localQueues {
 				queueMembers[name] = workloadNamesFromLQ(q)
 			}
@@ -1155,8 +1155,8 @@ func TestHeadsCancelled(t *testing.T) {
 
 // popNamesFromCQ pops all the workloads from the clusterQueue and returns
 // the keyed names in the order they are popped.
-func popNamesFromCQ(cq *ClusterQueue) []workload.WorkloadReference {
-	var names []workload.WorkloadReference
+func popNamesFromCQ(cq *ClusterQueue) []workload.Reference {
+	var names []workload.Reference
 	for w := cq.Pop(); w != nil; w = cq.Pop() {
 		names = append(names, workload.Key(w.Obj))
 	}
@@ -1164,8 +1164,8 @@ func popNamesFromCQ(cq *ClusterQueue) []workload.WorkloadReference {
 }
 
 // workloadNamesFromLQ returns all the names of the workloads in a localQueue.
-func workloadNamesFromLQ(q *LocalQueue) sets.Set[workload.WorkloadReference] {
-	names := sets.New[workload.WorkloadReference]()
+func workloadNamesFromLQ(q *LocalQueue) sets.Set[workload.Reference] {
+	names := sets.New[workload.Reference]()
 	for k := range q.items {
 		names.Insert(k)
 	}
@@ -1285,9 +1285,9 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 
 	cases := map[string]struct {
 		workloads []*kueue.Workload
-		deleted   sets.Set[workload.WorkloadReference]
+		deleted   sets.Set[workload.Reference]
 		passTime  time.Duration
-		wantReady sets.Set[workload.WorkloadReference]
+		wantReady sets.Set[workload.Reference]
 	}{
 		"single queued workload checked immediately": {
 			workloads: []*kueue.Workload{baseWorkloadNeedingSecondPass.Obj()},
@@ -1314,7 +1314,7 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 			},
 			deleted:   sets.New(workload.Key(baseWorkloadNeedingSecondPass.Obj())),
 			passTime:  time.Second,
-			wantReady: sets.New(workload.NewWorkloadReference("default", "second")),
+			wantReady: sets.New(workload.NewReference("default", "second")),
 		},
 	}
 	for name, tc := range cases {
@@ -1334,7 +1334,7 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 				manager.secondPassQueue.deleteByKey(wl)
 			}
 			fakeClock.Step(tc.passTime)
-			gotReady := sets.New[workload.WorkloadReference]()
+			gotReady := sets.New[workload.Reference]()
 			for _, wlInfo := range manager.secondPassQueue.takeAllReady() {
 				gotReady.Insert(workload.Key(wlInfo.Obj))
 			}
diff --git a/pkg/scheduler/flavorassigner/flavorassigner_test.go b/pkg/scheduler/flavorassigner/flavorassigner_test.go
index 3524e395a..ff937ed42 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner_test.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner_test.go
@@ -37,18 +37,16 @@ import (
 )
 
 type testOracle struct {
-	CanPreemptInCohort bool
+	simulationResult map[resources.FlavorResource]preemptioncommon.PreemptionPossibility
 }
 
 func (f *testOracle) SimulatePreemption(log logr.Logger, cq *cache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) preemptioncommon.PreemptionPossibility {
-	if !cq.BorrowingWith(fr, quantity) {
-		return preemptioncommon.Reclaim
-	}
-	if f.CanPreemptInCohort {
-		return preemptioncommon.PriorityBased
-	} else {
-		return preemptioncommon.None
+	if f.simulationResult != nil {
+		if result, ok := f.simulationResult[fr]; ok {
+			return result
+		}
 	}
+	return preemptioncommon.Preempt
 }
 
 func TestAssignFlavors(t *testing.T) {
@@ -90,7 +88,7 @@ func TestAssignFlavors(t *testing.T) {
 		wantAssignment             Assignment
 		disableLendingLimit        bool
 		enableFairSharing          bool
-		cannotPreemptInCohort      bool
+		simulationResult           map[resources.FlavorResource]preemptioncommon.PreemptionPossibility
 	}{
 		"single flavor, fits": {
 			wlPods: []kueue.PodSet{
@@ -1824,8 +1822,10 @@ func TestAssignFlavors(t *testing.T) {
 			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
 				{Flavor: "one", Resource: corev1.ResourceCPU}: 2_000,
 			},
-			cannotPreemptInCohort: true,
-			wantRepMode:           Fit,
+			simulationResult: map[resources.FlavorResource]preemptioncommon.PreemptionPossibility{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: preemptioncommon.NoCandidates,
+			},
+			wantRepMode: Fit,
 			wantAssignment: Assignment{
 				PodSets: []PodSetAssignment{{
 					Name: kueue.DefaultPodSetName,
@@ -2047,7 +2047,7 @@ func TestAssignFlavors(t *testing.T) {
 				secondaryClusterQueue.AddUsage(workload.Usage{Quota: tc.secondaryClusterQueueUsage})
 			}
 
-			flvAssigner := New(wlInfo, clusterQueue, resourceFlavors, tc.enableFairSharing, &testOracle{CanPreemptInCohort: !tc.cannotPreemptInCohort})
+			flvAssigner := New(wlInfo, clusterQueue, resourceFlavors, tc.enableFairSharing, &testOracle{simulationResult: tc.simulationResult})
 			assignment := flvAssigner.Assign(log, nil)
 			if repMode := assignment.RepresentativeMode(); repMode != tc.wantRepMode {
 				t.Errorf("e.assignFlavors(_).RepresentativeMode()=%s, want %s", repMode, tc.wantRepMode)
@@ -2072,6 +2072,7 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 		flavorFungibility      *kueue.FlavorFungibility
 		wantMode               FlavorAssignmentMode
 		wantAssigment          rfMap
+		simulationResult       map[resources.FlavorResource]preemptioncommon.PreemptionPossibility
 	}{
 		"Select first flavor which fits": {
 			workloadRequests: utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("gpu", "10"),
@@ -2093,6 +2094,10 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 				{Flavor: "due", Resource: "gpu"}: 1,
 				{Flavor: "tre", Resource: "gpu"}: 1,
 			},
+			simulationResult: map[resources.FlavorResource]preemptioncommon.PreemptionPossibility{
+				{Flavor: "uno", Resource: "gpu"}: preemptioncommon.Preempt,
+				{Flavor: "due", Resource: "gpu"}: preemptioncommon.Reclaim,
+			},
 			wantMode:      Preempt,
 			wantAssigment: rfMap{"gpu": "due"},
 		},
@@ -2132,6 +2137,11 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 				{Flavor: "due", Resource: "gpu"}: 1,
 				{Flavor: "tre", Resource: "gpu"}: 1,
 			},
+			simulationResult: map[resources.FlavorResource]preemptioncommon.PreemptionPossibility{
+				{Flavor: "uno", Resource: "gpu"}: preemptioncommon.Preempt,
+				{Flavor: "due", Resource: "gpu"}: preemptioncommon.Reclaim,
+				{Flavor: "tre", Resource: "gpu"}: preemptioncommon.Reclaim,
+			},
 			wantMode:      Preempt,
 			wantAssigment: rfMap{"gpu": "tre", "compute": "tre"},
 		},
@@ -2200,7 +2210,7 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 			testClusterQueue := snapshot.ClusterQueue("test-clusterqueue")
 			testClusterQueue.AddUsage(workload.Usage{Quota: tc.testClusterQueueUsage})
 
-			flvAssigner := New(wlInfo, testClusterQueue, resourceFlavors, false, &testOracle{})
+			flvAssigner := New(wlInfo, testClusterQueue, resourceFlavors, false, &testOracle{tc.simulationResult})
 			assignment := flvAssigner.Assign(log, nil)
 			if gotRepMode := assignment.RepresentativeMode(); gotRepMode != tc.wantMode {
 				t.Errorf("Unexpected RepresentativeMode. got %s, want %s", gotRepMode, tc.wantMode)
diff --git a/pkg/scheduler/preemption/preemption_test.go b/pkg/scheduler/preemption/preemption_test.go
index ab60b57e8..ebdd1fc10 100644
--- a/pkg/scheduler/preemption/preemption_test.go
+++ b/pkg/scheduler/preemption/preemption_test.go
@@ -2787,7 +2787,7 @@ func TestFairPreemptions(t *testing.T) {
 	}
 }
 
-func targetKeyReason(key workload.WorkloadReference, reason string) string {
+func targetKeyReason(key workload.Reference, reason string) string {
 	return fmt.Sprintf("%s:%s", key, reason)
 }
 func TestCandidatesOrdering(t *testing.T) {
@@ -2827,11 +2827,11 @@ func TestCandidatesOrdering(t *testing.T) {
 	sort.Slice(candidates, func(i int, j int) bool {
 		return CandidatesOrdering(candidates[i], candidates[j], "self", now)
 	})
-	gotNames := make([]workload.WorkloadReference, len(candidates))
+	gotNames := make([]workload.Reference, len(candidates))
 	for i, c := range candidates {
 		gotNames[i] = workload.Key(c.Obj)
 	}
-	wantCandidates := []workload.WorkloadReference{"/evicted", "/other", "/low", "/current", "/old-a", "/old-b", "/high"}
+	wantCandidates := []workload.Reference{"/evicted", "/other", "/low", "/current", "/old-a", "/old-b", "/high"}
 	if diff := cmp.Diff(wantCandidates, gotNames); diff != "" {
 		t.Errorf("Sorted with wrong order (-want,+got):\n%s", diff)
 	}
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index 40427088a..24616ccb7 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -257,19 +257,19 @@ func TestSchedule(t *testing.T) {
 		cohorts []kueuealpha.Cohort
 
 		// wantAssignments is a summary of all the admissions in the cache after this cycle.
-		wantAssignments map[workload.WorkloadReference]kueue.Admission
+		wantAssignments map[workload.Reference]kueue.Admission
 		// wantScheduled is the subset of workloads that got scheduled/admitted in this cycle.
-		wantScheduled []workload.WorkloadReference
+		wantScheduled []workload.Reference
 		// workloadCmpOpts are the cmp options to compare workloads.
 		workloadCmpOpts cmp.Options
 		// wantWorkloads is the subset of workloads that got admitted in this cycle.
 		wantWorkloads []kueue.Workload
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents ignored if empty, the Message is ignored (it contains the duration)
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the cmp options to compare recorded events.
@@ -291,7 +291,7 @@ func TestSchedule(t *testing.T) {
 					Generation(1).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/foo": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -308,7 +308,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/foo"},
+			wantScheduled: []workload.Reference{"sales/foo"},
 			workloadCmpOpts: cmp.Options{
 				cmpopts.EquateEmpty(),
 				cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime"),
@@ -391,7 +391,7 @@ func TestSchedule(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/foo": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -408,7 +408,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/foo"},
+			wantScheduled: []workload.Reference{"sales/foo"},
 			eventCmpOpts:  ignoreEventMessageCmpOpts,
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -428,7 +428,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			admissionError: errors.New("admission"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/foo"},
 			},
 		},
@@ -447,7 +447,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("sales", "one").Assignment(corev1.ResourceCPU, "default", "40000m").AssignmentPodCount(40).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/assigned": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -464,7 +464,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -477,7 +477,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"sales/new"},
 			},
 		},
@@ -496,7 +496,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -528,7 +528,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new", "eng-alpha/new"},
+			wantScheduled: []workload.Reference{"sales/new", "eng-alpha/new"},
 		},
 		"admit in same cohort with no borrowing": {
 			workloads: []kueue.Workload{
@@ -545,7 +545,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -577,7 +577,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new", "eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new", "eng-beta/new"},
 		},
 		"assign multiple resources and flavors": {
 			workloads: []kueue.Workload{
@@ -594,7 +594,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/new": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -623,7 +623,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-beta/new"},
 		},
 		"cannot borrow if cohort was assigned and would result in overadmission": {
 			workloads: []kueue.Workload{
@@ -640,7 +640,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -657,8 +657,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -677,7 +677,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -709,7 +709,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new", "eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new", "eng-beta/new"},
 		},
 		"can borrow if needs reclaim from cohort in different flavor": {
 			workloads: []kueue.Workload{
@@ -730,15 +730,15 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "spot", "1000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"eng-alpha/can-reclaim"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/user-spot":       *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "spot", "1000m").Obj(),
 				"eng-beta/user-on-demand":  *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "50000m").Obj(),
 				"eng-beta/needs-to-borrow": *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "1000m").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/needs-to-borrow",
 			},
 		},
@@ -753,10 +753,10 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"lend/a": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "2000m").Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"lend-b": {"lend/b"},
 			},
 		},
@@ -772,11 +772,11 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"lend/a": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "2000m").Obj(),
 				"lend/b": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "3000m").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"lend/b",
 			},
 		},
@@ -805,12 +805,12 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "60000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/borrower", "eng-beta/low-2"),
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/borrower", "eng-beta/low-2"),
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/use-all-spot": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"eng-beta/low-1":         *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "30").Obj(),
 				// Removal from cache for the preempted workloads is deferred until we receive Workload updates
@@ -859,15 +859,15 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"other-beta": {"eng-beta/preemptor"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/pending"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/use-all"),
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/use-all"),
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				// Removal from cache for the preempted workloads is deferred until we receive Workload updates
 				"eng-alpha/use-all": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj(),
 			},
@@ -879,7 +879,7 @@ func TestSchedule(t *testing.T) {
 					Request("example.com/gpu", "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"eng-alpha/new"},
 			},
 		},
@@ -898,7 +898,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "45000m").AssignmentPodCount(45).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -930,7 +930,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
 		},
 		"workload should not fit in nonexistent clusterQueue": {
 			workloads: []kueue.Workload{
@@ -947,7 +947,7 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"flavor-nonexistent-cq": {"sales/foo"},
 			},
 		},
@@ -1035,7 +1035,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-gamma/existing": *utiltesting.MakeAdmission("eng-gamma").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -1062,8 +1062,8 @@ func TestSchedule(t *testing.T) {
 				"eng-beta/new":        *utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").AssignmentPodCount(50).Obj(),
 				"eng-alpha/new-alpha": *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "1").AssignmentPodCount(1).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-beta/new", "eng-alpha/new-alpha"},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-beta/new", "eng-alpha/new-alpha"},
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-gamma": {"eng-gamma/new-gamma"},
 			},
 			wantSkippedPreemptions: map[string]int{
@@ -1082,7 +1082,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1099,7 +1099,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new"},
+			wantScheduled: []workload.Reference{"sales/new"},
 		},
 		"partial admission single variable pod set, preempt first": {
 			workloads: []kueue.Workload{
@@ -1119,7 +1119,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment("example.com/gpu", "model-a", "10").AssignmentPodCount(10).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/old": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1136,8 +1136,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/old"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/old"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1159,7 +1159,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment("example.com/gpu", "model-a", "10").AssignmentPodCount(10).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/old": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1176,8 +1176,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/old"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/old"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1200,7 +1200,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1237,7 +1237,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new"},
+			wantScheduled: []workload.Reference{"sales/new"},
 		},
 		"partial admission disabled, multiple variable pod sets": {
 			workloads: []kueue.Workload{
@@ -1258,7 +1258,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			disablePartialAdmission: true,
@@ -1288,8 +1288,8 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r2", "16").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1", "sales/wl2"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1", "sales/wl2"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
@@ -1323,8 +1323,8 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r1", "14").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1", "sales/wl2"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1", "sales/wl2"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
@@ -1358,13 +1358,13 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r1", "16").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq2": {"sales/wl2"},
 			},
 		},
@@ -1460,7 +1460,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/admitted_a": {
 					ClusterQueue: "cq_a",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1492,10 +1492,10 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/b",
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq_a": {"eng-alpha/a"},
 			},
 		},
@@ -1541,13 +1541,13 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/all_nominal": *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").AssignmentPodCount(50).Obj(),
 				"eng-beta/borrowing":    *utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "55").AssignmentPodCount(55).Obj(),
 				"eng-alpha/new":         *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "5").AssignmentPodCount(5).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/older_new"},
 			},
 		},
@@ -1675,14 +1675,14 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/d0": *utiltesting.MakeAdmission("d", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/e0": *utiltesting.MakeAdmission("e", "one").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"eng-alpha/g0": *utiltesting.MakeAdmission("g", "one").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj(),
 				"eng-alpha/d1": *utiltesting.MakeAdmission("d", "one").Assignment(corev1.ResourceCPU, "on-demand", "70").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/d1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/d1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"e": {"eng-alpha/e1"},
 				"g": {"eng-alpha/g1"},
 				"f": {"eng-alpha/f1"},
@@ -1743,12 +1743,12 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/b0": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/b1": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/b1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/b1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"c": {"eng-alpha/c1"},
 			},
 		},
@@ -1820,12 +1820,12 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("a", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/b1": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/a1", "eng-alpha/b1", "eng-alpha/c1"},
+			wantScheduled: []workload.Reference{"eng-alpha/a1", "eng-alpha/b1", "eng-alpha/c1"},
 			wantLeft:      nil,
 		},
 		"fair sharing schedule highest priority first": {
@@ -1874,11 +1874,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/c1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/c1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -1930,11 +1930,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/c1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/c1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -2014,11 +2014,11 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-alpha/a2"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-alpha/a2"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-alpha/a3": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
@@ -2071,10 +2071,10 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 			},
@@ -2122,12 +2122,12 @@ func TestSchedule(t *testing.T) {
 					Queue("main").
 					Request(corev1.ResourceCPU, "30").Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/alpha1", "eng-gamma/gamma1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/alpha1", "eng-gamma/gamma1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/all_spot": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"eng-alpha/alpha1":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"eng-alpha/alpha2":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
@@ -2193,12 +2193,12 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
@@ -2255,15 +2255,15 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-beta": {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/fit": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "1").Obj(),
 				"eng-beta/b1":   *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/fit"},
+			wantScheduled: []workload.Reference{"eng-alpha/fit"},
 			wantSkippedPreemptions: map[string]int{
 				"other-alpha": 0,
 				"other-beta":  0,
@@ -2341,12 +2341,12 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
@@ -2445,13 +2445,13 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-beta/b1", "eng-gamma/c1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-beta/b1", "eng-gamma/c1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 				"other-gamma": {"eng-gamma/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").
 					Assignment(corev1.ResourceCPU, "default", "3").Obj(),
 				"eng-beta/b1": *utiltesting.MakeAdmission("other-beta").
@@ -2559,12 +2559,12 @@ func TestSchedule(t *testing.T) {
 					Request("beta-resource", "1").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-gamma/c1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-gamma/c1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").
 					Assignment("alpha-resource", "default", "1").Obj(),
 				"eng-beta/b1": *utiltesting.MakeAdmission("other-beta").
@@ -2587,7 +2587,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2606,7 +2606,7 @@ func TestSchedule(t *testing.T) {
 					WithValue("Max", corev1.ResourceCPU, "300m").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2635,7 +2635,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2663,7 +2663,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2719,11 +2719,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "6").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
 			},
@@ -2781,11 +2781,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "6").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "spot", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
@@ -2846,11 +2846,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "5").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "6").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "spot", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
@@ -2945,14 +2945,14 @@ func TestSchedule(t *testing.T) {
 					SimpleReserveQuota("CQ3", "on-demand", now).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-gamma/Admitted-Workload-2"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-gamma/Admitted-Workload-2"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"CQ2": {"eng-beta/WL2"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"CQ1": {"eng-alpha/WL1"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/Admitted-Workload-1": *utiltesting.MakeAdmission("CQ1").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-gamma/Admitted-Workload-2": *utiltesting.MakeAdmission("CQ3").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-gamma/Admitted-Workload-3": *utiltesting.MakeAdmission("CQ3").Assignment("gpu", "on-demand", "5").Obj(),
@@ -2997,13 +2997,13 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantLeft: nil,
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueA": {"eng-alpha/a2-pending"},
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/b1-pending",
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1-admitted": *utiltesting.MakeAdmission("ClusterQueueA").Assignment("gpu", "on-demand", "1").Obj(),
 				"eng-beta/b1-pending":   *utiltesting.MakeAdmission("ClusterQueueB").Assignment("gpu", "on-demand", "1").Obj(),
 			},
@@ -3046,13 +3046,13 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueB": {"eng-beta/b1-pending"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueA": {"eng-alpha/a2-pending"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1-admitted": *utiltesting.MakeAdmission("ClusterQueueA").Assignment("gpu", "on-demand", "1").Obj(),
 			},
 		},
@@ -3111,11 +3111,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/guaranteed": *utiltesting.MakeAdmission("guaranteed", "one").Assignment(corev1.ResourceCPU, "default", "4").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/guaranteed"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/guaranteed"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"best-effort": {"eng-alpha/best-effort"},
 			},
 		},
@@ -3175,8 +3175,8 @@ func TestSchedule(t *testing.T) {
 					Priority(100).
 					Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new":      *utiltesting.MakeAdmission("cq1").Assignment(corev1.ResourceCPU, "spot", "1").Obj(),
 				"eng-alpha/admitted": *utiltesting.MakeAdmission("cq2").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 			},
@@ -3239,7 +3239,7 @@ func TestSchedule(t *testing.T) {
 			}
 
 			scheduler := New(qManager, cqCache, cl, recorder, WithFairSharing(&config.FairSharing{Enable: tc.enableFairSharing}), WithClock(t, fakeClock))
-			gotScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			gotScheduled := make(map[workload.Reference]kueue.Admission)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				if tc.admissionError != nil {
@@ -3255,7 +3255,7 @@ func TestSchedule(t *testing.T) {
 				func() { wg.Add(1) },
 				func() { wg.Done() },
 			))
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -3270,7 +3270,7 @@ func TestSchedule(t *testing.T) {
 			scheduler.schedule(ctx)
 			wg.Wait()
 
-			wantScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			wantScheduled := make(map[workload.Reference]kueue.Admission)
 			for _, key := range tc.wantScheduled {
 				wantScheduled[key] = tc.wantAssignments[key]
 			}
@@ -3283,7 +3283,7 @@ func TestSchedule(t *testing.T) {
 			}
 
 			// Verify assignments in cache.
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			var gotWorkloads []kueue.Workload
 			snapshot, err := cqCache.Snapshot(ctx)
 			if err != nil {
@@ -3750,9 +3750,9 @@ func TestLastSchedulingContext(t *testing.T) {
 		admittedWorkloads              []kueue.Workload
 		workloads                      []kueue.Workload
 		deleteWorkloads                []kueue.Workload
-		wantPreempted                  sets.Set[workload.WorkloadReference]
-		wantAdmissionsOnFirstSchedule  map[workload.WorkloadReference]kueue.Admission
-		wantAdmissionsOnSecondSchedule map[workload.WorkloadReference]kueue.Admission
+		wantPreempted                  sets.Set[workload.Reference]
+		wantAdmissionsOnFirstSchedule  map[workload.Reference]kueue.Admission
+		wantAdmissionsOnSecondSchedule map[workload.Reference]kueue.Admission
 	}{
 		{
 			name: "scheduling context not changed: use next flavor if can't preempt",
@@ -3767,9 +3767,9 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads:               []kueue.Workload{},
-			wantPreempted:                 sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/new":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
 				"default/low-1": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 			},
@@ -3789,9 +3789,9 @@ func TestLastSchedulingContext(t *testing.T) {
 			deleteWorkloads: []kueue.Workload{
 				*wl,
 			},
-			wantPreempted:                 sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/preemptor": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
 		},
@@ -3816,12 +3816,12 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload1": *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"default/borrower":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/workload1":   *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"default/borrower":    *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
@@ -3849,11 +3849,11 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/placeholder1": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/workload":     *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
@@ -3886,11 +3886,11 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "40").Obj(),
 				"default/placeholder1": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "40").Obj(),
 				"default/placeholder2": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
@@ -3920,9 +3920,9 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads:               []kueue.Workload{*utiltesting.MakeWorkload("placeholder-alpha", "default").Obj()},
-			wantPreempted:                 sets.New[workload.WorkloadReference]("default/placeholder-alpha"),
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.New[workload.Reference]("default/placeholder-alpha"),
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder-theta-spot": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"default/new":                    *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
@@ -4003,8 +4003,8 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{*utiltesting.MakeWorkload("alpha2", "default").Obj()},
-			wantPreempted:   sets.New[workload.WorkloadReference]("default/alpha2"),
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.New[workload.Reference]("default/alpha2"),
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/alpha1": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "22").Obj(),
 				"default/alpha3": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "spot", "22").Obj(),
 				"default/beta1":  *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "spot", "22").Obj(),
@@ -4050,7 +4050,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder, WithClock(t, fakeClock))
-			gotScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			gotScheduled := make(map[workload.Reference]kueue.Admission)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -4063,7 +4063,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				func() { wg.Add(1) },
 				func() { wg.Done() },
 			))
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -4104,7 +4104,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
 			// Verify assignments in cache.
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			snapshot, err := cqCache.Snapshot(ctx)
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
@@ -4138,8 +4138,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 	cases := []struct {
 		name              string
 		e                 entry
-		wantWorkloads     map[kueue.ClusterQueueReference][]workload.WorkloadReference
-		wantInadmissible  map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantWorkloads     map[kueue.ClusterQueueReference][]workload.Reference
+		wantInadmissible  map[kueue.ClusterQueueReference][]workload.Reference
 		wantStatus        kueue.WorkloadStatus
 		wantStatusUpdates int
 	}{
@@ -4159,7 +4159,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantInadmissible: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissible: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -4170,7 +4170,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          assumed,
 				inadmissibleMsg: "",
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -4180,7 +4180,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          nominated,
 				inadmissibleMsg: "failed to admit workload",
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -4201,7 +4201,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -4641,11 +4641,11 @@ func TestScheduleForTAS(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -4676,7 +4676,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4749,7 +4749,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-reservation", "1000m").
 					AssignmentPodCount(1).
@@ -4813,7 +4813,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4870,7 +4870,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4927,7 +4927,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "3000m").
 					AssignmentPodCount(1).
@@ -4992,7 +4992,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5049,7 +5049,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5106,7 +5106,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5189,7 +5189,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one", "two").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5259,7 +5259,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "26").
 					AssignmentPodCount(26).
@@ -5342,7 +5342,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-second", "1000m").
 					AssignmentPodCount(1).
@@ -5466,7 +5466,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one", "two").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -5541,7 +5541,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					DelayedTopologyRequest(kueue.DelayedTopologyRequestStatePending).
@@ -5612,7 +5612,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-second", "1000m").
 					AssignmentPodCount(1).
@@ -5657,7 +5657,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					DelayedTopologyRequest(kueue.DelayedTopologyRequestStatePending).
@@ -5691,7 +5691,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5735,7 +5735,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5787,7 +5787,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5838,7 +5838,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "default", "1000m").
 					AssignmentPodCount(1).
@@ -5884,7 +5884,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -5949,7 +5949,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5993,7 +5993,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6046,7 +6046,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-custom-flavor", "1").
 					AssignmentPodCount(1).
@@ -6090,7 +6090,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6140,7 +6140,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6172,7 +6172,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6230,7 +6230,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "500m").
 					AssignmentPodCount(1).
@@ -6301,7 +6301,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "500m").
 					Assignment(corev1.ResourceMemory, "tas-default", "500Mi").
@@ -6378,7 +6378,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6436,7 +6436,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "launcher", "worker").
 					AssignmentWithIndex(0, corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCountWithIndex(0, 1).
@@ -6532,7 +6532,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "launcher", "worker").
 					AssignmentWithIndex(0, corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCountWithIndex(0, 1).
@@ -6641,7 +6641,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -6724,7 +6724,7 @@ func TestScheduleForTAS(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -6769,7 +6769,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -6854,7 +6854,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6880,7 +6880,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "0").
 					Assignment(corev1.ResourceMemory, "tas-default", "10Mi").
@@ -6967,7 +6967,7 @@ func TestScheduleForTAS(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) && !workload.HasNodeToReplace(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
@@ -6979,7 +6979,7 @@ func TestScheduleForTAS(t *testing.T) {
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -7003,7 +7003,7 @@ func TestScheduleForTAS(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
@@ -7103,13 +7103,13 @@ func TestScheduleForTASPreemption(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -7157,8 +7157,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7222,8 +7222,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/high-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7308,8 +7308,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7396,8 +7396,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7468,10 +7468,10 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/low-priority-which-would-fit"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/mid-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7530,14 +7530,14 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -7551,7 +7551,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 				func() { wg.Done() },
 			))
 
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -7572,7 +7572,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 			if diff := cmp.Diff(tc.wantPreempted, gotPreempted); diff != "" {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
@@ -7700,13 +7700,13 @@ func TestScheduleForTASCohorts(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -7726,7 +7726,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "6").
 					AssignmentPodCount(6).
@@ -7802,10 +7802,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -7913,10 +7913,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8002,10 +8002,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a2-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a2-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8127,11 +8127,11 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 				"tas-cq-c": {"default/c1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a2-admitted", "default/a3-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a2-admitted", "default/a3-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8179,7 +8179,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "5").
 					AssignmentPodCount(1).
@@ -8256,7 +8256,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -8333,7 +8333,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -8349,7 +8349,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8394,10 +8394,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "5").
 					AssignmentPodCount(5).
@@ -8457,7 +8457,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "2").
 					AssignmentPodCount(1).
@@ -8473,7 +8473,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8552,11 +8552,11 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8633,10 +8633,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8710,7 +8710,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8732,7 +8732,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 					Message:   `couldn't assign flavors to pod set one: topology "tas-single-level" allows to fit only 3 out of 4 pod(s)`,
 				},
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/b1": *utiltesting.MakeAdmission("tas-cq-b", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "3").
 					AssignmentPodCount(3).
@@ -8796,14 +8796,14 @@ func TestScheduleForTASCohorts(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -8817,7 +8817,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 				func() { wg.Done() },
 			))
 
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -8838,7 +8838,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 			if diff := cmp.Diff(tc.wantPreempted, gotPreempted); diff != "" {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
diff --git a/test/e2e/customconfigs/waitforpodsready_test.go b/test/e2e/customconfigs/waitforpodsready_test.go
index d8edd031d..fd3415a77 100644
--- a/test/e2e/customconfigs/waitforpodsready_test.go
+++ b/test/e2e/customconfigs/waitforpodsready_test.go
@@ -41,7 +41,7 @@ const (
 	metricsReaderClusterRoleName = "kueue-metrics-reader"
 )
 
-var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, func() {
+var _ = ginkgo.Describe("WaitForPodsReady with tiny Timeout and no RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
 	var (
 		ns    *corev1.Namespace
 		rf    *kueue.ResourceFlavor
@@ -74,21 +74,48 @@ var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, f
 			},
 		}
 		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
+
+		updateKueueConfiguration(func(cfg *configapi.Configuration) {
+			cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+				Enable:          true,
+				BlockAdmission:  ptr.To(true),
+				Timeout:         &metav1.Duration{Duration: util.TinyTimeout},
+				RecoveryTimeout: nil,
+				RequeuingStrategy: &configapi.RequeuingStrategy{
+					Timestamp:          ptr.To(configapi.EvictionTimestamp),
+					BackoffBaseSeconds: ptr.To(int32(10)),
+					BackoffLimitCount:  ptr.To(int32(1)),
+				},
+			}
+		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
 	ginkgo.BeforeEach(func() {
 		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
 
 		rf = testing.MakeResourceFlavor("default").Obj()
-		gomega.Expect(k8sClient.Create(ctx, rf)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, rf)
 
 		cq = testing.MakeClusterQueue("cq").
 			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
 			Obj()
-		gomega.Expect(k8sClient.Create(ctx, cq)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, cq)
 
 		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
-		gomega.Expect(k8sClient.Create(ctx, lq)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, lq)
 	})
 
 	ginkgo.AfterEach(func() {
@@ -99,284 +126,358 @@ var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, f
 	})
 
 	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
 		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, true)
 	})
 
-	ginkgo.When("WaitForPodsReady has a tiny Timeout and no RecoveryTimeout", func() {
-		ginkgo.BeforeEach(func() {
-			updateKueueConfiguration(func(cfg *configapi.Configuration) {
-				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
-					Enable:          true,
-					BlockAdmission:  ptr.To(true),
-					Timeout:         &metav1.Duration{Duration: util.TinyTimeout},
-					RecoveryTimeout: nil,
-					RequeuingStrategy: &configapi.RequeuingStrategy{
-						Timestamp:          ptr.To(configapi.EvictionTimestamp),
-						BackoffBaseSeconds: ptr.To(int32(10)),
-						BackoffLimitCount:  ptr.To(int32(1)),
-					},
-				}
-			})
-
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
-				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				TerminationGracePeriod(1).
+	ginkgo.It("should evict and requeue workload when pods readiness timeout is surpassed", func() {
+		ginkgo.By("creating a suspended job so its pods never report Ready", func() {
+			job = testingjob.MakeJob("job-timeout", ns.Name).
+				Queue(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
 				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			curlContainerName = curlPod.Spec.Containers[0].Name
+		ginkgo.By("waiting for the workload to be created and verifying it is not admitted", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.Admission).To(gomega.BeNil())
+			}, util.Timeout, util.Interval).Should(gomega.Succeed())
 		})
 
-		ginkgo.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		ginkgo.By("waiting for the workload to be evicted", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalseAndReason(kueue.WorkloadPodsReady, kueue.WorkloadWaitForStart))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadEvicted, kueue.WorkloadEvictedByPodsReadyTimeout))
+				g.Expect(wl.Status.SchedulingStats.Evictions).To(
+					gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
+						Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
+						UnderlyingCause: kueue.WorkloadWaitForStart,
+						Count:           1,
+					}}),
+				)
+			}, util.Timeout, util.Interval).Should(gomega.Succeed())
 		})
 
-		ginkgo.It("should evict and requeue workload when pods readiness timeout is surpassed", func() {
-			ginkgo.By("creating a suspended job so its pods never report Ready", func() {
-				job = testingjob.MakeJob("job-timeout", ns.Name).
-					Queue(kueue.LocalQueueName(lq.Name)).
-					Request(corev1.ResourceCPU, "2").
-					Parallelism(1).
-					Obj()
-				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+		ginkgo.By("verifying that the metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForStart, "1"},
 			})
+		})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+		ginkgo.By("verifying that the job is suspended", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(job), job)).Should(gomega.Succeed())
+				g.Expect(ptr.Deref(job.Spec.Suspend, false)).To(gomega.BeTrue())
+			}, util.Timeout, util.Interval).Should(gomega.Succeed())
+		})
 
-			ginkgo.By("waiting for the workload to be created and verifying it is not admitted", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.Admission).To(gomega.BeNil())
-				}, util.Timeout, util.Interval).Should(gomega.Succeed())
-			})
+		ginkgo.By("verifying that the workload is requeued", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
+				g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
+			}, util.Timeout, util.Interval).Should(gomega.Succeed())
+		})
 
-			ginkgo.By("waiting for the workload to be evicted", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalseAndReason(kueue.WorkloadPodsReady, kueue.WorkloadWaitForStart))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadEvicted, kueue.WorkloadEvictedByPodsReadyTimeout))
-					g.Expect(wl.Status.SchedulingStats.Evictions).To(
-						gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
-							Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
-							UnderlyingCause: kueue.WorkloadWaitForStart,
-							Count:           1,
-						}}),
-					)
-				}, util.Timeout, util.Interval).Should(gomega.Succeed())
-			})
+		ginkgo.By("verifying that the workload is deactivated after the second eviction", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(ptr.Deref(wl.Spec.Active, true)).Should(gomega.BeFalse())
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
+	})
+})
 
-			ginkgo.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForStart, "1"},
-				})
-			})
+var _ = ginkgo.Describe("WaitForPodsReady with default Timeout and a tiny RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
+	var (
+		ns    *corev1.Namespace
+		rf    *kueue.ResourceFlavor
+		cq    *kueue.ClusterQueue
+		lq    *kueue.LocalQueue
+		job   *batchv1.Job
+		wl    kueue.Workload
+		wlKey types.NamespacedName
 
-			ginkgo.By("verifying that the job is suspended", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(job), job)).Should(gomega.Succeed())
-					g.Expect(ptr.Deref(job.Spec.Suspend, false)).To(gomega.BeTrue())
-				}, util.Timeout, util.Interval).Should(gomega.Succeed())
-			})
+		metricsReaderClusterRoleBinding *rbacv1.ClusterRoleBinding
 
-			ginkgo.By("verifying that the workload is requeued", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
-					g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
-				}, util.Timeout, util.Interval).Should(gomega.Succeed())
-			})
+		curlContainerName string
+		curlPod           *corev1.Pod
+	)
 
-			ginkgo.By("verifying that the workload is deactivated after the second eviction", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(ptr.Deref(wl.Spec.Active, true)).Should(gomega.BeFalse())
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+	ginkgo.BeforeAll(func() {
+		metricsReaderClusterRoleBinding = &rbacv1.ClusterRoleBinding{
+			ObjectMeta: metav1.ObjectMeta{Name: "metrics-reader-rolebinding"},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind:      "ServiceAccount",
+					Name:      serviceAccountName,
+					Namespace: configapi.DefaultNamespace,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				APIGroup: rbacv1.GroupName,
+				Kind:     "ClusterRole",
+				Name:     metricsReaderClusterRoleName,
+			},
+		}
+		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
+
+		updateKueueConfiguration(func(cfg *configapi.Configuration) {
+			cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+				Enable:          true,
+				BlockAdmission:  ptr.To(true),
+				RecoveryTimeout: &metav1.Duration{Duration: util.TinyTimeout},
+				RequeuingStrategy: &configapi.RequeuingStrategy{
+					Timestamp:          ptr.To(configapi.EvictionTimestamp),
+					BackoffBaseSeconds: ptr.To(int32(1)),
+					BackoffLimitCount:  ptr.To(int32(1)),
+				},
+			}
 		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
-	ginkgo.When("WaitForPodsReady has default Timeout and a tiny RecoveryTimeout", func() {
-		ginkgo.BeforeEach(func() {
-			updateKueueConfiguration(func(cfg *configapi.Configuration) {
-				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
-					Enable:          true,
-					BlockAdmission:  ptr.To(true),
-					RecoveryTimeout: &metav1.Duration{Duration: util.TinyTimeout},
-					RequeuingStrategy: &configapi.RequeuingStrategy{
-						Timestamp:          ptr.To(configapi.EvictionTimestamp),
-						BackoffBaseSeconds: ptr.To(int32(1)),
-						BackoffLimitCount:  ptr.To(int32(1)),
-					},
-				}
-			})
+	ginkgo.BeforeEach(func() {
+		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
+
+		rf = testing.MakeResourceFlavor("default").Obj()
+		util.MustCreate(ctx, k8sClient, rf)
+
+		cq = testing.MakeClusterQueue("cq").
+			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
+			Obj()
+		util.MustCreate(ctx, k8sClient, cq)
+
+		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
+		util.MustCreate(ctx, k8sClient, lq)
+	})
+
+	ginkgo.AfterEach(func() {
+		gomega.Expect(util.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, cq, true)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, rf, true)
+		util.ExpectAllPodsInNamespaceDeleted(ctx, k8sClient, ns)
+	})
+
+	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, true)
+	})
 
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
+	ginkgo.It("should evict and requeue workload when pod failure causes recovery timeout", func() {
+		ginkgo.By("creating a job", func() {
+			job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
 				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				TerminationGracePeriod(1).
+				Queue(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
+				BackoffLimitPerIndex(2).
+				CompletionMode(batchv1.IndexedCompletion).
+				Completions(1).
 				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			curlContainerName = curlPod.Spec.Containers[0].Name
+		ginkgo.By("checking workload availability", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
 		})
 
-		ginkgo.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		ginkgo.By("simulating pod failure", func() {
+			util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
 		})
 
-		ginkgo.It("should evict and requeue workload when pod failure causes recovery timeout", func() {
-			ginkgo.By("creating a job", func() {
-				job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
-					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Queue(kueue.LocalQueueName(lq.Name)).
-					Request(corev1.ResourceCPU, "2").
-					Parallelism(1).
-					BackoffLimitPerIndex(2).
-					CompletionMode(batchv1.IndexedCompletion).
-					Completions(1).
-					Obj()
-
-				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+		ginkgo.By("verifying that the workload is requeued", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
+				g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadStarted))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalse(kueue.WorkloadEvicted))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadRequeued))
+
+				g.Expect(wl.Status.SchedulingStats.Evictions).To(
+					gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
+						Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
+						UnderlyingCause: kueue.WorkloadWaitForRecovery,
+						Count:           1,
+					}}),
+				)
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
+
+		ginkgo.By("verifying that the metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForRecovery, "1"},
 			})
+		})
+	})
+})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+var _ = ginkgo.Describe("WaitForPodsReady with default Timeout and a long RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
+	var (
+		ns    *corev1.Namespace
+		rf    *kueue.ResourceFlavor
+		cq    *kueue.ClusterQueue
+		lq    *kueue.LocalQueue
+		job   *batchv1.Job
+		wl    kueue.Workload
+		wlKey types.NamespacedName
 
-			ginkgo.By("checking workload availability", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+		metricsReaderClusterRoleBinding *rbacv1.ClusterRoleBinding
 
-			ginkgo.By("simulating pod failure", func() {
-				util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
-			})
+		curlContainerName string
+		curlPod           *corev1.Pod
+	)
 
-			ginkgo.By("verifying that the workload is requeued", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
-					g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadStarted))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalse(kueue.WorkloadEvicted))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadRequeued))
-
-					g.Expect(wl.Status.SchedulingStats.Evictions).To(
-						gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
-							Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
-							UnderlyingCause: kueue.WorkloadWaitForRecovery,
-							Count:           1,
-						}}),
-					)
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+	ginkgo.BeforeAll(func() {
+		metricsReaderClusterRoleBinding = &rbacv1.ClusterRoleBinding{
+			ObjectMeta: metav1.ObjectMeta{Name: "metrics-reader-rolebinding"},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind:      "ServiceAccount",
+					Name:      serviceAccountName,
+					Namespace: configapi.DefaultNamespace,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				APIGroup: rbacv1.GroupName,
+				Kind:     "ClusterRole",
+				Name:     metricsReaderClusterRoleName,
+			},
+		}
+		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
 
-			ginkgo.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForRecovery, "1"},
-				})
-			})
+		updateKueueConfiguration(func(cfg *configapi.Configuration) {
+			cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+				Enable:          true,
+				BlockAdmission:  ptr.To(true),
+				RecoveryTimeout: &metav1.Duration{Duration: util.LongTimeout},
+				RequeuingStrategy: &configapi.RequeuingStrategy{
+					Timestamp:          ptr.To(configapi.EvictionTimestamp),
+					BackoffBaseSeconds: ptr.To(int32(1)),
+					BackoffLimitCount:  ptr.To(int32(1)),
+				},
+			}
 		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
-	ginkgo.When("WaitForPodsReady has default Timeout and a long RecoveryTimeout", func() {
-		ginkgo.BeforeEach(func() {
-			updateKueueConfiguration(func(cfg *configapi.Configuration) {
-				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
-					Enable:          true,
-					BlockAdmission:  ptr.To(true),
-					RecoveryTimeout: &metav1.Duration{Duration: util.LongTimeout},
-					RequeuingStrategy: &configapi.RequeuingStrategy{
-						Timestamp:          ptr.To(configapi.EvictionTimestamp),
-						BackoffBaseSeconds: ptr.To(int32(1)),
-						BackoffLimitCount:  ptr.To(int32(1)),
-					},
-				}
-			})
+	ginkgo.BeforeEach(func() {
+		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
 
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
-				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				TerminationGracePeriod(1).
-				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+		rf = testing.MakeResourceFlavor("default").Obj()
+		util.MustCreate(ctx, k8sClient, rf)
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		cq = testing.MakeClusterQueue("cq").
+			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
+			Obj()
+		util.MustCreate(ctx, k8sClient, cq)
 
-			curlContainerName = curlPod.Spec.Containers[0].Name
-		})
+		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
+		util.MustCreate(ctx, k8sClient, lq)
+	})
 
-		ginkgo.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
-		})
+	ginkgo.AfterEach(func() {
+		gomega.Expect(util.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, cq, true)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, rf, true)
+		util.ExpectAllPodsInNamespaceDeleted(ctx, k8sClient, ns)
+	})
 
-		ginkgo.It("should continue running workload if pod recovers before recoveryTimeout", func() {
-			ginkgo.By("creating a job", func() {
-				job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
-					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-					Queue(kueue.LocalQueueName(lq.Name)).
-					Request(corev1.ResourceCPU, "2").
-					Parallelism(1).
-					BackoffLimitPerIndex(2).
-					CompletionMode(batchv1.IndexedCompletion).
-					Completions(1).
-					Obj()
-
-				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
-			})
+	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, true)
+	})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+	ginkgo.It("should continue running workload if pod recovers before recoveryTimeout", func() {
+		ginkgo.By("creating a job", func() {
+			job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
+				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+				Queue(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
+				BackoffLimitPerIndex(2).
+				CompletionMode(batchv1.IndexedCompletion).
+				Completions(1).
+				Obj()
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			ginkgo.By("checking workload availability", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			ginkgo.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_ready_wait_time_seconds_count", cq.Name},
-					{"kueue_admitted_until_ready_wait_time_seconds_count", cq.Name},
-					{"kueue_local_queue_ready_wait_time_seconds", ns.Name, lq.Name},
-					{"kueue_local_queue_admitted_until_ready_wait_time_seconds", ns.Name, lq.Name}})
-			})
+		ginkgo.By("checking workload availability", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
 
-			ginkgo.By("simulating pod failure", func() {
-				util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
-			})
+		ginkgo.By("verifying that the metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_ready_wait_time_seconds_count", cq.Name},
+				{"kueue_admitted_until_ready_wait_time_seconds_count", cq.Name},
+				{"kueue_local_queue_ready_wait_time_seconds", ns.Name, lq.Name},
+				{"kueue_local_queue_admitted_until_ready_wait_time_seconds", ns.Name, lq.Name}})
+		})
 
-			ginkgo.By("verifying the pod is recovered before recoveryTimeout", func() {
-				gomega.Eventually(func(g gomega.Gomega) {
-					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadRecovered))
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+		ginkgo.By("simulating pod failure", func() {
+			util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
+		})
+
+		ginkgo.By("verifying the pod is recovered before recoveryTimeout", func() {
+			gomega.Eventually(func(g gomega.Gomega) {
+				g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadRecovered))
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
 
-			ginkgo.By("verifying that the metric is not updated", func() {
-				util.ExpectMetricsNotToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", ns.Name},
-				})
+		ginkgo.By("verifying that the metric is not updated", func() {
+			util.ExpectMetricsNotToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", ns.Name},
 			})
 		})
 	})
diff --git a/test/e2e/kueueviz/cypress.config.js b/test/e2e/kueueviz/cypress.config.js
index c8bd55c23..bddc57ba6 100644
--- a/test/e2e/kueueviz/cypress.config.js
+++ b/test/e2e/kueueviz/cypress.config.js
@@ -3,6 +3,9 @@ import { defineConfig } from "cypress";
 export default defineConfig({
   e2e: {
     baseUrl: 'http://localhost:3000',
+    screenshotsFolder: process.env.CYPRESS_SCREENSHOTS_FOLDER || 'cypress/screenshots',
+    video: true,
+    videosFolder: process.env.CYPRESS_VIDEOS_FOLDER || 'cypress/videos',
     specPattern: 'cypress/e2e/**/*.cy.{js,ts}',
     supportFile: false,
     setupNodeEvents(on, config) {
diff --git a/test/e2e/kueueviz/cypress/screenshots/app.cy.js/Kueue Dashboard -- should verify cohort link and navigate to cohorts page (failed).png b/test/e2e/kueueviz/cypress/screenshots/app.cy.js/Kueue Dashboard -- should verify cohort link and navigate to cohorts page (failed).png
deleted file mode 100644
index 53e76c9d6..000000000
Binary files a/test/e2e/kueueviz/cypress/screenshots/app.cy.js/Kueue Dashboard -- should verify cohort link and navigate to cohorts page (failed).png and /dev/null differ
diff --git a/test/util/util.go b/test/util/util.go
index 912e86ef5..03be84ca5 100644
--- a/test/util/util.go
+++ b/test/util/util.go
@@ -526,18 +526,18 @@ func ExpectLQAdmittedWorkloadsTotalMetric(lq *kueue.LocalQueue, value int) {
 }
 
 func ExpectLQByStatusMetric(lq *kueue.LocalQueue, status metav1.ConditionStatus) {
-	for i, s := range metrics.ConditionStatusValues {
-		var wantV float64
-		if metrics.ConditionStatusValues[i] == status {
-			wantV = 1
-		}
-		metric := metrics.LocalQueueByStatus.WithLabelValues(lq.Name, lq.Namespace, string(s))
-		gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
+	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
+		for i, s := range metrics.ConditionStatusValues {
+			var wantV float64
+			if metrics.ConditionStatusValues[i] == status {
+				wantV = 1
+			}
+			metric := metrics.LocalQueueByStatus.WithLabelValues(lq.Name, lq.Namespace, string(s))
 			v, err := testutil.GetGaugeMetricValue(metric)
 			g.Expect(err).ToNot(gomega.HaveOccurred())
 			g.Expect(v).Should(gomega.Equal(wantV), "local_queue_status with status=%s", s)
-		}, Timeout, Interval).Should(gomega.Succeed())
-	}
+		}
+	}, Timeout, Interval).Should(gomega.Succeed())
 }
 
 func ExpectPendingWorkloadsMetric(cq *kueue.ClusterQueue, active, inadmissible int) {