Repository: kubernetes-sigs/kueue

Issue:
Rename WorkloadReference to Reference
<!-- Please only use this template for submitting clean up requests -->

**What would you like to be cleaned**:

I would like to rename `WorkloadReference` to `Reference` in https://github.com/kubernetes-sigs/kueue/blob/c47505f90ea356ed6fbf1c2238a28eaf5551d9f3/pkg/workload/workload.go#L72-L73

**Why is this needed**:

As I mentioned in https://github.com/kubernetes-sigs/kueue/pull/5366/files#r2120797124, we should avoid repeat the package name in contents like variables.
The client code calls it as `workload.WorkloadReference`. This form must be avoided and the workload pacakge allows client codes to call it as `workload.Reference`.

See more detailed recommendations in Go blog: https://go.dev/blog/package-names#naming-package-contents

> Avoid repetition. Since client code uses the package name as a prefix when referring to the package contents, the names for those contents need not repeat the package name. The HTTP server provided by the http package is called Server, not HTTPServer. Client code refers to this type as http.Server, so there is no ambiguity.

Discussion:
@tenzen-y: @mimowo @vladikkuzn I opened this issue since the PR was merged before I checked your comments.
Can you post the point of view for this one if you still believe `WorkloadReference` is better?
@mimowo: > Can you post the point of view for this one if you still believe `WorkloadReference` is better?

I posted the motivation for WorkloadReference in [response](https://github.com/kubernetes-sigs/kueue/pull/5366/files#r2123016475), but basically:
1. consistency with other "Reference" names
2. better name when we move the const to API package

Having said that I'm ok with the rename as you propose, since temporarily it looks awkward.

Alternatively we could consider moving this to API package as for ClusterQueueReference. @tenzen-y: > > Can you post the point of view for this one if you still believe `WorkloadReference` is better?
> 
> I posted the motivation for WorkloadReference in [response](https://github.com/kubernetes-sigs/kueue/pull/5366/files#r2123016475), but basically:
> 
> 1. consistency with other "Reference" names
> 2. better name when we move the const to API package
> 
> Having said that I'm ok with the rename as you propose, since temporarily it looks awkward.
> 
> Alternatively we could consider moving this to API package as for ClusterQueueReference.

The difference between workload and others is others are used in CRD, but workload one isn't used in CRD.
So, I still believe that having `Reference` typed in the workload package.

@mimowo Do you have any motivations that you want to have WorkloadReference typed in API package?
@mimowo: > The difference between workload and others is others are used in CRD, but workload one isn't used in CRD.

Yeah, but using in CRD is not the only reason to declare a const in API pkg. 

For example, in core k8s you have in API declarations of consts corresponding to 
- [well_known_taints](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/well_known_taints.go#L22), example TaintNodeNotReady
- [well_known_labels](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/well_known_labels.go), example `LabelTopologyZone   = "topology.kubernetes.io/zone"`
- [well known resource types](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/types.go#L6606-L6613), example CPU

> @mimowo Do you have any motivations that you want to have WorkloadReference typed in API package?

Nothing serious, I'm totally ok to rename as workload.Reference if you prefer.
@mimowo: In any case, Im happy to merge the rename PR. @vladikkuzn would you like to follow up?@vladikkuzn: Yes, sure, np@vladikkuzn: /assign@tenzen-y: > > The difference between workload and others is others are used in CRD, but workload one isn't used in CRD.
> 
> Yeah, but using in CRD is not the only reason to declare a const in API pkg.
> 
> For example, in core k8s you have in API declarations of consts corresponding to
> 
> * [well_known_taints](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/well_known_taints.go#L22), example TaintNodeNotReady
> * [well_known_labels](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/well_known_labels.go), example `LabelTopologyZone   = "topology.kubernetes.io/zone"`
> * [well known resource types](https://github.com/kubernetes/kubernetes/blob/8d3fb9ee0a51b6a6ea135d991391c35806422c19/staging/src/k8s.io/api/core/v1/types.go#L6606-L6613), example CPU
> 
> > [@mimowo](https://github.com/mimowo) Do you have any motivations that you want to have WorkloadReference typed in API package?
> 
> Nothing serious, I'm totally ok to rename as workload.Reference if you prefer.

For the above constants, yes that makes sense. However, the `WorkloadReference` is typed not constants, and if we host it as API package, we need to deliver Initialization function, `NewWorkloadReference` in API package as well. So, I recommended to move it to `workload` package.

In anycase, if you are ok with renaming to `workload.Reference`, I'm fine with that.@mimowo: Sure, let's go with workload Reference

Solution patch:
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/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/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/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/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/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/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)) {