Rolling average class latency

Part 2. (multi-tier support)
--------------------------------------
There is also an introduction to kMaxTiers in Cache.h
- this should probably be split from this commit.

added per tier pool class rolling average latency (based on upstream PR)

cachelib/allocator/Cache.h

@@ -85,6 +85,9 @@ class CacheBase {
   CacheBase(CacheBase&&) = default;
   CacheBase& operator=(CacheBase&&) = default;
 
+  // TODO: come up with some reasonable number
+  static constexpr unsigned kMaxTiers = 2;
+
   // Get a string referring to the cache name for this cache
   virtual const std::string getCacheName() const = 0;
 

cachelib/allocator/CacheAllocator.h

@@ -2783,7 +2783,7 @@ CacheAllocator<CacheTrait>::allocateInternalTier(TierId tid,
   // the allocation class in our memory allocator.
   const auto cid = allocator_[tid]->getAllocationClassId(pid, requiredSize);
   util::RollingLatencyTracker rollTracker{
-      (*stats_.classAllocLatency)[pid][cid]};
+      (*stats_.classAllocLatency)[tid][pid][cid]};
 
   // TODO: per-tier
   (*stats_.allocAttempts)[pid][cid].inc();
@@ -2895,7 +2895,7 @@ CacheAllocator<CacheTrait>::allocateChainedItemInternal(const Item& parent,
   // TODO: per-tier? Right now stats_ are not used in any public periodic
   // worker
   util::RollingLatencyTracker rollTracker{
-      (*stats_.classAllocLatency)[pid][cid]};
+      (*stats_.classAllocLatency)[tid][pid][cid]};
 
   (*stats_.allocAttempts)[pid][cid].inc();
 
@@ -4918,7 +4918,7 @@ ACStats CacheAllocator<CacheTrait>::getACStats(TierId tid,
   const auto& pool = allocator_[tid]->getPool(poolId);
   const auto& ac = pool.getAllocationClass(classId);
   auto stats = ac.getStats();
-  stats.allocLatencyNs = (*stats_.classAllocLatency)[poolId][classId];
+  stats.allocLatencyNs = (*stats_.classAllocLatency)[tid][poolId][classId];
   return stats;
 }
 

cachelib/allocator/CacheStats.cpp

@@ -44,7 +44,7 @@ void Stats::init() {
   initToZero(*chainedItemEvictions);
   initToZero(*regularItemEvictions);
 
-  classAllocLatency = std::make_unique<PerPoolClassRollingStats>();
+  classAllocLatency = std::make_unique<PerTierPoolClassRollingStats>();
 }
 
 template <int>

cachelib/allocator/CacheStats.h

@@ -27,6 +27,7 @@
 #include "cachelib/allocator/memory/Slab.h"
 #include "cachelib/common/FastStats.h"
 #include "cachelib/common/PercentileStats.h"
+#include "cachelib/common/RollingStats.h"
 #include "cachelib/common/Time.h"
 
 namespace facebook {

cachelib/allocator/CacheStatsInternal.h

@@ -230,12 +230,13 @@ struct Stats {
   std::unique_ptr<PerPoolClassAtomicCounters> chainedItemEvictions{};
   std::unique_ptr<PerPoolClassAtomicCounters> regularItemEvictions{};
 
-  using PerPoolClassRollingStats =
+  using PerTierPoolClassRollingStats = std::array<
       std::array<std::array<util::RollingStats, MemoryAllocator::kMaxClasses>,
-                 MemoryPoolManager::kMaxPools>;
+                 MemoryPoolManager::kMaxPools>,
+      CacheBase::kMaxTiers>;
 
   // rolling latency tracking for every alloc class in every pool
-  std::unique_ptr<PerPoolClassRollingStats> classAllocLatency{};
+  std::unique_ptr<PerTierPoolClassRollingStats> classAllocLatency{};
 
   // Eviction failures due to parent cannot be removed from access container
   AtomicCounter evictFailParentAC{0};

cachelib/cachebench/cache/CacheStats.h

@@ -203,18 +203,11 @@ struct 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("tid{:2} pid{:2} cid{:4} {:8.2f}{} memorySize: {:8.2f}{}",
-                              tid, pid, cid, allocSize, allocSizeSuffix, memorySize,
-                              memorySizeSuffix)
-            << std::endl;
-      });
-
-      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
         // will grow at the same rate. This value will be the same for all ACs.
@@ -224,8 +217,10 @@ struct Stats {
 
         out << folly::sformat(
                    "tid{:2} pid{:2} cid{:4} {:8.2f}{} usageFraction: {:4.2f} "
+                   "memorySize: {:8.2f}{} "
                    "rollingAvgAllocLatency: {:8.2f}ns",
                    tid, pid, cid, allocSize, allocSizeSuffix, acUsageFraction,
+                   memorySize, memorySizeSuffix,
                    stats.allocLatencyNs.estimate())
             << std::endl;
       });