initial impl of bkgrd eviction

Author: byrnedj

cachelib/allocator/BackgroundEvictor-inl.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Intel and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+namespace facebook {
+namespace cachelib {
+
+
+template <typename CacheT>
+BackgroundEvictor<CacheT>::BackgroundEvictor(Cache& cache,
+                               std::shared_ptr<BackgroundEvictorStrategy> strategy,
+                               unsigned int tid)
+    : cache_(cache),
+      strategy_(strategy),
+      tid_(tid) {
+
+}
+
+template <typename CacheT>
+BackgroundEvictor<CacheT>::~BackgroundEvictor() { stop(std::chrono::seconds(0)); }
+
+template <typename CacheT>
+void BackgroundEvictor<CacheT>::work() {
+  try {
+    for (const auto pid : cache_.getRegularPoolIds()) {
+      //check if we exceed threshold (per class basis static right now)
+      checkAndRun(pid);
+    }
+  } catch (const std::exception& ex) {
+    XLOGF(ERR, "BackgroundEvictor interrupted due to exception: {}", ex.what());
+  }
+}
+
+
+// Look for classes that exceed the target memory capacity
+// and return those for eviction
+template <typename CacheT>
+void BackgroundEvictor<CacheT>::checkAndRun(PoolId pid) {
+    
+  const auto& mpStats = cache_.getPoolByTid(pid,tid_).getStats();
+  for (auto& cid : mpStats.classIds) {
+    if (strategy_->shouldEvict(cache_,tid_,pid,cid)) {
+        unsigned int batch = strategy_->calculateBatchSize(cache_,tid_,pid,cid);
+        //try evicting BATCH items from the class in order to reach free target
+        unsigned int evicted = 
+            BackgroundEvictorAPIWrapper<CacheT>::traverseAndEvictItems(cache_,
+                tid_,pid,cid,batch);
+        numEvictedItems_ += evicted;
+    }
+  }
+  runCount_ = runCount_ + 1;
+}
+
+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);
+  return stats;
+}
+
+} // namespace cachelib
+} // namespace facebook

cachelib/allocator/BackgroundEvictor.cpp

@@ -18,37 +18,61 @@
 
 #include <gtest/gtest_prod.h>
 
-#include "cachelib/allocator/Cache.h"
 #include "cachelib/allocator/CacheStats.h"
 #include "cachelib/common/PeriodicWorker.h"
+#include "cachelib/allocator/BackgroundEvictorStrategy.h"
+
 
 namespace facebook {
 namespace cachelib {
 
+// wrapper that exposes the private APIs of CacheType that are specifically
+// needed for the eviction.
+template <typename C>
+struct BackgroundEvictorAPIWrapper {
+
+  static unsigned int traverseAndEvictItems(C& cache,
+          unsigned int tid, unsigned int pid, unsigned int cid, unsigned int batch) {
+    return cache.traverseAndEvictItems(tid,pid,cid,batch);
+  }
+};
+
 // Periodic worker that evicts items from tiers in batches
 // The primary aim is to reduce insertion times for new items in the
 // cache
+template <typename CacheT>
 class BackgroundEvictor : public PeriodicWorker {
  public:
+  using Cache = CacheT;
   // @param cache               the cache interface
   // @param target_free         the target amount of memory to keep free in 
   //                            this tier
   // @param tier id             memory tier to perform eviction on 
-  BackgroundEvictor(CacheBase& cache,
-                    double targetFree
+  BackgroundEvictor(Cache& cache,
+                    std::shared_ptr<BackgroundEvictorStrategy> strategy,
                     unsigned int tid);
 
   ~BackgroundEvictor() override;
 
+  BackgroundEvictorStats getStats() const noexcept;
 
  private:
   // cache allocator's interface for evicting
-  CacheBase& cache_;
-  double targetFree_;
+  
+  using Item = typename Cache::Item;
+  
+  Cache& cache_;
+  std::shared_ptr<BackgroundEvictorStrategy> strategy_;
   unsigned int tid_;
 
   // implements the actual logic of running the background evictor
-  void work() final;
+  void work() override final;
+  void checkAndRun(PoolId pid);
+  
+  std::atomic<uint64_t> numEvictedItems_{0};
+  std::atomic<uint64_t> runCount_{0};
 };
 } // namespace cachelib
 } // namespace facebook
+
+#include "cachelib/allocator/BackgroundEvictor-inl.h"

cachelib/allocator/BackgroundEvictor.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cachelib/allocator/BackgroundEvictorStrategy.h"
+
+#include <folly/logging/xlog.h>
+
+namespace facebook {
+namespace cachelib {
+
+
+bool BackgroundEvictorStrategy::shouldEvict(const CacheBase& cache,
+                                       unsigned int tid,
+                                       PoolId pid,
+                                       ClassId cid ) {
+  return true;
+}
+
+
+unsigned int BackgroundEvictorStrategy::calculateBatchSize(const CacheBase& cache,
+                                       unsigned int tid,
+                                       PoolId pid,
+                                       ClassId cid ) {
+  return 1;
+}
+
+
+} // namespace cachelib
+} // namespace facebook

cachelib/allocator/BackgroundEvictorStrategy.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "cachelib/allocator/Cache.h"
+
+namespace facebook {
+namespace cachelib {
+
+//struct RebalanceContext {
+//  // Victim and Receiver must belong to the same pool
+//  ClassId victimClassId{Slab::kInvalidClassId};
+//  ClassId receiverClassId{Slab::kInvalidClassId};
+//
+//  RebalanceContext() = default;
+//  RebalanceContext(ClassId victim, ClassId receiver)
+//      : victimClassId(victim), receiverClassId(receiver) {}
+//};
+
+// Base class for background eviction strategy.
+class BackgroundEvictorStrategy {
+
+public:
+  BackgroundEvictorStrategy() {}
+
+  ~BackgroundEvictorStrategy() {}
+
+  unsigned int calculateBatchSize(const CacheBase& cache,
+                                       unsigned int tid,
+                                       PoolId pid,
+                                       ClassId cid );
+
+  bool shouldEvict(const CacheBase& cache,
+                                       unsigned int tid,
+                                       PoolId pid,
+                                       ClassId cid );
+
+
+};
+
+} // namespace cachelib
+} // namespace facebook