Extract counter decrement logic into decrementCounters()

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: jbachorik

ddprof-lib/src/main/cpp/callTraceHashTable.cpp

@@ -102,42 +102,43 @@ CallTraceHashTable::~CallTraceHashTable() {
 }
 
 
-ChunkList CallTraceHashTable::clearTableOnly() {
-  // Wait for all refcount guards to clear before detaching chunks
-  RefCountGuard::waitForAllRefCountsToClear();
-
+void CallTraceHashTable::decrementCounters() {
 #ifdef COUNTERS
   // Compute and decrement the global counters for everything in this table.
-  // After waitForAllRefCountsToClear() there are no concurrent writers, so
-  // plain iteration (same pattern as collect()) is safe.
+  // Must only be called after waitForAllRefCountsToClear() so there are no
+  // concurrent writers and plain iteration is safe.
   // Use a set to deduplicate: put() may store the same CallTrace* pointer in
   // both a newer and an older table (when findCallTrace finds it in prev()),
   // but the counter was only incremented once, so we must only count it once.
-  {
-    const size_t header_size = sizeof(CallTrace) - sizeof(ASGCT_CallFrame);
-    long long freed_bytes = 0;
-    long long freed_traces = 0;
-    std::unordered_set<CallTrace*> seen;
-    for (LongHashTable *t = _table; t != nullptr; t = t->prev()) {
-      u64 *keys = t->keys();
-      CallTraceSample *values = t->values();
-      u32 capacity = t->capacity();
-      for (u32 slot = 0; slot < capacity; slot++) {
-        if (keys[slot] != 0) {
-          CallTrace *trace = values[slot].acquireTrace();
-          if (trace != nullptr && trace != CallTraceSample::PREPARING) {
-            if (seen.insert(trace).second) {
-              freed_bytes += header_size + trace->num_frames * sizeof(ASGCT_CallFrame);
-              freed_traces++;
-            }
+  const size_t header_size = sizeof(CallTrace) - sizeof(ASGCT_CallFrame);
+  long long freed_bytes = 0;
+  long long freed_traces = 0;
+  std::unordered_set<CallTrace*> seen;
+  for (LongHashTable *t = _table; t != nullptr; t = t->prev()) {
+    u64 *keys = t->keys();
+    CallTraceSample *values = t->values();
+    u32 capacity = t->capacity();
+    for (u32 slot = 0; slot < capacity; slot++) {
+      if (keys[slot] != 0) {
+        CallTrace *trace = values[slot].acquireTrace();
+        if (trace != nullptr && trace != CallTraceSample::PREPARING) {
+          if (seen.insert(trace).second) {
+            freed_bytes += header_size + trace->num_frames * sizeof(ASGCT_CallFrame);
+            freed_traces++;
           }
         }
       }
     }
-    Counters::increment(CALLTRACE_STORAGE_BYTES, -freed_bytes);
-    Counters::increment(CALLTRACE_STORAGE_TRACES, -freed_traces);
   }
+  Counters::increment(CALLTRACE_STORAGE_BYTES, -freed_bytes);
+  Counters::increment(CALLTRACE_STORAGE_TRACES, -freed_traces);
 #endif // COUNTERS
+}
+
+ChunkList CallTraceHashTable::clearTableOnly() {
+  // Wait for all refcount guards to clear before detaching chunks
+  RefCountGuard::waitForAllRefCountsToClear();
+  decrementCounters();
 
   // Clear previous chain pointers to prevent traversal during deallocation
   for (LongHashTable *table = _table; table != nullptr; table = table->prev()) {

ddprof-lib/src/main/cpp/callTraceHashTable.h

@@ -72,6 +72,7 @@ class CallTraceHashTable {
   CallTrace *storeCallTrace(int num_frames, ASGCT_CallFrame *frames,
                             bool truncated, u64 trace_id);
   CallTrace *findCallTrace(LongHashTable *table, u64 hash);
+  void decrementCounters();
 
 
 public: