Measure per metric in render scale bench

benchmarks/bench_metric.cpp

@@ -156,39 +156,15 @@ int main() {
               [&]() { histogram.observe(2.0); });
   }
 
-  // Callback metrics performance
-  {
-    auto counter_family =
-        metric::create_counter("callback_counter", "Callback counter");
-    auto gauge_family =
-        metric::create_gauge("callback_gauge", "Callback gauge");
-
-    std::atomic<double> counter_value{0};
-    std::atomic<double> gauge_value{100};
-
-    // Register callbacks
-    counter_family.register_callback(
-        {{"type", "callback"}}, [&counter_value]() {
-          return counter_value.load(std::memory_order_relaxed);
-        });
-
-    gauge_family.register_callback({{"type", "callback"}}, [&gauge_value]() {
-      return gauge_value.load(std::memory_order_relaxed);
-    });
-
-    ArenaAllocator arena;
-
-    bench.run("render() - with callback metrics", [&]() {
-      auto output = metric::render(arena);
-      ankerl::nanobench::doNotOptimizeAway(output);
-      arena.reset();
-    });
-  }
-
   // Render performance scaling
   {
     bench.unit("metric");
+    bench.title("render performance");
     // Test render performance as number of metrics increases
+
+    // Create varying numbers of metrics
+    for (int scale : {10, 100, 1000}) {
+      metric::reset_metrics_for_testing();
       std::vector<metric::Counter> counters;
       std::vector<metric::Gauge> gauges;
       std::vector<metric::Histogram> histograms;
@@ -196,14 +172,14 @@ int main() {
       auto counter_family =
           metric::create_counter("scale_counter", "Scale counter");
       auto gauge_family = metric::create_gauge("scale_gauge", "Scale gauge");
+      auto buckets = std::initializer_list<double>{0.1, 0.5,  1.0,  2.5,
+                                                   5.0, 10.0, 25.0, 50.0};
       auto histogram_family = metric::create_histogram(
-        "scale_histogram", "Scale histogram",
-        std::initializer_list<double>{0.1, 0.5, 1.0, 2.5, 5.0, 10.0, 25.0,
-                                      50.0});
+          "scale_histogram", "Scale histogram", buckets);
 
-    // Create varying numbers of metrics
-    for (int scale : {10, 100, 1000}) {
-      bench.batch(scale);
+      std::atomic<double> counter_value{3.1415924654};
+      bench.batch(scale * (/*counter*/ 1 + /*gauge*/ 1 + /*callback*/ 1 +
+                           /*histogram*/ (buckets.size() * 2 + 2)));
       // Clear previous metrics by creating new families
       // (Note: In real usage, metrics persist for application lifetime)
       for (int i = 0; i < scale; ++i) {
@@ -217,6 +193,12 @@ int main() {
         counters.back().inc(static_cast<double>(i));
         gauges.back().set(static_cast<double>(i * 2));
         histograms.back().observe(static_cast<double>(i) * 0.1);
+        // Register callbacks
+        counter_family.register_callback(
+            {{"type", "callback"}, {"id", std::to_string(i)}},
+            [&counter_value]() {
+              return counter_value.load(std::memory_order_relaxed);
+            });
       }
 
       ArenaAllocator arena;

src/metric.cpp

@@ -1695,30 +1695,26 @@ void reset_metrics_for_testing() {
   std::lock_guard _{Metric::mutex};
   ++Metric::registration_version;
 
-  // WARNING: This function assumes no metric objects are in use!
-  // Clear all family maps - this will leak the Family::State objects but
-  // that's acceptable for testing since they were allocated in the global arena
+  Metric::get_counter_families().clear();
+  Metric::get_gauge_families().clear();
+  Metric::get_histogram_families().clear();
+  Metric::get_interned_labels().clear();
+  Metric::get_interned_static_text().clear();
 
-  // Get references to the maps
-  auto &counter_families = Metric::get_counter_families();
-  auto &gauge_families = Metric::get_gauge_families();
-  auto &histogram_families = Metric::get_histogram_families();
-  auto &interned_labels = Metric::get_interned_labels();
-
-  // Clear all family registrations
-  counter_families.clear();
-  gauge_families.clear();
-  histogram_families.clear();
-  interned_labels.clear();
-
-  // Clear interned static text
-  auto &interned_static_text = Metric::get_interned_static_text();
-  interned_static_text.clear();
-
-  // Reset the global arena - this will invalidate all arena-allocated strings
-  // but since we're clearing everything, that's OK
   Metric::get_global_arena().reset();
 
+  auto reset_arena = [](auto &m) {
+    using M = std::decay_t<decltype(m)>;
+    using A = M::allocator_type;
+    m = M{A{&Metric::get_global_arena()}};
+  };
+
+  reset_arena(Metric::get_counter_families());
+  reset_arena(Metric::get_gauge_families());
+  reset_arena(Metric::get_histogram_families());
+  reset_arena(Metric::get_interned_labels());
+  reset_arena(Metric::get_interned_static_text());
+
   // Note: Thread-local arenas will be cleaned up by ThreadInit destructors
   // when threads exit naturally
 }