bench: reset pool allocator maps

l0rinc · l0rinc · commit 4d97ae86e328 · 2026-04-19T18:23:14.000+02:00
The pool map benchmarks cleared their maps inside the timed call but reused the grown bucket state.
That changed the insertion preconditions for later iterations.

The benchmark keeps the same reviewer check in place.
It records the reset bucket count and asserts that each timed call starts from that same bucket layout.
That fails on the old code on the second timed call.

Reset the maps in `setup()` with `rehash(0)` so each timed call starts from the same empty bucket layout.
diff --git a/src/bench/pool.cpp b/src/bench/pool.cpp
@@ -5,6 +5,7 @@
 #include <bench/bench.h>
 #include <support/allocators/pool.h>
 
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
@@ -15,18 +16,22 @@ template <typename Map>
 void BenchFillClearMap(benchmark::Bench& bench, Map& map)
 {
     size_t batch_size = 5000;
-
-    // make sure each iteration of the benchmark contains exactly 5000 inserts and one clear.
-    // do this at least 10 times so we get reasonable accurate results
-
-    bench.batch(batch_size).minEpochIterations(10).run([&] {
-        // assert(map.bucket_count() == 0);
-        auto rng = ankerl::nanobench::Rng(1234);
-        for (size_t i = 0; i < batch_size; ++i) {
-            map[rng()];
-        }
-        map.clear();
-    });
+    size_t reset_bucket_count = 0;
+
+    // Each timed call inserts batch_size keys into a freshly reset map.
+    bench.batch(batch_size).epochIterations(1)
+        .setup([&] {
+            map.clear();
+            map.rehash(0);
+            reset_bucket_count = map.bucket_count();
+        })
+        .run([&] {
+            assert(map.bucket_count() == reset_bucket_count);
+            auto rng = ankerl::nanobench::Rng(1234);
+            for (size_t i = 0; i < batch_size; ++i) {
+                map[rng()];
+            }
+        });
 }
 
 static void PoolAllocator_StdUnorderedMap(benchmark::Bench& bench)
