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].set(allocator_->getPoolUsedSize(pid));
       handle.markNascent();
       (*stats_.fragmentationSize)[pid][cid].add(
           util::getFragmentation(*this, *handle));

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

@@ -49,7 +49,7 @@ struct SizeVerify {};
 
 void Stats::populateGlobalCacheStats(GlobalCacheStats& ret) const {
 #ifndef SKIP_SIZE_VERIFY
-  SizeVerify<sizeof(Stats)> a = SizeVerify<16144>{};
+  SizeVerify<sizeof(Stats)> a = SizeVerify<16672>{};
   std::ignore = a;
 #endif
   ret.numCacheGets = numCacheGets.get();
@@ -125,6 +125,10 @@ void Stats::populateGlobalCacheStats(GlobalCacheStats& ret) const {
   ret.numEvictions = accum(*chainedItemEvictions);
   ret.numEvictions += accum(*regularItemEvictions);
 
+  for (const auto& x : usedSize_) {
+    ret.poolUsedSize.emplace_back(x.get());
+  }
+
   ret.invalidAllocs = invalidAllocs.get();
   ret.numRefcountOverflow = numRefcountOverflow.get();
 

cachelib/allocator/CacheStats.h

@@ -416,6 +416,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

@@ -221,6 +221,8 @@ struct Stats {
   std::unique_ptr<PerPoolClassAtomicCounters> chainedItemEvictions{};
   std::unique_ptr<PerPoolClassAtomicCounters> regularItemEvictions{};
 
+  std::array<AtomicCounter, MemoryPoolManager::kMaxPools> 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;