updated the background eviction stats to use AtomicCounters lib

Author: guptask

cachelib/allocator/BackgroundEvictor-inl.h

@@ -39,10 +39,11 @@ void BackgroundEvictor<CacheT>::work() {
       while (auto entry = tasks_.try_dequeue()) {
         auto [pid, cid] = entry.value();
         auto batch = strategy_->calculateBatchSize(cache_, tid_, pid, cid);
+        stats.evictionSize.add(batch);
         auto evicted = BackgroundEvictorAPIWrapper<CacheT>::traverseAndEvictItems(cache_,
                 tid_,pid,cid,batch);
-        numEvictedItemsFromSchedule_.fetch_add(1, std::memory_order_relaxed);
-        runCount_.fetch_add(1, std::memory_order_relaxed);
+        stats.numEvictedItemsFromSchedule.inc();
+        stats.numTraversals.inc();
       }
     } else {
       for (const auto pid : cache_.getRegularPoolIds()) {
@@ -67,22 +68,25 @@ void BackgroundEvictor<CacheT>::checkAndRun(PoolId pid) {
       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);
-      numEvictedItems_.fetch_add(evicted, std::memory_order_relaxed);
+      stats.numEvictedItems.add(evicted);
   }
-  runCount_.fetch_add(1, std::memory_order_relaxed);
+  stats.numTraversals.inc();
 }
 
 template <typename CacheT>
-BackgroundEvictorStats BackgroundEvictor<CacheT>::getStats() const noexcept {
-  BackgroundEvictorStats stats;
-  stats.numEvictedItems = numEvictedItems_.load(std::memory_order_relaxed);
-  stats.numTraversals = runCount_.load(std::memory_order_relaxed);
-  stats.numEvictedItemsFromSchedule = numEvictedItemsFromSchedule_.load(std::memory_order_relaxed);
-  return stats;
+BackgroundEvictionStats BackgroundEvictor<CacheT>::getStats() const noexcept {
+  BackgroundEvictionStats evicStats;
+  evicStats.numEvictedItems = stats.numEvictedItems.get();
+  evicStats.numEvictedItemsFromSchedule = stats.numEvictedItemsFromSchedule.get();
+  evicStats.numTraversals = stats.numTraversals.get();
+  evicStats.evictionSize = stats.evictionSize.get();
+
+  return evicStats;
 }
 
 } // namespace cachelib

cachelib/allocator/BackgroundEvictor.h

@@ -22,6 +22,7 @@
 #include "cachelib/allocator/CacheStats.h"
 #include "cachelib/common/PeriodicWorker.h"
 #include "cachelib/allocator/BackgroundEvictorStrategy.h"
+#include "cachelib/common/AtomicCounter.h"
 
 
 namespace facebook {
@@ -38,6 +39,20 @@ struct BackgroundEvictorAPIWrapper {
   }
 };
 
+struct BackgroundEvictorStats {
+  // items evicted
+  AtomicCounter numEvictedItems{0};
+
+  // items evicted from schedule
+  AtomicCounter numEvictedItemsFromSchedule;
+
+  // traversals
+  AtomicCounter numTraversals{0};
+
+  // item eviction size
+  AtomicCounter evictionSize{0};
+};
+
 // Periodic worker that evicts items from tiers in batches
 // The primary aim is to reduce insertion times for new items in the
 // cache
@@ -58,7 +73,8 @@ class BackgroundEvictor : public PeriodicWorker {
   void schedule(size_t pid, size_t cid) {
       tasks_.enqueue(std::make_pair(pid,cid));
   }
-  BackgroundEvictorStats getStats() const noexcept;
+
+  BackgroundEvictionStats getStats() const noexcept;
 
  private:
   // cache allocator's interface for evicting
@@ -73,10 +89,8 @@ class BackgroundEvictor : public PeriodicWorker {
   // implements the actual logic of running the background evictor
   void work() override final;
   void checkAndRun(PoolId pid);
-  
-  std::atomic<uint64_t> numEvictedItems_{0};
-  std::atomic<uint64_t> numEvictedItemsFromSchedule_{0};
-  std::atomic<uint64_t> runCount_{0};
+
+  BackgroundEvictorStats stats;
 };
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/CacheAllocator-inl.h

@@ -3676,7 +3676,7 @@ GlobalCacheStats CacheAllocator<CacheTrait>::getGlobalCacheStats() const {
   ret.nvmCacheEnabled = nvmCache_ ? nvmCache_->isEnabled() : false;
   ret.nvmUpTime = currTime - getNVMCacheCreationTime();
   ret.reaperStats = getReaperStats();
-  ret.backgroundEvictorStats = getBackgroundEvictorStats();
+  ret.evictionStats = getBackgroundEvictorStats();
   ret.numActiveHandles = getNumActiveHandles();
 
   return ret;

cachelib/allocator/CacheAllocator.h

@@ -1044,8 +1044,8 @@ class CacheAllocator : public CacheBase {
   }
 
   // returns the background evictor
-  BackgroundEvictorStats getBackgroundEvictorStats() const {
-    auto stats = backgroundEvictor_ ? backgroundEvictor_->getStats() : BackgroundEvictorStats{};
+  BackgroundEvictionStats getBackgroundEvictorStats() const {
+    auto stats = backgroundEvictor_ ? backgroundEvictor_->getStats() : BackgroundEvictionStats{};
     return stats;
   }
 

cachelib/allocator/CacheStats.h

@@ -285,8 +285,8 @@ struct ReaperStats {
   uint64_t avgTraversalTimeMs{0};
 };
 
-// Stats for background evictor
-struct BackgroundEvictorStats {
+// Eviction Stats
+struct BackgroundEvictionStats {
   // the number of items this worker evicted by looking at pools/classes stats
   uint64_t numEvictedItems{0};
 
@@ -296,6 +296,8 @@ struct BackgroundEvictorStats {
   // number of times we went executed the thread //TODO: is this def correct?
   uint64_t numTraversals{0};
 
+  // eviction size
+  uint64_t evictionSize{0};
 };
 
 // CacheMetadata type to export
@@ -318,6 +320,9 @@ struct Stats;
 // Stats that apply globally in cache and
 // the ones that are aggregated over all pools
 struct GlobalCacheStats {
+  // background eviction stats
+  BackgroundEvictionStats evictionStats;
+
   // number of calls to CacheAllocator::find
   uint64_t numCacheGets{0};
 
@@ -482,9 +487,6 @@ struct GlobalCacheStats {
 
   // stats related to the reaper
   ReaperStats reaperStats;
-  
-  // stats related to the background evictor
-  BackgroundEvictorStats backgroundEvictorStats;
 
   uint64_t numNvmRejectsByExpiry{};
   uint64_t numNvmRejectsByClean{};

cachelib/cachebench/cache/Cache-inl.h

@@ -522,14 +522,19 @@ Stats Cache<Allocator>::getStats() const {
   const auto navyStats = cache_->getNvmCacheStatsMap();
 
   Stats ret;
+  ret.backgndEvicStats.nEvictedItems =
+            cacheStats.evictionStats.numEvictedItems;
+  ret.backgndEvicStats.nEvictedItemsFromSchedule =
+            cacheStats.evictionStats.numEvictedItemsFromSchedule;
+  ret.backgndEvicStats.nTraversals =
+            cacheStats.evictionStats.numTraversals;
+  ret.backgndEvicStats.evictionSize =
+            cacheStats.evictionStats.evictionSize;
+
   ret.numEvictions = aggregate.numEvictions();
   ret.numItems = aggregate.numItems();
   ret.allocAttempts = cacheStats.allocAttempts;
   ret.allocFailures = cacheStats.allocFailures;
-  
-  ret.numBackgroundEvictions = cacheStats.backgroundEvictorStats.numEvictedItems;
-  ret.numBackgroundEvictionsFromSchedule = cacheStats.backgroundEvictorStats.numEvictedItemsFromSchedule;
-  ret.numBackgroundEvictorRuns = cacheStats.backgroundEvictorStats.numTraversals;
 
   ret.numCacheGets = cacheStats.numCacheGets;
   ret.numCacheGetMiss = cacheStats.numCacheGetMiss;

cachelib/cachebench/cache/CacheStats.h

@@ -25,17 +25,30 @@ DECLARE_bool(report_api_latency);
 namespace facebook {
 namespace cachelib {
 namespace cachebench {
+
+struct BackgroundEvictionStats {
+  // the number of items this worker evicted by looking at pools/classes stats
+  uint64_t nEvictedItems{0};
+
+  // the number of items this worker evicted for pools/classes requested by schedule call
+  uint64_t nEvictedItemsFromSchedule{0};
+
+  // number of times we went executed the thread //TODO: is this def correct?
+  uint64_t nTraversals{0};
+
+  // size of evicted items
+  uint64_t evictionSize;
+};
+
 struct Stats {
+  BackgroundEvictionStats backgndEvicStats;
+
   uint64_t numEvictions{0};
   uint64_t numItems{0};
 
   uint64_t allocAttempts{0};
   uint64_t allocFailures{0};
 
-  uint64_t numBackgroundEvictions{0};
-  uint64_t numBackgroundEvictionsFromSchedule{0};
-  uint64_t numBackgroundEvictorRuns{0};
-
   uint64_t numCacheGets{0};
   uint64_t numCacheGetMiss{0};
   uint64_t numRamDestructorCalls{0};
@@ -118,12 +131,15 @@ struct Stats {
                           invertPctFn(allocFailures, allocAttempts))
         << std::endl;
     out << folly::sformat("RAM Evictions : {:,}", numEvictions) << std::endl;
-    
 
-    out << folly::sformat("Background Tier 0 Evictions : {:,}", numBackgroundEvictions) << std::endl;
-    out << folly::sformat("Background Tier 0 Evictions from schedule() : {:,}", numBackgroundEvictionsFromSchedule) << std::endl;
-    
-    out << folly::sformat("Background Tier 0 Eviction Runs : {:,}", numBackgroundEvictorRuns) << std::endl;
+    out << folly::sformat("Tier 0 Background Evicted items : {:,}",
+                            backgndEvicStats.nEvictedItems) << std::endl;
+    out << folly::sformat("Tier 0 Background Evicted items from schedule : {:,}",
+                            backgndEvicStats.nEvictedItemsFromSchedule) << std::endl;
+    out << folly::sformat("Tier 0 Background Traversals : {:,}",
+                            backgndEvicStats.nTraversals) << std::endl;
+    out << folly::sformat("Tier 0 Background Evicted Size : {:,}",
+                            backgndEvicStats.evictionSize) << std::endl;
 
     if (numCacheGets > 0) {
       out << folly::sformat("Cache Gets    : {:,}", numCacheGets) << std::endl;