Added per pool per class used size metrics

(cherry picked from commit ea5b3a3)

Author: guptask

cachelib/allocator/CacheAllocator-inl.h

@@ -324,6 +324,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 +2240,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/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

@@ -393,6 +393,10 @@ class AllocatorHitStatsTest : public SlabAllocatorTestBase {
     ASSERT_EQ(nThreads * numHits, poolStats.numPoolGetHits);
     ASSERT_EQ(nThreads * (numHits + numMiss), globalCacheStats.numCacheGets);
     ASSERT_EQ(nThreads * numMiss, globalCacheStats.numCacheGetMiss);
+    ASSERT_EQ(globalCacheStats.poolUsedSize.size(),
+              MemoryPoolManager::kMaxPools);
+    ASSERT_EQ(4521459712, globalCacheStats.poolUsedSize[0]);
+    ASSERT_EQ(4521459712, globalCacheStats.poolUsedSize[1]);
 
     uint64_t totalHits = 0;
     for (const auto& classId : poolStats.getClassIds()) {

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;

cachelib/cachebench/cache/CacheStats.h

@@ -32,6 +32,7 @@ struct Stats {
   uint64_t allocAttempts{0};
   uint64_t allocFailures{0};
 
+  std::vector<uint64_t> poolUsedSize;
   uint64_t numCacheGets{0};
   uint64_t numCacheGetMiss{0};
   uint64_t numRamDestructorCalls{0};
@@ -115,6 +116,12 @@ struct Stats {
         << std::endl;
     out << folly::sformat("RAM Evictions : {:,}", numEvictions) << std::endl;
 
+    for (auto pid = 0U; pid < poolUsedSize.size(); pid++) {
+      out << folly::sformat("Pool {:,} Used size : {:,} Bytes", pid,
+                            poolUsedSize[pid])
+          << std::endl;
+    }
+
     if (numCacheGets > 0) {
       out << folly::sformat("Cache Gets    : {:,}", numCacheGets) << std::endl;
       out << folly::sformat("Hit Ratio     : {:6.2f}%", overallHitRatio)