Build per allocation statistics.

Author: mjp41

src/snmalloc/mem/allocstats.h

@@ -0,0 +1,64 @@
+#include "../ds_core/ds_core.h"
+#include <array>
+#include "sizeclasstable.h"
+
+namespace snmalloc
+{
+  class MonotoneStat
+  {
+    size_t value{0};
+  public:
+    void operator++(int)
+    {
+      value++;
+    }
+
+    void operator+=(const MonotoneStat& other)
+    {
+      value += other.value;
+    }
+
+    size_t operator*()
+    {
+      return value;
+    }
+  };
+
+  struct AllocStat
+  {
+    MonotoneStat objects_allocated{};
+    MonotoneStat objects_deallocated{};
+    // MonotoneStat slabs_allocated;
+    // MonotoneStat slabs_deallocated;
+  };
+
+  class AllocStats
+  {
+    std::array<AllocStat, SIZECLASS_REP_SIZE> sizeclass{};
+
+  public:
+    AllocStat& operator[](sizeclass_t index)
+    {
+      auto i = index.raw();
+      return sizeclass[i];
+    }
+
+    AllocStat& operator[](smallsizeclass_t index)
+    {
+      return sizeclass[sizeclass_t::from_small_class(index).raw()];
+    }
+
+    AllocStat operator+=(const AllocStats& other)
+    {
+      AllocStat result;
+      for (size_t i = 0; i < SIZECLASS_REP_SIZE; i++)
+      {
+        sizeclass[i].objects_allocated += other.sizeclass[i].objects_allocated;
+        sizeclass[i].objects_deallocated += other.sizeclass[i].objects_deallocated;
+        // result.slabs_allocated += other.sizeclass[i].slabs_allocated;
+        // result.slabs_deallocated += other.sizeclass[i].slabs_deallocated;
+      }
+      return result;
+    }
+  };
+} // namespace snmalloc

src/snmalloc/mem/corealloc.h

@@ -111,6 +111,11 @@ namespace snmalloc
      */
     Ticker<typename Config::Pal> ticker;
 
+    /**
+     * Tracks this allocators memory usage
+     */
+    AllocStats stats;
+
     /**
      * The message queue needs to be accessible from other threads
      *
@@ -672,13 +677,14 @@ namespace snmalloc
       // pointers
       auto& entry =
         Config::Backend::template get_metaentry(snmalloc::address_cast(p));
-      if (SNMALLOC_LIKELY(dealloc_local_object_fast(entry, p, entropy)))
+      if (SNMALLOC_LIKELY(dealloc_local_object_fast<false>(entry, p, entropy)))
         return;
 
       dealloc_local_object_slow(p, entry);
     }
 
-    SNMALLOC_FAST_PATH static bool dealloc_local_object_fast(
+    template<bool Statistics = true>
+    SNMALLOC_FAST_PATH bool dealloc_local_object_fast(
       const PagemapEntry& entry,
       CapPtr<void, capptr::bounds::Alloc> p,
       LocalEntropy& entropy)
@@ -699,6 +705,10 @@ namespace snmalloc
       // Update the head and the next pointer in the free list.
       meta->free_queue.add(cp, key, entropy);
 
+      if constexpr (Statistics)
+      {
+        stats[entry.get_sizeclass()].objects_deallocated++;
+      }
       return SNMALLOC_LIKELY(!meta->return_object());
     }
 
@@ -745,6 +755,7 @@ namespace snmalloc
         }
 
         auto r = finish_alloc<zero_mem, Config>(p, sizeclass);
+        stats[sizeclass].objects_allocated++;
         return ticker.check_tick(r);
       }
       return small_alloc_slow<zero_mem>(sizeclass, fast_free_list);
@@ -817,6 +828,8 @@ namespace snmalloc
       }
 
       auto r = finish_alloc<zero_mem, Config>(p, sizeclass);
+
+      stats[sizeclass].objects_allocated++;
       return ticker.check_tick(r);
     }
 
@@ -992,6 +1005,11 @@ namespace snmalloc
 
       return debug_is_empty_impl(result);
     }
+
+    const AllocStats& get_stats()
+    {
+      return stats;
+    }
   };
 
   /**

src/snmalloc/mem/globalalloc.h

@@ -137,4 +137,36 @@ namespace snmalloc
     }
   }
 
+  template<SNMALLOC_CONCEPT(ConceptBackendGlobals) SharedStateHandle>
+  inline static AllocStats get_stats()
+  {
+    auto alloc = AllocPool<SharedStateHandle>::iterate();
+    AllocStats stats;
+    while (alloc != nullptr)
+    {
+      stats += alloc->get_stats();
+      alloc = AllocPool<SharedStateHandle>::iterate(alloc);
+    }
+    return stats;
+  }
+
+  template<SNMALLOC_CONCEPT(ConceptBackendGlobals) SharedStateHandle>
+  inline static void print_alloc_stats()
+  {
+#ifndef SNMALLOC_PASS_THROUGH // This test depends on snmalloc internals
+    auto stats = snmalloc::get_stats<SharedStateHandle>();
+    for (size_t i = 0; i < snmalloc::SIZECLASS_REP_SIZE; i++)
+    {
+      auto sc = snmalloc::sizeclass_t::from_raw(i);
+      auto allocated = *stats[sc].objects_allocated;
+      auto deallocated = *stats[sc].objects_deallocated;
+      if (allocated == 0 && deallocated == 0)
+        continue;
+      auto size =
+        snmalloc::sizeclass_full_to_size(snmalloc::sizeclass_t::from_raw(i));
+      auto in_use = allocated - deallocated;
+      snmalloc::message<1024>("{},{},{},{},{}", i, size, allocated, deallocated, in_use);
+    }
+#endif
+  }
 } // namespace snmalloc

src/snmalloc/mem/localalloc.h

@@ -211,6 +211,9 @@ namespace snmalloc
             chunk.unsafe_ptr(), bits::next_pow2(size));
         }
 
+        if (chunk.unsafe_ptr() != nullptr)
+          core_alloc->stats[size_to_sizeclass_full(size)].objects_allocated++;
+
         return capptr_chunk_is_alloc(capptr_to_user_address_control(chunk));
       });
     }
@@ -246,7 +249,7 @@ namespace snmalloc
       };
 
       return local_cache.template alloc<zero_mem, Config>(
-        domesticate, size, slowpath);
+        domesticate, core_alloc->stats, size, slowpath);
     }
 
     /**
@@ -648,7 +651,7 @@ namespace snmalloc
       {
         dealloc_cheri_checks(p_tame.unsafe_ptr());
 
-        if (SNMALLOC_LIKELY(CoreAlloc::dealloc_local_object_fast(
+        if (SNMALLOC_LIKELY(core_alloc->dealloc_local_object_fast(
               entry, p_tame, local_cache.entropy)))
           return;
         core_alloc->dealloc_local_object_slow(p_tame, entry);

src/snmalloc/mem/localcache.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../ds/ds.h"
+#include "allocstats.h"
 #include "freelist.h"
 #include "remotecache.h"
 #include "sizeclasstable.h"
@@ -95,14 +96,15 @@ namespace snmalloc
       typename Slowpath,
       typename Domesticator>
     SNMALLOC_FAST_PATH capptr::Alloc<void>
-    alloc(Domesticator domesticate, size_t size, Slowpath slowpath)
+    alloc(Domesticator domesticate, AllocStats& stats, size_t size, Slowpath slowpath)
     {
       auto& key = entropy.get_free_list_key();
       smallsizeclass_t sizeclass = size_to_sizeclass(size);
       auto& fl = small_fast_free_lists[sizeclass];
       if (SNMALLOC_LIKELY(!fl.empty()))
       {
         auto p = fl.take(key, domesticate);
+        stats[sizeclass].objects_allocated++;
         return finish_alloc<zero_mem, Config>(p, sizeclass);
       }
       return slowpath(sizeclass, &fl);

src/test/func/statistics/stats.cc

@@ -18,14 +18,19 @@ void debug_check_empty_1()
   auto r = a.alloc(size);
 
   snmalloc::debug_check_empty<snmalloc::StandardConfig>(&result);
+  snmalloc::print_alloc_stats<snmalloc::StandardConfig>();
   if (result != false)
   {
     std::cout << "debug_check_empty failed to detect leaked memory:" << size
               << std::endl;
     abort();
   }
 
-  a.dealloc(r);
+  snmalloc::print_alloc_stats<snmalloc::Globals>();
+
+   a.dealloc(r);
+
+  snmalloc::print_alloc_stats<snmalloc::Globals>();
 
   snmalloc::debug_check_empty<snmalloc::StandardConfig>(&result);
   if (result != true)
@@ -34,7 +39,11 @@ void debug_check_empty_1()
     abort();
   }
 
-  r = a.alloc(size);
+  snmalloc::print_alloc_stats<snmalloc::StandardConfig>();
+
+  r = a.alloc(16);
+
+  snmalloc::print_alloc_stats<snmalloc::StandardConfig>();
 
   snmalloc::debug_check_empty<snmalloc::StandardConfig>(&result);
   if (result != false)
@@ -44,14 +53,21 @@ void debug_check_empty_1()
     abort();
   }
 
+  snmalloc::print_alloc_stats<snmalloc::Globals>();
+
   a.dealloc(r);
 
+  snmalloc::print_alloc_stats<snmalloc::StandardConfig>();
+
   snmalloc::debug_check_empty<snmalloc::StandardConfig>(&result);
   if (result != true)
   {
     std::cout << "debug_check_empty failed to say empty:" << size << std::endl;
     abort();
   }
+
+  snmalloc::print_alloc_stats<snmalloc::StandardConfig>();
+#endif
 }
 
 template<size_t size>