Test wether weak pointers / cleanup works

lrmap.go

···
 		redoLog         []operation[K, V]
 		readHandlers    map[weak.Pointer[ReadHandler[K, V]]]struct{}
 		readHandlerPool sync.Pool
+		metrics         *metrics
+	}
+
+	metrics struct {
+		readHandlersCreated   uint64
+		readHandlersClosed    uint64
+		readHandlersRecycled  uint64
+		readHandlersCleanedUp uint64
 	}
 
 	arena[K comparable, V any] map[K]V
···
 
 	return m
 }
+
+// recordMetrics enables the collection of metrics for read handlers.  This is not thread-safe, you must
+// call this before sharing the LRMap with other goroutines.
+func (m *LRMap[K, V]) recordMetrics() { m.metrics = new(metrics) }
 
 func (m *LRMap[K, V]) Set(key K, value V) {
 	m.mu.Lock()
···
 	rh := &ReadHandler[K, V]{lrmap: m}
 
 	wp := weak.Make(rh)
+	rh.wp = wp
 
 	m.mu.Lock()
 	m.readHandlers[wp] = struct{}{}
···
 		lrmap.mu.Lock()
 		defer lrmap.mu.Unlock()
 
+		if lrmap.metrics != nil {
+			atomic.AddUint64(&lrmap.metrics.readHandlersCleanedUp, 1)
+		}
+
 		delete(lrmap.readHandlers, wp)
 	}, m)
 
-	rh.wp = wp
+	if m.metrics != nil {
+		atomic.AddUint64(&m.metrics.readHandlersCreated, 1)
+	}
+
 	return rh
 }
 
···
 func (rh *ReadHandler[K, V]) Close() {
 	rh.assertReady()
 
+	if rh.lrmap.metrics != nil {
+		atomic.AddUint64(&rh.lrmap.metrics.readHandlersClosed, 1)
+	}
+
 	rh.ready = false
 
 	rh.lrmap.mu.Lock()
···
 
 	if rh.entered() {
 		panic("reader illegal state: must call Leave() before recycling")
+	}
+
+	if rh.lrmap.metrics != nil {
+		atomic.AddUint64(&rh.lrmap.metrics.readHandlersRecycled, 1)
 	}
 
 	rh.ready = false

lrmap_test.go

···
 
 import (
 	"math"
+	"runtime"
+	"sync/atomic"
 	"testing"
 )
 
···
 		t.Errorf("overflow(%d) is odd", overflow)
 	}
 }
+
+func TestCleanup(t *testing.T) {
+	const n = 1000
+
+	lrmap := New[int, int]()
+	lrmap.recordMetrics()
+
+	readHandlers := make([]*ReadHandler[int, int], n)
+	for i := 0; i < n; i++ {
+		readHandlers[i] = lrmap.NewReadHandler()
+	}
+
+	runtime.GC()
+
+	if created, cleanedUp := atomic.LoadUint64(&lrmap.metrics.readHandlersCreated), atomic.LoadUint64(&lrmap.metrics.readHandlersCleanedUp); created != n || cleanedUp != 0 {
+		t.Errorf("created %d read handlers, cleaned up %d read handlers", created, cleanedUp)
+	}
+
+	if len(lrmap.readHandlers) != n {
+		t.Errorf("expected %d read handlers, got %d", n, len(lrmap.readHandlers))
+	}
+
+	for i := range readHandlers {
+		readHandlers[i] = nil
+	}
+
+	runtime.GC()
+
+	if created, cleanedUp := atomic.LoadUint64(&lrmap.metrics.readHandlersCreated), atomic.LoadUint64(&lrmap.metrics.readHandlersCleanedUp); created != n || cleanedUp != n {
+		t.Errorf("created %d read handlers, cleaned up %d read handlers", created, cleanedUp)
+	}
+
+	if len(lrmap.readHandlers) != 0 {
+		t.Errorf("expected no read handlers, got %d", len(lrmap.readHandlers))
+	}
+}