Dynamic stats for each class high threshold

cachelib/allocator/BackgroundEvictor-inl.h

@@ -103,7 +103,7 @@ BackgroundEvictionStats BackgroundEvictor<CacheT>::getStats() const noexcept {
   evicStats.runCount = stats.numTraversals.get();
   evicStats.evictionSize = stats.evictionSize.get();
   evicStats.totalClasses = stats.totalClasses.get();
-
+  evicStats.strategyStats = strategy_->getStats();
   return evicStats;
 }
 

cachelib/allocator/BackgroundEvictor.h

@@ -51,6 +51,7 @@ struct BackgroundEvictorStats {
 
   // item eviction size
   AtomicCounter evictionSize{0};
+
 };
 
 // Periodic worker that evicts items from tiers in batches

cachelib/allocator/BackgroundEvictorStrategy.h

@@ -27,6 +27,7 @@ class BackgroundEvictorStrategy {
 public:
   virtual std::vector<size_t> calculateBatchSizes(const CacheBase& cache,
                                        std::vector<std::tuple<TierId, PoolId, ClassId>> acVec) = 0;
+  virtual BackgroundStrategyStats getStats() = 0; 
 };
 
 } // namespace cachelib

cachelib/allocator/CacheStats.h

@@ -28,6 +28,8 @@
 #include "cachelib/common/RollingStats.h"
 #include "cachelib/common/Time.h"
 
+//#include "cachelib/allocator/BackgroundEvictorStrategy.h"
+
 namespace facebook {
 namespace cachelib {
 
@@ -300,6 +302,21 @@ struct ReaperStats {
   uint64_t avgTraversalTimeMs{0};
 };
 
+struct BackgroundStrategyStats {
+
+    std::map<uint32_t,double> highEvictionAcWatermarks;
+
+    BackgroundStrategyStats& operator+=(const BackgroundStrategyStats& rhs){
+        for (const auto entry : rhs.highEvictionAcWatermarks) {
+            auto cid = entry.first;
+            auto count = entry.second;
+            highEvictionAcWatermarks[cid] = count;
+        }
+        return *this;
+    }
+
+};
+
 // Eviction Stats
 struct BackgroundEvictionStats {
   // the number of items this worker evicted by looking at pools/classes stats
@@ -314,11 +331,14 @@ struct BackgroundEvictionStats {
   // eviction size
   uint64_t evictionSize{0};
 
+  BackgroundStrategyStats strategyStats;
+
   BackgroundEvictionStats& operator+=(const BackgroundEvictionStats& rhs) {
     numEvictedItems += rhs.numEvictedItems;
     runCount += rhs.runCount;
     totalClasses += rhs.totalClasses;
     evictionSize += rhs.evictionSize;
+    strategyStats += rhs.strategyStats;
     return *this;
   }
 };

cachelib/allocator/DynamicFreeThresholdStrategy.cpp

@@ -148,5 +148,19 @@ void DynamicFreeThresholdStrategy::calculateBenefitMig(uint64_t acLatency, unsig
     std::get<0>(acBenefits[tid][pid][cid]) = 1 / acLatency;
 }
 
+BackgroundStrategyStats DynamicFreeThresholdStrategy::getStats() { 
+    BackgroundStrategyStats s;
+
+    auto numClasses = MemoryAllocator::kMaxClasses;
+    for (int i = 0; i < 1; i++) {
+      for (int j = 0; j < 1; j++) {
+        for (int k = 0; k < numClasses; k++) {
+            s.highEvictionAcWatermarks[k] = std::get<0>( highEvictionAcWatermarks[i][j][k] );
+        }
+      }
+    }
+    return s;
+}
+
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/DynamicFreeThresholdStrategy.h

@@ -38,11 +38,8 @@ class DynamicFreeThresholdStrategy : public BackgroundEvictorStrategy {
   ~DynamicFreeThresholdStrategy() {}
 
   std::vector<size_t> calculateBatchSizes(const CacheBase& cache, std::vector<std::tuple<TierId, PoolId, ClassId>> acVec);
-                                       //unsigned int tid,
-                                       //PoolId pid,
-                                       //ClassId cid,
-                                       //size_t allocSize,
-                                       //size_t acMemorySize);
+
+  BackgroundStrategyStats getStats();
 
 private:
   double lowEvictionAcWatermark{2.0}; //this threshold is used outside this class and is not adjusted currently

cachelib/allocator/FreeThresholdStrategy.cpp

@@ -63,5 +63,10 @@ std::vector<size_t> FreeThresholdStrategy::calculateBatchSizes(
   return batches;
 }
 
+BackgroundStrategyStats FreeThresholdStrategy::getStats() { 
+  BackgroundStrategyStats s;
+  return s;
+}
+
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/FreeThresholdStrategy.h

@@ -32,6 +32,8 @@ class FreeThresholdStrategy : public BackgroundEvictorStrategy {
 
   std::vector<size_t> calculateBatchSizes(const CacheBase& cache,
                             std::vector<std::tuple<TierId, PoolId, ClassId>> acVecs);
+
+  BackgroundStrategyStats getStats(); 
 private:
   double lowEvictionAcWatermark{2.0}; 
   double highEvictionAcWatermark{5.0};

cachelib/allocator/PromotionStrategy.h

@@ -71,6 +71,11 @@ class PromotionStrategy : public BackgroundEvictorStrategy {
 
     return batches;
   }
+
+  BackgroundStrategyStats getStats() { 
+    BackgroundStrategyStats s;
+    return s;
+  }
 private:
   double promotionAcWatermark{4.0};
   uint64_t maxPromotionBatch{40};

cachelib/cachebench/cache/Cache-inl.h

@@ -614,6 +614,7 @@ Stats Cache<Allocator>::getStats() const {
     ret.nvmCounters = cache_->getNvmCacheStatsMap();
   }
 
+  ret.acHighWatermarks = cacheStats.evictionStats.strategyStats.highEvictionAcWatermarks;
   ret.backgroundEvictionClasses = cache_->getBackgroundEvictorClassStats();
   ret.backgroundPromotionClasses = cache_->getBackgroundPromoterClassStats();
 

cachelib/cachebench/cache/CacheStats.h

@@ -135,6 +135,8 @@ struct Stats {
   std::map<uint32_t, uint64_t> backgroundEvictionClasses;
   std::map<uint32_t, uint64_t> backgroundPromotionClasses;
 
+  std::map<uint32_t, double> acHighWatermarks;
+
   // errors from the nvm engine.
   std::unordered_map<std::string, double> nvmErrors;
 
@@ -190,13 +192,13 @@ struct Stats {
 
       foreachAC([&](auto tid, auto pid, auto cid, auto stats){
         auto [allocSizeSuffix, allocSize] = formatMemory(stats.allocSize);
-        out << folly::sformat("tid{:2} pid{:2} cid{:4} {:8.2f}{} free: {:4.2f}%",
+        out << folly::sformat("tid{:2} pid{:2} cid{:4} {:8}{} free: {:4.2f}%",
           tid, pid, cid, allocSize, allocSizeSuffix, stats.approxFreePercent) << std::endl;
       });
 
       foreachAC([&](auto tid, auto pid, auto cid, auto stats){
         auto [allocSizeSuffix, allocSize] = formatMemory(stats.allocSize);
-        out << folly::sformat("tid{:2} pid{:2} cid{:4} {:8.2f}{} latency: {:8.2f}%",
+        out << folly::sformat("tid{:2} pid{:2} cid{:4} {:8}{} latency: {:8}",
           tid, pid, cid, allocSize, allocSizeSuffix, stats.allocLatencyNs.estimate()) << std::endl;
       });
     }
@@ -380,6 +382,13 @@ struct Stats {
       }
     }
 
+    if (!acHighWatermarks.empty() && backgndEvicStats.nEvictedItems > 0 ) {
+      out << "== Class High Threshold ==" << std::endl;
+      for (const auto& it : acHighWatermarks) {
+        out << it.first << "  :  " << it.second << std::endl;
+      }
+    }
+
     if (!backgroundPromotionClasses.empty() && backgndPromoStats.nPromotedItems > 0) {
       out << "== Class Background Promotion Counters Map ==" << std::endl;
       for (const auto& it : backgroundPromotionClasses) {