refactor(flowcontrol): remove the queue plugin registry

pkg/epp/flowcontrol/contracts/mocks/mocks.go

@@ -159,7 +159,6 @@ func (m *MockEndpointCandidates) Locate(ctx context.Context, requestMetadata map
 // It is used for tests that need to control the exact return values of a queue's methods without simulating the queue's
 // internal logic or state.
 type MockSafeQueue struct {
-	NameV       string
 	LenV        int
 	ByteSizeV   uint64
 	PeekV       flowcontrol.QueueItemAccessor
@@ -169,7 +168,6 @@ type MockSafeQueue struct {
 	DrainFunc   func() []flowcontrol.QueueItemAccessor
 }
 
-func (m *MockSafeQueue) Name() string     { return m.NameV }
 func (m *MockSafeQueue) Len() int         { return m.LenV }
 func (m *MockSafeQueue) ByteSize() uint64 { return m.ByteSizeV }
 
@@ -330,7 +328,6 @@ func (m *MockManagedQueue) Drain() []flowcontrol.QueueItemAccessor {
 }
 
 func (m *MockManagedQueue) FlowKey() flowcontrol.FlowKey { return m.FlowKeyV }
-func (m *MockManagedQueue) Name() string                 { return "" }
 func (m *MockManagedQueue) OrderingPolicy() flowcontrol.OrderingPolicy {
 	if m.OrderingPolicyFunc != nil {
 		return m.OrderingPolicyFunc()

pkg/epp/flowcontrol/framework/plugins/queue/benchmark_test.go

@@ -28,33 +28,27 @@ import (
 
 var benchmarkFlowKey = flowcontrol.FlowKey{ID: "benchmark-flow"}
 
-// BenchmarkQueues runs a series of benchmarks against all registered queue implementations.
+// BenchmarkQueues runs a series of benchmarks against the priority queue implementation.
 func BenchmarkQueues(b *testing.B) {
-	for queueName, constructor := range RegisteredQueues {
-		b.Run(string(queueName), func(b *testing.B) {
-			// All queue implementations must support the default enqueue time comparator.
-			q, err := constructor(enqueueTimePolicy)
-			if err != nil {
-				b.Fatalf("Failed to construct queue '%s': %v", queueName, err)
-			}
+	b.Run(PriorityQueueName, func(b *testing.B) {
+		q := New(enqueueTimePolicy)
 
-			b.Run("AddRemove", func(b *testing.B) {
-				benchmarkAddRemove(b, q)
-			})
+		b.Run("AddRemove", func(b *testing.B) {
+			benchmarkAddRemove(b, q)
+		})
 
-			b.Run("AddPeekRemove", func(b *testing.B) {
-				benchmarkAddPeekRemove(b, q)
-			})
+		b.Run("AddPeekRemove", func(b *testing.B) {
+			benchmarkAddPeekRemove(b, q)
+		})
 
-			b.Run("BulkAddThenBulkRemove", func(b *testing.B) {
-				benchmarkBulkAddThenBulkRemove(b, q)
-			})
+		b.Run("BulkAddThenBulkRemove", func(b *testing.B) {
+			benchmarkBulkAddThenBulkRemove(b, q)
+		})
 
-			b.Run("HighContention", func(b *testing.B) {
-				benchmarkHighContention(b, q)
-			})
+		b.Run("HighContention", func(b *testing.B) {
+			benchmarkHighContention(b, q)
 		})
-	}
+	})
 }
 
 // benchmarkAddRemove measures the throughput of tightly coupled Add and Remove operations in parallel. This is a good