use approximate usage fraction

Author: byrnedj

cachelib/allocator/BackgroundMoverStrategy.h

@@ -38,5 +38,34 @@ class BackgroundMoverStrategy {
   virtual ~BackgroundMoverStrategy() = default;
 };
 
+class DefaultBackgroundMoverStrategy : public BackgroundMoverStrategy {
+  public:
+    DefaultBackgroundMoverStrategy(uint64_t batchSize, double targetFree)
+      : batchSize_(batchSize), targetFree_((double)targetFree/100.0) {}
+    ~DefaultBackgroundMoverStrategy() {}
+
+  std::vector<size_t> calculateBatchSizes(
+      const CacheBase& cache,
+      std::vector<MemoryDescriptorType> acVec) {
+    std::vector<size_t> batches{};
+    for (auto [tid, pid, cid] : acVec) {
+        double usage = cache.getPoolByTid(pid, tid).getApproxUsage(cid);
+        uint32_t perSlab = cache.getPoolByTid(pid, tid).getPerSlab(cid);
+        if (usage >= (1.0-targetFree_)) {
+          uint32_t batch = batchSize_ > perSlab ? perSlab : batchSize_;
+          batches.push_back(batch);
+        } else {
+          //no work to be done since there is already
+          //at least targetFree remaining in the class
+          batches.push_back(0);
+        }
+    }
+    return batches;
+  }
+  private:
+    uint64_t batchSize_{100};
+    double targetFree_{0.05};
+};
+
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/CacheAllocator-inl.h

@@ -401,9 +401,13 @@ CacheAllocator<CacheTrait>::allocate(PoolId poolId,
 }
 
 template <typename CacheTrait>
-bool CacheAllocator<CacheTrait>::shouldWakeupBgEvictor(TierId tid,
-                                                       PoolId /* pid */,
-                                                       ClassId /* cid */) {
+bool CacheAllocator<CacheTrait>::shouldWakeupBgEvictor(TierId tid, PoolId pid, ClassId cid) {
+  // TODO: should we also work on lower tiers? should we have separate set of params?
+  if (tid == 1) return false;
+  double usage = getPoolByTid(pid, tid).getApproxUsage(cid);
+  if (((1-usage)*100) <= config_.lowEvictionAcWatermark) {
+    return true;
+  }
   return false;
 }
 

cachelib/allocator/FreeThresholdStrategy.cpp

@@ -34,14 +34,18 @@ std::vector<size_t> FreeThresholdStrategy::calculateBatchSizes(
     std::vector<MemoryDescriptorType> acVec) {
   std::vector<size_t> batches{};
   for (auto [tid, pid, cid] : acVec) {
-    auto stats = cache.getACStats(tid, pid, cid);
-    if ((1-stats.usageFraction())*100 >= highEvictionAcWatermark) {
+    const auto& pool = cache.getPoolByTid(pid, tid);
+    if (pool.getApproxFreeSlabs()) {
       batches.push_back(0);
-    } else {
-      auto toFreeMemPercent = highEvictionAcWatermark - (1-stats.usageFraction())*100;
+    }
+    double usage = pool.getApproxUsage(cid);
+    if ((1-usage)*100 < highEvictionAcWatermark && pool.allSlabsAllocated()) {
+      auto toFreeMemPercent = highEvictionAcWatermark - (1-usage)*100;
       auto toFreeItems = static_cast<size_t>(
-          toFreeMemPercent * (stats.totalSlabs() * Slab::kSize) / stats.allocSize);
+          toFreeMemPercent * (pool.getApproxSlabs(cid) * pool.getPerSlab(cid)) );
       batches.push_back(toFreeItems);
+    } else {
+      batches.push_back(0);
     }
   }
 

cachelib/allocator/PromotionStrategy.h

@@ -38,13 +38,14 @@ class PromotionStrategy : public BackgroundMoverStrategy {
     std::vector<size_t> batches{};
     for (auto [tid, pid, cid] : acVec) {
       XDCHECK(tid > 0);
-      auto stats = cache.getACStats(tid - 1, pid, cid);
-      if ((1-stats.usageFraction())*100 < promotionAcWatermark)
+      const auto& pool = cache.getPoolByTid(pid, tid-1);
+      double usage = pool.getApproxUsage(cid);
+      if ((1-usage)*100 <= promotionAcWatermark)
         batches.push_back(0);
       else {
         auto maxPossibleItemsToPromote = static_cast<size_t>(
-            (promotionAcWatermark - (1-stats.usageFraction())*100) *
-            (stats.totalSlabs() * Slab::kSize) / stats.allocSize);
+            ( (promotionAcWatermark - (1-usage*100) ) *
+              (pool.getApproxSlabs(cid) * pool.getPerSlab(cid)) ) );
         batches.push_back(maxPossibleItemsToPromote);
       }
     }

cachelib/allocator/memory/AllocationClass.cpp

@@ -704,6 +704,30 @@ ACStats AllocationClass::getStats() const {
   });
 }
 
+uint32_t AllocationClass::getPerSlab() const {
+  return getAllocsPerSlab();
+}
+
+uint32_t AllocationClass::getApproxSlabs() const {
+  return allocatedSlabs_.size();
+}
+
+double AllocationClass::getApproxUsage() const {
+  const unsigned long long nSlabsAllocated = allocatedSlabs_.size();
+  if (nSlabsAllocated == 0) {
+      return 0.0;
+  }
+  const unsigned long long perSlab = getAllocsPerSlab();
+  const auto freeAllocsInCurrSlab =
+      canAllocateFromCurrentSlabLocked()
+          ? (Slab::kSize - currOffset_) / allocationSize_
+          : 0;
+  const unsigned long long nFreedAllocs = freedAllocations_.size();
+  const unsigned long long nActiveAllocs =
+      nSlabsAllocated * perSlab - nFreedAllocs - freeAllocsInCurrSlab;
+  return (double) nActiveAllocs / (double) (nSlabsAllocated * perSlab);
+}
+
 void AllocationClass::createSlabReleaseAllocMapLocked(const Slab* slab) {
   // Initialize slab free state
   // Each bit represents whether or not an alloc has already been freed

cachelib/allocator/memory/AllocationClass.h

@@ -97,6 +97,13 @@ class AllocationClass {
   // fetch stats about this allocation class.
   ACStats getStats() const;
 
+  // get approx usage as fraction of used allocs/total allocs in this class
+  double getApproxUsage() const;
+  // get approx slabs in this class
+  uint32_t getApproxSlabs() const;
+  // get items per slabs in this class
+  uint32_t getPerSlab() const;
+
   // Whether the pool is full or free to allocate more in the current state.
   // This is only a hint and not a gurantee that subsequent allocate will
   // fail/succeed.

cachelib/allocator/memory/MemoryAllocatorStats.h

@@ -70,7 +70,7 @@ struct ACStats {
 
     return activeAllocs / (usedSlabs * allocsPerSlab);
   }
-
+  
   constexpr double approxUsage() const noexcept {
     const unsigned long long nSlabsAllocated = usedSlabs;
     if (nSlabsAllocated == 0) {

cachelib/allocator/memory/MemoryPool.cpp

@@ -523,3 +523,22 @@ MPStats MemoryPool::getStats() const {
                  slabsUnAllocated,    nSlabResize_,       nSlabRebalance_,
                  curSlabsAdvised_};
 }
+
+double MemoryPool::getApproxUsage(ClassId cid) const {
+  const auto& ac = getAllocationClassFor(cid);
+  return ac.getApproxUsage();
+}
+
+uint32_t MemoryPool::getApproxFreeSlabs() const {
+  return freeSlabs_.size();
+}
+
+uint32_t MemoryPool::getApproxSlabs(ClassId cid) const {
+  const auto& ac = getAllocationClassFor(cid);
+  return ac.getApproxSlabs();
+}
+
+uint32_t MemoryPool::getPerSlab(ClassId cid) const {
+  const auto& ac = getAllocationClassFor(cid);
+  return ac.getPerSlab();
+}

cachelib/allocator/memory/MemoryPool.h

@@ -132,6 +132,14 @@ class MemoryPool {
   }
 
   MPStats getStats() const;
+  // approx usage fraction per class
+  double getApproxUsage(ClassId cid) const;
+  // approx slabs assigned to a given class
+  uint32_t getApproxSlabs(ClassId cid) const;
+  
+  uint32_t getApproxFreeSlabs() const;
+  // items per slab for a class
+  uint32_t getPerSlab(ClassId cid) const;
 
   // allocates memory of at least _size_ bytes.
   //

cachelib/cachebench/util/CacheConfig.cpp

@@ -177,7 +177,13 @@ std::shared_ptr<BackgroundMoverStrategy> CacheConfig::getBackgroundEvictorStrate
   if (backgroundEvictorIntervalMilSec == 0) {
     return nullptr;
   }
-  return std::make_shared<FreeThresholdStrategy>(lowEvictionAcWatermark, highEvictionAcWatermark, maxEvictionBatch, minEvictionBatch);
+  if (backgroundEvictorStrategy == "threshold") {
+    return std::make_shared<FreeThresholdStrategy>(lowEvictionAcWatermark, highEvictionAcWatermark, maxEvictionBatch, minEvictionBatch);
+  } else if (backgroundEvictorStrategy == "fixed") {
+    return std::make_shared<DefaultBackgroundMoverStrategy>(maxEvictionBatch, highEvictionAcWatermark);
+  } else {
+    return std::make_shared<FreeThresholdStrategy>(lowEvictionAcWatermark, highEvictionAcWatermark, maxEvictionBatch, minEvictionBatch);
+  }
 }
 
 std::shared_ptr<BackgroundMoverStrategy> CacheConfig::getBackgroundPromoterStrategy() const {