32 shards

Author: Thomas Stromberg

cache_persist_test.go

@@ -593,15 +593,15 @@ func TestCache_GhostQueue(t *testing.T) {
 func TestCache_MainQueueEviction(t *testing.T) {
 	ctx := context.Background()
 
-	// Create cache with capacity divisible by 16 shards (48 = 3 per shard)
-	cache, err := New[string, int](ctx, WithMemorySize(48))
+	// Create cache with capacity divisible by 32 shards (64 = 2 per shard)
+	cache, err := New[string, int](ctx, WithMemorySize(64))
 	if err != nil {
 		t.Fatalf("New: %v", err)
 	}
 	defer func() { _ = cache.Close() }() //nolint:errcheck // Test cleanup
 
 	// Insert and access items to get them into Main queue
-	for i := range 72 {
+	for i := range 96 {
 		key := fmt.Sprintf("key%d", i)
 		if err := cache.Set(ctx, key, i, 0); err != nil {
 			t.Fatalf("Set: %v", err)
@@ -611,7 +611,7 @@ func TestCache_MainQueueEviction(t *testing.T) {
 	}
 
 	// Insert more items to trigger eviction from Main queue
-	for i := range 48 {
+	for i := range 64 {
 		key := fmt.Sprintf("key%d", i+100)
 		if err := cache.Set(ctx, key, i+100, 0); err != nil {
 			t.Fatalf("Set: %v", err)
@@ -620,8 +620,8 @@ func TestCache_MainQueueEviction(t *testing.T) {
 	}
 
 	// Verify cache is at capacity
-	if cache.Len() > 48 {
-		t.Errorf("Cache length %d exceeds capacity 48", cache.Len())
+	if cache.Len() > 64 {
+		t.Errorf("Cache length %d exceeds capacity 64", cache.Len())
 	}
 }
 

cache_test.go

@@ -544,29 +544,29 @@ func TestCache_DeleteNonExistent(t *testing.T) {
 
 func TestCache_EvictFromMain(t *testing.T) {
 	ctx := context.Background()
-	// Cache with capacity divisible by 16 shards (48 = 3 per shard)
-	cache, err := New[int, int](ctx, WithMemorySize(48))
+	// Cache with capacity divisible by 32 shards (64 = 2 per shard)
+	cache, err := New[int, int](ctx, WithMemorySize(64))
 	if err != nil {
 		t.Fatalf("New: %v", err)
 	}
 	defer func() { _ = cache.Close() }() //nolint:errcheck // Test cleanup
 
 	// Fill small queue and promote items to main by accessing them twice
-	for i := range 72 {
+	for i := range 96 {
 		_ = cache.Set(ctx, i, i, 0) //nolint:errcheck // Test fixture
 		// Access immediately to promote to main
 		_, _, _ = cache.Get(ctx, i) //nolint:errcheck // Exercising code path
 	}
 
 	// Add more items to force eviction from main queue
-	for i := range 48 {
+	for i := range 64 {
 		_ = cache.Set(ctx, i+100, i+100, 0) //nolint:errcheck // Test fixture
 		_, _, _ = cache.Get(ctx, i+100)     //nolint:errcheck // Exercising code path
 	}
 
 	// Cache should not exceed capacity
-	if cache.Len() > 48 {
-		t.Errorf("cache length = %d; should not exceed 48", cache.Len())
+	if cache.Len() > 64 {
+		t.Errorf("cache length = %d; should not exceed 64", cache.Len())
 	}
 }
 

s3fifo.go

@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-const numShards = 16
+const numShards = 32
 
 // s3fifo implements the S3-FIFO eviction algorithm from SOSP'23 paper
 // "FIFO queues are all you need for cache eviction"

s3fifo_test.go

@@ -477,26 +477,26 @@ func TestS3FIFODetailed(t *testing.T) {
 }
 
 func TestS3FIFO_Flush(t *testing.T) {
-	cache := newS3FIFO[string, int](100)
+	cache := newS3FIFO[string, int](1000)
 
-	// Add some items
-	for i := range 50 {
+	// Add some items (fewer than capacity to avoid eviction)
+	for i := range 100 {
 		cache.setToMemory(fmt.Sprintf("key%d", i), i, time.Time{})
 	}
 
 	// Access some to promote to main queue
-	for i := range 10 {
+	for i := range 20 {
 		cache.getFromMemory(fmt.Sprintf("key%d", i))
 	}
 
-	if cache.memoryLen() != 50 {
-		t.Errorf("cache length = %d; want 50", cache.memoryLen())
+	if cache.memoryLen() != 100 {
+		t.Errorf("cache length = %d; want 100", cache.memoryLen())
 	}
 
 	// Flush
 	removed := cache.flushMemory()
-	if removed != 50 {
-		t.Errorf("flushMemory removed %d items; want 50", removed)
+	if removed != 100 {
+		t.Errorf("flushMemory removed %d items; want 100", removed)
 	}
 
 	// Cache should be empty
@@ -505,7 +505,7 @@ func TestS3FIFO_Flush(t *testing.T) {
 	}
 
 	// All keys should be gone
-	for i := range 50 {
+	for i := range 100 {
 		if _, ok := cache.getFromMemory(fmt.Sprintf("key%d", i)); ok {
 			t.Errorf("key%d should not be found after flush", i)
 		}