AC stats multi-tier

Author: byrnedj

cachelib/allocator/Cache.h

@@ -106,7 +106,7 @@ class CacheBase {
   //
   // @param poolId   the pool id
   // @param classId   the class id
-  virtual ACStats getACStats(PoolId poolId, ClassId classId) const = 0;
+  virtual ACStats getACStats(TierId tid, PoolId poolId, ClassId classId) const = 0;
 
   // @param poolId   the pool id
   virtual AllSlabReleaseEvents getAllSlabReleaseEvents(PoolId poolId) const = 0;

cachelib/allocator/CacheAllocator-inl.h

@@ -2419,9 +2419,10 @@ PoolStats CacheAllocator<CacheTrait>::getPoolStats(PoolId poolId) const {
 }
 
 template <typename CacheTrait>
-ACStats CacheAllocator<CacheTrait>::getACStats(PoolId poolId,
+ACStats CacheAllocator<CacheTrait>::getACStats(TierId tid,
+                                               PoolId poolId,
                                                ClassId classId) const {
-  const auto& pool = allocator_[currentTier()]->getPool(poolId);
+  const auto& pool = allocator_[tid]->getPool(poolId);
   const auto& ac = pool.getAllocationClass(classId);
   return ac.getStats();
 }

cachelib/allocator/CacheAllocator.h

@@ -1183,7 +1183,7 @@ class CacheAllocator : public CacheBase {
   CacheMemoryStats getCacheMemoryStats() const override final;
 
   // return stats for Allocation Class
-  ACStats getACStats(PoolId pid, ClassId cid) const override final;
+  ACStats getACStats(TierId tid, PoolId pid, ClassId cid) const override final;
 
   // return the nvm cache stats map
   util::StatsMap getNvmCacheStatsMap() const override final;

cachelib/allocator/tests/CacheBaseTest.cpp

@@ -34,7 +34,7 @@ class CacheBaseTest : public CacheBase, public SlabAllocatorTestBase {
   bool isObjectCache() const override { return false; }
   const MemoryPool& getPool(PoolId) const override { return memoryPool_; }
   PoolStats getPoolStats(PoolId) const override { return PoolStats(); }
-  ACStats getACStats(PoolId, ClassId) const { return ACStats(); };
+  ACStats getACStats(TierId, PoolId, ClassId) const { return ACStats(); };
   AllSlabReleaseEvents getAllSlabReleaseEvents(PoolId) const override {
     return AllSlabReleaseEvents{};
   }

cachelib/cachebench/cache/Cache-inl.h

@@ -620,12 +620,14 @@ Stats Cache<Allocator>::getStats() const {
     aggregate += poolStats;
   }
 
-  std::map<PoolId, std::map<ClassId, ACStats>> allocationClassStats{};
+  std::map<TierId, std::map<PoolId, std::map<ClassId, ACStats>>> allocationClassStats{};
 
   for (size_t pid = 0; pid < pools_.size(); pid++) {
     auto cids = cache_->getPoolStats(static_cast<PoolId>(pid)).getClassIds();
-    for (auto cid : cids)
-      allocationClassStats[pid][cid] = cache_->getACStats(pid, cid);
+    for (TierId tid = 0; tid < cache_->getNumTiers(); tid++) {
+      for (auto cid : cids)
+        allocationClassStats[tid][pid][cid] = cache_->getACStats(tid, pid, cid);
+    }
   }
 
   const auto cacheStats = cache_->getGlobalCacheStats();

cachelib/cachebench/cache/Cache.h

@@ -325,8 +325,8 @@ class Cache {
   // return the stats for the pool.
   PoolStats getPoolStats(PoolId pid) const { return cache_->getPoolStats(pid); }
 
-  ACStats getACStats(PoolId pid, ClassId cid) const {
-    return cache_->getACStats(pid, cid);
+  ACStats getACStats(TierId tid, PoolId pid, ClassId cid) const {
+    return cache_->getACStats(tid, pid, cid);
   }
 
   // return the total number of inconsistent operations detected since start.

cachelib/cachebench/cache/CacheStats.h

@@ -101,7 +101,7 @@ struct Stats {
   uint64_t invalidDestructorCount{0};
   int64_t unDestructedItemCount{0};
 
-  std::map<PoolId, std::map<ClassId, ACStats>> allocationClassStats;
+  std::map<TierId, std::map<PoolId, std::map<ClassId, ACStats>>> allocationClassStats;
 
   // populate the counters related to nvm usage. Cache implementation can decide
   // what to populate since not all of those are interesting when running
@@ -156,24 +156,26 @@ struct Stats {
       };
 
       auto foreachAC = [&](auto cb) {
-        for (auto& pidStat : allocationClassStats) {
-          for (auto& cidStat : pidStat.second) {
-            cb(pidStat.first, cidStat.first, cidStat.second);
+        for (auto& tidStat : allocationClassStats) {
+          for (auto& pidStat : tidStat.second) {
+            for (auto& cidStat : pidStat.second) {
+              cb(tidStat.first, pidStat.first, cidStat.first, cidStat.second);
+            }
           }
         }
       };
 
-      foreachAC([&](auto pid, auto cid, auto stats) {
+      foreachAC([&](auto tid, auto pid, auto cid, auto stats) {
         auto [allocSizeSuffix, allocSize] = formatMemory(stats.allocSize);
         auto [memorySizeSuffix, memorySize] =
             formatMemory(stats.totalAllocatedSize());
-        out << folly::sformat("pid{:2} cid{:4} {:8.2f}{} memorySize: {:8.2f}{}",
-                              pid, cid, allocSize, allocSizeSuffix, memorySize,
+        out << folly::sformat("tid{:2} pid{:2} cid{:4} {:8.2f}{} memorySize: {:8.2f}{}",
+                              tid, pid, cid, allocSize, allocSizeSuffix, memorySize,
                               memorySizeSuffix)
             << std::endl;
       });
 
-      foreachAC([&](auto pid, auto cid, auto stats) {
+      foreachAC([&](auto tid, auto pid, auto cid, auto stats) {
         auto [allocSizeSuffix, allocSize] = formatMemory(stats.allocSize);
 
         // If the pool is not full, extrapolate usageFraction for AC assuming it