updates

Author: guptask

cachelib/allocator/BackgroundEvictor-inl.h

@@ -63,18 +63,32 @@ void BackgroundEvictor<CacheT>::work() {
 template <typename CacheT>
 void BackgroundEvictor<CacheT>::checkAndRun(PoolId pid) {    
   const auto& mpStats = cache_.getPoolByTid(pid,tid_).getStats();
+  unsigned int evictions = 0;
+  unsigned int classes = 0;
   for (auto& cid : mpStats.classIds) {
+      classes++;
       auto batch = strategy_->calculateBatchSize(cache_,tid_,pid,cid);
-      if (!batch)
+      if (!batch) {
         continue;
+      }
 
       stats.evictionSize.add(batch);
       //try evicting BATCH items from the class in order to reach free target
       auto evicted =
           BackgroundEvictorAPIWrapper<CacheT>::traverseAndEvictItems(cache_,
               tid_,pid,cid,batch);
-      stats.numEvictedItems.add(evicted);
+
+      evictions += evicted;
+      const size_t cid_id = (size_t)mpStats.acStats.at(cid).allocSize;
+      auto it = evictions_per_class_.find(cid_id);
+      if (it != evictions_per_class_.end()) {
+          it->second += evicted;
+      } else {
+          evictions_per_class_[cid_id] = 0;
+      }
   }
+  stats.numEvictedItems.add(evictions);
+  stats.numClasses.add(classes);
   stats.numTraversals.inc();
 }
 
@@ -84,10 +98,16 @@ BackgroundEvictionStats BackgroundEvictor<CacheT>::getStats() const noexcept {
   evicStats.numEvictedItems = stats.numEvictedItems.get();
   evicStats.numEvictedItemsFromSchedule = stats.numEvictedItemsFromSchedule.get();
   evicStats.numTraversals = stats.numTraversals.get();
+  evicStats.numClasses = stats.numClasses.get();
   evicStats.evictionSize = stats.evictionSize.get();
 
   return evicStats;
 }
 
+template <typename CacheT>
+std::map<uint32_t,uint64_t> BackgroundEvictor<CacheT>::getClassStats() const noexcept {
+  return evictions_per_class_;
+}
+
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/BackgroundEvictor.h

@@ -49,6 +49,9 @@ struct BackgroundEvictorStats {
   // traversals
   AtomicCounter numTraversals{0};
 
+  // total number of classes
+  AtomicCounter numClasses{0};
+
   // item eviction size
   AtomicCounter evictionSize{0};
 };
@@ -76,6 +79,8 @@ class BackgroundEvictor : public PeriodicWorker {
 
   BackgroundEvictionStats getStats() const noexcept;
 
+  std::map<uint32_t,uint64_t> getClassStats() const noexcept;
+
  private:
   // cache allocator's interface for evicting
 
@@ -91,6 +96,8 @@ class BackgroundEvictor : public PeriodicWorker {
   void checkAndRun(PoolId pid);
 
   BackgroundEvictorStats stats;
+
+  std::map<uint32_t,uint64_t> evictions_per_class_;
 };
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/CacheAllocator.h

@@ -1048,6 +1048,11 @@ class CacheAllocator : public CacheBase {
     auto stats = backgroundEvictor_ ? backgroundEvictor_->getStats() : BackgroundEvictionStats{};
     return stats;
   }
+  
+  std::map<uint32_t,uint64_t> getBackgroundEvictorClassStats() const {
+    auto stats = backgroundEvictor_ ? backgroundEvictor_->getClassStats() : std::map<uint32_t,uint64_t>();
+    return stats;
+  }
 
   // return the LruType of an item
   typename MMType::LruType getItemLruType(const Item& item) const;

cachelib/allocator/CacheStats.h

@@ -296,6 +296,9 @@ struct BackgroundEvictionStats {
   // number of times we went executed the thread //TODO: is this def correct?
   uint64_t numTraversals{0};
 
+  // total number of classes
+  uint64_t numClasses{0};
+
   // eviction size
   uint64_t evictionSize{0};
 };

cachelib/cachebench/cache/Cache-inl.h

@@ -59,6 +59,11 @@ Cache<Allocator>::Cache(const CacheConfig& config,
   allocatorConfig_.enablePoolRebalancing(
       config_.getRebalanceStrategy(),
       std::chrono::seconds(config_.poolRebalanceIntervalSec));
+ 
+  //for another day
+  //allocatorConfig_.enablePoolOptimizer(
+  //    config_.getPoolOptimizerStrategy(),
+  //    std::chrono::seconds(config_.poolOptimizerIntervalSec));
 
   allocatorConfig_.enableBackgroundEvictor(
       config_.getBackgroundEvictorStrategy(),
@@ -539,6 +544,12 @@ Stats Cache<Allocator>::getStats() const {
   ret.numCacheGets = cacheStats.numCacheGets;
   ret.numCacheGetMiss = cacheStats.numCacheGetMiss;
   ret.numRamDestructorCalls = cacheStats.numRamDestructorCalls;
+  
+  ret.numBackgroundEvictions = cacheStats.backgroundEvictorStats.numEvictedItems;
+  ret.numBackgroundEvictionsFromSchedule = cacheStats.backgroundEvictorStats.numEvictedItemsFromSchedule;
+  ret.numBackgroundEvictorRuns = cacheStats.backgroundEvictorStats.numTraversals;
+  ret.numClasses = cacheStats.backgroundEvictorStats.numClasses;
+
   ret.numNvmGets = cacheStats.numNvmGets;
   ret.numNvmGetMiss = cacheStats.numNvmGetMiss;
   ret.numNvmGetCoalesced = cacheStats.numNvmGetCoalesced;
@@ -581,6 +592,8 @@ Stats Cache<Allocator>::getStats() const {
     ret.nvmCounters = cache_->getNvmCacheStatsMap();
   }
 
+  ret.backgroundEvictionClasses = cache_->getBackgroundEvictorClassStats();
+
   // nvm stats from navy
   if (!isRamOnly() && !navyStats.empty()) {
     auto lookup = [&navyStats](const std::string& key) {

cachelib/cachebench/cache/CacheStats.h

@@ -36,6 +36,9 @@ struct BackgroundEvictionStats {
   // number of times we went executed the thread //TODO: is this def correct?
   uint64_t nTraversals{0};
 
+  // number of classes searched
+  uint64_t nClasses{0};
+
   // size of evicted items
   uint64_t evictionSize;
 };
@@ -116,6 +119,8 @@ struct Stats {
   // what to populate since not all of those are interesting when running
   // cachebench.
   std::unordered_map<std::string, double> nvmCounters;
+  
+  std::map<uint32_t, uint64_t> backgroundEvictionClasses;
 
   // errors from the nvm engine.
   std::unordered_map<std::string, double> nvmErrors;
@@ -138,6 +143,8 @@ struct Stats {
                             backgndEvicStats.nEvictedItemsFromSchedule) << std::endl;
     out << folly::sformat("Tier 0 Background Traversals : {:,}",
                             backgndEvicStats.nTraversals) << std::endl;
+    out << folly::sformat("Tier 0 Classes searched : {:,}",
+                            backgndEvicStats.nClasses) << std::endl;
     out << folly::sformat("Tier 0 Background Evicted Size : {:,}",
                             backgndEvicStats.evictionSize) << std::endl;
 
@@ -298,6 +305,13 @@ struct Stats {
         out << it.first << "  :  " << it.second << std::endl;
       }
     }
+    
+    if (!backgroundEvictionClasses.empty()) {
+      out << "== Class Background Eviction Counters Map ==" << std::endl;
+      for (const auto& it : backgroundEvictionClasses) {
+        out << it.first << "  :  " << it.second << std::endl;
+      }
+    }
 
     if (numRamDestructorCalls > 0 || numNvmDestructorCalls > 0) {
       out << folly::sformat("Destructor executed from RAM {}, from NVM {}",