Added per pool per class used size metrics

(cherry picked from commit ea5b3a3)

Author: guptask

cachelib/allocator/CacheAllocator-inl.h

@@ -287,6 +287,20 @@ CacheAllocator<CacheTrait>::allocate(PoolId poolId,
                           ttlSecs == 0 ? 0 : creationTime + ttlSecs);
 }
 
+template <typename CacheTrait>
+ClassId CacheAllocator<CacheTrait>::getAllocClassId(PoolId pid,
+                                                    typename Item::Key key,
+                                                    uint32_t size) const {
+  const auto requiredSize = Item::getRequiredSize(key, size);
+  return allocator_->getAllocationClassId(pid, requiredSize);
+}
+
+template <typename CacheTrait>
+uint64_t CacheAllocator<CacheTrait>::getAllocationSize(ClassId cid,
+                                                       PoolId pid) const {
+  return getPool(pid).getAllocationClass(cid).getAllocSize();
+}
+
 template <typename CacheTrait>
 typename CacheAllocator<CacheTrait>::WriteHandle
 CacheAllocator<CacheTrait>::allocateInternal(PoolId pid,
@@ -324,6 +338,7 @@ CacheAllocator<CacheTrait>::allocateInternal(PoolId pid,
 
     handle = acquire(new (memory) Item(key, size, creationTime, expiryTime));
     if (handle) {
+      (*stats_.usedSize)[pid][cid].set(allocator_->getPoolUsedSize(pid));
       handle.markNascent();
       (*stats_.fragmentationSize)[pid][cid].add(
           util::getFragmentation(*this, *handle));
@@ -2239,7 +2254,7 @@ PoolStats CacheAllocator<CacheTrait>::getPoolStats(PoolId poolId) const {
             (*stats_.fragmentationSize)[poolId][cid].get(), classHits,
             (*stats_.chainedItemEvictions)[poolId][cid].get(),
             (*stats_.regularItemEvictions)[poolId][cid].get(),
-            container.getStats()}});
+            (*stats_.usedSize)[poolId][cid].get(), container.getStats()}});
       totalHits += classHits;
     }
   }

cachelib/allocator/CacheAllocator.h

@@ -1110,6 +1110,12 @@ class CacheAllocator : public CacheBase {
   // Whether this cache allocator was created on shared memory.
   bool isOnShm() const noexcept { return isOnShm_; }
 
+  ClassId getAllocClassId(PoolId pid,
+                          typename Item::Key key,
+                          uint32_t size) const;
+
+  uint64_t getAllocationSize(ClassId cid, PoolId pid) const;
+
   // Whether NvmCache is currently enabled
   bool isNvmCacheEnabled() const noexcept {
     return nvmCache_ && nvmCache_->isEnabled();

cachelib/allocator/CacheStats.cpp

@@ -29,6 +29,7 @@ void Stats::init() {
   allocFailures = std::make_unique<PerPoolClassAtomicCounters>();
   chainedItemEvictions = std::make_unique<PerPoolClassAtomicCounters>();
   regularItemEvictions = std::make_unique<PerPoolClassAtomicCounters>();
+  usedSize = std::make_unique<PerPoolClassAtomicCounters>();
   auto initToZero = [](auto& a) {
     for (auto& s : a) {
       for (auto& c : s) {
@@ -42,6 +43,7 @@ void Stats::init() {
   initToZero(*fragmentationSize);
   initToZero(*chainedItemEvictions);
   initToZero(*regularItemEvictions);
+  initToZero(*usedSize);
 }
 
 template <int>
@@ -125,6 +127,14 @@ void Stats::populateGlobalCacheStats(GlobalCacheStats& ret) const {
   ret.numEvictions = accum(*chainedItemEvictions);
   ret.numEvictions += accum(*regularItemEvictions);
 
+  for (const auto& x : *usedSize) {
+    uint64_t sum{0};
+    for (const auto& v : x) {
+      sum += v.get();
+    }
+    ret.poolUsedSize.emplace_back(sum);
+  }
+
   ret.invalidAllocs = invalidAllocs.get();
   ret.numRefcountOverflow = numRefcountOverflow.get();
 
@@ -176,6 +186,7 @@ PoolStats& PoolStats::operator+=(const PoolStats& other) {
       d.numHits += s.numHits;
       d.chainedItemEvictions += s.chainedItemEvictions;
       d.regularItemEvictions += s.regularItemEvictions;
+      d.usedSize += s.usedSize;
     }
 
     // aggregate container stats within CacheStat

cachelib/allocator/CacheStats.h

@@ -121,6 +121,9 @@ struct CacheStat {
   // number of regular items that were evicted from this classId
   uint64_t regularItemEvictions;
 
+  // used size of this classId
+  uint64_t usedSize;
+
   // the stats from the mm container
   MMContainerStat containerStat;
 
@@ -416,6 +419,9 @@ struct GlobalCacheStats {
   // number of evictions across all the pools in the cache.
   uint64_t numEvictions{0};
 
+  // Used size of all the pools
+  std::vector<uint64_t> poolUsedSize;
+
   // number of allocation attempts with invalid input params.
   uint64_t invalidAllocs{0};
 

cachelib/allocator/CacheStatsInternal.h

@@ -220,6 +220,7 @@ struct Stats {
   std::unique_ptr<PerPoolClassAtomicCounters> fragmentationSize{};
   std::unique_ptr<PerPoolClassAtomicCounters> chainedItemEvictions{};
   std::unique_ptr<PerPoolClassAtomicCounters> regularItemEvictions{};
+  std::unique_ptr<PerPoolClassAtomicCounters> usedSize{};
 
   // Eviction failures due to parent cannot be removed from access container
   AtomicCounter evictFailParentAC{0};

cachelib/allocator/memory/MemoryAllocator.h

@@ -633,6 +633,12 @@ class MemoryAllocator {
     memoryPoolManager_.updateNumSlabsToAdvise(numSlabs);
   }
 
+  // fetch used size of a particular pool
+  // @return used size of the pool
+  size_t getPoolUsedSize(PoolId id) {
+    return slabAllocator_.getPoolUsedSize(id);
+  }
+
  private:
   // @param memory    pointer to the memory.
   // @return          the MemoryPool corresponding to the memory.

cachelib/allocator/memory/SlabAllocator.cpp

@@ -91,6 +91,13 @@ SlabAllocator::~SlabAllocator() {
   }
 }
 
+size_t SlabAllocator::getPoolUsedSize(PoolId id) {
+  if (id >= memoryPoolSize_.size()) {
+    throw std::invalid_argument(folly::sformat("Invalid pool id {}.", id));
+  }
+  return memoryPoolSize_[id];
+}
+
 void SlabAllocator::stopMemoryLocker() {
   if (memoryLocker_.joinable()) {
     stopLocking_ = true;

cachelib/allocator/memory/SlabAllocator.h

@@ -316,6 +316,10 @@ class SlabAllocator {
     return PtrCompressor<PtrType, SlabAllocator>(*this);
   }
 
+  // Retrive used size of a pool
+  // @return used size of Pool
+  size_t getPoolUsedSize(PoolId id);
+
  private:
   // null Slab* presenttation. With 4M Slab size, a valid slab index would never
   // reach 2^16 - 1;

cachelib/allocator/tests/AllocatorHitStatsTest.h

@@ -25,6 +25,7 @@
 #include <mutex>
 #include <set>
 #include <thread>
+#include <unordered_map>
 #include <vector>
 
 #include "cachelib/allocator/CacheAllocator.h"
@@ -247,17 +248,31 @@ class AllocatorHitStatsTest : public SlabAllocatorTestBase {
     std::vector<std::string> keys;
     const unsigned int nKeys = 1000;
     unsigned int initialAllocs = 0;
+    std::unordered_map<ClassId, uint64_t> pool1Alloc;
     while (keys.size() != nKeys) {
       const auto keyLen = folly::Random::rand32(10, 100);
       const auto allocSize = folly::Random::rand32(100, 1024 * 1024 - 1000);
       auto str = cachelib::test_util::getRandomAsciiStr(keyLen);
       ++initialAllocs;
+      auto classId = alloc.getAllocClassId(poolId, str, allocSize);
       auto handle = util::allocateAccessible(alloc, poolId, str, allocSize);
       if (handle) {
         keys.push_back(str);
+        pool1Alloc[classId] += alloc.getAllocationSize(classId, poolId);
       }
     }
 
+    // Adjust pool alloc size for each class to its ceiling slab size
+    // and calculate the total
+    uint64_t pool1AllocSize = 0;
+    for (const auto& cAlloc : pool1Alloc) {
+      pool1AllocSize += (cAlloc.second + Slab::kSize - 1) / Slab::kSize;
+    }
+    pool1AllocSize *= Slab::kSize;
+    const auto tempCacheStats = alloc.getGlobalCacheStats();
+    ASSERT_EQ(tempCacheStats.poolUsedSize.size(), MemoryPoolManager::kMaxPools);
+    ASSERT_EQ(tempCacheStats.poolUsedSize[0], pool1AllocSize);
+
     if (!evictedKeys.empty()) {
       for (const auto& key : evictedKeys) {
         auto it = std::find(keys.begin(), keys.end(), key);

cachelib/cachebench/cache/Cache-inl.h

@@ -461,6 +461,7 @@ Stats Cache<Allocator>::getStats() const {
   ret.allocAttempts = cacheStats.allocAttempts;
   ret.allocFailures = cacheStats.allocFailures;
 
+  ret.poolUsedSize = cacheStats.poolUsedSize;
   ret.numCacheGets = cacheStats.numCacheGets;
   ret.numCacheGetMiss = cacheStats.numCacheGetMiss;
   ret.numRamDestructorCalls = cacheStats.numRamDestructorCalls;