bug fixes - changed timer to MS for bg evict

Author: byrnedj

cachelib/allocator/BackgroundEvictorStrategy.cpp

@@ -35,19 +35,16 @@ namespace cachelib {
 class BackgroundEvictorStrategy {
 
 public:
-  BackgroundEvictorStrategy() {}
 
-  ~BackgroundEvictorStrategy() {}
-
-  unsigned int calculateBatchSize(const CacheBase& cache,
+  virtual unsigned int calculateBatchSize(const CacheBase& cache,
                                        unsigned int tid,
                                        PoolId pid,
-                                       ClassId cid );
+                                       ClassId cid ) = 0;
 
-  bool shouldEvict(const CacheBase& cache,
+  virtual bool shouldEvict(const CacheBase& cache,
                                        unsigned int tid,
                                        PoolId pid,
-                                       ClassId cid );
+                                       ClassId cid ) = 0;
 
 
 };

cachelib/allocator/BackgroundEvictorStrategy.h

@@ -27,7 +27,6 @@ add_library (cachelib_allocator
   ${SERIALIZE_THRIFT_FILES}
   ${DATASTRUCT_SERIALIZE_THRIFT_FILES}
   ${MEMORY_SERIALIZE_THRIFT_FILES}
-    BackgroundEvictorStrategy.cpp
     CacheAllocator.cpp
     Cache.cpp
     CacheDetails.cpp

cachelib/allocator/CMakeLists.txt

@@ -270,7 +270,7 @@ class CacheAllocatorConfig {
   // to evict to the next tier
   CacheAllocatorConfig& enableBackgroundEvictor(
       std::shared_ptr<BackgroundEvictorStrategy> backgroundEvictorStrategy,
-      std::chrono::seconds regularInterval);
+      std::chrono::milliseconds regularInterval);
 
   // This enables an optimization for Pool rebalancing and resizing.
   // The rough idea is to ensure only the least useful items are evicted when
@@ -440,7 +440,7 @@ class CacheAllocatorConfig {
   std::chrono::milliseconds poolRebalanceInterval{std::chrono::seconds{1}};
 
   // time interval to sleep between runs of the background evictor
-  std::chrono::milliseconds backgroundEvictorInterval{std::chrono::seconds{1}};
+  std::chrono::milliseconds backgroundEvictorInterval{std::chrono::milliseconds{1000}};
 
   // Free slabs pro-actively if the ratio of number of freeallocs to
   // the number of allocs per slab in a slab class is above this
@@ -984,7 +984,7 @@ CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::enablePoolRebalancing(
 template <typename T>
 CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::enableBackgroundEvictor(
     std::shared_ptr<BackgroundEvictorStrategy> strategy,
-    std::chrono::seconds interval) {
+    std::chrono::milliseconds interval) {
   backgroundEvictorStrategy = strategy;
   backgroundEvictorInterval = interval;
   return *this;

cachelib/allocator/CacheAllocatorConfig.h

@@ -62,7 +62,7 @@ Cache<Allocator>::Cache(const CacheConfig& config,
 
   allocatorConfig_.enableBackgroundEvictor(
       config_.getBackgroundEvictorStrategy(),
-      std::chrono::seconds(config_.backgroundEvictorIntervalSec));
+      std::chrono::milliseconds(config_.backgroundEvictorIntervalMilSec));
 
   if (config_.moveOnSlabRelease && movingSync != nullptr) {
     allocatorConfig_.enableMovingOnSlabRelease(
@@ -523,6 +523,9 @@ Stats Cache<Allocator>::getStats() const {
   ret.numItems = aggregate.numItems();
   ret.allocAttempts = cacheStats.allocAttempts;
   ret.allocFailures = cacheStats.allocFailures;
+  
+  ret.numBackgroundEvictions = cacheStats.backgroundEvictorStats.numEvictedItems;
+  ret.numBackgroundEvictorRuns = cacheStats.backgroundEvictorStats.numTraversals;
 
   ret.numCacheGets = cacheStats.numCacheGets;
   ret.numCacheGetMiss = cacheStats.numCacheGetMiss;

cachelib/cachebench/cache/Cache-inl.h

@@ -32,6 +32,9 @@ struct Stats {
   uint64_t allocAttempts{0};
   uint64_t allocFailures{0};
 
+  uint64_t numBackgroundEvictions{0};
+  uint64_t numBackgroundEvictorRuns{0};
+
   uint64_t numCacheGets{0};
   uint64_t numCacheGetMiss{0};
   uint64_t numRamDestructorCalls{0};
@@ -114,6 +117,11 @@ 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 Eviction Runs : {:,}", numBackgroundEvictorRuns) << std::endl;
 
     if (numCacheGets > 0) {
       out << folly::sformat("Cache Gets    : {:,}", numCacheGets) << std::endl;

cachelib/cachebench/cache/CacheStats.h

@@ -30,7 +30,7 @@ CacheConfig::CacheConfig(const folly::dynamic& configJson) {
   JSONSetVal(configJson, allocator);
   JSONSetVal(configJson, cacheSizeMB);
   JSONSetVal(configJson, poolRebalanceIntervalSec);
-  JSONSetVal(configJson, backgroundEvictorIntervalSec);
+  JSONSetVal(configJson, backgroundEvictorIntervalMilSec);
   JSONSetVal(configJson, moveOnSlabRelease);
   JSONSetVal(configJson, rebalanceStrategy);
   JSONSetVal(configJson, rebalanceMinSlabs);
@@ -143,7 +143,7 @@ std::shared_ptr<RebalanceStrategy> CacheConfig::getRebalanceStrategy() const {
 }
 
 std::shared_ptr<BackgroundEvictorStrategy> CacheConfig::getBackgroundEvictorStrategy() const {
-  if (backgroundEvictorIntervalSec == 0) {
+  if (backgroundEvictorIntervalMilSec == 0) {
     return nullptr;
   }
 

cachelib/cachebench/util/CacheConfig.cpp

@@ -72,7 +72,7 @@ struct CacheConfig : public JSONConfig {
 
   uint64_t cacheSizeMB{0};
   uint64_t poolRebalanceIntervalSec{0};
-  uint64_t backgroundEvictorIntervalSec{0};
+  uint64_t backgroundEvictorIntervalMilSec{0};
   std::string rebalanceStrategy;
   std::string backgroundEvictorStrategy;
   double freeThreshold{0.01}; //keep 1% of space free