memory optimization

Author: Thomas Stromberg

benchmarks/runner.go

@@ -625,10 +625,12 @@ func validateCompetitive(res, prev *Results, testsFilter, suitesFilter string) e
 
 	// For partial suite runs, only validate relevant placements.
 	var fails []string
+	headerPrinted := false
 
 	// Score validation only for full runs.
 	if fullRun {
 		fmt.Println("\n=== Final Validation ===")
+		headerPrinted = true
 		if mc.Score >= minMulticacheScore {
 			fmt.Printf("✓ multicache score: %d (goal: ≥%d)\n", mc.Score, minMulticacheScore)
 		} else {
@@ -672,9 +674,9 @@ func validateCompetitive(res, prev *Results, testsFilter, suitesFilter string) e
 
 		for _, r := range cat.Rankings {
 			if r.Name == "multicache" {
-				// Print header if we haven't yet (partial suite run).
-				if !fullRun {
+				if !headerPrinted {
 					fmt.Println("\n=== Final Validation ===")
+					headerPrinted = true
 				}
 				if r.Rank <= maxPlace {
 					fmt.Printf("✓ %s placement: %d (goal: ≤%d)\n", cat.Name, r.Rank, maxPlace)

memory.go

@@ -64,7 +64,7 @@ func (c *Cache[K, V]) Set(key K, value V) {
 		c.memory.set(key, value, 0)
 		return
 	}
-	c.memory.set(key, value, timeToNano(c.expiry(0)))
+	c.memory.set(key, value, timeToSec(c.expiry(0)))
 }
 
 // SetTTL stores a value with an explicit TTL.
@@ -74,7 +74,7 @@ func (c *Cache[K, V]) SetTTL(key K, value V, ttl time.Duration) {
 		c.memory.set(key, value, 0)
 		return
 	}
-	c.memory.set(key, value, time.Now().Add(ttl).UnixNano())
+	c.memory.set(key, value, uint32(time.Now().Add(ttl).Unix()))
 }
 
 // Delete removes a key from the cache.

memory_test.go

@@ -40,8 +40,8 @@ func TestCache_Basic(t *testing.T) {
 func TestCache_WithTTL(t *testing.T) {
 	cache := New[string, string]()
 
-	// Set with short TTL
-	cache.SetTTL("temp", "value", 50*time.Millisecond)
+	// Set with short TTL (minimum 1 second granularity)
+	cache.SetTTL("temp", "value", 1*time.Second)
 
 	// Should be available immediately
 	val, found := cache.Get("temp")
@@ -50,7 +50,7 @@ func TestCache_WithTTL(t *testing.T) {
 	}
 
 	// Wait for expiration
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Should be expired
 	_, found = cache.Get("temp")
@@ -60,7 +60,7 @@ func TestCache_WithTTL(t *testing.T) {
 }
 
 func TestCache_DefaultTTL(t *testing.T) {
-	cache := New[string, int](TTL(50 * time.Millisecond))
+	cache := New[string, int](TTL(1 * time.Second))
 
 	// Set without explicit TTL (ttl=0 uses default)
 	cache.Set("key", 100)
@@ -72,7 +72,7 @@ func TestCache_DefaultTTL(t *testing.T) {
 	}
 
 	// Wait for default TTL expiration
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Should be expired
 	_, found = cache.Get("key")
@@ -236,11 +236,11 @@ func TestCache_EvictFromMain(t *testing.T) {
 func TestCache_GetExpired(t *testing.T) {
 	cache := New[string, int]()
 
-	// Set with very short TTL
-	cache.SetTTL("key1", 42, 1*time.Millisecond)
+	// Set with short TTL (1 second granularity)
+	cache.SetTTL("key1", 42, 1*time.Second)
 
 	// Wait for expiration
-	time.Sleep(10 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Get should return not found
 	_, found := cache.Get("key1")
@@ -368,8 +368,8 @@ func TestCache_SetTTL(t *testing.T) {
 		t.Error("default-ttl should be found")
 	}
 
-	// SetTTL uses explicit short TTL
-	cache.SetTTL("short-ttl", 2, 50*time.Millisecond)
+	// SetTTL uses explicit short TTL (1 second granularity)
+	cache.SetTTL("short-ttl", 2, 1*time.Second)
 	if _, found := cache.Get("short-ttl"); !found {
 		t.Error("short-ttl should be found immediately")
 	}
@@ -387,7 +387,7 @@ func TestCache_SetTTL(t *testing.T) {
 	}
 
 	// Wait for short TTL to expire
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// short-ttl should be expired, others should still exist
 	if _, found := cache.Get("short-ttl"); found {
@@ -411,7 +411,7 @@ func TestCache_Set_NoDefaultTTL(t *testing.T) {
 	cache.Set("no-expiry", 42)
 
 	// Wait a bit
-	time.Sleep(50 * time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
 
 	// Should still exist
 	val, found := cache.Get("no-expiry")
@@ -531,8 +531,8 @@ func TestCache_GetSet_WithTTL(t *testing.T) {
 		return loaderCalls * 10, nil
 	}
 
-	// First call with short TTL
-	val, err := cache.GetSetTTL("key1", loader, 50*time.Millisecond)
+	// First call with short TTL (1 second granularity)
+	val, err := cache.GetSetTTL("key1", loader, 1*time.Second)
 	if err != nil {
 		t.Fatalf("GetSet error: %v", err)
 	}
@@ -541,10 +541,10 @@ func TestCache_GetSet_WithTTL(t *testing.T) {
 	}
 
 	// Wait for TTL to expire
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Second call - should call loader again (cache expired)
-	val, err = cache.GetSetTTL("key1", loader, 50*time.Millisecond)
+	val, err = cache.GetSetTTL("key1", loader, 1*time.Second)
 	if err != nil {
 		t.Fatalf("GetSet error: %v", err)
 	}

persistent.go

@@ -62,7 +62,7 @@ func (c *TieredCache[K, V]) Get(ctx context.Context, key K) (V, bool, error) {
 		return zero, false, nil
 	}
 
-	c.memory.set(key, val, timeToNano(expiry))
+	c.memory.set(key, val, timeToSec(expiry))
 	return val, true, nil
 }
 
@@ -85,7 +85,7 @@ func (c *TieredCache[K, V]) SetTTL(ctx context.Context, key K, value V, ttl time
 		return err
 	}
 
-	c.memory.set(key, value, timeToNano(expiry))
+	c.memory.set(key, value, timeToSec(expiry))
 
 	if err := c.Store.Set(ctx, key, value, expiry); err != nil {
 		return fmt.Errorf("persistence store failed: %w", err)
@@ -108,7 +108,7 @@ func (c *TieredCache[K, V]) SetAsyncTTL(ctx context.Context, key K, value V, ttl
 		return err
 	}
 
-	c.memory.set(key, value, timeToNano(expiry))
+	c.memory.set(key, value, timeToSec(expiry))
 
 	go func() {
 		storeCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), asyncTimeout)
@@ -148,7 +148,7 @@ func (c *TieredCache[K, V]) getSet(ctx context.Context, key K, loader func(conte
 		return zero, fmt.Errorf("persistence load: %w", err)
 	}
 	if found {
-		c.memory.set(key, val, timeToNano(expiry))
+		c.memory.set(key, val, timeToSec(expiry))
 		return val, nil
 	}
 
@@ -178,7 +178,7 @@ func (c *TieredCache[K, V]) getSet(ctx context.Context, key K, loader func(conte
 		return zero, call.err
 	}
 	if found {
-		c.memory.set(key, val, timeToNano(expiry))
+		c.memory.set(key, val, timeToSec(expiry))
 		call.val = val
 		c.flights.Delete(key)
 		call.wg.Done()
@@ -194,7 +194,7 @@ func (c *TieredCache[K, V]) getSet(ctx context.Context, key K, loader func(conte
 	}
 
 	exp := c.expiry(ttl)
-	c.memory.set(key, val, timeToNano(exp))
+	c.memory.set(key, val, timeToSec(exp))
 
 	if err := c.Store.Set(ctx, key, val, exp); err != nil {
 		slog.Warn("GetSet persistence failed", "key", key, "error", err)

persistent_test.go

@@ -829,8 +829,8 @@ func TestTieredCache_Set_VariadicTTL(t *testing.T) {
 		t.Error("default-ttl should be found")
 	}
 
-	// Set with explicit short TTL
-	if err := cache.SetTTL(ctx, "short-ttl", 2, 50*time.Millisecond); err != nil {
+	// Set with explicit short TTL (1 second granularity)
+	if err := cache.SetTTL(ctx, "short-ttl", 2, 1*time.Second); err != nil {
 		t.Fatalf("Set: %v", err)
 	}
 	_, found, err = cache.Get(ctx, "short-ttl")
@@ -842,7 +842,7 @@ func TestTieredCache_Set_VariadicTTL(t *testing.T) {
 	}
 
 	// Wait for short TTL to expire
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// short-ttl should be expired in memory, default-ttl should still exist
 	_, found, err = cache.Get(ctx, "short-ttl")
@@ -1057,8 +1057,8 @@ func TestNew_InvalidSize(t *testing.T) {
 }
 
 func TestNew_TTL_Behavior(t *testing.T) {
-	// Test that TTL option is correctly applied as default
-	defaultTTL := 100 * time.Millisecond
+	// Test that TTL option is correctly applied as default (1 second granularity)
+	defaultTTL := 1 * time.Second
 	cache := New[string, int](TTL(defaultTTL))
 
 	// Set without explicit TTL -> uses default
@@ -1068,7 +1068,7 @@ func TestNew_TTL_Behavior(t *testing.T) {
 	cache.SetTTL("longer", 2, 1*time.Hour)
 
 	// Wait for default to expire
-	time.Sleep(defaultTTL + 10*time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	if _, ok := cache.Get("default"); ok {
 		t.Error("Item with default TTL should have expired")
@@ -1080,7 +1080,7 @@ func TestNew_TTL_Behavior(t *testing.T) {
 
 func TestNewTiered_WithTTL_Behavior(t *testing.T) {
 	store := newMockStore[string, int]()
-	defaultTTL := 100 * time.Millisecond
+	defaultTTL := 1 * time.Second
 	cache, err := NewTiered[string, int](store, TTL(defaultTTL))
 	if err != nil {
 		t.Fatalf("NewTiered failed: %v", err)
@@ -1104,7 +1104,7 @@ func TestNewTiered_WithTTL_Behavior(t *testing.T) {
 	}
 
 	// Wait for default to expire
-	time.Sleep(defaultTTL + 10*time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Check memory first (using Get)
 	if _, ok := cache.memory.get("default"); ok {
@@ -1300,8 +1300,8 @@ func TestTieredCache_GetSet_WithTTL(t *testing.T) {
 		return loaderCalls * 10, nil
 	}
 
-	// First call with short TTL
-	val, err := cache.GetSetTTL(ctx, "key1", loader, 50*time.Millisecond)
+	// First call with short TTL (1 second granularity)
+	val, err := cache.GetSetTTL(ctx, "key1", loader, 1*time.Second)
 	if err != nil {
 		t.Fatalf("GetSet error: %v", err)
 	}
@@ -1310,10 +1310,10 @@ func TestTieredCache_GetSet_WithTTL(t *testing.T) {
 	}
 
 	// Wait for TTL to expire
-	time.Sleep(100 * time.Millisecond)
+	time.Sleep(2 * time.Second)
 
 	// Second call - should call loader again (cache expired)
-	val, err = cache.GetSetTTL(ctx, "key1", loader, 50*time.Millisecond)
+	val, err = cache.GetSetTTL(ctx, "key1", loader, 1*time.Second)
 	if err != nil {
 		t.Fatalf("GetSet error: %v", err)
 	}