Factor out common peak statistic

Author: mjp41

src/snmalloc/backend_helpers/statsrange.h

@@ -17,8 +17,7 @@ namespace snmalloc
     {
       using ContainsParent<ParentRange>::parent;
 
-      static inline std::atomic<size_t> current_usage{};
-      static inline std::atomic<size_t> peak_usage{};
+    static inline Stat usage{};
 
     public:
       static constexpr bool Aligned = ParentRange::Aligned;
@@ -29,36 +28,28 @@ namespace snmalloc
 
       constexpr Type() = default;
 
-      CapPtr<void, ChunkBounds> alloc_range(size_t size)
+      capptr::Arena<void> alloc_range(size_t size)
       {
-        auto result = parent.alloc_range(size);
-        if (result != nullptr)
-        {
-          auto prev = current_usage.fetch_add(size);
-          auto curr = peak_usage.load();
-          while (curr < prev + size)
-          {
-            if (peak_usage.compare_exchange_weak(curr, prev + size))
-              break;
-          }
-        }
-        return result;
+        auto r = parent.alloc_range(size);
+        if (r != nullptr)
+          usage += size;
+        return r;
       }
 
-      void dealloc_range(CapPtr<void, ChunkBounds> base, size_t size)
+      void dealloc_range(capptr::Arena<void> base, size_t size)
       {
-        current_usage -= size;
+        usage -= size;
         parent.dealloc_range(base, size);
       }
 
       size_t get_current_usage()
       {
-        return current_usage.load();
+        return usage.get_curr();
       }
 
       size_t get_peak_usage()
       {
-        return peak_usage.load();
+        return usage.get_peak();
       }
     };
   };

src/snmalloc/ds_core/ds_core.h

@@ -15,3 +15,4 @@
 #include "ptrwrap.h"
 #include "redblacktree.h"
 #include "seqset.h"
+#include "stats.h"

src/snmalloc/ds_core/stats.h

@@ -0,0 +1,64 @@
+#include <atomic>
+#include <cstddef>
+#include "defines.h"
+
+namespace snmalloc
+{
+  /**
+   * Very basic statistic that tracks current and peak values.
+   */
+  class Stat
+  {
+  private:
+    std::atomic<size_t> curr{0};
+    std::atomic<size_t> peak{0};
+
+  public:
+    void increase(size_t amount)
+    {
+      size_t c = (curr += amount);
+      size_t p = peak.load(std::memory_order_relaxed);
+      while (c > p)
+      {
+        if (peak.compare_exchange_strong(p, c))
+          break;
+      }
+    }
+
+    void decrease(size_t amount)
+    {
+      size_t prev = curr.fetch_sub(amount);
+      SNMALLOC_ASSERT(prev >= amount);
+    }
+
+    size_t get_curr()
+    {
+      return curr.load(std::memory_order_relaxed);
+    }
+
+    size_t get_peak()
+    {
+      return peak.load(std::memory_order_relaxed);
+    }
+
+    void operator+=(size_t amount)
+    {
+      increase(amount);
+    }
+
+    void operator-=(size_t amount)
+    {
+      decrease(amount);
+    }
+
+    void operator++()
+    {
+      increase(1);
+    }
+
+    void operator--()
+    {
+      decrease(1);
+    }
+  };
+} // namespace snmalloc

src/snmalloc/mem/globalalloc.h

@@ -87,7 +87,7 @@ namespace snmalloc
       }
     }
 
-    if (result == nullptr  && RemoteDeallocCache::remote_inflight.load() != 0)
+    if (result == nullptr  && RemoteDeallocCache::remote_inflight.get_curr() != 0)
       error("ERROR: RemoteDeallocCache::remote_inflight != 0");
 
     if (result != nullptr)

src/snmalloc/mem/remotecache.h

@@ -19,7 +19,7 @@ namespace snmalloc
   {
     std::array<freelist::Builder<false>, REMOTE_SLOTS> list;
 
-    static inline std::atomic<size_t> remote_inflight{0};
+    static inline Stat remote_inflight;
 
     /**
      * The total amount of bytes of memory in the cache.