Track remote inflight.

snmalloc::RemoteDeallocCache::remote_inflight tracks the amount of bytes
that are inbetween threads.

Author: mjp41

src/snmalloc/mem/corealloc.h

@@ -478,14 +478,18 @@ namespace snmalloc
                            SNMALLOC_FAST_PATH_LAMBDA {
                              return capptr_domesticate<Config>(local_state, p);
                            };
-      auto cb = [this,
-                 &need_post](freelist::HeadPtr msg) SNMALLOC_FAST_PATH_LAMBDA {
+
+      size_t received_bytes = 0;
+
+      auto cb = [this, &need_post, &received_bytes](
+                  freelist::HeadPtr msg) SNMALLOC_FAST_PATH_LAMBDA {
 #ifdef SNMALLOC_TRACING
         message<1024>("Handling remote");
 #endif
 
         auto& entry =
           Config::Backend::template get_metaentry(snmalloc::address_cast(msg));
+        received_bytes += sizeclass_full_to_size(entry.get_sizeclass());
 
         handle_dealloc_remote(entry, msg.as_void(), need_post);
 
@@ -514,6 +518,9 @@ namespace snmalloc
         post();
       }
 
+      // Push size to global statistics
+      RemoteDeallocCache::remote_inflight -= received_bytes;
+
       return action(args...);
     }
 
@@ -542,10 +549,7 @@ namespace snmalloc
       }
       else
       {
-        if (
-          !need_post &&
-          !attached_cache->remote_dealloc_cache.reserve_space(entry))
-          need_post = true;
+        need_post = attached_cache->remote_dealloc_cache.reserve_space(entry);
         attached_cache->remote_dealloc_cache
           .template dealloc<sizeof(CoreAllocator)>(
             entry.get_remote()->trunc_id(), p.as_void());
@@ -834,17 +838,19 @@ namespace snmalloc
       {
         auto p_wild = message_queue().destroy();
         auto p_tame = domesticate(p_wild);
-
+        size_t received_bytes = 0;
         while (p_tame != nullptr)
         {
           bool need_post = true; // Always going to post, so ignore.
           auto n_tame =
             p_tame->atomic_read_next(RemoteAllocator::key_global, domesticate);
           const PagemapEntry& entry =
             Config::Backend::get_metaentry(snmalloc::address_cast(p_tame));
+          received_bytes += sizeclass_full_to_size(entry.get_sizeclass());
           handle_dealloc_remote(entry, p_tame.as_void(), need_post);
           p_tame = n_tame;
         }
+        RemoteDeallocCache::remote_inflight -= received_bytes;
       }
       else
       {

src/snmalloc/mem/globalalloc.h

@@ -87,6 +87,9 @@ namespace snmalloc
       }
     }
 
+    if (result == nullptr  && RemoteDeallocCache::remote_inflight.load() != 0)
+      error("ERROR: RemoteDeallocCache::remote_inflight != 0");
+
     if (result != nullptr)
     {
       *result = okay;

src/snmalloc/mem/localalloc.h

@@ -418,7 +418,7 @@ namespace snmalloc
         message<1024>("flush(): core_alloc={}", core_alloc);
 #endif
         local_cache.remote_allocator = &Config::unused_remote;
-        local_cache.remote_dealloc_cache.capacity = 0;
+        local_cache.remote_dealloc_cache.cache_bytes = REMOTE_CACHE;
       }
     }
 

src/snmalloc/mem/remotecache.h

@@ -19,14 +19,17 @@ namespace snmalloc
   {
     std::array<freelist::Builder<false>, REMOTE_SLOTS> list;
 
+    static inline std::atomic<size_t> remote_inflight{0};
+
     /**
-     * The total amount of memory we are waiting for before we will dispatch
-     * to other allocators. Zero can mean we have not initialised the allocator
-     * yet. This is initialised to the 0 so that we always hit a slow path to
-     * start with, when we hit the slow path and need to dispatch everything, we
-     * can check if we are a real allocator and lazily provide a real allocator.
+     * The total amount of bytes of memory in the cache.
+     *
+     * REMOTE_CACHE is used as the initial value, so that we always hit a slow
+     * path to start with, when we hit the slow path and need to dispatch
+     * everything, we can check if we are a real allocator and lazily provide a
+     * real allocator.
      */
-    int64_t capacity{0};
+    size_t cache_bytes{REMOTE_CACHE};
 
 #ifndef NDEBUG
     bool initialised = false;
@@ -56,13 +59,10 @@ namespace snmalloc
     template<typename Entry>
     SNMALLOC_FAST_PATH bool reserve_space(const Entry& entry)
     {
-      auto size =
-        static_cast<int64_t>(sizeclass_full_to_size(entry.get_sizeclass()));
+      auto size = sizeclass_full_to_size(entry.get_sizeclass());
 
-      bool result = capacity > size;
-      if (result)
-        capacity -= size;
-      return result;
+      cache_bytes += size;
+      return cache_bytes < REMOTE_CACHE;
     }
 
     template<size_t allocator_size>
@@ -91,6 +91,8 @@ namespace snmalloc
                              return capptr_domesticate<Config>(local_state, p);
                            };
 
+      // We are about to post cache_bytes bytes to other allocators.
+      remote_inflight += cache_bytes;
       while (true)
       {
         auto my_slot = get_slot<allocator_size>(id, post_round);
@@ -152,7 +154,7 @@ namespace snmalloc
       }
 
       // Reset capacity as we have empty everything
-      capacity = REMOTE_CACHE;
+      cache_bytes = 0;
 
       return sent_something;
     }
@@ -177,7 +179,7 @@ namespace snmalloc
         // a null address.
         l.init(0, RemoteAllocator::key_global);
       }
-      capacity = REMOTE_CACHE;
+      cache_bytes = 0;
     }
   };
 } // namespace snmalloc