Repository: kubernetes-sigs/kueue

Issue:
TAS: Follow the DUMP principle in node_failure_controller UTs
<!-- Please only use this template for submitting clean up requests -->

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

I would like to dump the test data in https://github.com/kubernetes-sigs/kueue/blob/7afe46898218e1508056dd3344b755c06d183a1d/pkg/controller/tas/node_failure_controller_test.go

We could define the following base node object inside of TestNodeFailureReconciler:

```go
baseNode := testingnode.MakeNode(name).
			StatusConditions(corev1.NodeCondition{
				Type:               corev1.NodeReady,
				Status:             readyStatus,
				LastTransitionTime: metav1.NewTime(clock.Now().Add(-transitionTimeOffset)),
			})
```

Then each test case clones the `baseNode`, and update case specific parameters by wrapper functions in the following:

```go
baseNode.Clone().
	StatusConditions(xyz)
```

**Why is this needed**:

We should follow the DUMP principle instead of DRY principle in tests.


Discussion:
@tenzen-y: cc @mimowo @PBundyra @pajakd 
@mimowo: Thank you for opening, yes it will benefit the project long term@olekzabl: /assign

Solution patch:
diff --git a/cmd/kueue/main.go b/cmd/kueue/main.go
index 657f17a5d..7768a3687 100644
--- a/cmd/kueue/main.go
+++ b/cmd/kueue/main.go
@@ -51,7 +51,8 @@ import (
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/config"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/admissionchecks/multikueue"
@@ -64,7 +65,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/debugger"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/util/cert"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
@@ -210,25 +210,25 @@ func main() {
 	} else {
 		close(certsReady)
 	}
-	cacheOptions := []cache.Option{cache.WithPodsReadyTracking(blockForPodsReady(&cfg))}
-	queueOptions := []queue.Option{queue.WithPodsReadyRequeuingTimestamp(podsReadyRequeuingTimestamp(&cfg))}
+	cacheOptions := []schdcache.Option{schdcache.WithPodsReadyTracking(blockForPodsReady(&cfg))}
+	queueOptions := []qcache.Option{qcache.WithPodsReadyRequeuingTimestamp(podsReadyRequeuingTimestamp(&cfg))}
 	if cfg.Resources != nil && len(cfg.Resources.ExcludeResourcePrefixes) > 0 {
-		cacheOptions = append(cacheOptions, cache.WithExcludedResourcePrefixes(cfg.Resources.ExcludeResourcePrefixes))
-		queueOptions = append(queueOptions, queue.WithExcludedResourcePrefixes(cfg.Resources.ExcludeResourcePrefixes))
+		cacheOptions = append(cacheOptions, schdcache.WithExcludedResourcePrefixes(cfg.Resources.ExcludeResourcePrefixes))
+		queueOptions = append(queueOptions, qcache.WithExcludedResourcePrefixes(cfg.Resources.ExcludeResourcePrefixes))
 	}
 	if features.Enabled(features.ConfigurableResourceTransformations) && cfg.Resources != nil && len(cfg.Resources.Transformations) > 0 {
-		cacheOptions = append(cacheOptions, cache.WithResourceTransformations(cfg.Resources.Transformations))
-		queueOptions = append(queueOptions, queue.WithResourceTransformations(cfg.Resources.Transformations))
+		cacheOptions = append(cacheOptions, schdcache.WithResourceTransformations(cfg.Resources.Transformations))
+		queueOptions = append(queueOptions, qcache.WithResourceTransformations(cfg.Resources.Transformations))
 	}
 	if cfg.FairSharing != nil {
-		cacheOptions = append(cacheOptions, cache.WithFairSharing(cfg.FairSharing.Enable))
+		cacheOptions = append(cacheOptions, schdcache.WithFairSharing(cfg.FairSharing.Enable))
 	}
 	if cfg.AdmissionFairSharing != nil {
-		queueOptions = append(queueOptions, queue.WithAdmissionFairSharing(cfg.AdmissionFairSharing))
-		cacheOptions = append(cacheOptions, cache.WithAdmissionFairSharing(cfg.AdmissionFairSharing))
+		queueOptions = append(queueOptions, qcache.WithAdmissionFairSharing(cfg.AdmissionFairSharing))
+		cacheOptions = append(cacheOptions, schdcache.WithAdmissionFairSharing(cfg.AdmissionFairSharing))
 	}
-	cCache := cache.New(mgr.GetClient(), cacheOptions...)
-	queues := queue.NewManager(mgr.GetClient(), cCache, queueOptions...)
+	cCache := schdcache.New(mgr.GetClient(), cacheOptions...)
+	queues := qcache.NewManager(mgr.GetClient(), cCache, queueOptions...)
 
 	ctx := ctrl.SetupSignalHandler()
 	if err := setupIndexes(ctx, mgr, &cfg); err != nil {
@@ -313,7 +313,7 @@ func setupIndexes(ctx context.Context, mgr ctrl.Manager, cfg *configapi.Configur
 	return jobframework.SetupIndexes(ctx, mgr.GetFieldIndexer(), opts...)
 }
 
-func setupControllers(ctx context.Context, mgr ctrl.Manager, cCache *cache.Cache, queues *queue.Manager, certsReady chan struct{}, cfg *configapi.Configuration, serverVersionFetcher *kubeversion.ServerVersionFetcher) error {
+func setupControllers(ctx context.Context, mgr ctrl.Manager, cCache *schdcache.Cache, queues *qcache.Manager, certsReady chan struct{}, cfg *configapi.Configuration, serverVersionFetcher *kubeversion.ServerVersionFetcher) error {
 	// The controllers won't work until the webhooks are operating, and the webhook won't work until the
 	// certs are all in place.
 	cert.WaitForCertsReady(setupLog, certsReady)
@@ -419,7 +419,7 @@ func setupProbeEndpoints(mgr ctrl.Manager, certsReady <-chan struct{}) error {
 	return nil
 }
 
-func setupScheduler(mgr ctrl.Manager, cCache *cache.Cache, queues *queue.Manager, cfg *configapi.Configuration) error {
+func setupScheduler(mgr ctrl.Manager, cCache *schdcache.Cache, queues *qcache.Manager, cfg *configapi.Configuration) error {
 	sched := scheduler.New(
 		queues,
 		cCache,
diff --git a/pkg/hierarchy/clusterqueue.go b/pkg/cache/hierarchy/clusterqueue.go
similarity index 100%
rename from pkg/hierarchy/clusterqueue.go
rename to pkg/cache/hierarchy/clusterqueue.go
diff --git a/pkg/hierarchy/cohort.go b/pkg/cache/hierarchy/cohort.go
similarity index 100%
rename from pkg/hierarchy/cohort.go
rename to pkg/cache/hierarchy/cohort.go
diff --git a/pkg/hierarchy/cycle.go b/pkg/cache/hierarchy/cycle.go
similarity index 100%
rename from pkg/hierarchy/cycle.go
rename to pkg/cache/hierarchy/cycle.go
diff --git a/pkg/hierarchy/manager.go b/pkg/cache/hierarchy/manager.go
similarity index 100%
rename from pkg/hierarchy/manager.go
rename to pkg/cache/hierarchy/manager.go
diff --git a/pkg/queue/afs_entry_penalties.go b/pkg/cache/queue/afs_entry_penalties.go
similarity index 100%
rename from pkg/queue/afs_entry_penalties.go
rename to pkg/cache/queue/afs_entry_penalties.go
diff --git a/pkg/queue/cluster_queue.go b/pkg/cache/queue/cluster_queue.go
similarity index 99%
rename from pkg/queue/cluster_queue.go
rename to pkg/cache/queue/cluster_queue.go
index e4562087d..186769045 100644
--- a/pkg/queue/cluster_queue.go
+++ b/pkg/cache/queue/cluster_queue.go
@@ -33,7 +33,7 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	afs "sigs.k8s.io/kueue/pkg/util/admissionfairsharing"
 	"sigs.k8s.io/kueue/pkg/util/heap"
 	utilmaps "sigs.k8s.io/kueue/pkg/util/maps"
diff --git a/pkg/queue/cohort.go b/pkg/cache/queue/cohort.go
similarity index 96%
rename from pkg/queue/cohort.go
rename to pkg/cache/queue/cohort.go
index 766b8c9b7..2e1e924d2 100644
--- a/pkg/queue/cohort.go
+++ b/pkg/cache/queue/cohort.go
@@ -18,7 +18,7 @@ package queue
 
 import (
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 )
 
 // cohort is a set of ClusterQueues that can borrow resources from
diff --git a/pkg/queue/dumper.go b/pkg/cache/queue/dumper.go
similarity index 100%
rename from pkg/queue/dumper.go
rename to pkg/cache/queue/dumper.go
diff --git a/pkg/queue/local_queue.go b/pkg/cache/queue/local_queue.go
similarity index 100%
rename from pkg/queue/local_queue.go
rename to pkg/cache/queue/local_queue.go
diff --git a/pkg/queue/manager.go b/pkg/cache/queue/manager.go
similarity index 99%
rename from pkg/queue/manager.go
rename to pkg/cache/queue/manager.go
index a53bc709a..538c0c7b6 100644
--- a/pkg/queue/manager.go
+++ b/pkg/cache/queue/manager.go
@@ -34,9 +34,9 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	utilindexer "sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	afs "sigs.k8s.io/kueue/pkg/util/admissionfairsharing"
 	utilmaps "sigs.k8s.io/kueue/pkg/util/maps"
diff --git a/pkg/queue/second_pass_queue.go b/pkg/cache/queue/second_pass_queue.go
similarity index 100%
rename from pkg/queue/second_pass_queue.go
rename to pkg/cache/queue/second_pass_queue.go
diff --git a/pkg/queue/status_checker.go b/pkg/cache/queue/status_checker.go
similarity index 100%
rename from pkg/queue/status_checker.go
rename to pkg/cache/queue/status_checker.go
diff --git a/pkg/cache/admissioncheck.go b/pkg/cache/scheduler/admissioncheck.go
similarity index 97%
rename from pkg/cache/admissioncheck.go
rename to pkg/cache/scheduler/admissioncheck.go
index e72f743e6..c8d840c12 100644
--- a/pkg/cache/admissioncheck.go
+++ b/pkg/cache/scheduler/admissioncheck.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 type AdmissionCheck struct {
 	Active     bool
diff --git a/pkg/cache/cache.go b/pkg/cache/scheduler/cache.go
similarity index 99%
rename from pkg/cache/cache.go
rename to pkg/cache/scheduler/cache.go
index ba31b5248..eddc25245 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/scheduler/cache.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"context"
@@ -36,9 +36,9 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	utilindexer "sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/util/queue"
diff --git a/pkg/cache/clusterqueue.go b/pkg/cache/scheduler/clusterqueue.go
similarity index 99%
rename from pkg/cache/clusterqueue.go
rename to pkg/cache/scheduler/clusterqueue.go
index 61bad5a1f..73f50193e 100644
--- a/pkg/cache/clusterqueue.go
+++ b/pkg/cache/scheduler/clusterqueue.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"errors"
@@ -33,8 +33,8 @@ import (
 	"k8s.io/utils/ptr"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/util/admissioncheck"
diff --git a/pkg/cache/clusterqueue_snapshot.go b/pkg/cache/scheduler/clusterqueue_snapshot.go
similarity index 99%
rename from pkg/cache/clusterqueue_snapshot.go
rename to pkg/cache/scheduler/clusterqueue_snapshot.go
index 0bb4a0152..1fe225478 100644
--- a/pkg/cache/clusterqueue_snapshot.go
+++ b/pkg/cache/scheduler/clusterqueue_snapshot.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"iter"
@@ -26,8 +26,8 @@ import (
 	"k8s.io/apimachinery/pkg/util/sets"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/resources"
 	utiltas "sigs.k8s.io/kueue/pkg/util/tas"
diff --git a/pkg/cache/cohort.go b/pkg/cache/scheduler/cohort.go
similarity index 97%
rename from pkg/cache/cohort.go
rename to pkg/cache/scheduler/cohort.go
index 2f842b2bf..1dfbeb7d0 100644
--- a/pkg/cache/cohort.go
+++ b/pkg/cache/scheduler/cohort.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"iter"
@@ -22,7 +22,7 @@ import (
 	"k8s.io/apimachinery/pkg/api/resource"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 )
 
 // cohort is a set of ClusterQueues that can borrow resources from each other.
diff --git a/pkg/cache/cohort_snapshot.go b/pkg/cache/scheduler/cohort_snapshot.go
similarity index 97%
rename from pkg/cache/cohort_snapshot.go
rename to pkg/cache/scheduler/cohort_snapshot.go
index 6a5a8bc4c..2a7129854 100644
--- a/pkg/cache/cohort_snapshot.go
+++ b/pkg/cache/scheduler/cohort_snapshot.go
@@ -14,13 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"k8s.io/apimachinery/pkg/api/resource"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/resources"
 )
 
diff --git a/pkg/cache/fair_sharing.go b/pkg/cache/scheduler/fair_sharing.go
similarity index 99%
rename from pkg/cache/fair_sharing.go
rename to pkg/cache/scheduler/fair_sharing.go
index 325ad5255..d9629148c 100644
--- a/pkg/cache/fair_sharing.go
+++ b/pkg/cache/scheduler/fair_sharing.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"math"
diff --git a/pkg/cache/localqueue.go b/pkg/cache/scheduler/localqueue.go
similarity index 98%
rename from pkg/cache/localqueue.go
rename to pkg/cache/scheduler/localqueue.go
index 717939c4e..a7e356e42 100644
--- a/pkg/cache/localqueue.go
+++ b/pkg/cache/scheduler/localqueue.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"sync"
diff --git a/pkg/cache/resource.go b/pkg/cache/scheduler/resource.go
similarity index 99%
rename from pkg/cache/resource.go
rename to pkg/cache/scheduler/resource.go
index 66e052627..775dda245 100644
--- a/pkg/cache/resource.go
+++ b/pkg/cache/scheduler/resource.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	corev1 "k8s.io/api/core/v1"
diff --git a/pkg/cache/resource_node.go b/pkg/cache/scheduler/resource_node.go
similarity index 99%
rename from pkg/cache/resource_node.go
rename to pkg/cache/scheduler/resource_node.go
index b8985fce8..47a9325ae 100644
--- a/pkg/cache/resource_node.go
+++ b/pkg/cache/scheduler/resource_node.go
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"maps"
 
 	"k8s.io/apimachinery/pkg/util/sets"
 
-	"sigs.k8s.io/kueue/pkg/hierarchy"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/resources"
 )
 
diff --git a/pkg/cache/snapshot.go b/pkg/cache/scheduler/snapshot.go
similarity index 99%
rename from pkg/cache/snapshot.go
rename to pkg/cache/scheduler/snapshot.go
index 33cc9e75a..633a0593e 100644
--- a/pkg/cache/snapshot.go
+++ b/pkg/cache/scheduler/snapshot.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"context"
@@ -30,8 +30,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	afs "sigs.k8s.io/kueue/pkg/util/admissionfairsharing"
 	utilmaps "sigs.k8s.io/kueue/pkg/util/maps"
 	utilqueue "sigs.k8s.io/kueue/pkg/util/queue"
diff --git a/pkg/cache/tas_cache.go b/pkg/cache/scheduler/tas_cache.go
similarity index 99%
rename from pkg/cache/tas_cache.go
rename to pkg/cache/scheduler/tas_cache.go
index f1e73c47e..d9d2c87c8 100644
--- a/pkg/cache/tas_cache.go
+++ b/pkg/cache/scheduler/tas_cache.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"maps"
diff --git a/pkg/cache/tas_flavor.go b/pkg/cache/scheduler/tas_flavor.go
similarity index 99%
rename from pkg/cache/tas_flavor.go
rename to pkg/cache/scheduler/tas_flavor.go
index 22dd7b248..2c828b37c 100644
--- a/pkg/cache/tas_flavor.go
+++ b/pkg/cache/scheduler/tas_flavor.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"context"
diff --git a/pkg/cache/tas_flavor_snapshot.go b/pkg/cache/scheduler/tas_flavor_snapshot.go
similarity index 99%
rename from pkg/cache/tas_flavor_snapshot.go
rename to pkg/cache/scheduler/tas_flavor_snapshot.go
index 4373b3c48..4129b5b6c 100644
--- a/pkg/cache/tas_flavor_snapshot.go
+++ b/pkg/cache/scheduler/tas_flavor_snapshot.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"cmp"
diff --git a/pkg/controller/core/admissioncheck_controller.go b/pkg/controller/core/admissioncheck_controller.go
index 48ca29bf2..6c8fe09c2 100644
--- a/pkg/controller/core/admissioncheck_controller.go
+++ b/pkg/controller/core/admissioncheck_controller.go
@@ -38,8 +38,8 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/util/slices"
 )
 
@@ -50,9 +50,9 @@ type AdmissionCheckUpdateWatcher interface {
 // AdmissionCheckReconciler reconciles a AdmissionCheck object
 type AdmissionCheckReconciler struct {
 	log        logr.Logger
-	qManager   *queue.Manager
+	qManager   *qcache.Manager
 	client     client.Client
-	cache      *cache.Cache
+	cache      *schdcache.Cache
 	cqUpdateCh chan event.GenericEvent
 	watchers   []AdmissionCheckUpdateWatcher
 }
@@ -62,8 +62,8 @@ var _ predicate.TypedPredicate[*kueue.AdmissionCheck] = (*AdmissionCheckReconcil
 
 func NewAdmissionCheckReconciler(
 	client client.Client,
-	qMgr *queue.Manager,
-	cache *cache.Cache,
+	qMgr *qcache.Manager,
+	cache *schdcache.Cache,
 ) *AdmissionCheckReconciler {
 	return &AdmissionCheckReconciler{
 		log:        ctrl.Log.WithName("admissioncheck-reconciler"),
@@ -179,7 +179,7 @@ func (r *AdmissionCheckReconciler) NotifyClusterQueueUpdate(oldCq *kueue.Cluster
 }
 
 type acCqHandler struct {
-	cache *cache.Cache
+	cache *schdcache.Cache
 }
 
 func (h *acCqHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
diff --git a/pkg/controller/core/clusterqueue_controller.go b/pkg/controller/core/clusterqueue_controller.go
index d80bdfa94..c0b23ebe7 100644
--- a/pkg/controller/core/clusterqueue_controller.go
+++ b/pkg/controller/core/clusterqueue_controller.go
@@ -48,11 +48,11 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/resource"
 	utilslices "sigs.k8s.io/kueue/pkg/util/slices"
 	"sigs.k8s.io/kueue/pkg/workload"
@@ -68,8 +68,8 @@ type ClusterQueueUpdateWatcher interface {
 type ClusterQueueReconciler struct {
 	client                               client.Client
 	log                                  logr.Logger
-	qManager                             *queue.Manager
-	cache                                *cache.Cache
+	qManager                             *qcache.Manager
+	cache                                *schdcache.Cache
 	snapshotsQueue                       workqueue.TypedInterface[kueue.ClusterQueueReference]
 	snapUpdateCh                         chan event.GenericEvent
 	nonCQObjectUpdateCh                  chan event.TypedGenericEvent[iter.Seq[kueue.ClusterQueueReference]]
@@ -136,8 +136,8 @@ var defaultCQOptions = ClusterQueueReconcilerOptions{
 
 func NewClusterQueueReconciler(
 	client client.Client,
-	qMgr *queue.Manager,
-	cache *cache.Cache,
+	qMgr *qcache.Manager,
+	cache *schdcache.Cache,
 	opts ...ClusterQueueReconcilerOption,
 ) *ClusterQueueReconciler {
 	options := defaultCQOptions
@@ -494,8 +494,8 @@ func clearOldResourceQuotas(oldCq, newCq *kueue.ClusterQueue) {
 
 // cqNamespaceHandler handles namespace update events.
 type cqNamespaceHandler struct {
-	qManager *queue.Manager
-	cache    *cache.Cache
+	qManager *qcache.Manager
+	cache    *schdcache.Cache
 }
 
 func (h *cqNamespaceHandler) Create(_ context.Context, _ event.CreateEvent, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) {
diff --git a/pkg/controller/core/cohort_controller.go b/pkg/controller/core/cohort_controller.go
index 7a6890e24..895e6acc4 100644
--- a/pkg/controller/core/cohort_controller.go
+++ b/pkg/controller/core/cohort_controller.go
@@ -36,9 +36,9 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 type CohortReconcilerOptions struct {
@@ -59,16 +59,16 @@ func CohortReconcilerWithFairSharing(enabled bool) CohortReconcilerOption {
 type CohortReconciler struct {
 	client             client.Client
 	log                logr.Logger
-	cache              *cache.Cache
-	qManager           *queue.Manager
+	cache              *schdcache.Cache
+	qManager           *qcache.Manager
 	cqUpdateCh         chan event.GenericEvent
 	fairSharingEnabled bool
 }
 
 func NewCohortReconciler(
 	client client.Client,
-	cache *cache.Cache,
-	qManager *queue.Manager,
+	cache *schdcache.Cache,
+	qManager *qcache.Manager,
 	opts ...CohortReconcilerOption,
 ) *CohortReconciler {
 	options := CohortReconcilerOptions{}
@@ -194,7 +194,7 @@ func (r *CohortReconciler) NotifyClusterQueueUpdate(oldCQ, newCQ *kueue.ClusterQ
 }
 
 type cohortCqHandler struct {
-	cache *cache.Cache
+	cache *schdcache.Cache
 }
 
 func (h *cohortCqHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
diff --git a/pkg/controller/core/core.go b/pkg/controller/core/core.go
index cdcbd1b45..aa1acaceb 100644
--- a/pkg/controller/core/core.go
+++ b/pkg/controller/core/core.go
@@ -22,10 +22,10 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 const (
@@ -34,7 +34,7 @@ const (
 
 // SetupControllers sets up the core controllers. It returns the name of the
 // controller that failed to create and an error, if any.
-func SetupControllers(mgr ctrl.Manager, qManager *queue.Manager, cc *cache.Cache, cfg *configapi.Configuration) (string, error) {
+func SetupControllers(mgr ctrl.Manager, qManager *qcache.Manager, cc *schdcache.Cache, cfg *configapi.Configuration) (string, error) {
 	rfRec := NewResourceFlavorReconciler(mgr.GetClient(), qManager, cc)
 	if err := rfRec.SetupWithManager(mgr, cfg); err != nil {
 		return "ResourceFlavor", err
diff --git a/pkg/controller/core/localqueue_controller.go b/pkg/controller/core/localqueue_controller.go
index 12982ae86..fb873f0d0 100644
--- a/pkg/controller/core/localqueue_controller.go
+++ b/pkg/controller/core/localqueue_controller.go
@@ -42,12 +42,12 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	afs "sigs.k8s.io/kueue/pkg/util/admissionfairsharing"
 	utilqueue "sigs.k8s.io/kueue/pkg/util/queue"
 	"sigs.k8s.io/kueue/pkg/util/resource"
@@ -92,8 +92,8 @@ var defaultLQOptions = LocalQueueReconcilerOptions{
 type LocalQueueReconciler struct {
 	client            client.Client
 	log               logr.Logger
-	queues            *queue.Manager
-	cache             *cache.Cache
+	queues            *qcache.Manager
+	cache             *schdcache.Cache
 	wlUpdateCh        chan event.GenericEvent
 	admissionFSConfig *config.AdmissionFairSharing
 	clock             clock.Clock
@@ -104,8 +104,8 @@ var _ predicate.TypedPredicate[*kueue.LocalQueue] = (*LocalQueueReconciler)(nil)
 
 func NewLocalQueueReconciler(
 	client client.Client,
-	queues *queue.Manager,
-	cache *cache.Cache,
+	queues *qcache.Manager,
+	cache *schdcache.Cache,
 	opts ...LocalQueueReconcilerOption,
 ) *LocalQueueReconciler {
 	options := defaultLQOptions
diff --git a/pkg/controller/core/resourceflavor_controller.go b/pkg/controller/core/resourceflavor_controller.go
index 895bc7f27..f0b4af525 100644
--- a/pkg/controller/core/resourceflavor_controller.go
+++ b/pkg/controller/core/resourceflavor_controller.go
@@ -38,8 +38,8 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 )
 
 type ResourceFlavorUpdateWatcher interface {
@@ -49,8 +49,8 @@ type ResourceFlavorUpdateWatcher interface {
 // ResourceFlavorReconciler reconciles a ResourceFlavor object
 type ResourceFlavorReconciler struct {
 	log        logr.Logger
-	qManager   *queue.Manager
-	cache      *cache.Cache
+	qManager   *qcache.Manager
+	cache      *schdcache.Cache
 	client     client.Client
 	cqUpdateCh chan event.GenericEvent
 	watchers   []ResourceFlavorUpdateWatcher
@@ -61,8 +61,8 @@ var _ predicate.TypedPredicate[*kueue.ResourceFlavor] = (*ResourceFlavorReconcil
 
 func NewResourceFlavorReconciler(
 	client client.Client,
-	qMgr *queue.Manager,
-	cache *cache.Cache,
+	qMgr *qcache.Manager,
+	cache *schdcache.Cache,
 ) *ResourceFlavorReconciler {
 	return &ResourceFlavorReconciler{
 		log:        ctrl.Log.WithName("resourceflavor-reconciler"),
@@ -205,7 +205,7 @@ func (r *ResourceFlavorReconciler) NotifyClusterQueueUpdate(oldCQ, newCQ *kueue.
 // Since the events come from a channel Source, only the Generic handler will
 // receive events.
 type cqHandler struct {
-	cache *cache.Cache
+	cache *schdcache.Cache
 }
 
 func (h *cqHandler) Create(context.Context, event.CreateEvent, workqueue.TypedRateLimitingInterface[reconcile.Request]) {
diff --git a/pkg/controller/core/workload_controller.go b/pkg/controller/core/workload_controller.go
index 8917a3f41..d48437f06 100644
--- a/pkg/controller/core/workload_controller.go
+++ b/pkg/controller/core/workload_controller.go
@@ -51,11 +51,11 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/admissioncheck"
 	clientutil "sigs.k8s.io/kueue/pkg/util/client"
 	utilslices "sigs.k8s.io/kueue/pkg/util/slices"
@@ -112,8 +112,8 @@ type WorkloadUpdateWatcher interface {
 // WorkloadReconciler reconciles a Workload object
 type WorkloadReconciler struct {
 	log               logr.Logger
-	queues            *queue.Manager
-	cache             *cache.Cache
+	queues            *qcache.Manager
+	cache             *schdcache.Cache
 	client            client.Client
 	watchers          []WorkloadUpdateWatcher
 	waitForPodsReady  *waitForPodsReadyConfig
@@ -125,7 +125,7 @@ type WorkloadReconciler struct {
 var _ reconcile.Reconciler = (*WorkloadReconciler)(nil)
 var _ predicate.TypedPredicate[*kueue.Workload] = (*WorkloadReconciler)(nil)
 
-func NewWorkloadReconciler(client client.Client, queues *queue.Manager, cache *cache.Cache, recorder record.EventRecorder, options ...Option) *WorkloadReconciler {
+func NewWorkloadReconciler(client client.Client, queues *qcache.Manager, cache *schdcache.Cache, recorder record.EventRecorder, options ...Option) *WorkloadReconciler {
 	r := &WorkloadReconciler{
 		log:      ctrl.Log.WithName("workload-reconciler"),
 		client:   client,
diff --git a/pkg/controller/jobframework/base_webhook.go b/pkg/controller/jobframework/base_webhook.go
index 8c3102697..e813a5fac 100644
--- a/pkg/controller/jobframework/base_webhook.go
+++ b/pkg/controller/jobframework/base_webhook.go
@@ -25,9 +25,9 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 // BaseWebhook applies basic defaulting and validation for jobs.
@@ -36,8 +36,8 @@ type BaseWebhook struct {
 	ManageJobsWithoutQueueName   bool
 	ManagedJobsNamespaceSelector labels.Selector
 	FromObject                   func(runtime.Object) GenericJob
-	Queues                       *queue.Manager
-	Cache                        *cache.Cache
+	Queues                       *qcache.Manager
+	Cache                        *schdcache.Cache
 }
 
 func BaseWebhookFactory(job GenericJob, fromObject func(runtime.Object) GenericJob) func(ctrl.Manager, ...Option) error {
diff --git a/pkg/controller/jobframework/defaults.go b/pkg/controller/jobframework/defaults.go
index 994758a91..65bd7198e 100644
--- a/pkg/controller/jobframework/defaults.go
+++ b/pkg/controller/jobframework/defaults.go
@@ -27,10 +27,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utilqueue "sigs.k8s.io/kueue/pkg/util/queue"
 )
 
@@ -96,7 +96,7 @@ func ApplyDefaultLocalQueue(jobObj client.Object, defaultQueueExist func(string)
 	}
 }
 
-func ApplyDefaultForManagedBy(job GenericJob, queues *queue.Manager, cache *cache.Cache, log logr.Logger) {
+func ApplyDefaultForManagedBy(job GenericJob, queues *qcache.Manager, cache *schdcache.Cache, log logr.Logger) {
 	if managedJob, ok := job.(JobWithManagedBy); ok {
 		if managedJob.CanDefaultManagedBy() {
 			localQueueName, found := job.Object().GetLabels()[constants.QueueLabel]
diff --git a/pkg/controller/jobframework/reconciler.go b/pkg/controller/jobframework/reconciler.go
index c204ae67d..75fa8e0a0 100644
--- a/pkg/controller/jobframework/reconciler.go
+++ b/pkg/controller/jobframework/reconciler.go
@@ -46,14 +46,14 @@ import (
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	controllerconsts "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/podset"
-	"sigs.k8s.io/kueue/pkg/queue"
 	clientutil "sigs.k8s.io/kueue/pkg/util/client"
 	"sigs.k8s.io/kueue/pkg/util/equality"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
@@ -103,8 +103,8 @@ type Options struct {
 	EnabledExternalFrameworks    sets.Set[string]
 	ManagerName                  string
 	LabelKeysToCopy              []string
-	Queues                       *queue.Manager
-	Cache                        *cache.Cache
+	Queues                       *qcache.Manager
+	Cache                        *schdcache.Cache
 	Clock                        clock.Clock
 	WorkloadRetentionPolicy      WorkloadRetentionPolicy
 }
@@ -196,14 +196,14 @@ func WithLabelKeysToCopy(n []string) Option {
 }
 
 // WithQueues adds the queue manager.
-func WithQueues(q *queue.Manager) Option {
+func WithQueues(q *qcache.Manager) Option {
 	return func(o *Options) {
 		o.Queues = q
 	}
 }
 
 // WithCache adds the cache manager.
-func WithCache(c *cache.Cache) Option {
+func WithCache(c *schdcache.Cache) Option {
 	return func(o *Options) {
 		o.Cache = c
 	}
diff --git a/pkg/controller/jobs/deployment/deployment_webhook.go b/pkg/controller/jobs/deployment/deployment_webhook.go
index 49367ff41..515e966d4 100644
--- a/pkg/controller/jobs/deployment/deployment_webhook.go
+++ b/pkg/controller/jobs/deployment/deployment_webhook.go
@@ -28,19 +28,19 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
 	controllerconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 type Webhook struct {
 	client                       client.Client
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 }
 
 func SetupWebhook(mgr ctrl.Manager, opts ...jobframework.Option) error {
diff --git a/pkg/controller/jobs/job/job_webhook.go b/pkg/controller/jobs/job/job_webhook.go
index f3a7ed138..1596ddbe8 100644
--- a/pkg/controller/jobs/job/job_webhook.go
+++ b/pkg/controller/jobs/job/job_webhook.go
@@ -34,11 +34,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/workloadslicing"
 )
 
@@ -77,8 +77,8 @@ type JobWebhook struct {
 	client                       client.Client
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	queues                       *queue.Manager
-	cache                        *cache.Cache
+	queues                       *qcache.Manager
+	cache                        *schdcache.Cache
 }
 
 // SetupWebhook configures the webhook for batchJob.
diff --git a/pkg/controller/jobs/jobset/jobset_webhook.go b/pkg/controller/jobs/jobset/jobset_webhook.go
index c77c94142..e409cfec2 100644
--- a/pkg/controller/jobs/jobset/jobset_webhook.go
+++ b/pkg/controller/jobs/jobset/jobset_webhook.go
@@ -28,11 +28,11 @@ import (
 	jobsetapi "sigs.k8s.io/jobset/api/jobset/v1alpha2"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/podset"
 )
 
@@ -44,8 +44,8 @@ type JobSetWebhook struct {
 	client                       client.Client
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	queues                       *queue.Manager
-	cache                        *cache.Cache
+	queues                       *qcache.Manager
+	cache                        *schdcache.Cache
 }
 
 // SetupJobSetWebhook configures the webhook for kubeflow JobSet.
diff --git a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
index 72d51e167..ed2f452c3 100644
--- a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
+++ b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
@@ -33,11 +33,11 @@ import (
 	leaderworkersetv1 "sigs.k8s.io/lws/api/leaderworkerset/v1"
 
 	kueuebeta "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/podset"
 )
 
@@ -45,7 +45,7 @@ type Webhook struct {
 	client                       client.Client
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 }
 
 func SetupWebhook(mgr ctrl.Manager, opts ...jobframework.Option) error {
diff --git a/pkg/controller/jobs/mpijob/mpijob_webhook.go b/pkg/controller/jobs/mpijob/mpijob_webhook.go
index 8753a5ef2..56f76d591 100644
--- a/pkg/controller/jobs/mpijob/mpijob_webhook.go
+++ b/pkg/controller/jobs/mpijob/mpijob_webhook.go
@@ -29,11 +29,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
 	"sigs.k8s.io/kueue/pkg/util/podset"
 )
@@ -47,8 +47,8 @@ type MpiJobWebhook struct {
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
 	kubeServerVersion            *kubeversion.ServerVersionFetcher
-	queues                       *queue.Manager
-	cache                        *cache.Cache
+	queues                       *qcache.Manager
+	cache                        *schdcache.Cache
 }
 
 // SetupMPIJobWebhook configures the webhook for MPIJob.
diff --git a/pkg/controller/jobs/pod/pod_webhook.go b/pkg/controller/jobs/pod/pod_webhook.go
index 9e5f4b005..19dbc3542 100644
--- a/pkg/controller/jobs/pod/pod_webhook.go
+++ b/pkg/controller/jobs/pod/pod_webhook.go
@@ -34,13 +34,13 @@ import (
 
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
 	ctrlconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utilpod "sigs.k8s.io/kueue/pkg/util/pod"
 )
 
@@ -59,7 +59,7 @@ var (
 
 type PodWebhook struct {
 	client                       client.Client
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
 	namespaceSelector            *metav1.LabelSelector
diff --git a/pkg/controller/jobs/raycluster/raycluster_webhook.go b/pkg/controller/jobs/raycluster/raycluster_webhook.go
index 066f7a6c2..02b168732 100644
--- a/pkg/controller/jobs/raycluster/raycluster_webhook.go
+++ b/pkg/controller/jobs/raycluster/raycluster_webhook.go
@@ -30,11 +30,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kueuebeta "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/podset"
 )
 
@@ -46,10 +46,10 @@ var (
 
 type RayClusterWebhook struct {
 	client                       client.Client
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	cache                        *cache.Cache
+	cache                        *schdcache.Cache
 }
 
 // SetupRayClusterWebhook configures the webhook for rayv1 RayCluster.
diff --git a/pkg/controller/jobs/rayjob/rayjob_webhook.go b/pkg/controller/jobs/rayjob/rayjob_webhook.go
index d85490a74..d5cf7fdae 100644
--- a/pkg/controller/jobs/rayjob/rayjob_webhook.go
+++ b/pkg/controller/jobs/rayjob/rayjob_webhook.go
@@ -30,11 +30,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kueuebeta "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework/webhook"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/podset"
 )
 
@@ -46,10 +46,10 @@ var (
 
 type RayJobWebhook struct {
 	client                       client.Client
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	cache                        *cache.Cache
+	cache                        *schdcache.Cache
 }
 
 // SetupRayJobWebhook configures the webhook for RayJob.
diff --git a/pkg/controller/jobs/statefulset/statefulset_webhook.go b/pkg/controller/jobs/statefulset/statefulset_webhook.go
index 96c250e5e..a5cf14395 100644
--- a/pkg/controller/jobs/statefulset/statefulset_webhook.go
+++ b/pkg/controller/jobs/statefulset/statefulset_webhook.go
@@ -32,18 +32,18 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
 	controllerconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 type Webhook struct {
 	client                       client.Client
 	manageJobsWithoutQueueName   bool
 	managedJobsNamespaceSelector labels.Selector
-	queues                       *queue.Manager
+	queues                       *qcache.Manager
 }
 
 func SetupWebhook(mgr ctrl.Manager, opts ...jobframework.Option) error {
diff --git a/pkg/controller/tas/controllers.go b/pkg/controller/tas/controllers.go
index 19e4d8a21..6e32fee1e 100644
--- a/pkg/controller/tas/controllers.go
+++ b/pkg/controller/tas/controllers.go
@@ -20,12 +20,12 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
-func SetupControllers(mgr ctrl.Manager, queues *queue.Manager, cache *cache.Cache, cfg *configapi.Configuration) (string, error) {
+func SetupControllers(mgr ctrl.Manager, queues *qcache.Manager, cache *schdcache.Cache, cfg *configapi.Configuration) (string, error) {
 	recorder := mgr.GetEventRecorderFor(TASResourceFlavorController)
 	topologyRec := newTopologyReconciler(mgr.GetClient(), queues, cache)
 	if ctrlName, err := topologyRec.setupWithManager(mgr, cfg); err != nil {
diff --git a/pkg/controller/tas/resource_flavor.go b/pkg/controller/tas/resource_flavor.go
index 0fe7c4f7d..39d15ad4f 100644
--- a/pkg/controller/tas/resource_flavor.go
+++ b/pkg/controller/tas/resource_flavor.go
@@ -41,10 +41,10 @@ import (
 
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 var nodeSemantic = conversion.EqualitiesOrDie(
@@ -67,8 +67,8 @@ func nodeConditionEqual(a, b corev1.NodeCondition) bool {
 
 type rfReconciler struct {
 	log      logr.Logger
-	queues   *queue.Manager
-	cache    *cache.Cache
+	queues   *qcache.Manager
+	cache    *schdcache.Cache
 	client   client.Client
 	recorder record.EventRecorder
 }
@@ -80,7 +80,7 @@ var _ predicate.TypedPredicate[*kueue.ResourceFlavor] = (*rfReconciler)(nil)
 // +kubebuilder:rbac:groups=kueue.x-k8s.io,resources=topologies,verbs=get;list;watch
 // +kubebuilder:rbac:groups=kueue.x-k8s.io,resources=resourceflavors,verbs=get;list;watch
 
-func newRfReconciler(c client.Client, queues *queue.Manager, cache *cache.Cache, recorder record.EventRecorder) *rfReconciler {
+func newRfReconciler(c client.Client, queues *qcache.Manager, cache *schdcache.Cache, recorder record.EventRecorder) *rfReconciler {
 	return &rfReconciler{
 		log:      ctrl.Log.WithName(TASResourceFlavorController),
 		client:   c,
@@ -90,7 +90,7 @@ func newRfReconciler(c client.Client, queues *queue.Manager, cache *cache.Cache,
 	}
 }
 
-func (r *rfReconciler) setupWithManager(mgr ctrl.Manager, cache *cache.Cache, cfg *configapi.Configuration) (string, error) {
+func (r *rfReconciler) setupWithManager(mgr ctrl.Manager, cache *schdcache.Cache, cfg *configapi.Configuration) (string, error) {
 	nodeHandler := nodeHandler{
 		cache: cache,
 	}
@@ -114,7 +114,7 @@ var _ handler.EventHandler = (*nodeHandler)(nil)
 
 // nodeHandler handles node update events.
 type nodeHandler struct {
-	cache *cache.Cache
+	cache *schdcache.Cache
 }
 
 func (h *nodeHandler) Create(_ context.Context, e event.CreateEvent, q workqueue.TypedRateLimitingInterface[reconcile.Request]) {
diff --git a/pkg/controller/tas/topology_controller.go b/pkg/controller/tas/topology_controller.go
index 6ec6b0eda..9d223e4c5 100644
--- a/pkg/controller/tas/topology_controller.go
+++ b/pkg/controller/tas/topology_controller.go
@@ -38,10 +38,10 @@ import (
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
-	"sigs.k8s.io/kueue/pkg/queue"
 )
 
 const (
@@ -51,15 +51,15 @@ const (
 type topologyReconciler struct {
 	log              logr.Logger
 	client           client.Client
-	queues           *queue.Manager
-	cache            *cache.Cache
+	queues           *qcache.Manager
+	cache            *schdcache.Cache
 	topologyUpdateCh chan event.GenericEvent
 }
 
 var _ reconcile.Reconciler = (*topologyReconciler)(nil)
 var _ predicate.TypedPredicate[*kueuealpha.Topology] = (*topologyReconciler)(nil)
 
-func newTopologyReconciler(c client.Client, queues *queue.Manager, cache *cache.Cache) *topologyReconciler {
+func newTopologyReconciler(c client.Client, queues *qcache.Manager, cache *schdcache.Cache) *topologyReconciler {
 	return &topologyReconciler{
 		log:              ctrl.Log.WithName(TASTopologyController),
 		client:           c,
diff --git a/pkg/debugger/debugger.go b/pkg/debugger/debugger.go
index 9624257ea..f4e7a8ae4 100644
--- a/pkg/debugger/debugger.go
+++ b/pkg/debugger/debugger.go
@@ -24,16 +24,16 @@ import (
 
 	ctrl "sigs.k8s.io/controller-runtime"
 
-	"sigs.k8s.io/kueue/pkg/cache"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 )
 
 type Dumper struct {
-	cache  *cache.Cache
-	queues *queue.Manager
+	cache  *schdcache.Cache
+	queues *qcache.Manager
 }
 
-func NewDumper(c *cache.Cache, q *queue.Manager) *Dumper {
+func NewDumper(c *schdcache.Cache, q *qcache.Manager) *Dumper {
 	return &Dumper{cache: c, queues: q}
 }
 
diff --git a/pkg/scheduler/fair_sharing_iterator.go b/pkg/scheduler/fair_sharing_iterator.go
index 799e4f386..11394d1e1 100644
--- a/pkg/scheduler/fair_sharing_iterator.go
+++ b/pkg/scheduler/fair_sharing_iterator.go
@@ -25,7 +25,7 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/util/priority"
 	"sigs.k8s.io/kueue/pkg/workload"
@@ -37,14 +37,14 @@ import (
 type fairSharingIterator struct {
 	// cqToEntry tracks ClusterQueues which still have workloads
 	// to schedule, and the corresponding workload entry.
-	cqToEntry     map[*cache.ClusterQueueSnapshot]*entry
+	cqToEntry     map[*schdcache.ClusterQueueSnapshot]*entry
 	entryComparer entryComparer
 	log           logr.Logger
 }
 
 func makeFairSharingIterator(ctx context.Context, entries []entry, workloadOrdering workload.Ordering) *fairSharingIterator {
 	f := fairSharingIterator{
-		cqToEntry: make(map[*cache.ClusterQueueSnapshot]*entry, len(entries)),
+		cqToEntry: make(map[*schdcache.ClusterQueueSnapshot]*entry, len(entries)),
 		entryComparer: entryComparer{
 			workloadOrdering: workloadOrdering,
 		},
@@ -101,7 +101,7 @@ func (f *fairSharingIterator) pop() *entry {
 // scheduling order of workloads in different Cohort. Workload
 // consideration is nearly deterministic within Cohort (only when DRS,
 // Priority, and time are equal it is non-deterministic).
-func (f *fairSharingIterator) getCq() *cache.ClusterQueueSnapshot {
+func (f *fairSharingIterator) getCq() *schdcache.ClusterQueueSnapshot {
 	for cq := range f.cqToEntry {
 		return cq
 	}
@@ -118,7 +118,7 @@ func (f *fairSharingIterator) getCq() *cache.ClusterQueueSnapshot {
 // This process results in one workload (or zero if Cohort has no
 // remaining workloads to schedule this cycle) being bubbled up per
 // node, until exactly one workload remains at the root.
-func runTournament(cohort *cache.CohortSnapshot, ec entryComparer, cqToEntry map[*cache.ClusterQueueSnapshot]*entry) *entry {
+func runTournament(cohort *schdcache.CohortSnapshot, ec entryComparer, cqToEntry map[*schdcache.ClusterQueueSnapshot]*entry) *entry {
 	candidates := make([]*entry, 0, cohort.ChildCount())
 
 	// Run algorithm recursively for each of the child Cohorts.
@@ -192,7 +192,7 @@ func (e *entryComparer) less(a, b *entry, parentCohort kueue.CohortReference) bo
 // root-1.  During the tournament, these values are used to compare
 // all children the parentCohort, to select the child with the lowest
 // DRS after admission of its nominated workload.
-func (e *entryComparer) computeDRS(rootCohort *cache.CohortSnapshot, cqToEntry map[*cache.ClusterQueueSnapshot]*entry) {
+func (e *entryComparer) computeDRS(rootCohort *schdcache.CohortSnapshot, cqToEntry map[*schdcache.ClusterQueueSnapshot]*entry) {
 	e.drsValues = make(map[drsKey]int)
 	for _, cq := range rootCohort.SubtreeClusterQueues() {
 		entry, ok := cqToEntry[cq]
diff --git a/pkg/scheduler/flavorassigner/flavorassigner.go b/pkg/scheduler/flavorassigner/flavorassigner.go
index 1f41660d3..c657c0b52 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner.go
@@ -33,7 +33,7 @@ import (
 	"k8s.io/utils/ptr"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption/classical"
@@ -58,7 +58,7 @@ type Assignment struct {
 }
 
 // UpdateForTASResult updates the Assignment with the TAS result
-func (a *Assignment) UpdateForTASResult(result cache.TASAssignmentsResult) {
+func (a *Assignment) UpdateForTASResult(result schdcache.TASAssignmentsResult) {
 	for psName, psResult := range result {
 		psAssignment := a.podSetAssignmentByName(psName)
 		psAssignment.TopologyAssignment = psResult.TopologyAssignment
@@ -399,12 +399,12 @@ type FlavorAssignment struct {
 }
 
 type preemptionOracle interface {
-	SimulatePreemption(log logr.Logger, cq *cache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int)
+	SimulatePreemption(log logr.Logger, cq *schdcache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int)
 }
 
 type FlavorAssigner struct {
 	wl                *workload.Info
-	cq                *cache.ClusterQueueSnapshot
+	cq                *schdcache.ClusterQueueSnapshot
 	resourceFlavors   map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor
 	enableFairSharing bool
 	oracle            preemptionOracle
@@ -420,7 +420,7 @@ type FlavorAssigner struct {
 	preemptWorkloadSlice *workload.Info
 }
 
-func New(wl *workload.Info, cq *cache.ClusterQueueSnapshot, resourceFlavors map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor, enableFairSharing bool, oracle preemptionOracle, preemptWorkloadSlice *workload.Info) *FlavorAssigner {
+func New(wl *workload.Info, cq *schdcache.ClusterQueueSnapshot, resourceFlavors map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor, enableFairSharing bool, oracle preemptionOracle, preemptWorkloadSlice *workload.Info) *FlavorAssigner {
 	return &FlavorAssigner{
 		wl:                   wl,
 		cq:                   cq,
@@ -431,7 +431,7 @@ func New(wl *workload.Info, cq *cache.ClusterQueueSnapshot, resourceFlavors map[
 	}
 }
 
-func lastAssignmentOutdated(wl *workload.Info, cq *cache.ClusterQueueSnapshot) bool {
+func lastAssignmentOutdated(wl *workload.Info, cq *schdcache.ClusterQueueSnapshot) bool {
 	return cq.AllocatableResourceGeneration > wl.LastAssignment.ClusterQueueGeneration
 }
 
@@ -575,7 +575,7 @@ func (a *FlavorAssigner) assignFlavors(log logr.Logger, counts []int32) Assignme
 	if features.Enabled(features.TopologyAwareScheduling) {
 		tasRequests := assignment.WorkloadsTopologyRequests(a.wl, a.cq)
 		if assignment.RepresentativeMode() == Fit {
-			result := a.cq.FindTopologyAssignmentsForWorkload(tasRequests, cache.WithWorkload(a.wl.Obj))
+			result := a.cq.FindTopologyAssignmentsForWorkload(tasRequests, schdcache.WithWorkload(a.wl.Obj))
 			if failure := result.Failure(); failure != nil {
 				// There is at least one PodSet which does not fit
 				psAssignment := assignment.podSetAssignmentByName(failure.PodSetName)
@@ -590,7 +590,7 @@ func (a *FlavorAssigner) assignFlavors(log logr.Logger, counts []int32) Assignme
 		}
 		if assignment.RepresentativeMode() == Preempt && !workload.HasNodeToReplace(a.wl.Obj) {
 			// Don't preempt other workloads if looking for a failed node replacement
-			result := a.cq.FindTopologyAssignmentsForWorkload(tasRequests, cache.WithSimulateEmpty(true))
+			result := a.cq.FindTopologyAssignmentsForWorkload(tasRequests, schdcache.WithSimulateEmpty(true))
 			if failure := result.Failure(); failure != nil {
 				// There is at least one PodSet which does not fit even if
 				// all workloads are preempted.
@@ -848,7 +848,7 @@ func flavorSelector(spec *corev1.PodSpec, allowedKeys sets.Set[string]) nodeaffi
 // if borrowing is required when preempting.
 // If the flavor doesn't satisfy limits immediately (when waiting or preemption
 // could help), it returns a Status with reasons.
-func (a *FlavorAssigner) fitsResourceQuota(log logr.Logger, fr resources.FlavorResource, val int64, rQuota cache.ResourceQuota) (preemptionMode, int, *Status) {
+func (a *FlavorAssigner) fitsResourceQuota(log logr.Logger, fr resources.FlavorResource, val int64, rQuota schdcache.ResourceQuota) (preemptionMode, int, *Status) {
 	var status Status
 
 	available := a.cq.Available(fr)
diff --git a/pkg/scheduler/flavorassigner/tas_flavorassigner.go b/pkg/scheduler/flavorassigner/tas_flavorassigner.go
index 97f651018..770af894e 100644
--- a/pkg/scheduler/flavorassigner/tas_flavorassigner.go
+++ b/pkg/scheduler/flavorassigner/tas_flavorassigner.go
@@ -24,13 +24,13 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
 // WorkloadsTopologyRequests - returns the TopologyRequests of the workload
-func (a *Assignment) WorkloadsTopologyRequests(wl *workload.Info, cq *cache.ClusterQueueSnapshot) cache.WorkloadTASRequests {
-	tasRequests := make(cache.WorkloadTASRequests)
+func (a *Assignment) WorkloadsTopologyRequests(wl *workload.Info, cq *schdcache.ClusterQueueSnapshot) schdcache.WorkloadTASRequests {
+	tasRequests := make(schdcache.WorkloadTASRequests)
 	for i, podSet := range wl.Obj.Spec.PodSets {
 		if isTASRequested(&podSet, cq) {
 			psAssignment := a.podSetAssignmentByName(podSet.Name)
@@ -71,9 +71,9 @@ func (psa *PodSetAssignment) HasFailedNode(wl *workload.Info) bool {
 
 func podSetTopologyRequest(psAssignment *PodSetAssignment,
 	wl *workload.Info,
-	cq *cache.ClusterQueueSnapshot,
+	cq *schdcache.ClusterQueueSnapshot,
 	isTASImplied bool,
-	podSetIndex int) (*cache.TASPodSetRequests, error) {
+	podSetIndex int) (*schdcache.TASPodSetRequests, error) {
 	if len(cq.TASFlavors) == 0 {
 		return nil, errors.New("workload requires Topology, but there is no TAS cache information")
 	}
@@ -109,7 +109,7 @@ func podSetTopologyRequest(psAssignment *PodSetAssignment,
 		podSetGroupName = podSet.TopologyRequest.PodSetGroupName
 	}
 
-	return &cache.TASPodSetRequests{
+	return &schdcache.TASPodSetRequests{
 		Count:             podCount,
 		SinglePodRequests: singlePodRequests,
 		PodSet:            podSet,
@@ -135,7 +135,7 @@ func onlyFlavor(ra ResourceAssignment) (*kueue.ResourceFlavorReference, error) {
 	return nil, errors.New("no flavor assigned")
 }
 
-func checkPodSetAndFlavorMatchForTAS(cq *cache.ClusterQueueSnapshot, ps *kueue.PodSet, flavor *kueue.ResourceFlavor) *string {
+func checkPodSetAndFlavorMatchForTAS(cq *schdcache.ClusterQueueSnapshot, ps *kueue.PodSet, flavor *kueue.ResourceFlavor) *string {
 	if isTASRequested(ps, cq) {
 		if isTASImplied(ps, cq) {
 			// If this is a TAS-only CQ, then we don't need to check the flavor because
@@ -170,12 +170,12 @@ func checkPodSetAndFlavorMatchForTAS(cq *cache.ClusterQueueSnapshot, ps *kueue.P
 }
 
 // isTASImplied returns true if TAS is requested implicitly.
-func isTASImplied(ps *kueue.PodSet, cq *cache.ClusterQueueSnapshot) bool {
+func isTASImplied(ps *kueue.PodSet, cq *schdcache.ClusterQueueSnapshot) bool {
 	return !workload.IsExplicitlyRequestingTAS(*ps) && cq.IsTASOnly()
 }
 
 // isTASRequested checks if TAS is requested for the input PodSet, either
 // explicitly or implicitly.
-func isTASRequested(ps *kueue.PodSet, cq *cache.ClusterQueueSnapshot) bool {
+func isTASRequested(ps *kueue.PodSet, cq *schdcache.ClusterQueueSnapshot) bool {
 	return workload.IsExplicitlyRequestingTAS(*ps) || isTASImplied(ps, cq)
 }
diff --git a/pkg/scheduler/logging.go b/pkg/scheduler/logging.go
index 00c59a066..14d604d5d 100644
--- a/pkg/scheduler/logging.go
+++ b/pkg/scheduler/logging.go
@@ -20,7 +20,7 @@ import (
 	"github.com/go-logr/logr"
 	"k8s.io/klog/v2"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/util/logging"
 )
 
@@ -42,7 +42,7 @@ func logAdmissionAttemptIfVerbose(log logr.Logger, e *entry) {
 	logV.Info("Workload evaluated for admission", args...)
 }
 
-func logSnapshotIfVerbose(log logr.Logger, s *cache.Snapshot) {
+func logSnapshotIfVerbose(log logr.Logger, s *schdcache.Snapshot) {
 	if logV := log.V(6); logV.Enabled() {
 		s.Log(logV)
 	}
diff --git a/pkg/scheduler/preemption/classical/candidate_generator.go b/pkg/scheduler/preemption/classical/candidate_generator.go
index 8e4e3a00c..240683edb 100644
--- a/pkg/scheduler/preemption/classical/candidate_generator.go
+++ b/pkg/scheduler/preemption/classical/candidate_generator.go
@@ -26,7 +26,7 @@ import (
 	"k8s.io/utils/clock"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
@@ -35,7 +35,7 @@ type candidateIterator struct {
 	candidates                        []*candidateElem
 	runIndex                          int
 	frsNeedPreemption                 sets.Set[resources.FlavorResource]
-	snapshot                          *cache.Snapshot
+	snapshot                          *schdcache.Snapshot
 	NoCandidateFromOtherQueues        bool
 	NoCandidateForHierarchicalReclaim bool
 	hierarchicalReclaimCtx            *HierarchicalPreemptionCtx
@@ -44,7 +44,7 @@ type candidateIterator struct {
 type candidateElem struct {
 	wl *workload.Info
 	// lca of this queue and cq (queue to which the new workload is submitted)
-	lca *cache.CohortSnapshot
+	lca *schdcache.CohortSnapshot
 	// candidates above priority threshold cannot be preempted if at the same time
 	// cq would borrow from other queues/cohorts
 	preemptionVariant preemptionVariant
@@ -78,7 +78,7 @@ func NewCandidateIterator(
 	hierarchicalReclaimCtx *HierarchicalPreemptionCtx,
 	enabledAfs bool,
 	frsNeedPreemption sets.Set[resources.FlavorResource],
-	snapshot *cache.Snapshot,
+	snapshot *schdcache.Snapshot,
 	clock clock.Clock,
 	ordering func(logr.Logger, bool, *workload.Info, *workload.Info, kueue.ClusterQueueReference, time.Time) bool,
 ) *candidateIterator {
@@ -140,7 +140,7 @@ func (c *candidateIterator) candidateIsValid(candidate *candidateElem, borrow bo
 		return false
 	}
 	cq := c.snapshot.ClusterQueue(candidate.wl.ClusterQueue)
-	if cache.IsWithinNominalInResources(cq, c.frsNeedPreemption) {
+	if schdcache.IsWithinNominalInResources(cq, c.frsNeedPreemption) {
 		return false
 	}
 	// we don't go all the way to the root but only to the lca node
@@ -148,7 +148,7 @@ func (c *candidateIterator) candidateIsValid(candidate *candidateElem, borrow bo
 		if node == candidate.lca {
 			break
 		}
-		if cache.IsWithinNominalInResources(node, c.frsNeedPreemption) {
+		if schdcache.IsWithinNominalInResources(node, c.frsNeedPreemption) {
 			return false
 		}
 	}
diff --git a/pkg/scheduler/preemption/classical/hierarchical_preemption.go b/pkg/scheduler/preemption/classical/hierarchical_preemption.go
index 5f8fb87d8..3ebd03133 100644
--- a/pkg/scheduler/preemption/classical/hierarchical_preemption.go
+++ b/pkg/scheduler/preemption/classical/hierarchical_preemption.go
@@ -21,7 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/sets"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/util/priority"
 	"sigs.k8s.io/kueue/pkg/workload"
@@ -61,13 +61,13 @@ func (m preemptionVariant) PreemptionReason() string {
 type HierarchicalPreemptionCtx struct {
 	Log               logr.Logger
 	Wl                *kueue.Workload
-	Cq                *cache.ClusterQueueSnapshot
+	Cq                *schdcache.ClusterQueueSnapshot
 	FrsNeedPreemption sets.Set[resources.FlavorResource]
 	Requests          resources.FlavorResourceQuantities
 	WorkloadOrdering  workload.Ordering
 }
 
-func IsBorrowingWithinCohortForbidden(cq *cache.ClusterQueueSnapshot) (bool, *int32) {
+func IsBorrowingWithinCohortForbidden(cq *schdcache.ClusterQueueSnapshot) (bool, *int32) {
 	borrowWithinCohort := cq.Preemption.BorrowWithinCohort
 	if borrowWithinCohort == nil || borrowWithinCohort.Policy == kueue.BorrowWithinCohortPolicyNever {
 		return true, nil
@@ -138,7 +138,7 @@ func collectSameQueueCandidates(ctx *HierarchicalPreemptionCtx) []*candidateElem
 	return getCandidatesFromCQ(ctx.Cq, nil, ctx, false)
 }
 
-func getCandidatesFromCQ(cq *cache.ClusterQueueSnapshot, lca *cache.CohortSnapshot, ctx *HierarchicalPreemptionCtx, hasHiearchicalAdvantage bool) []*candidateElem {
+func getCandidatesFromCQ(cq *schdcache.ClusterQueueSnapshot, lca *schdcache.CohortSnapshot, ctx *HierarchicalPreemptionCtx, hasHiearchicalAdvantage bool) []*candidateElem {
 	candidates := []*candidateElem{}
 	for _, candidateWl := range cq.Workloads {
 		preemptionVariant := classifyPreemptionVariant(ctx, candidateWl, hasHiearchicalAdvantage)
@@ -161,10 +161,10 @@ func collectCandidatesForHierarchicalReclaim(ctx *HierarchicalPreemptionCtx) ([]
 	if !ctx.Cq.HasParent() || ctx.Cq.Preemption.ReclaimWithinCohort == kueue.PreemptionPolicyNever {
 		return hierarchyCandidates, priorityCandidates
 	}
-	var previousSubtreeRoot *cache.CohortSnapshot
+	var previousSubtreeRoot *schdcache.CohortSnapshot
 	var candidateList *[]*candidateElem
 	var fits bool
-	hasHierarchicalAdvantage, remainingRequests := cache.QuantitiesFitInQuota(ctx.Cq, ctx.Requests)
+	hasHierarchicalAdvantage, remainingRequests := schdcache.QuantitiesFitInQuota(ctx.Cq, ctx.Requests)
 	for currentSubtreeRoot := range ctx.Cq.PathParentToRoot() {
 		if hasHierarchicalAdvantage {
 			candidateList = &hierarchyCandidates
@@ -172,7 +172,7 @@ func collectCandidatesForHierarchicalReclaim(ctx *HierarchicalPreemptionCtx) ([]
 			candidateList = &priorityCandidates
 		}
 		collectCandidatesInSubtree(ctx, currentSubtreeRoot, currentSubtreeRoot, previousSubtreeRoot, hasHierarchicalAdvantage, candidateList)
-		fits, remainingRequests = cache.QuantitiesFitInQuota(currentSubtreeRoot, remainingRequests)
+		fits, remainingRequests = schdcache.QuantitiesFitInQuota(currentSubtreeRoot, remainingRequests)
 		// Once we find a subtree sT that fits the requests, we will look for workloads that use quota
 		// of that subtree. The preemptor will have hierarchical advantage over all such workloads
 		// because it belongs to subtree sT. For that reason variable hasHierarchicalAdvantage
@@ -185,14 +185,14 @@ func collectCandidatesForHierarchicalReclaim(ctx *HierarchicalPreemptionCtx) ([]
 
 // visit the nodes in the hierarchy and collect the ones that exceed quota
 // avoid subtrees that are within quota and the skipped subtree
-func collectCandidatesInSubtree(ctx *HierarchicalPreemptionCtx, currentCohort *cache.CohortSnapshot, subtreeRoot *cache.CohortSnapshot, skipSubtree *cache.CohortSnapshot, hasHierarchicalAdvantage bool, result *[]*candidateElem) {
+func collectCandidatesInSubtree(ctx *HierarchicalPreemptionCtx, currentCohort *schdcache.CohortSnapshot, subtreeRoot *schdcache.CohortSnapshot, skipSubtree *schdcache.CohortSnapshot, hasHierarchicalAdvantage bool, result *[]*candidateElem) {
 	for _, childCohort := range currentCohort.ChildCohorts() {
 		// we already processed this subtree
 		if childCohort == skipSubtree {
 			continue
 		}
 		// don't look for candidates in subtrees that are not exceeding their quotas
-		if cache.IsWithinNominalInResources(childCohort, ctx.FrsNeedPreemption) {
+		if schdcache.IsWithinNominalInResources(childCohort, ctx.FrsNeedPreemption) {
 			continue
 		}
 		collectCandidatesInSubtree(ctx, childCohort, subtreeRoot, skipSubtree, hasHierarchicalAdvantage, result)
@@ -201,14 +201,14 @@ func collectCandidatesInSubtree(ctx *HierarchicalPreemptionCtx, currentCohort *c
 		if childCq == ctx.Cq {
 			continue
 		}
-		if !cache.IsWithinNominalInResources(childCq, ctx.FrsNeedPreemption) {
+		if !schdcache.IsWithinNominalInResources(childCq, ctx.FrsNeedPreemption) {
 			*result = append(*result, getCandidatesFromCQ(childCq, subtreeRoot, ctx, hasHierarchicalAdvantage)...)
 		}
 	}
 }
 
 // getNodeHeight calculates the distance to the furthest leaf
-func getNodeHeight(node *cache.CohortSnapshot) int {
+func getNodeHeight(node *schdcache.CohortSnapshot) int {
 	maxHeight := min(node.ChildCount(), 1)
 	for _, childCohort := range node.ChildCohorts() {
 		maxHeight = max(maxHeight, getNodeHeight(childCohort)+1)
@@ -220,16 +220,16 @@ func getNodeHeight(node *cache.CohortSnapshot) int {
 // that fits additional val of resource fr. If no such subtree exists, it returns
 // height the whole cohort hierarchy. Note that height of a trivial subtree
 // with only one node is 0. It also returns if the returned subtree is smaller than the whole cohort tree.
-func FindHeightOfLowestSubtreeThatFits(c *cache.ClusterQueueSnapshot, fr resources.FlavorResource, val int64) (int, bool) {
+func FindHeightOfLowestSubtreeThatFits(c *schdcache.ClusterQueueSnapshot, fr resources.FlavorResource, val int64) (int, bool) {
 	if !c.BorrowingWith(fr, val) || !c.HasParent() {
 		return 0, c.HasParent()
 	}
-	remaining := val - cache.LocalAvailable(c, fr)
+	remaining := val - schdcache.LocalAvailable(c, fr)
 	for trackingNode := range c.PathParentToRoot() {
 		if !trackingNode.BorrowingWith(fr, remaining) {
 			return getNodeHeight(trackingNode), trackingNode.HasParent()
 		}
-		remaining -= cache.LocalAvailable(trackingNode, fr)
+		remaining -= schdcache.LocalAvailable(trackingNode, fr)
 	}
 	// no fit found
 	return getNodeHeight(c.Parent().Root()), false
diff --git a/pkg/scheduler/preemption/fairsharing/least_common_ancestor.go b/pkg/scheduler/preemption/fairsharing/least_common_ancestor.go
index cdbaf974b..bd03bbde9 100644
--- a/pkg/scheduler/preemption/fairsharing/least_common_ancestor.go
+++ b/pkg/scheduler/preemption/fairsharing/least_common_ancestor.go
@@ -14,7 +14,7 @@
 
 package fairsharing
 
-import "sigs.k8s.io/kueue/pkg/cache"
+import schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 
 // almostLCA is defined on two ClusterQueues, as the two nodes before
 // the lowest shared node - the LeastCommonAncestor (LCA). While LCA
@@ -32,7 +32,7 @@ func getAlmostLCAs(t *TargetClusterQueue) (almostLCA, almostLCA) {
 // getLCA traverses from a ClusterQueue towards the root Cohort,
 // returning the first Cohort which contains the preemptor
 // ClusterQueue in its subtree.
-func getLCA(t *TargetClusterQueue) *cache.CohortSnapshot {
+func getLCA(t *TargetClusterQueue) *schdcache.CohortSnapshot {
 	for ancestor := range t.targetCq.PathParentToRoot() {
 		if t.ordering.onPathFromRootToPreemptorCQ(ancestor) {
 			return ancestor
@@ -45,7 +45,7 @@ func getLCA(t *TargetClusterQueue) *cache.CohortSnapshot {
 // getAlmostLCA traverses from a ClusterQueue towards the root,
 // returning the first Cohort or ClusterQueue that has the
 // LeastCommonAncestor as its parent.
-func getAlmostLCA(cq *cache.ClusterQueueSnapshot, lca *cache.CohortSnapshot) almostLCA {
+func getAlmostLCA(cq *schdcache.ClusterQueueSnapshot, lca *schdcache.CohortSnapshot) almostLCA {
 	var aLca almostLCA = cq
 	for ancestor := range cq.PathParentToRoot() {
 		if ancestor == lca {
diff --git a/pkg/scheduler/preemption/fairsharing/ordering.go b/pkg/scheduler/preemption/fairsharing/ordering.go
index 242f52b18..9327b94a1 100644
--- a/pkg/scheduler/preemption/fairsharing/ordering.go
+++ b/pkg/scheduler/preemption/fairsharing/ordering.go
@@ -22,7 +22,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/sets"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
@@ -41,9 +41,9 @@ import (
 // TargetClusterQueueOrdering.DropQueue must be called between each
 // entry returned.
 type TargetClusterQueueOrdering struct {
-	preemptorCq *cache.ClusterQueueSnapshot
+	preemptorCq *schdcache.ClusterQueueSnapshot
 	// ancestor Cohorts of the preemptor ClusterQueue.
-	preemptorAncestors sets.Set[*cache.CohortSnapshot]
+	preemptorAncestors sets.Set[*schdcache.CohortSnapshot]
 
 	clusterQueueToTarget map[kueue.ClusterQueueReference][]*workload.Info
 
@@ -52,19 +52,19 @@ type TargetClusterQueueOrdering struct {
 	// determine our stopping condition: once the rootCohort is in
 	// the prunedCohorts list, we will not find any more
 	// preemption target candidates.
-	prunedClusterQueues sets.Set[*cache.ClusterQueueSnapshot]
-	prunedCohorts       sets.Set[*cache.CohortSnapshot]
+	prunedClusterQueues sets.Set[*schdcache.ClusterQueueSnapshot]
+	prunedCohorts       sets.Set[*schdcache.CohortSnapshot]
 }
 
-func MakeClusterQueueOrdering(cq *cache.ClusterQueueSnapshot, candidates []*workload.Info) TargetClusterQueueOrdering {
+func MakeClusterQueueOrdering(cq *schdcache.ClusterQueueSnapshot, candidates []*workload.Info) TargetClusterQueueOrdering {
 	t := TargetClusterQueueOrdering{
 		preemptorCq:        cq,
-		preemptorAncestors: sets.New[*cache.CohortSnapshot](),
+		preemptorAncestors: sets.New[*schdcache.CohortSnapshot](),
 
 		clusterQueueToTarget: make(map[kueue.ClusterQueueReference][]*workload.Info),
 
-		prunedClusterQueues: sets.New[*cache.ClusterQueueSnapshot](),
-		prunedCohorts:       sets.New[*cache.CohortSnapshot](),
+		prunedClusterQueues: sets.New[*schdcache.ClusterQueueSnapshot](),
+		prunedCohorts:       sets.New[*schdcache.CohortSnapshot](),
 	}
 
 	for ancestor := range cq.PathParentToRoot() {
@@ -116,11 +116,11 @@ func (t *TargetClusterQueueOrdering) DropQueue(cq *TargetClusterQueue) {
 	t.prunedClusterQueues.Insert(cq.targetCq)
 }
 
-func (t *TargetClusterQueueOrdering) onPathFromRootToPreemptorCQ(cohort *cache.CohortSnapshot) bool {
+func (t *TargetClusterQueueOrdering) onPathFromRootToPreemptorCQ(cohort *schdcache.CohortSnapshot) bool {
 	return t.preemptorAncestors.Has(cohort)
 }
 
-func (t *TargetClusterQueueOrdering) hasWorkload(cq *cache.ClusterQueueSnapshot) bool {
+func (t *TargetClusterQueueOrdering) hasWorkload(cq *schdcache.ClusterQueueSnapshot) bool {
 	return len(t.clusterQueueToTarget[cq.GetName()]) > 0
 }
 
@@ -130,8 +130,8 @@ func (t *TargetClusterQueueOrdering) hasWorkload(cq *cache.ClusterQueueSnapshot)
 // call if it is a Cohort.  The return of nil doesn't mean that there
 // are no more candidate ClusterQueues; an iteration may have only
 // pruned nodes from the tree.
-func (t *TargetClusterQueueOrdering) nextTarget(cohort *cache.CohortSnapshot) *TargetClusterQueue {
-	var highestCq *cache.ClusterQueueSnapshot = nil
+func (t *TargetClusterQueueOrdering) nextTarget(cohort *schdcache.CohortSnapshot) *TargetClusterQueue {
+	var highestCq *schdcache.ClusterQueueSnapshot = nil
 	highestCqDrs := -1
 	for _, cq := range cohort.ChildCQs() {
 		if t.prunedClusterQueues.Has(cq) {
@@ -149,7 +149,7 @@ func (t *TargetClusterQueueOrdering) nextTarget(cohort *cache.CohortSnapshot) *T
 		}
 	}
 
-	var highestCohort *cache.CohortSnapshot = nil
+	var highestCohort *schdcache.CohortSnapshot = nil
 	highestCohortDrs := -1
 	for _, cohort := range cohort.ChildCohorts() {
 		if t.prunedCohorts.Has(cohort) {
diff --git a/pkg/scheduler/preemption/fairsharing/target.go b/pkg/scheduler/preemption/fairsharing/target.go
index 11e6fda95..c07ff0686 100644
--- a/pkg/scheduler/preemption/fairsharing/target.go
+++ b/pkg/scheduler/preemption/fairsharing/target.go
@@ -15,7 +15,7 @@
 package fairsharing
 
 import (
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
@@ -23,7 +23,7 @@ import (
 // workloads for preemption.
 type TargetClusterQueue struct {
 	ordering *TargetClusterQueueOrdering
-	targetCq *cache.ClusterQueueSnapshot
+	targetCq *schdcache.ClusterQueueSnapshot
 }
 
 // InClusterQueuePreemption indicates that the TargetClusterQueue is
diff --git a/pkg/scheduler/preemption/policy.go b/pkg/scheduler/preemption/policy.go
index 6e0bbf794..352b7287c 100644
--- a/pkg/scheduler/preemption/policy.go
+++ b/pkg/scheduler/preemption/policy.go
@@ -18,12 +18,12 @@ package preemption
 
 import (
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 )
 
 // CanAlwaysReclaim indicates that the CQ is guaranteed to
 // be able to reclaim the capacity of workloads borrowing
 // its capacity.
-func CanAlwaysReclaim(cq *cache.ClusterQueueSnapshot) bool {
+func CanAlwaysReclaim(cq *schdcache.ClusterQueueSnapshot) bool {
 	return cq.Preemption.ReclaimWithinCohort == kueue.PreemptionPolicyAny
 }
diff --git a/pkg/scheduler/preemption/preemption.go b/pkg/scheduler/preemption/preemption.go
index e5651bfba..0500b3a02 100644
--- a/pkg/scheduler/preemption/preemption.go
+++ b/pkg/scheduler/preemption/preemption.go
@@ -37,7 +37,7 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
@@ -70,10 +70,10 @@ type Preemptor struct {
 type preemptionCtx struct {
 	log               logr.Logger
 	preemptor         workload.Info
-	preemptorCQ       *cache.ClusterQueueSnapshot
-	snapshot          *cache.Snapshot
+	preemptorCQ       *schdcache.ClusterQueueSnapshot
+	snapshot          *schdcache.Snapshot
 	workloadUsage     workload.Usage
-	tasRequests       cache.WorkloadTASRequests
+	tasRequests       schdcache.WorkloadTASRequests
 	frsNeedPreemption sets.Set[resources.FlavorResource]
 }
 
@@ -117,7 +117,7 @@ func (t *Target) GetObject() client.Object {
 
 // GetTargets returns the list of workloads that should be evicted in
 // order to make room for wl.
-func (p *Preemptor) GetTargets(log logr.Logger, wl workload.Info, assignment flavorassigner.Assignment, snapshot *cache.Snapshot) []*Target {
+func (p *Preemptor) GetTargets(log logr.Logger, wl workload.Info, assignment flavorassigner.Assignment, snapshot *schdcache.Snapshot) []*Target {
 	cq := snapshot.ClusterQueue(wl.ClusterQueue)
 	tasRequests := assignment.WorkloadsTopologyRequests(&wl, cq)
 	return p.getTargets(&preemptionCtx{
@@ -283,7 +283,7 @@ func fillBackWorkloads(preemptionCtx *preemptionCtx, targets []*Target, allowBor
 	return targets
 }
 
-func restoreSnapshot(snapshot *cache.Snapshot, targets []*Target) {
+func restoreSnapshot(snapshot *schdcache.Snapshot, targets []*Target) {
 	for _, t := range targets {
 		snapshot.AddWorkload(t.WorkloadInfo)
 	}
@@ -443,7 +443,7 @@ func flavorResourcesNeedPreemption(assignment flavorassigner.Assignment) sets.Se
 // findCandidates obtains candidates for preemption within the ClusterQueue and
 // cohort that respect the preemption policy and are using a resource that the
 // preempting workload needs.
-func (p *Preemptor) findCandidates(wl *kueue.Workload, cq *cache.ClusterQueueSnapshot, frsNeedPreemption sets.Set[resources.FlavorResource]) []*workload.Info {
+func (p *Preemptor) findCandidates(wl *kueue.Workload, cq *schdcache.ClusterQueueSnapshot, frsNeedPreemption sets.Set[resources.FlavorResource]) []*workload.Info {
 	var candidates []*workload.Info
 	wlPriority := priority.Priority(wl)
 	preemptorTS := p.workloadOrdering.GetQueueOrderTimestamp(wl)
@@ -503,7 +503,7 @@ func (p *Preemptor) findCandidates(wl *kueue.Workload, cq *cache.ClusterQueueSna
 	return candidates
 }
 
-func cqIsBorrowing(cq *cache.ClusterQueueSnapshot, frsNeedPreemption sets.Set[resources.FlavorResource]) bool {
+func cqIsBorrowing(cq *schdcache.ClusterQueueSnapshot, frsNeedPreemption sets.Set[resources.FlavorResource]) bool {
 	if !cq.HasParent() {
 		return false
 	}
diff --git a/pkg/scheduler/preemption/preemption_oracle.go b/pkg/scheduler/preemption/preemption_oracle.go
index 0ea3d4af6..084b030ce 100644
--- a/pkg/scheduler/preemption/preemption_oracle.go
+++ b/pkg/scheduler/preemption/preemption_oracle.go
@@ -20,25 +20,25 @@ import (
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/util/sets"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption/classical"
 	preemptioncommon "sigs.k8s.io/kueue/pkg/scheduler/preemption/common"
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
-func NewOracle(preemptor *Preemptor, snapshot *cache.Snapshot) *PreemptionOracle {
+func NewOracle(preemptor *Preemptor, snapshot *schdcache.Snapshot) *PreemptionOracle {
 	return &PreemptionOracle{preemptor, snapshot}
 }
 
 type PreemptionOracle struct {
 	preemptor *Preemptor
-	snapshot  *cache.Snapshot
+	snapshot  *schdcache.Snapshot
 }
 
 // SimulatePreemption runs the preemption algorithm for a given flavor resource to check if
 // preemption and reclaim are possible in this flavor resource.
-func (p *PreemptionOracle) SimulatePreemption(log logr.Logger, cq *cache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int) {
+func (p *PreemptionOracle) SimulatePreemption(log logr.Logger, cq *schdcache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int) {
 	candidates := p.preemptor.getTargets(&preemptionCtx{
 		log:               log,
 		preemptor:         wl,
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
index 9f0e1da8b..d788dc493 100644
--- a/pkg/scheduler/scheduler.go
+++ b/pkg/scheduler/scheduler.go
@@ -40,11 +40,11 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	controllerconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption"
@@ -69,8 +69,8 @@ var (
 )
 
 type Scheduler struct {
-	queues                  *queue.Manager
-	cache                   *cache.Cache
+	queues                  *qcache.Manager
+	cache                   *schdcache.Cache
 	client                  client.Client
 	recorder                record.EventRecorder
 	admissionRoutineWrapper routine.Wrapper
@@ -131,7 +131,7 @@ func WithClock(_ testing.TB, c clock.Clock) Option {
 	}
 }
 
-func New(queues *queue.Manager, cache *cache.Cache, cl client.Client, recorder record.EventRecorder, opts ...Option) *Scheduler {
+func New(queues *qcache.Manager, cache *schdcache.Cache, cl client.Client, recorder record.EventRecorder, opts ...Option) *Scheduler {
 	options := defaultOptions
 	for _, opt := range opts {
 		opt(&options)
@@ -194,10 +194,10 @@ func (s *Scheduler) schedule(ctx context.Context) wait.SpeedSignal {
 	log := ctrl.LoggerFrom(ctx).WithValues("schedulingCycle", s.schedulingCycle)
 	ctx = ctrl.LoggerInto(ctx, log)
 
-	var snapshotOpts []cache.SnapshotOption
+	var snapshotOpts []schdcache.SnapshotOption
 	if afs.Enabled(s.admissionFairSharing) {
 		s.queues.RebuildClusterQueuesWithEntryPenalties()
-		snapshotOpts = append(snapshotOpts, cache.WithAfsEntryPenalties(s.queues.GetAfsEntryPenalties()))
+		snapshotOpts = append(snapshotOpts, schdcache.WithAfsEntryPenalties(s.queues.GetAfsEntryPenalties()))
 	}
 
 	// 1. Get the heads from the queues, including their desired clusterQueue.
@@ -308,7 +308,7 @@ func (s *Scheduler) schedule(ctx context.Context) wait.SpeedSignal {
 			}
 			if preempted != 0 {
 				e.inadmissibleMsg += fmt.Sprintf(". Pending the preemption of %d workload(s)", preempted)
-				e.requeueReason = queue.RequeueReasonPendingPreemption
+				e.requeueReason = qcache.RequeueReasonPendingPreemption
 			}
 			continue
 		}
@@ -388,9 +388,9 @@ type entry struct {
 	assignment           flavorassigner.Assignment
 	status               entryStatus
 	inadmissibleMsg      string
-	requeueReason        queue.RequeueReason
+	requeueReason        qcache.RequeueReason
 	preemptionTargets    []*preemption.Target
-	clusterQueueSnapshot *cache.ClusterQueueSnapshot
+	clusterQueueSnapshot *schdcache.ClusterQueueSnapshot
 }
 
 func (e *entry) assignmentUsage() workload.Usage {
@@ -400,7 +400,7 @@ func (e *entry) assignmentUsage() workload.Usage {
 // nominate returns the workloads with their requirements (resource flavors, borrowing) if
 // they were admitted by the clusterQueues in the snapshot. The second return value
 // is the list of inadmissibleEntries.
-func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, snap *cache.Snapshot) ([]entry, []entry) {
+func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, snap *schdcache.Snapshot) ([]entry, []entry) {
 	log := ctrl.LoggerFrom(ctx)
 	entries := make([]entry, 0, len(workloads))
 	var inadmissibleEntries []entry
@@ -422,7 +422,7 @@ func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, sna
 			e.inadmissibleMsg = fmt.Sprintf("Could not obtain workload namespace: %v", err)
 		} else if !e.clusterQueueSnapshot.NamespaceSelector.Matches(labels.Set(ns.Labels)) {
 			e.inadmissibleMsg = "Workload namespace doesn't match ClusterQueue selector"
-			e.requeueReason = queue.RequeueReasonNamespaceMismatch
+			e.requeueReason = qcache.RequeueReasonNamespaceMismatch
 		} else if err := workload.ValidateResources(&w); err != nil {
 			e.inadmissibleMsg = fmt.Sprintf("%s: %v", errInvalidWLResources, err.ToAggregate())
 		} else if err := workload.ValidateLimitRange(ctx, s.client, &w); err != nil {
@@ -439,7 +439,7 @@ func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, sna
 	return entries, inadmissibleEntries
 }
 
-func fits(cq *cache.ClusterQueueSnapshot, usage *workload.Usage, preemptedWorkloads preemption.PreemptedWorkloads, newTargets []*preemption.Target) bool {
+func fits(cq *schdcache.ClusterQueueSnapshot, usage *workload.Usage, preemptedWorkloads preemption.PreemptedWorkloads, newTargets []*preemption.Target) bool {
 	workloads := slices.Collect(maps.Values(preemptedWorkloads))
 	for _, target := range newTargets {
 		workloads = append(workloads, target.WorkloadInfo)
@@ -450,7 +450,7 @@ func fits(cq *cache.ClusterQueueSnapshot, usage *workload.Usage, preemptedWorklo
 }
 
 // resourcesToReserve calculates how much of the available resources in cq/cohort assignment should be reserved.
-func resourcesToReserve(e *entry, cq *cache.ClusterQueueSnapshot) workload.Usage {
+func resourcesToReserve(e *entry, cq *schdcache.ClusterQueueSnapshot) workload.Usage {
 	return netUsage(e, quotaResourcesToReserve(e, cq))
 }
 
@@ -466,7 +466,7 @@ func netUsage(e *entry, netQuota resources.FlavorResourceQuantities) workload.Us
 	return result
 }
 
-func quotaResourcesToReserve(e *entry, cq *cache.ClusterQueueSnapshot) resources.FlavorResourceQuantities {
+func quotaResourcesToReserve(e *entry, cq *schdcache.ClusterQueueSnapshot) resources.FlavorResourceQuantities {
 	if e.assignment.RepresentativeMode() != flavorassigner.Preempt {
 		return e.assignment.Usage.Quota
 	}
@@ -491,7 +491,7 @@ type partialAssignment struct {
 	preemptionTargets []*preemption.Target
 }
 
-func (s *Scheduler) getAssignments(log logr.Logger, wl *workload.Info, snap *cache.Snapshot) (flavorassigner.Assignment, []*preemption.Target) {
+func (s *Scheduler) getAssignments(log logr.Logger, wl *workload.Info, snap *schdcache.Snapshot) (flavorassigner.Assignment, []*preemption.Target) {
 	assignment, targets := s.getInitialAssignments(log, wl, snap)
 	cq := snap.ClusterQueue(wl.ClusterQueue)
 	updateAssignmentForTAS(cq, wl, &assignment, targets)
@@ -520,7 +520,7 @@ func (s *Scheduler) getAssignments(log logr.Logger, wl *workload.Info, snap *cac
 //     identified during scheduling.
 //
 // If no valid assignment can be made, returns the original full assignment with no preemption targets.
-func (s *Scheduler) getInitialAssignments(log logr.Logger, wl *workload.Info, snap *cache.Snapshot) (flavorassigner.Assignment, []*preemption.Target) {
+func (s *Scheduler) getInitialAssignments(log logr.Logger, wl *workload.Info, snap *schdcache.Snapshot) (flavorassigner.Assignment, []*preemption.Target) {
 	cq := snap.ClusterQueue(wl.ClusterQueue)
 
 	preemptionTargets, replaceableWorkloadSlice := workloadslicing.ReplacedWorkloadSlice(wl, snap)
@@ -575,11 +575,11 @@ func (s *Scheduler) evictWorkloadAfterFailedTASReplacement(ctx context.Context,
 	return nil
 }
 
-func updateAssignmentForTAS(cq *cache.ClusterQueueSnapshot, wl *workload.Info, assignment *flavorassigner.Assignment, targets []*preemption.Target) {
+func updateAssignmentForTAS(cq *schdcache.ClusterQueueSnapshot, wl *workload.Info, assignment *flavorassigner.Assignment, targets []*preemption.Target) {
 	if features.Enabled(features.TopologyAwareScheduling) && assignment.RepresentativeMode() == flavorassigner.Preempt &&
 		(workload.IsExplicitlyRequestingTAS(wl.Obj.Spec.PodSets...) || cq.IsTASOnly()) && !workload.HasTopologyAssignmentWithNodeToReplace(wl.Obj) {
 		tasRequests := assignment.WorkloadsTopologyRequests(wl, cq)
-		var tasResult cache.TASAssignmentsResult
+		var tasResult schdcache.TASAssignmentsResult
 		if len(targets) > 0 {
 			var targetWorkloads []*workload.Info
 			for _, target := range targets {
@@ -595,7 +595,7 @@ func updateAssignmentForTAS(cq *cache.ClusterQueueSnapshot, wl *workload.Info, a
 			// in the next scheduling cycle by the waiting workload. To obtain
 			// a TAS assignment for reserving the resources we run the algorithm
 			// assuming the cluster is empty.
-			tasResult = cq.FindTopologyAssignmentsForWorkload(tasRequests, cache.WithSimulateEmpty(true))
+			tasResult = cq.FindTopologyAssignmentsForWorkload(tasRequests, schdcache.WithSimulateEmpty(true))
 		}
 		assignment.UpdateForTASResult(tasResult)
 	}
@@ -604,7 +604,7 @@ func updateAssignmentForTAS(cq *cache.ClusterQueueSnapshot, wl *workload.Info, a
 // admit sets the admitting clusterQueue and flavors into the workload of
 // the entry, and asynchronously updates the object in the apiserver after
 // assuming it in the cache.
-func (s *Scheduler) admit(ctx context.Context, e *entry, cq *cache.ClusterQueueSnapshot) error {
+func (s *Scheduler) admit(ctx context.Context, e *entry, cq *schdcache.ClusterQueueSnapshot) error {
 	log := ctrl.LoggerFrom(ctx)
 	newWorkload := e.Obj.DeepCopy()
 	admission := &kueue.Admission{
@@ -754,9 +754,9 @@ func makeClassicalIterator(entries []entry, workloadOrdering workload.Ordering)
 
 func (s *Scheduler) requeueAndUpdate(ctx context.Context, e entry) {
 	log := ctrl.LoggerFrom(ctx)
-	if e.status != notNominated && e.requeueReason == queue.RequeueReasonGeneric {
+	if e.status != notNominated && e.requeueReason == qcache.RequeueReasonGeneric {
 		// Failed after nomination is the only reason why a workload would be requeued downstream.
-		e.requeueReason = queue.RequeueReasonFailedAfterNomination
+		e.requeueReason = qcache.RequeueReasonFailedAfterNomination
 	}
 
 	if s.queues.QueueSecondPassIfNeeded(ctx, e.Obj) {
diff --git a/pkg/visibility/api/install.go b/pkg/visibility/api/install.go
index 66449b0f8..19938e0ed 100644
--- a/pkg/visibility/api/install.go
+++ b/pkg/visibility/api/install.go
@@ -25,7 +25,7 @@ import (
 	genericapiserver "k8s.io/apiserver/pkg/server"
 
 	visibilityv1beta1 "sigs.k8s.io/kueue/apis/visibility/v1beta1"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	apiv1beta1 "sigs.k8s.io/kueue/pkg/visibility/api/v1beta1"
 )
 
@@ -42,7 +42,7 @@ func init() {
 }
 
 // Install installs API scheme and registers storages
-func Install(server *genericapiserver.GenericAPIServer, kueueMgr *queue.Manager) error {
+func Install(server *genericapiserver.GenericAPIServer, kueueMgr *qcache.Manager) error {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(visibilityv1beta1.GroupVersion.Group, Scheme, ParameterCodec, Codecs)
 	apiGroupInfo.VersionedResourcesStorageMap[visibilityv1beta1.GroupVersion.Version] = apiv1beta1.NewStorage(kueueMgr)
 	return server.InstallAPIGroups(&apiGroupInfo)
diff --git a/pkg/visibility/api/v1beta1/pending_workloads_cq.go b/pkg/visibility/api/v1beta1/pending_workloads_cq.go
index 8f744e217..389c84830 100644
--- a/pkg/visibility/api/v1beta1/pending_workloads_cq.go
+++ b/pkg/visibility/api/v1beta1/pending_workloads_cq.go
@@ -28,14 +28,14 @@ import (
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	visibility "sigs.k8s.io/kueue/apis/visibility/v1beta1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 
 	_ "k8s.io/metrics/pkg/apis/metrics/install"
 )
 
 type pendingWorkloadsInCqREST struct {
-	queueMgr *queue.Manager
+	queueMgr *qcache.Manager
 	log      logr.Logger
 }
 
@@ -43,7 +43,7 @@ var _ rest.Storage = &pendingWorkloadsInCqREST{}
 var _ rest.GetterWithOptions = &pendingWorkloadsInCqREST{}
 var _ rest.Scoper = &pendingWorkloadsInCqREST{}
 
-func NewPendingWorkloadsInCqREST(kueueMgr *queue.Manager) *pendingWorkloadsInCqREST {
+func NewPendingWorkloadsInCqREST(kueueMgr *qcache.Manager) *pendingWorkloadsInCqREST {
 	return &pendingWorkloadsInCqREST{
 		queueMgr: kueueMgr,
 		log:      ctrl.Log.WithName("pending-workload-in-cq"),
diff --git a/pkg/visibility/api/v1beta1/pending_workloads_lq.go b/pkg/visibility/api/v1beta1/pending_workloads_lq.go
index 072eff35d..5fcc15ca2 100644
--- a/pkg/visibility/api/v1beta1/pending_workloads_lq.go
+++ b/pkg/visibility/api/v1beta1/pending_workloads_lq.go
@@ -29,15 +29,15 @@ import (
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	visibility "sigs.k8s.io/kueue/apis/visibility/v1beta1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utilqueue "sigs.k8s.io/kueue/pkg/util/queue"
 
 	_ "k8s.io/metrics/pkg/apis/metrics/install"
 )
 
 type pendingWorkloadsInLqREST struct {
-	queueMgr *queue.Manager
+	queueMgr *qcache.Manager
 	log      logr.Logger
 }
 
@@ -45,7 +45,7 @@ var _ rest.Storage = &pendingWorkloadsInLqREST{}
 var _ rest.GetterWithOptions = &pendingWorkloadsInLqREST{}
 var _ rest.Scoper = &pendingWorkloadsInLqREST{}
 
-func NewPendingWorkloadsInLqREST(kueueMgr *queue.Manager) *pendingWorkloadsInLqREST {
+func NewPendingWorkloadsInLqREST(kueueMgr *qcache.Manager) *pendingWorkloadsInLqREST {
 	return &pendingWorkloadsInLqREST{
 		queueMgr: kueueMgr,
 		log:      ctrl.Log.WithName("pending-workload-in-lq"),
diff --git a/pkg/visibility/api/v1beta1/storage.go b/pkg/visibility/api/v1beta1/storage.go
index 61d3e817f..f641d2e8b 100644
--- a/pkg/visibility/api/v1beta1/storage.go
+++ b/pkg/visibility/api/v1beta1/storage.go
@@ -19,10 +19,10 @@ package v1beta1
 import (
 	"k8s.io/apiserver/pkg/registry/rest"
 
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 )
 
-func NewStorage(mgr *queue.Manager) map[string]rest.Storage {
+func NewStorage(mgr *qcache.Manager) map[string]rest.Storage {
 	return map[string]rest.Storage{
 		"clusterqueues":                  NewCqREST(),
 		"clusterqueues/pendingworkloads": NewPendingWorkloadsInCqREST(mgr),
diff --git a/pkg/visibility/server.go b/pkg/visibility/server.go
index 1d180cd76..2a467ce8c 100644
--- a/pkg/visibility/server.go
+++ b/pkg/visibility/server.go
@@ -34,7 +34,7 @@ import (
 
 	generatedopenapi "sigs.k8s.io/kueue/apis/visibility/openapi"
 	visibilityv1beta1 "sigs.k8s.io/kueue/apis/visibility/v1beta1"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/visibility/api"
 
 	_ "k8s.io/component-base/metrics/prometheus/restclient" // for client-go metrics registration
@@ -57,7 +57,7 @@ var (
 // +kubebuilder:rbac:groups=flowcontrol.apiserver.k8s.io,resources=flowschemas/status,verbs=patch
 
 // CreateAndStartVisibilityServer creates visibility server injecting KueueManager and starts it
-func CreateAndStartVisibilityServer(ctx context.Context, kueueMgr *queue.Manager) error {
+func CreateAndStartVisibilityServer(ctx context.Context, kueueMgr *qcache.Manager) error {
 	config := newVisibilityServerConfig()
 	if err := applyVisibilityServerOptions(config); err != nil {
 		return fmt.Errorf("unable to apply VisibilityServerOptions: %w", err)
diff --git a/pkg/workloadslicing/workloadslicing.go b/pkg/workloadslicing/workloadslicing.go
index 9e61cd502..81ac76b96 100644
--- a/pkg/workloadslicing/workloadslicing.go
+++ b/pkg/workloadslicing/workloadslicing.go
@@ -31,7 +31,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption"
@@ -284,7 +284,7 @@ func StartWorkloadSlicePods(ctx context.Context, clnt client.Client, object clie
 // - The input workload or snapshot is nil
 // - The workload has no replacement slice key
 // - The referenced replacement workload is not found in the ClusterQueue snapshot
-func ReplacedWorkloadSlice(wl *workload.Info, snap *cache.Snapshot) ([]*preemption.Target, *workload.Info) {
+func ReplacedWorkloadSlice(wl *workload.Info, snap *schdcache.Snapshot) ([]*preemption.Target, *workload.Info) {
 	if !features.Enabled(features.ElasticJobsViaWorkloadSlices) || wl == nil || snap == nil {
 		return nil, nil
 	}



Test patch:
diff --git a/pkg/hierarchy/manager_test.go b/pkg/cache/hierarchy/manager_test.go
similarity index 100%
rename from pkg/hierarchy/manager_test.go
rename to pkg/cache/hierarchy/manager_test.go
diff --git a/pkg/queue/cluster_queue_test.go b/pkg/cache/queue/cluster_queue_test.go
similarity index 100%
rename from pkg/queue/cluster_queue_test.go
rename to pkg/cache/queue/cluster_queue_test.go
diff --git a/pkg/queue/manager_test.go b/pkg/cache/queue/manager_test.go
similarity index 100%
rename from pkg/queue/manager_test.go
rename to pkg/cache/queue/manager_test.go
diff --git a/pkg/cache/cache_test.go b/pkg/cache/scheduler/cache_test.go
similarity index 99%
rename from pkg/cache/cache_test.go
rename to pkg/cache/scheduler/cache_test.go
index 57d695bfd..62dbe02b4 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/scheduler/cache_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"context"
@@ -39,8 +39,8 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/util/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
diff --git a/pkg/cache/clusterqueue_test.go b/pkg/cache/scheduler/clusterqueue_test.go
similarity index 99%
rename from pkg/cache/clusterqueue_test.go
rename to pkg/cache/scheduler/clusterqueue_test.go
index ffd99527c..78ba59efb 100644
--- a/pkg/cache/clusterqueue_test.go
+++ b/pkg/cache/scheduler/clusterqueue_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"testing"
diff --git a/pkg/cache/fair_sharing_test.go b/pkg/cache/scheduler/fair_sharing_test.go
similarity index 99%
rename from pkg/cache/fair_sharing_test.go
rename to pkg/cache/scheduler/fair_sharing_test.go
index 4970cc43e..e9dedb954 100644
--- a/pkg/cache/fair_sharing_test.go
+++ b/pkg/cache/scheduler/fair_sharing_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"fmt"
diff --git a/pkg/cache/resource_node_test.go b/pkg/cache/scheduler/resource_node_test.go
similarity index 99%
rename from pkg/cache/resource_node_test.go
rename to pkg/cache/scheduler/resource_node_test.go
index 2dd52552c..59502772a 100644
--- a/pkg/cache/resource_node_test.go
+++ b/pkg/cache/scheduler/resource_node_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"testing"
diff --git a/pkg/cache/resource_test.go b/pkg/cache/scheduler/resource_test.go
similarity index 99%
rename from pkg/cache/resource_test.go
rename to pkg/cache/scheduler/resource_test.go
index 367d9a532..d2e581ab6 100644
--- a/pkg/cache/resource_test.go
+++ b/pkg/cache/scheduler/resource_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"testing"
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/scheduler/snapshot_test.go
similarity index 99%
rename from pkg/cache/snapshot_test.go
rename to pkg/cache/scheduler/snapshot_test.go
index 3fb40be98..6d51933ff 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/scheduler/snapshot_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"testing"
@@ -29,8 +29,8 @@ import (
 	"k8s.io/utils/ptr"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/resources"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/pkg/workload"
diff --git a/pkg/cache/tas_cache_test.go b/pkg/cache/scheduler/tas_cache_test.go
similarity index 99%
rename from pkg/cache/tas_cache_test.go
rename to pkg/cache/scheduler/tas_cache_test.go
index d11a0c123..14122e09c 100644
--- a/pkg/cache/tas_cache_test.go
+++ b/pkg/cache/scheduler/tas_cache_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"sort"
diff --git a/pkg/cache/tas_flavor_snapshot_test.go b/pkg/cache/scheduler/tas_flavor_snapshot_test.go
similarity index 99%
rename from pkg/cache/tas_flavor_snapshot_test.go
rename to pkg/cache/scheduler/tas_flavor_snapshot_test.go
index bfbf3ce57..f5d6ba72a 100644
--- a/pkg/cache/tas_flavor_snapshot_test.go
+++ b/pkg/cache/scheduler/tas_flavor_snapshot_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package cache
+package scheduler
 
 import (
 	"testing"
diff --git a/pkg/controller/core/clusterqueue_controller_test.go b/pkg/controller/core/clusterqueue_controller_test.go
index 1532a1086..ea880ca44 100644
--- a/pkg/controller/core/clusterqueue_controller_test.go
+++ b/pkg/controller/core/clusterqueue_controller_test.go
@@ -30,10 +30,10 @@ import (
 	"k8s.io/utils/ptr"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingmetrics "sigs.k8s.io/kueue/pkg/util/testing/metrics"
 )
@@ -183,11 +183,11 @@ func TestUpdateCqStatusIfChanged(t *testing.T) {
 			},
 		},
 		"cluster queue does not exist on manager": {
-			wantError: queue.ErrClusterQueueDoesNotExist,
+			wantError: qcache.ErrClusterQueueDoesNotExist,
 		},
 		"cluster queue does not exist on cache": {
 			insertCqIntoManager: true,
-			wantError:           cache.ErrCqNotFound,
+			wantError:           schdcache.ErrCqNotFound,
 		},
 	}
 
@@ -204,8 +204,8 @@ func TestUpdateCqStatusIfChanged(t *testing.T) {
 
 			cl := utiltesting.NewClientBuilder().WithLists(defaultWls).WithObjects(lq, cq).WithStatusSubresource(lq, cq).
 				Build()
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			if tc.insertCqIntoCache {
 				if err := cqCache.AddClusterQueue(ctx, cq); err != nil {
 					t.Fatalf("Inserting clusterQueue in cache: %v", err)
@@ -571,8 +571,8 @@ func TestClusterQueuePendingWorkloadsStatus(t *testing.T) {
 
 			cl := utiltesting.NewClientBuilder().WithLists(defaultWls).WithObjects(lq, cq).WithStatusSubresource(lq, cq).
 				Build()
-			cCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cCache)
+			cCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cCache)
 			ctx, _ := utiltesting.ContextWithLog(t)
 			if err := qManager.AddClusterQueue(ctx, cq); err != nil {
 				t.Fatalf("Inserting clusterQueue in manager: %v", err)
diff --git a/pkg/controller/core/cohort_controller_test.go b/pkg/controller/core/cohort_controller_test.go
index 54bc853eb..6cad55964 100644
--- a/pkg/controller/core/cohort_controller_test.go
+++ b/pkg/controller/core/cohort_controller_test.go
@@ -29,8 +29,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
-	"sigs.k8s.io/kueue/pkg/queue"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/resources"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 )
@@ -38,8 +38,8 @@ import (
 func TestCohortReconcileCohortNotFoundDelete(t *testing.T) {
 	cl := utiltesting.NewClientBuilder().Build()
 	ctx, _ := utiltesting.ContextWithLog(t)
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	cohort := utiltesting.MakeCohort("cohort").Obj()
@@ -73,8 +73,8 @@ func TestCohortReconcileCohortNotFoundIdempotentDelete(t *testing.T) {
 	cl := utiltesting.NewClientBuilder().
 		Build()
 	ctx, _ := utiltesting.ContextWithLog(t)
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	snapshot, err := cache.Snapshot(ctx)
@@ -110,8 +110,8 @@ func TestCohortReconcileCycleNoError(t *testing.T) {
 		WithStatusSubresource(&kueue.Cohort{}).
 		Build()
 	ctx, _ := utiltesting.ContextWithLog(t)
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	// no cycle when creating first cohort
@@ -155,8 +155,8 @@ func TestCohortReconcileErrorOtherThanNotFoundNotDeleted(t *testing.T) {
 	}
 	cl := utiltesting.NewClientBuilder().WithInterceptorFuncs(funcs).Build()
 
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 	cohort := utiltesting.MakeCohort("cohort").Obj()
 	_ = cache.AddOrUpdateCohort(cohort)
@@ -191,8 +191,8 @@ func TestCohortReconcileLifecycle(t *testing.T) {
 		*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 	).Obj()
 	cl := utiltesting.NewClientBuilder().WithObjects(cohort).WithStatusSubresource(&kueue.Cohort{}).Build()
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	// create
@@ -281,8 +281,8 @@ func TestCohortReconcileLifecycle(t *testing.T) {
 func TestCohortReconcilerFilters(t *testing.T) {
 	cl := utiltesting.NewClientBuilder().
 		Build()
-	cache := cache.New(cl)
-	qManager := queue.NewManager(cl, cache)
+	cache := schdcache.New(cl)
+	qManager := qcache.NewManager(cl, cache)
 	reconciler := NewCohortReconciler(cl, cache, qManager)
 
 	t.Run("delete returns true", func(t *testing.T) {
diff --git a/pkg/controller/core/localqueue_controller_test.go b/pkg/controller/core/localqueue_controller_test.go
index 0598d79fa..27589a576 100644
--- a/pkg/controller/core/localqueue_controller_test.go
+++ b/pkg/controller/core/localqueue_controller_test.go
@@ -35,9 +35,9 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/test/util"
 )
@@ -513,7 +513,7 @@ func TestLocalQueueReconcile(t *testing.T) {
 				Build()
 
 			ctxWithLogger, log := utiltesting.ContextWithLog(t)
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			if err := cqCache.AddClusterQueue(ctxWithLogger, tc.clusterQueue); err != nil {
 				t.Fatalf("Unexpected error: %v", err)
 			}
@@ -521,7 +521,7 @@ func TestLocalQueueReconcile(t *testing.T) {
 			for _, wl := range tc.runningWls {
 				cqCache.AddOrUpdateWorkload(log, &wl)
 			}
-			qManager := queue.NewManager(cl, cqCache)
+			qManager := qcache.NewManager(cl, cqCache)
 			if err := qManager.AddClusterQueue(ctxWithLogger, tc.clusterQueue); err != nil {
 				t.Fatalf("Unexpected error: %v", err)
 			}
diff --git a/pkg/controller/core/workload_controller_test.go b/pkg/controller/core/workload_controller_test.go
index f7d546e23..1e7994b0d 100644
--- a/pkg/controller/core/workload_controller_test.go
+++ b/pkg/controller/core/workload_controller_test.go
@@ -37,9 +37,9 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/test/util"
 )
@@ -2014,8 +2014,8 @@ func TestReconcile(t *testing.T) {
 			cl := clientBuilder.Build()
 			recorder := &utiltesting.EventRecorder{}
 
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			reconciler := NewWorkloadReconciler(cl, qManager, cqCache, recorder, tc.reconcilerOpts...)
 			// use a fake clock with jitter = 0 to be able to assert on the requeueAt.
 			reconciler.clock = fakeClock
diff --git a/pkg/controller/jobframework/base_webhook_test.go b/pkg/controller/jobframework/base_webhook_test.go
index b607e14f7..728829fb1 100644
--- a/pkg/controller/jobframework/base_webhook_test.go
+++ b/pkg/controller/jobframework/base_webhook_test.go
@@ -30,12 +30,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/podset"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	utiljob "sigs.k8s.io/kueue/pkg/util/testingjobs/job"
 )
@@ -253,8 +253,8 @@ func TestBaseWebhookDefault(t *testing.T) {
 					utiltesting.MakeNamespace("default"),
 				)
 			cl := clientBuilder.Build()
-			cqCache := cache.New(cl)
-			queueManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			queueManager := qcache.NewManager(cl, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/jobs/deployment/deployment_webhook_test.go b/pkg/controller/jobs/deployment/deployment_webhook_test.go
index 7c233c20a..2b983e000 100644
--- a/pkg/controller/jobs/deployment/deployment_webhook_test.go
+++ b/pkg/controller/jobs/deployment/deployment_webhook_test.go
@@ -25,12 +25,12 @@ import (
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingdeployment "sigs.k8s.io/kueue/pkg/util/testingjobs/deployment"
 )
@@ -151,8 +151,8 @@ func TestDefault(t *testing.T) {
 			t.Cleanup(jobframework.EnableIntegrationsForTest(t, "pod"))
 			builder := utiltesting.NewClientBuilder()
 			client := builder.Build()
-			cqCache := cache.New(client)
-			queueManager := queue.NewManager(client, cqCache)
+			cqCache := schdcache.New(client)
+			queueManager := qcache.NewManager(client, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").
diff --git a/pkg/controller/jobs/job/job_webhook_test.go b/pkg/controller/jobs/job/job_webhook_test.go
index cbe064109..d597339b3 100644
--- a/pkg/controller/jobs/job/job_webhook_test.go
+++ b/pkg/controller/jobs/job/job_webhook_test.go
@@ -35,11 +35,11 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingutil "sigs.k8s.io/kueue/pkg/util/testingjobs/job"
 	testingmpijob "sigs.k8s.io/kueue/pkg/util/testingjobs/mpijob"
@@ -862,8 +862,8 @@ func TestDefault(t *testing.T) {
 				WithObjects(utiltesting.MakeNamespace("default")).
 				WithRuntimeObjects(tc.objs...)
 			cl := clientBuilder.Build()
-			cqCache := cache.New(cl)
-			queueManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			queueManager := qcache.NewManager(cl, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/jobs/jobset/jobset_webhook_test.go b/pkg/controller/jobs/jobset/jobset_webhook_test.go
index 0542ecd9e..fa3787789 100644
--- a/pkg/controller/jobs/jobset/jobset_webhook_test.go
+++ b/pkg/controller/jobs/jobset/jobset_webhook_test.go
@@ -29,10 +29,10 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingutil "sigs.k8s.io/kueue/pkg/util/testingjobs/jobset"
 )
@@ -429,8 +429,8 @@ func TestDefault(t *testing.T) {
 
 			clientBuilder := utiltesting.NewClientBuilder().WithObjects(utiltesting.MakeNamespace("default"))
 			cl := clientBuilder.Build()
-			cqCache := cache.New(cl)
-			queueManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			queueManager := qcache.NewManager(cl, cqCache)
 
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
diff --git a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook_test.go b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook_test.go
index 0500e2b02..a957d8155 100644
--- a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook_test.go
+++ b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook_test.go
@@ -29,12 +29,12 @@ import (
 	leaderworkersetv1 "sigs.k8s.io/lws/api/leaderworkerset/v1"
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingleaderworkerset "sigs.k8s.io/kueue/pkg/util/testingjobs/leaderworkerset"
 )
@@ -118,8 +118,8 @@ func TestDefault(t *testing.T) {
 
 			builder := utiltesting.NewClientBuilder()
 			cli := builder.Build()
-			cqCache := cache.New(cli)
-			queueManager := queue.NewManager(cli, cqCache)
+			cqCache := schdcache.New(cli)
+			queueManager := qcache.NewManager(cli, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/jobs/mpijob/mpijob_webhook_test.go b/pkg/controller/jobs/mpijob/mpijob_webhook_test.go
index 6722e2896..9b78a78cc 100644
--- a/pkg/controller/jobs/mpijob/mpijob_webhook_test.go
+++ b/pkg/controller/jobs/mpijob/mpijob_webhook_test.go
@@ -29,10 +29,10 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingutil "sigs.k8s.io/kueue/pkg/util/testingjobs/mpijob"
 )
@@ -405,8 +405,8 @@ func TestDefault(t *testing.T) {
 
 			clientBuilder := utiltesting.NewClientBuilder().WithObjects(utiltesting.MakeNamespace("default"))
 			cl := clientBuilder.Build()
-			cqCache := cache.New(cl)
-			queueManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			queueManager := qcache.NewManager(cl, cqCache)
 
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
diff --git a/pkg/controller/jobs/pod/pod_webhook_test.go b/pkg/controller/jobs/pod/pod_webhook_test.go
index 371d484d5..7d7e7a8b6 100644
--- a/pkg/controller/jobs/pod/pod_webhook_test.go
+++ b/pkg/controller/jobs/pod/pod_webhook_test.go
@@ -37,12 +37,12 @@ import (
 
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingjob "sigs.k8s.io/kueue/pkg/util/testingjobs/job"
 	testingmpijob "sigs.k8s.io/kueue/pkg/util/testingjobs/mpijob"
@@ -529,8 +529,8 @@ func TestDefault(t *testing.T) {
 			builder = builder.WithObjects(tc.initObjects...)
 			cli := builder.Build()
 
-			cqCache := cache.New(cli)
-			queueManager := queue.NewManager(cli, cqCache)
+			cqCache := schdcache.New(cli)
+			queueManager := qcache.NewManager(cli, cqCache)
 
 			ctx, _ := utiltesting.ContextWithLog(t)
 
diff --git a/pkg/controller/jobs/raycluster/raycluster_webhook_test.go b/pkg/controller/jobs/raycluster/raycluster_webhook_test.go
index 14d8c96bb..7db59b4a3 100644
--- a/pkg/controller/jobs/raycluster/raycluster_webhook_test.go
+++ b/pkg/controller/jobs/raycluster/raycluster_webhook_test.go
@@ -30,10 +30,10 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingrayutil "sigs.k8s.io/kueue/pkg/util/testingjobs/raycluster"
 )
@@ -104,8 +104,8 @@ func TestValidateDefault(t *testing.T) {
 			ctx, _ := utiltesting.ContextWithLog(t)
 			builder := utiltesting.NewClientBuilder()
 			cli := builder.Build()
-			cqCache := cache.New(cli)
-			queueManager := queue.NewManager(cli, cqCache)
+			cqCache := schdcache.New(cli)
+			queueManager := qcache.NewManager(cli, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/jobs/rayjob/rayjob_webhook_test.go b/pkg/controller/jobs/rayjob/rayjob_webhook_test.go
index c483797bb..426a037aa 100644
--- a/pkg/controller/jobs/rayjob/rayjob_webhook_test.go
+++ b/pkg/controller/jobs/rayjob/rayjob_webhook_test.go
@@ -30,10 +30,10 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingrayutil "sigs.k8s.io/kueue/pkg/util/testingjobs/rayjob"
 )
@@ -104,8 +104,8 @@ func TestDefault(t *testing.T) {
 			ctx, _ := utiltesting.ContextWithLog(t)
 			builder := utiltesting.NewClientBuilder()
 			cli := builder.Build()
-			cqCache := cache.New(cli)
-			queueManager := queue.NewManager(cli, cqCache)
+			cqCache := schdcache.New(cli)
+			queueManager := qcache.NewManager(cli, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/jobs/statefulset/statefulset_webhook_test.go b/pkg/controller/jobs/statefulset/statefulset_webhook_test.go
index 7c17b3e13..484966c4b 100644
--- a/pkg/controller/jobs/statefulset/statefulset_webhook_test.go
+++ b/pkg/controller/jobs/statefulset/statefulset_webhook_test.go
@@ -33,14 +33,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 	leaderworkersetv1 "sigs.k8s.io/lws/api/leaderworkerset/v1"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/appwrapper"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/leaderworkerset"
 	podconstants "sigs.k8s.io/kueue/pkg/controller/jobs/pod/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	testingappwrapper "sigs.k8s.io/kueue/pkg/util/testingjobs/appwrapper"
 	testingleaderworkerset "sigs.k8s.io/kueue/pkg/util/testingjobs/leaderworkerset"
@@ -181,8 +181,8 @@ func TestDefault(t *testing.T) {
 
 			builder := utiltesting.NewClientBuilder().WithObjects(tc.initObjs...)
 			cli := builder.Build()
-			cqCache := cache.New(cli)
-			queueManager := queue.NewManager(cli, cqCache)
+			cqCache := schdcache.New(cli)
+			queueManager := qcache.NewManager(cli, cqCache)
 			if tc.defaultLqExist {
 				if err := queueManager.AddLocalQueue(ctx, utiltesting.MakeLocalQueue("default", "default").
 					ClusterQueue("cluster-queue").Obj()); err != nil {
diff --git a/pkg/controller/tas/node_failure_controller_test.go b/pkg/controller/tas/node_failure_controller_test.go
index 66bf2f629..d9385810b 100644
--- a/pkg/controller/tas/node_failure_controller_test.go
+++ b/pkg/controller/tas/node_failure_controller_test.go
@@ -28,7 +28,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/component-base/featuregate"
-	"k8s.io/utils/clock"
 	testingclock "k8s.io/utils/clock/testing"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/interceptor"
@@ -44,14 +43,6 @@ import (
 	testingpod "sigs.k8s.io/kueue/pkg/util/testingjobs/pod"
 )
 
-// newNodeTest is a helper to create a Node object for testing
-func newNodeTest(name string, readyStatus corev1.ConditionStatus, clock clock.Clock, transitionTimeOffset time.Duration) *corev1.Node {
-	return testingnode.MakeNode(name).StatusConditions(corev1.NodeCondition{
-		Type:               corev1.NodeReady,
-		Status:             readyStatus,
-		LastTransitionTime: metav1.NewTime(clock.Now().Add(-transitionTimeOffset))}).Obj()
-}
-
 func TestNodeFailureReconciler(t *testing.T) {
 	testStartTime := time.Now().Truncate(time.Second)
 	nodeName := "test-node-name"
@@ -108,6 +99,9 @@ func TestNodeFailureReconciler(t *testing.T) {
 		Admitted(true).
 		Obj()
 
+	now := metav1.NewTime(fakeClock.Now())
+	earlierTime := metav1.NewTime(now.Add(-NodeFailureDelay))
+
 	basePod := testingpod.MakePod("test-pod", nsName).
 		Annotation(kueuealpha.WorkloadAnnotation, wlName).
 		Label(kueuealpha.TASLabel, "true").
@@ -115,7 +109,7 @@ func TestNodeFailureReconciler(t *testing.T) {
 		Obj()
 
 	terminatingPod := basePod.DeepCopy()
-	terminatingPod.DeletionTimestamp = &metav1.Time{Time: fakeClock.Now()}
+	terminatingPod.DeletionTimestamp = &now
 	terminatingPod.Finalizers = []string{podcontroller.PodFinalizer}
 
 	failedPod := basePod.DeepCopy()
@@ -123,18 +117,20 @@ func TestNodeFailureReconciler(t *testing.T) {
 	failedPod.Status.ContainerStatuses = []corev1.ContainerStatus{
 		{
 			State: corev1.ContainerState{
-				Terminated: &corev1.ContainerStateTerminated{FinishedAt: metav1.NewTime(fakeClock.Now())},
+				Terminated: &corev1.ContainerStateTerminated{FinishedAt: now},
 			},
 		},
 	}
 	failedPod.Status.ContainerStatuses = []corev1.ContainerStatus{
 		{
 			State: corev1.ContainerState{
-				Terminated: &corev1.ContainerStateTerminated{FinishedAt: metav1.NewTime(fakeClock.Now())},
+				Terminated: &corev1.ContainerStateTerminated{FinishedAt: now},
 			},
 		},
 	}
 
+	baseNode := testingnode.MakeNode(nodeName)
+
 	tests := map[string]struct {
 		initObjs          []client.Object
 		reconcileRequests []reconcile.Request
@@ -146,7 +142,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 	}{
 		"Node Found and Healthy - not marked as unavailable": {
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionTrue, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionTrue,
+					LastTransitionTime: now}).Obj(),
 				baseWorkload.DeepCopy(),
 				basePod.DeepCopy(),
 			},
@@ -155,7 +154,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		},
 		"Node becomes healthy, annotation is removed": {
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionTrue, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionTrue,
+					LastTransitionTime: now}).Obj(),
 				workloadWithAnnotation.DeepCopy(),
 				basePod.DeepCopy(),
 			},
@@ -165,7 +167,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 
 		"Node Found and Unhealthy (NotReady), delay not passed - not marked as unavailable": {
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: now}).Obj(),
 				baseWorkload.DeepCopy(),
 				basePod.DeepCopy(),
 			},
@@ -175,7 +180,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		},
 		"Node Found and Unhealthy (NotReady), delay passed - marked as unavailable": {
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, NodeFailureDelay),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: earlierTime}).Obj(),
 				baseWorkload.DeepCopy(),
 				basePod.DeepCopy(),
 			},
@@ -185,7 +193,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		"Node NotReady, pod terminating, marked as unavailable": {
 			featureGates: []featuregate.Feature{features.TASReplaceNodeOnPodTermination},
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: earlierTime}).Obj(),
 				baseWorkload.DeepCopy(),
 				terminatingPod,
 			},
@@ -195,7 +206,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		"Node NotReady, pod failed, marked as unavailable": {
 			featureGates: []featuregate.Feature{features.TASReplaceNodeOnPodTermination},
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: now}).Obj(),
 				baseWorkload.DeepCopy(),
 				failedPod,
 			},
@@ -204,7 +218,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		},
 		"Node NotReady, pod failed, ReplaceNodeOnPodTermination feature gate off, requeued": {
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: now}).Obj(),
 				baseWorkload.DeepCopy(),
 				failedPod,
 			},
@@ -215,7 +232,10 @@ func TestNodeFailureReconciler(t *testing.T) {
 		"Node NotReady, pod running, not marked as unavailable, requeued": {
 			featureGates: []featuregate.Feature{features.TASReplaceNodeOnPodTermination},
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, time.Duration(0)),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: now}).Obj(),
 				baseWorkload.DeepCopy(),
 				basePod.DeepCopy(),
 			},
@@ -234,8 +254,14 @@ func TestNodeFailureReconciler(t *testing.T) {
 		"Two Nodes Unhealthy (NotReady), delay passed - workload evicted": {
 			featureGates: []featuregate.Feature{features.TASFailedNodeReplacement},
 			initObjs: []client.Object{
-				newNodeTest(nodeName, corev1.ConditionFalse, fakeClock, NodeFailureDelay),
-				newNodeTest(nodeName2, corev1.ConditionFalse, fakeClock, NodeFailureDelay),
+				baseNode.Clone().StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: earlierTime}).Obj(),
+				baseNode.Clone().Name(nodeName2).StatusConditions(corev1.NodeCondition{
+					Type:               corev1.NodeReady,
+					Status:             corev1.ConditionFalse,
+					LastTransitionTime: earlierTime}).Obj(),
 				workloadWithTwoNodes.DeepCopy(),
 				testingpod.MakePod("pod1", nsName).Annotation(kueuealpha.WorkloadAnnotation, wlName).Label(kueuealpha.TASLabel, "true").NodeName(nodeName).Obj(),
 				testingpod.MakePod("pod2", nsName).Annotation(kueuealpha.WorkloadAnnotation, wlName).Label(kueuealpha.TASLabel, "true").NodeName(nodeName2).Obj(),
diff --git a/pkg/scheduler/flavorassigner/flavorassigner_test.go b/pkg/scheduler/flavorassigner/flavorassigner_test.go
index 383e97e56..64093aead 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner_test.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner_test.go
@@ -28,7 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/api/resource"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/resources"
 	preemptioncommon "sigs.k8s.io/kueue/pkg/scheduler/preemption/common"
@@ -56,7 +56,7 @@ type testOracle struct {
 	simulationResult map[resources.FlavorResource]simulationResultForFlavor
 }
 
-func (f *testOracle) SimulatePreemption(log logr.Logger, cq *cache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int) {
+func (f *testOracle) SimulatePreemption(log logr.Logger, cq *schdcache.ClusterQueueSnapshot, wl workload.Info, fr resources.FlavorResource, quantity int64) (preemptioncommon.PreemptionPossibility, int) {
 	if f.simulationResult != nil {
 		if result, ok := f.simulationResult[fr]; ok {
 			return result.preemptionPossiblity, result.borrowingAfterSimulation
@@ -2441,7 +2441,7 @@ func TestAssignFlavors(t *testing.T) {
 				},
 			})
 
-			cache := cache.New(utiltesting.NewFakeClient())
+			cache := schdcache.New(utiltesting.NewFakeClient())
 			if err := cache.AddClusterQueue(ctx, &tc.clusterQueue); err != nil {
 				t.Fatalf("Failed to add CQ to cache")
 			}
@@ -2624,7 +2624,7 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 				testCq.Spec.FlavorFungibility = tc.flavorFungibility
 			}
 
-			cache := cache.New(utiltesting.NewFakeClient())
+			cache := schdcache.New(utiltesting.NewFakeClient())
 			if err := cache.AddClusterQueue(ctx, &testCq); err != nil {
 				t.Fatalf("Failed to add CQ to cache")
 			}
@@ -2746,7 +2746,7 @@ func TestDeletedFlavors(t *testing.T) {
 				},
 			})
 
-			cache := cache.New(utiltesting.NewFakeClient())
+			cache := schdcache.New(utiltesting.NewFakeClient())
 			if err := cache.AddClusterQueue(ctx, &tc.clusterQueue); err != nil {
 				t.Fatalf("Failed to add CQ to cache")
 			}
@@ -2791,7 +2791,7 @@ func TestDeletedFlavors(t *testing.T) {
 func TestLastAssignmentOutdated(t *testing.T) {
 	type args struct {
 		wl *workload.Info
-		cq *cache.ClusterQueueSnapshot
+		cq *schdcache.ClusterQueueSnapshot
 	}
 	tests := []struct {
 		name string
@@ -2806,7 +2806,7 @@ func TestLastAssignmentOutdated(t *testing.T) {
 						ClusterQueueGeneration: 0,
 					},
 				},
-				cq: &cache.ClusterQueueSnapshot{
+				cq: &schdcache.ClusterQueueSnapshot{
 					AllocatableResourceGeneration: 1,
 				},
 			},
@@ -2820,7 +2820,7 @@ func TestLastAssignmentOutdated(t *testing.T) {
 						ClusterQueueGeneration: 0,
 					},
 				},
-				cq: &cache.ClusterQueueSnapshot{
+				cq: &schdcache.ClusterQueueSnapshot{
 					AllocatableResourceGeneration: 0,
 				},
 			},
@@ -2924,7 +2924,7 @@ func TestHierarchical(t *testing.T) {
 			if tc.flavorFungibility != nil {
 				testCq.Spec.FlavorFungibility = tc.flavorFungibility
 			}
-			cache := cache.New(utiltesting.NewFakeClient())
+			cache := schdcache.New(utiltesting.NewFakeClient())
 			for _, cohort := range cohorts {
 				if err := cache.AddOrUpdateCohort(cohort); err != nil {
 					t.Fatalf("Couldn't add Cohort to cache: %v", err)
@@ -2970,14 +2970,14 @@ func TestHierarchical(t *testing.T) {
 
 func TestWorkloadsTopologyRequests_ErrorBranches(t *testing.T) {
 	cases := map[string]struct {
-		cq         cache.ClusterQueueSnapshot
+		cq         schdcache.ClusterQueueSnapshot
 		assignment Assignment
 		workload   workload.Info
 		wantErr    string
 	}{
 		"workload requires Topology, but there is no TAS cache information": {
-			cq: cache.ClusterQueueSnapshot{
-				TASFlavors: map[kueue.ResourceFlavorReference]*cache.TASFlavorSnapshot{},
+			cq: schdcache.ClusterQueueSnapshot{
+				TASFlavors: map[kueue.ResourceFlavorReference]*schdcache.TASFlavorSnapshot{},
 			},
 			assignment: Assignment{
 				PodSets: []PodSetAssignment{{
@@ -3002,8 +3002,8 @@ func TestWorkloadsTopologyRequests_ErrorBranches(t *testing.T) {
 			wantErr: "workload requires Topology, but there is no TAS cache information",
 		},
 		"workload requires Topology, but there is no TAS cache information for the assigned flavor": {
-			cq: cache.ClusterQueueSnapshot{
-				TASFlavors: map[kueue.ResourceFlavorReference]*cache.TASFlavorSnapshot{"tas": nil},
+			cq: schdcache.ClusterQueueSnapshot{
+				TASFlavors: map[kueue.ResourceFlavorReference]*schdcache.TASFlavorSnapshot{"tas": nil},
 			},
 			assignment: Assignment{
 				PodSets: []PodSetAssignment{{
diff --git a/pkg/scheduler/preemption/preemption_test.go b/pkg/scheduler/preemption/preemption_test.go
index 8b323eead..ba0affe30 100644
--- a/pkg/scheduler/preemption/preemption_test.go
+++ b/pkg/scheduler/preemption/preemption_test.go
@@ -38,11 +38,11 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	controllerconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
 	"sigs.k8s.io/kueue/pkg/util/slices"
@@ -54,11 +54,11 @@ var snapCmpOpts = cmp.Options{
 	// ignore zero values during comparison, as we consider
 	// zero FlavorResource usage to be same as no map entry.
 	cmpopts.IgnoreMapEntries(func(_ resources.FlavorResource, v int64) bool { return v == 0 }),
-	cmp.AllowUnexported(hierarchy.Manager[*cache.ClusterQueueSnapshot, *cache.CohortSnapshot]{}),
-	cmpopts.IgnoreFields(hierarchy.Manager[*cache.ClusterQueueSnapshot, *cache.CohortSnapshot]{}, "cohortFactory"),
-	cmpopts.IgnoreFields(cache.CohortSnapshot{}, "Cohort"),
-	cmp.AllowUnexported(cache.ClusterQueueSnapshot{}),
-	cmpopts.IgnoreFields(cache.ClusterQueueSnapshot{}, "ClusterQueue"),
+	cmp.AllowUnexported(hierarchy.Manager[*schdcache.ClusterQueueSnapshot, *schdcache.CohortSnapshot]{}),
+	cmpopts.IgnoreFields(hierarchy.Manager[*schdcache.ClusterQueueSnapshot, *schdcache.CohortSnapshot]{}, "cohortFactory"),
+	cmpopts.IgnoreFields(schdcache.CohortSnapshot{}, "Cohort"),
+	cmp.AllowUnexported(schdcache.ClusterQueueSnapshot{}),
+	cmpopts.IgnoreFields(schdcache.ClusterQueueSnapshot{}, "ClusterQueue"),
 }
 
 func TestPreemption(t *testing.T) {
@@ -1814,7 +1814,7 @@ func TestPreemption(t *testing.T) {
 				WithLists(&kueue.WorkloadList{Items: tc.admitted}).
 				Build()
 
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			for _, flv := range flavors {
 				cqCache.AddOrUpdateResourceFlavor(log, flv)
 			}
@@ -2732,7 +2732,7 @@ func TestFairPreemptions(t *testing.T) {
 			cl := utiltesting.NewClientBuilder().
 				WithLists(&kueue.WorkloadList{Items: tc.admitted}).
 				Build()
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			for _, flv := range flavors {
 				cqCache.AddOrUpdateResourceFlavor(log, flv)
 			}
@@ -4098,7 +4098,7 @@ func TestHierarchicalPreemptions(t *testing.T) {
 				WithLists(&kueue.WorkloadList{Items: tc.admitted}).
 				Build()
 
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			for _, flv := range flavors {
 				cqCache.AddOrUpdateResourceFlavor(log, flv)
 			}
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index a75ee5bde..0ff12c4c6 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -47,12 +47,12 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
 	"sigs.k8s.io/kueue/pkg/util/limitrange"
@@ -3292,8 +3292,8 @@ func TestSchedule(t *testing.T) {
 			}
 			cl := clientBuilder.Build()
 			recorder := &utiltesting.EventRecorder{}
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			// Workloads are loaded into queues or clusterQueues as we add them.
 			for _, q := range allQueues {
 				if err := qManager.AddLocalQueue(ctx, &q); err != nil {
@@ -4075,8 +4075,8 @@ func TestLastSchedulingContext(t *testing.T) {
 			broadcaster := record.NewBroadcaster()
 			recorder := broadcaster.NewRecorder(scheme,
 				corev1.EventSource{Component: constants.AdmissionName})
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			// Workloads are loaded into queues or clusterQueues as we add them.
 			for _, q := range queues {
 				if err := qManager.AddLocalQueue(ctx, &q); err != nil {
@@ -4268,8 +4268,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 			}).WithObjects(objs...).WithStatusSubresource(objs...).Build()
 			broadcaster := record.NewBroadcaster()
 			recorder := broadcaster.NewRecorder(scheme, corev1.EventSource{Component: constants.AdmissionName})
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			scheduler := New(qManager, cqCache, cl, recorder)
 			if err := qManager.AddLocalQueue(ctx, q1); err != nil {
 				t.Fatalf("Inserting queue %s/%s in manager: %v", q1.Namespace, q1.Name, err)
@@ -4484,7 +4484,7 @@ func TestResourcesToReserve(t *testing.T) {
 			cl := utiltesting.NewClientBuilder().
 				WithLists(&kueue.ClusterQueueList{Items: []kueue.ClusterQueue{*cq}}).
 				Build()
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			for _, flavor := range resourceFlavors {
 				cqCache.AddOrUpdateResourceFlavor(log, flavor)
 			}
@@ -6481,10 +6481,10 @@ func TestScheduleForTAS(t *testing.T) {
 			_ = tasindexer.SetupIndexes(ctx, utiltesting.AsIndexer(clientBuilder))
 			cl := clientBuilder.Build()
 			recorder := &utiltesting.EventRecorder{}
-			cqCache := cache.New(cl)
+			cqCache := schdcache.New(cl)
 			now := time.Now()
 			fakeClock := testingclock.NewFakeClock(now)
-			qManager := queue.NewManager(cl, cqCache, queue.WithClock(fakeClock))
+			qManager := qcache.NewManager(cl, cqCache, qcache.WithClock(fakeClock))
 			topologyByName := slices.ToMap(tc.topologies, func(i int) (kueue.TopologyReference, kueuealpha.Topology) {
 				return kueue.TopologyReference(tc.topologies[i].Name), tc.topologies[i]
 			})
@@ -7020,8 +7020,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 			_ = tasindexer.SetupIndexes(ctx, utiltesting.AsIndexer(clientBuilder))
 			cl := clientBuilder.Build()
 			recorder := &utiltesting.EventRecorder{}
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			topologyByName := slices.ToMap(tc.topologies, func(i int) (kueue.TopologyReference, kueuealpha.Topology) {
 				return kueue.TopologyReference(tc.topologies[i].Name), tc.topologies[i]
 			})
@@ -7958,8 +7958,8 @@ func TestScheduleForTASCohorts(t *testing.T) {
 			_ = tasindexer.SetupIndexes(ctx, utiltesting.AsIndexer(clientBuilder))
 			cl := clientBuilder.Build()
 			recorder := &utiltesting.EventRecorder{}
-			cqCache := cache.New(cl)
-			qManager := queue.NewManager(cl, cqCache)
+			cqCache := schdcache.New(cl)
+			qManager := qcache.NewManager(cl, cqCache)
 			topologyByName := slices.ToMap(tc.topologies, func(i int) (kueue.TopologyReference, kueuealpha.Topology) {
 				return kueue.TopologyReference(tc.topologies[i].Name), tc.topologies[i]
 			})
@@ -8284,8 +8284,8 @@ func TestScheduleForAFS(t *testing.T) {
 			fairSharing := &config.FairSharing{
 				Enable: tc.enableFairSharing,
 			}
-			cqCache := cache.New(cl, cache.WithFairSharing(fairSharing.Enable), cache.WithAdmissionFairSharing(afsConfig))
-			qManager := queue.NewManager(cl, cqCache, queue.WithAdmissionFairSharing(afsConfig))
+			cqCache := schdcache.New(cl, schdcache.WithFairSharing(fairSharing.Enable), schdcache.WithAdmissionFairSharing(afsConfig))
+			qManager := qcache.NewManager(cl, cqCache, qcache.WithAdmissionFairSharing(afsConfig))
 
 			ctx, log := utiltesting.ContextWithLog(t)
 			for _, q := range queues {
diff --git a/pkg/visibility/api/v1beta1/pending_workloads_cq_test.go b/pkg/visibility/api/v1beta1/pending_workloads_cq_test.go
index d977fc4f3..02c78e279 100644
--- a/pkg/visibility/api/v1beta1/pending_workloads_cq_test.go
+++ b/pkg/visibility/api/v1beta1/pending_workloads_cq_test.go
@@ -29,8 +29,8 @@ import (
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	visibility "sigs.k8s.io/kueue/apis/visibility/v1beta1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 )
 
@@ -317,7 +317,7 @@ func TestPendingWorkloadsInCQ(t *testing.T) {
 	}
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
-			manager := queue.NewManager(utiltesting.NewFakeClient(), nil)
+			manager := qcache.NewManager(utiltesting.NewFakeClient(), nil)
 			ctx, _ := utiltesting.ContextWithLog(t)
 			ctx, cancel := context.WithCancel(ctx)
 			defer cancel()
diff --git a/pkg/visibility/api/v1beta1/pending_workloads_lq_test.go b/pkg/visibility/api/v1beta1/pending_workloads_lq_test.go
index 592e6d9f4..44a7ab9e6 100644
--- a/pkg/visibility/api/v1beta1/pending_workloads_lq_test.go
+++ b/pkg/visibility/api/v1beta1/pending_workloads_lq_test.go
@@ -30,8 +30,8 @@ import (
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	visibility "sigs.k8s.io/kueue/apis/visibility/v1beta1"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
 	"sigs.k8s.io/kueue/pkg/constants"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 )
 
@@ -434,7 +434,7 @@ func TestPendingWorkloadsInLQ(t *testing.T) {
 	}
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
-			manager := queue.NewManager(utiltesting.NewFakeClient(), nil)
+			manager := qcache.NewManager(utiltesting.NewFakeClient(), nil)
 			ctx, _ := utiltesting.ContextWithLog(t)
 			ctx, cancel := context.WithCancel(ctx)
 			defer cancel()
diff --git a/pkg/workloadslicing/workloadslicing_test.go b/pkg/workloadslicing/workloadslicing_test.go
index b3800acd7..280e51940 100644
--- a/pkg/workloadslicing/workloadslicing_test.go
+++ b/pkg/workloadslicing/workloadslicing_test.go
@@ -40,10 +40,10 @@ import (
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	"sigs.k8s.io/kueue/pkg/cache/hierarchy"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/pkg/workload"
@@ -1119,7 +1119,7 @@ func Test_StartWorkloadSlicePods(t *testing.T) {
 func TestReplacedWorkloadSlice(t *testing.T) {
 	type args struct {
 		wl   *workload.Info
-		snap *cache.Snapshot
+		snap *schdcache.Snapshot
 	}
 	type want struct {
 		wl      *workload.Info
@@ -1145,7 +1145,7 @@ func TestReplacedWorkloadSlice(t *testing.T) {
 			featureEnabled: true,
 			args: args{
 				wl:   workload.NewInfo(utiltesting.MakeWorkload("test", "default").Obj()),
-				snap: &cache.Snapshot{},
+				snap: &schdcache.Snapshot{},
 			},
 		},
 		"ReplacedWorkloadIsNotFound_MissingClusterQueue": {
@@ -1154,10 +1154,10 @@ func TestReplacedWorkloadSlice(t *testing.T) {
 				wl: workload.NewInfo(utiltesting.MakeWorkload("test-new", "default").
 					Annotation(WorkloadSliceReplacementFor, "test-old").
 					Obj()),
-				snap: &cache.Snapshot{
+				snap: &schdcache.Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[kueue.CohortReference]*cache.CohortSnapshot{},
-						map[kueue.ClusterQueueReference]*cache.ClusterQueueSnapshot{}),
+						map[kueue.CohortReference]*schdcache.CohortSnapshot{},
+						map[kueue.ClusterQueueReference]*schdcache.ClusterQueueSnapshot{}),
 				},
 			},
 		},
@@ -1168,10 +1168,10 @@ func TestReplacedWorkloadSlice(t *testing.T) {
 					Annotation(WorkloadSliceReplacementFor, "test-old").
 					Admission(utiltesting.MakeAdmission("default").Obj()).
 					Obj()),
-				snap: &cache.Snapshot{
+				snap: &schdcache.Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[kueue.CohortReference]*cache.CohortSnapshot{},
-						map[kueue.ClusterQueueReference]*cache.ClusterQueueSnapshot{
+						map[kueue.CohortReference]*schdcache.CohortSnapshot{},
+						map[kueue.ClusterQueueReference]*schdcache.ClusterQueueSnapshot{
 							"default": {},
 						}),
 				},
@@ -1184,10 +1184,10 @@ func TestReplacedWorkloadSlice(t *testing.T) {
 					Annotation(WorkloadSliceReplacementFor, "test-old").
 					Admission(utiltesting.MakeAdmission("default").Obj()).
 					Obj()),
-				snap: &cache.Snapshot{
+				snap: &schdcache.Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[kueue.CohortReference]*cache.CohortSnapshot{},
-						map[kueue.ClusterQueueReference]*cache.ClusterQueueSnapshot{
+						map[kueue.CohortReference]*schdcache.CohortSnapshot{},
+						map[kueue.ClusterQueueReference]*schdcache.ClusterQueueSnapshot{
 							"default": {
 								Workloads: map[workload.Reference]*workload.Info{
 									"test-old": workload.NewInfo(utiltesting.MakeWorkload("test-old", "default").Obj()),
diff --git a/test/e2e/multikueue/e2e_test.go b/test/e2e/multikueue/e2e_test.go
index 98a2fd667..27ab2121a 100644
--- a/test/e2e/multikueue/e2e_test.go
+++ b/test/e2e/multikueue/e2e_test.go
@@ -237,7 +237,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 				{
 					Type:   corev1.PodInitialized,
 					Status: corev1.ConditionTrue,
-					Reason: finishReason},
+					Reason: finishReason,
+				},
 				{
 					Type:   corev1.PodReady,
 					Status: corev1.ConditionFalse,
@@ -246,7 +247,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 				{
 					Type:   corev1.ContainersReady,
 					Status: corev1.ConditionFalse,
-					Reason: finishReason},
+					Reason: finishReason,
+				},
 				{
 					Type:   corev1.PodScheduled,
 					Status: corev1.ConditionTrue,
@@ -258,7 +260,7 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 					createdPod := corev1.Pod{}
 					g.Expect(k8sManagerClient.Get(ctx, client.ObjectKeyFromObject(pod), &createdPod)).To(gomega.Succeed())
 					g.Expect(createdPod.Status.Phase).To(gomega.Equal(corev1.PodSucceeded))
-					g.Expect(createdPod.Status.Conditions).To(gomega.BeComparableTo(finishPodConditions, cmpopts.IgnoreFields(corev1.PodCondition{}, "LastTransitionTime")))
+					g.Expect(createdPod.Status.Conditions).To(gomega.BeComparableTo(finishPodConditions, util.IgnorePodConditionTimestampsMessageAndObservedGeneration))
 				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
 			})
 		})
diff --git a/test/e2e/singlecluster/pod_test.go b/test/e2e/singlecluster/pod_test.go
index ddb43b866..6dc957cf8 100644
--- a/test/e2e/singlecluster/pod_test.go
+++ b/test/e2e/singlecluster/pod_test.go
@@ -19,7 +19,6 @@ package e2e
 import (
 	"fmt"
 
-	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
@@ -333,7 +332,7 @@ var _ = ginkgo.Describe("Pod groups", func() {
 						Type:   corev1.PodScheduled,
 						Status: corev1.ConditionFalse,
 						Reason: corev1.PodReasonUnschedulable,
-					}, cmpopts.IgnoreFields(corev1.PodCondition{}, "LastProbeTime", "LastTransitionTime", "Message"))))
+					}, util.IgnorePodConditionTimestampsMessageAndObservedGeneration)))
 				}, util.Timeout, util.Interval).Should(gomega.Succeed())
 			})
 
diff --git a/test/integration/multikueue/suite_test.go b/test/integration/multikueue/suite_test.go
index 0d915db59..354004946 100644
--- a/test/integration/multikueue/suite_test.go
+++ b/test/integration/multikueue/suite_test.go
@@ -35,7 +35,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/admissionchecks/multikueue"
 	"sigs.k8s.io/kueue/pkg/controller/core"
@@ -52,7 +53,6 @@ import (
 	workloadpod "sigs.k8s.io/kueue/pkg/controller/jobs/pod"
 	workloadraycluster "sigs.k8s.io/kueue/pkg/controller/jobs/raycluster"
 	workloadrayjob "sigs.k8s.io/kueue/pkg/controller/jobs/rayjob"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/pkg/webhooks"
@@ -117,8 +117,8 @@ func managerSetup(ctx context.Context, mgr manager.Manager) {
 	err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	configuration := &config.Configuration{}
 	mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/admissionchecks/provisioning/suite_test.go b/test/integration/singlecluster/controller/admissionchecks/provisioning/suite_test.go
index 96bc817a2..89cae1713 100644
--- a/test/integration/singlecluster/controller/admissionchecks/provisioning/suite_test.go
+++ b/test/integration/singlecluster/controller/admissionchecks/provisioning/suite_test.go
@@ -27,11 +27,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/admissionchecks/provisioning"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -80,8 +80,8 @@ func managerSetup() framework.ManagerSetup {
 
 		controllersCfg.Metrics.EnableClusterQueueResources = true
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		failedCtrl, err := core.SetupControllers(mgr, queues, cCache, controllersCfg)
 		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "controller", failedCtrl)
diff --git a/test/integration/singlecluster/controller/core/suite_test.go b/test/integration/singlecluster/controller/core/suite_test.go
index 7639ed5df..aac947156 100644
--- a/test/integration/singlecluster/controller/core/suite_test.go
+++ b/test/integration/singlecluster/controller/core/suite_test.go
@@ -27,10 +27,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -83,8 +83,8 @@ func managerAndControllerSetup(controllersCfg *config.Configuration) framework.M
 
 		controllersCfg.Metrics.EnableClusterQueueResources = true
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		failedCtrl, err := core.SetupControllers(mgr, queues, cCache, controllersCfg)
 		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "controller", failedCtrl)
diff --git a/test/integration/singlecluster/controller/jobs/appwrapper/suite_test.go b/test/integration/singlecluster/controller/jobs/appwrapper/suite_test.go
index f97b26558..f18d97361 100644
--- a/test/integration/singlecluster/controller/jobs/appwrapper/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/appwrapper/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/appwrapper"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/jaxjob/suite_test.go b/test/integration/singlecluster/controller/jobs/jaxjob/suite_test.go
index dc6ba8905..e998dd0f1 100644
--- a/test/integration/singlecluster/controller/jobs/jaxjob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/jaxjob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/kubeflow/jobs/jaxjob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/job/suite_test.go b/test/integration/singlecluster/controller/jobs/job/suite_test.go
index 5f63ba77d..44ed85947 100644
--- a/test/integration/singlecluster/controller/jobs/job/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/job/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/job"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 )
@@ -96,8 +96,8 @@ func managerAndControllersSetup(
 		}
 		mgr.GetScheme().Default(configuration)
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		failedCtrl, err := core.SetupControllers(mgr, queues, cCache, configuration)
 		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "controller", failedCtrl)
diff --git a/test/integration/singlecluster/controller/jobs/jobset/suite_test.go b/test/integration/singlecluster/controller/jobs/jobset/suite_test.go
index ca4ac2ed7..7b5f75cbc 100644
--- a/test/integration/singlecluster/controller/jobs/jobset/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/jobset/suite_test.go
@@ -27,14 +27,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/jobset"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -86,8 +86,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 	return func(ctx context.Context, mgr manager.Manager) {
 		managerSetup(opts...)(ctx, mgr)
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/mpijob/suite_test.go b/test/integration/singlecluster/controller/jobs/mpijob/suite_test.go
index e53343b7f..dc2bcf271 100644
--- a/test/integration/singlecluster/controller/jobs/mpijob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/mpijob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -36,7 +37,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/mpijob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -105,8 +105,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 	return func(ctx context.Context, mgr manager.Manager) {
 		managerSetup(true, opts...)(ctx, mgr)
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/paddlejob/suite_test.go b/test/integration/singlecluster/controller/jobs/paddlejob/suite_test.go
index 39e8b088f..5866f9833 100644
--- a/test/integration/singlecluster/controller/jobs/paddlejob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/paddlejob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/kubeflow/jobs/paddlejob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/pod/suite_test.go b/test/integration/singlecluster/controller/jobs/pod/suite_test.go
index 16afb4147..edc332597 100644
--- a/test/integration/singlecluster/controller/jobs/pod/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/pod/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -36,7 +37,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/pod"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
 	"sigs.k8s.io/kueue/pkg/webhooks"
@@ -84,9 +84,9 @@ func managerSetup(
 	if configuration.WaitForPodsReady != nil {
 		opts = append(opts, jobframework.WithWaitForPodsReady(configuration.WaitForPodsReady))
 	}
-	var queueOptions []queue.Option
+	var queueOptions []qcache.Option
 	if configuration.Resources != nil && len(configuration.Resources.ExcludeResourcePrefixes) > 0 {
-		queueOptions = append([]queue.Option{}, queue.WithExcludedResourcePrefixes(configuration.Resources.ExcludeResourcePrefixes))
+		queueOptions = append([]qcache.Option{}, qcache.WithExcludedResourcePrefixes(configuration.Resources.ExcludeResourcePrefixes))
 	}
 	return func(ctx context.Context, mgr manager.Manager) {
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
@@ -114,8 +114,8 @@ func managerSetup(
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 		jobframework.EnableIntegration(job.FrameworkName)
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache, queueOptions...)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache, queueOptions...)
 		opts = append(opts, jobframework.WithQueues(queues))
 
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/pytorchjob/suite_test.go b/test/integration/singlecluster/controller/jobs/pytorchjob/suite_test.go
index cb6709e1a..24505412f 100644
--- a/test/integration/singlecluster/controller/jobs/pytorchjob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/pytorchjob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/kubeflow/jobs/pytorchjob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/raycluster/suite_test.go b/test/integration/singlecluster/controller/jobs/raycluster/suite_test.go
index b1cfc6dd0..a913f71e4 100644
--- a/test/integration/singlecluster/controller/jobs/raycluster/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/raycluster/suite_test.go
@@ -27,14 +27,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/raycluster"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/rayjob"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -91,8 +91,8 @@ func managerAndSchedulerSetup(opts ...jobframework.Option) framework.ManagerSetu
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 		opts = append(opts, jobframework.WithQueues(queues))
 
 		failedCtrl, err := core.SetupControllers(mgr, queues, cCache, &config.Configuration{})
diff --git a/test/integration/singlecluster/controller/jobs/rayjob/suite_test.go b/test/integration/singlecluster/controller/jobs/rayjob/suite_test.go
index 9941cce3f..d48ce220b 100644
--- a/test/integration/singlecluster/controller/jobs/rayjob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/rayjob/suite_test.go
@@ -27,13 +27,13 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/rayjob"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -87,8 +87,8 @@ func managerAndSchedulerSetup(opts ...jobframework.Option) framework.ManagerSetu
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/tfjob/suite_test.go b/test/integration/singlecluster/controller/jobs/tfjob/suite_test.go
index 23f079f4a..d1a4e5f1d 100644
--- a/test/integration/singlecluster/controller/jobs/tfjob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/tfjob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/kubeflow/jobs/tfjob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/controller/jobs/xgboostjob/suite_test.go b/test/integration/singlecluster/controller/jobs/xgboostjob/suite_test.go
index 654135203..e9da2f712 100644
--- a/test/integration/singlecluster/controller/jobs/xgboostjob/suite_test.go
+++ b/test/integration/singlecluster/controller/jobs/xgboostjob/suite_test.go
@@ -27,7 +27,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
@@ -35,7 +36,6 @@ import (
 	"sigs.k8s.io/kueue/pkg/controller/jobs/kubeflow/jobs/xgboostjob"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -90,8 +90,8 @@ func managerAndSchedulerSetup(setupTASControllers bool, opts ...jobframework.Opt
 		err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 		configuration := &config.Configuration{}
 		mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/importer/suite_test.go b/test/integration/singlecluster/importer/suite_test.go
index 5126d6481..75c0788f8 100644
--- a/test/integration/singlecluster/importer/suite_test.go
+++ b/test/integration/singlecluster/importer/suite_test.go
@@ -27,13 +27,13 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	workloadjob "sigs.k8s.io/kueue/pkg/controller/jobs/job"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/pod"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -68,8 +68,8 @@ func managerAndSchedulerSetup(ctx context.Context, mgr manager.Manager) {
 	err := indexer.Setup(ctx, mgr.GetFieldIndexer())
 	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	configuration := &config.Configuration{}
 	mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/kueuectl/suite_test.go b/test/integration/singlecluster/kueuectl/suite_test.go
index 73e798a4c..9bc67bf25 100644
--- a/test/integration/singlecluster/kueuectl/suite_test.go
+++ b/test/integration/singlecluster/kueuectl/suite_test.go
@@ -29,10 +29,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	utiltesting "sigs.k8s.io/kueue/pkg/util/testing"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -93,8 +93,8 @@ func managerSetup(ctx context.Context, mgr manager.Manager) {
 		},
 	}
 
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	failedCtrl, err := core.SetupControllers(mgr, queues, cCache, controllersCfg)
 	gomega.Expect(err).ToNot(gomega.HaveOccurred(), "controller", failedCtrl)
diff --git a/test/integration/singlecluster/scheduler/fairsharing/suite_test.go b/test/integration/singlecluster/scheduler/fairsharing/suite_test.go
index 0f9404a23..d4375951b 100644
--- a/test/integration/singlecluster/scheduler/fairsharing/suite_test.go
+++ b/test/integration/singlecluster/scheduler/fairsharing/suite_test.go
@@ -27,13 +27,13 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	workloadjob "sigs.k8s.io/kueue/pkg/controller/jobs/job"
 	"sigs.k8s.io/kueue/pkg/features"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -77,8 +77,8 @@ func managerAndSchedulerSetup(admissionFairSharing *config.AdmissionFairSharing)
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		_ = features.SetEnable(features.AdmissionFairSharing, true)
-		cCache := cache.New(mgr.GetClient(), cache.WithFairSharing(fairSharing.Enable), cache.WithAdmissionFairSharing(admissionFairSharing))
-		queues := queue.NewManager(mgr.GetClient(), cCache, queue.WithAdmissionFairSharing(admissionFairSharing))
+		cCache := schdcache.New(mgr.GetClient(), schdcache.WithFairSharing(fairSharing.Enable), schdcache.WithAdmissionFairSharing(admissionFairSharing))
+		queues := qcache.NewManager(mgr.GetClient(), cCache, qcache.WithAdmissionFairSharing(admissionFairSharing))
 
 		configuration := &config.Configuration{FairSharing: fairSharing, AdmissionFairSharing: admissionFairSharing}
 		configuration.Metrics.EnableClusterQueueResources = true
diff --git a/test/integration/singlecluster/scheduler/podsready/suite_test.go b/test/integration/singlecluster/scheduler/podsready/suite_test.go
index 7880fe992..7abfe8705 100644
--- a/test/integration/singlecluster/scheduler/podsready/suite_test.go
+++ b/test/integration/singlecluster/scheduler/podsready/suite_test.go
@@ -27,12 +27,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	workloadjob "sigs.k8s.io/kueue/pkg/controller/jobs/job"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -72,8 +72,8 @@ func managerAndSchedulerSetup(configuration *config.Configuration) framework.Man
 	}
 	return func(ctx context.Context, mgr manager.Manager) {
 		var (
-			cacheOpts  []cache.Option
-			queuesOpts []queue.Option
+			cacheOpts  []schdcache.Option
+			queuesOpts []qcache.Option
 			schedOpts  []scheduler.Option
 		)
 
@@ -86,17 +86,17 @@ func managerAndSchedulerSetup(configuration *config.Configuration) framework.Man
 			podsReadyTracking := configuration.WaitForPodsReady.Enable &&
 				configuration.WaitForPodsReady.BlockAdmission != nil &&
 				*configuration.WaitForPodsReady.BlockAdmission
-			cacheOpts = append(cacheOpts, cache.WithPodsReadyTracking(podsReadyTracking))
+			cacheOpts = append(cacheOpts, schdcache.WithPodsReadyTracking(podsReadyTracking))
 
 			if configuration.WaitForPodsReady.RequeuingStrategy != nil && configuration.WaitForPodsReady.RequeuingStrategy.Timestamp != nil {
 				timestamp := *configuration.WaitForPodsReady.RequeuingStrategy.Timestamp
-				queuesOpts = append(queuesOpts, queue.WithPodsReadyRequeuingTimestamp(timestamp))
+				queuesOpts = append(queuesOpts, qcache.WithPodsReadyRequeuingTimestamp(timestamp))
 				schedOpts = append(schedOpts, scheduler.WithPodsReadyRequeuingTimestamp(timestamp))
 			}
 		}
 
-		cCache := cache.New(mgr.GetClient(), cacheOpts...)
-		queues := queue.NewManager(mgr.GetClient(), cCache, queuesOpts...)
+		cCache := schdcache.New(mgr.GetClient(), cacheOpts...)
+		queues := qcache.NewManager(mgr.GetClient(), cCache, queuesOpts...)
 
 		failedCtrl, err := core.SetupControllers(mgr, queues, cCache, configuration)
 		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "controller", failedCtrl)
diff --git a/test/integration/singlecluster/scheduler/suite_test.go b/test/integration/singlecluster/scheduler/suite_test.go
index 5b8b10dc4..04857d527 100644
--- a/test/integration/singlecluster/scheduler/suite_test.go
+++ b/test/integration/singlecluster/scheduler/suite_test.go
@@ -30,12 +30,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	workloadjob "sigs.k8s.io/kueue/pkg/controller/jobs/job"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -81,8 +81,8 @@ func managerAndSchedulerSetup(ctx context.Context, mgr manager.Manager) {
 			Outputs:  corev1.ResourceList{corev1.ResourceCPU: resourcev1.MustParse("2")},
 		},
 	}
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache, queue.WithResourceTransformations(transformations))
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache, qcache.WithResourceTransformations(transformations))
 
 	configuration := &config.Configuration{}
 	mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/tas/suite_test.go b/test/integration/singlecluster/tas/suite_test.go
index 25d46d34b..1f4357749 100644
--- a/test/integration/singlecluster/tas/suite_test.go
+++ b/test/integration/singlecluster/tas/suite_test.go
@@ -27,14 +27,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/admissionchecks/provisioning"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/controller/tas"
 	tasindexer "sigs.k8s.io/kueue/pkg/controller/tas/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
@@ -81,9 +81,9 @@ func managerSetup(ctx context.Context, mgr manager.Manager) {
 	controllersCfg := &config.Configuration{}
 	mgr.GetScheme().Default(controllersCfg)
 
-	cacheOptions := []cache.Option{}
-	cCache := cache.New(mgr.GetClient(), cacheOptions...)
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cacheOptions := []schdcache.Option{}
+	cCache := schdcache.New(mgr.GetClient(), cacheOptions...)
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	failedCtrl, err := core.SetupControllers(mgr, queues, cCache, controllersCfg)
 	gomega.Expect(err).ToNot(gomega.HaveOccurred(), "Core controller", failedCtrl)
diff --git a/test/integration/singlecluster/webhook/core/suite_test.go b/test/integration/singlecluster/webhook/core/suite_test.go
index d5dc40e2c..4952223c7 100644
--- a/test/integration/singlecluster/webhook/core/suite_test.go
+++ b/test/integration/singlecluster/webhook/core/suite_test.go
@@ -27,10 +27,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/webhooks"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -69,8 +69,8 @@ func managerSetup(ctx context.Context, mgr manager.Manager, dispatcherName strin
 	failedWebhook, err := webhooks.Setup(mgr, dispatcherName)
 	gomega.Expect(err).ToNot(gomega.HaveOccurred(), "webhook", failedWebhook)
 
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	configuration := &config.Configuration{}
 	mgr.GetScheme().Default(configuration)
diff --git a/test/integration/singlecluster/webhook/jobs/suite_test.go b/test/integration/singlecluster/webhook/jobs/suite_test.go
index a4d0ee50c..87802ec58 100644
--- a/test/integration/singlecluster/webhook/jobs/suite_test.go
+++ b/test/integration/singlecluster/webhook/jobs/suite_test.go
@@ -27,10 +27,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/controller/jobframework"
 	"sigs.k8s.io/kueue/pkg/controller/jobs/job"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/util/kubeversion"
 	"sigs.k8s.io/kueue/test/integration/framework"
 	"sigs.k8s.io/kueue/test/util"
@@ -73,8 +73,8 @@ var _ = ginkgo.AfterSuite(func() {
 
 func managerSetup(setup func(ctrl.Manager, ...jobframework.Option) error, opts ...jobframework.Option) framework.ManagerSetup {
 	return func(ctx context.Context, mgr manager.Manager) {
-		cCache := cache.New(mgr.GetClient())
-		queues := queue.NewManager(mgr.GetClient(), cCache)
+		cCache := schdcache.New(mgr.GetClient())
+		queues := qcache.NewManager(mgr.GetClient(), cCache)
 		opts = append(opts, jobframework.WithCache(cCache), jobframework.WithQueues(queues))
 
 		err := setup(mgr, opts...)
diff --git a/test/performance/scheduler/minimalkueue/main.go b/test/performance/scheduler/minimalkueue/main.go
index c5d096e93..51307d130 100644
--- a/test/performance/scheduler/minimalkueue/main.go
+++ b/test/performance/scheduler/minimalkueue/main.go
@@ -39,12 +39,12 @@ import (
 	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
-	"sigs.k8s.io/kueue/pkg/cache"
+	qcache "sigs.k8s.io/kueue/pkg/cache/queue"
+	schdcache "sigs.k8s.io/kueue/pkg/cache/scheduler"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/controller/core"
 	"sigs.k8s.io/kueue/pkg/controller/core/indexer"
 	"sigs.k8s.io/kueue/pkg/metrics"
-	"sigs.k8s.io/kueue/pkg/queue"
 	"sigs.k8s.io/kueue/pkg/scheduler"
 )
 
@@ -153,8 +153,8 @@ func mainWithExitCode() int {
 		return 1
 	}
 
-	cCache := cache.New(mgr.GetClient())
-	queues := queue.NewManager(mgr.GetClient(), cCache)
+	cCache := schdcache.New(mgr.GetClient())
+	queues := qcache.NewManager(mgr.GetClient(), cCache)
 
 	go queues.CleanUpOnContext(ctx)
 	go cCache.CleanUpOnContext(ctx)
diff --git a/test/util/constants.go b/test/util/constants.go
index 4068d889c..32d9d6249 100644
--- a/test/util/constants.go
+++ b/test/util/constants.go
@@ -22,6 +22,7 @@ import (
 
 	"github.com/google/go-cmp/cmp/cmpopts"
 	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -47,11 +48,12 @@ const (
 )
 
 var (
-	IgnoreConditionTimestamps                      = cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime")
-	IgnoreConditionTimestampsAndObservedGeneration = cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime", "ObservedGeneration")
-	IgnoreConditionMessage                         = cmpopts.IgnoreFields(metav1.Condition{}, "Message")
-	IgnoreObjectMetaResourceVersion                = cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion")
-	IgnoreDeploymentConditionTimestampsAndMessage  = cmpopts.IgnoreFields(appsv1.DeploymentCondition{}, "LastTransitionTime", "LastUpdateTime", "Message")
+	IgnoreConditionTimestamps                                = cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime")
+	IgnoreConditionTimestampsAndObservedGeneration           = cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime", "ObservedGeneration")
+	IgnoreConditionMessage                                   = cmpopts.IgnoreFields(metav1.Condition{}, "Message")
+	IgnoreObjectMetaResourceVersion                          = cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion")
+	IgnoreDeploymentConditionTimestampsAndMessage            = cmpopts.IgnoreFields(appsv1.DeploymentCondition{}, "LastTransitionTime", "LastUpdateTime", "Message")
+	IgnorePodConditionTimestampsMessageAndObservedGeneration = cmpopts.IgnoreFields(corev1.PodCondition{}, "LastProbeTime", "LastTransitionTime", "Message", "ObservedGeneration")
 )
 
 var (