more tuning

Author: Thomas Stromberg

benchmarks/benchmark_test.go

@@ -543,7 +543,7 @@ func BenchmarkLRUSet(b *testing.B)       { benchLRUSet(b) }
 // Concurrent Throughput Benchmarks
 // =============================================================================
 
-const concurrentDuration = 1 * time.Second
+const concurrentDuration = 2 * time.Second
 
 type concurrentResult struct {
 	name   string

cache_persist_test.go

@@ -555,15 +555,15 @@ func TestCache_GhostQueue(t *testing.T) {
 func TestCache_MainQueueEviction(t *testing.T) {
 	ctx := context.Background()
 
-	// Create cache with capacity divisible by 32 shards (64 = 2 per shard)
-	cache, err := New[string, int](ctx, WithMemorySize(64))
+	// Create cache with 20000 capacity (approx 10 per shard with 2048 shards)
+	cache, err := New[string, int](ctx, WithMemorySize(20000))
 	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 96 {
+	for i := range 25000 {
 		key := fmt.Sprintf("key%d", i)
 		if err := cache.Set(ctx, key, i, 0); err != nil {
 			t.Fatalf("Set: %v", err)
@@ -573,17 +573,17 @@ func TestCache_MainQueueEviction(t *testing.T) {
 	}
 
 	// Insert more items to trigger eviction from Main queue
-	for i := range 64 {
-		key := fmt.Sprintf("key%d", i+100)
-		if err := cache.Set(ctx, key, i+100, 0); err != nil {
+	for i := range 10000 {
+		key := fmt.Sprintf("key%d", i+30000)
+		if err := cache.Set(ctx, key, i+30000, 0); err != nil {
 			t.Fatalf("Set: %v", err)
 		}
 		_, _, _ = cache.Get(ctx, key) //nolint:errcheck // Exercising code path
 	}
 
-	// Verify cache is at capacity
-	if cache.Len() > 64 {
-		t.Errorf("Cache length %d exceeds capacity 64", cache.Len())
+	// Verify cache is at capacity (with 2048 shards, effective capacity is ~20480)
+	if cache.Len() > 20480 {
+		t.Errorf("Cache length %d exceeds capacity 20480", cache.Len())
 	}
 }
 

cache_test.go

@@ -489,29 +489,30 @@ func TestCache_DeleteNonExistent(t *testing.T) {
 
 func TestCache_EvictFromMain(t *testing.T) {
 	ctx := context.Background()
-	// Cache with capacity divisible by 32 shards (64 = 2 per shard)
-	cache, err := New[int, int](ctx, WithMemorySize(64))
+	// Cache with 20000 capacity (approx 10 per shard with 2048 shards)
+	cache, err := New[int, int](ctx, WithMemorySize(20000))
 	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 96 {
+	// Fill cache and promote items to main by accessing them
+	for i := range 25000 {
 		_ = 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 64 {
-		_ = cache.Set(ctx, i+100, i+100, 0) //nolint:errcheck // Test fixture
-		_, _, _ = cache.Get(ctx, i+100)     //nolint:errcheck // Exercising code path
+	for i := range 10000 {
+		_ = cache.Set(ctx, i+30000, i+30000, 0) //nolint:errcheck // Test fixture
+		_, _, _ = cache.Get(ctx, i+30000)       //nolint:errcheck // Exercising code path
 	}
 
-	// Cache should not exceed capacity
-	if cache.Len() > 64 {
-		t.Errorf("cache length = %d; should not exceed 64", cache.Len())
+	// Cache should not exceed configured capacity by more than shard overhead
+	// With 2048 shards and rounding, effective capacity is ~20480
+	if cache.Len() > 20480 {
+		t.Errorf("cache length = %d; should not exceed 20480", cache.Len())
 	}
 }