update before rebase

Author: byrnedj

BUILD.md

@@ -243,6 +243,10 @@ Use the `-O` option to skip the installation of system packages, e.g.
 As all dependencies use `git/cmake/make`, rebuilding the same code (if there
 were no updates) will be very fast.
 
+Note - fmt library might fail a static assert - in this case it is recommended
+to use commit c5dce1caf9fc8dff4e309683252fee5fbc0b6c2b from the fmt repository
+with the following command in the cachelib/external/fmt directory:
+`git reset --hard c5dce1caf9fc8dff4e309683252fee5fbc0b6c2b`
 
 ## Downloading the source code without building
 

cachelib/CMakeLists.txt

@@ -314,7 +314,7 @@ install(
     PATTERN "CMakeFiles" EXCLUDE
 )
 
-
+include(sanitizers)
 # Install CMake package configuration files for cachelib
 # TODO: @ONLY?
 include(CMakePackageConfigHelpers)

cachelib/allocator/BackgroundEvictor.cpp

@@ -0,0 +1,139 @@
+/*
+ * 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.
+ */
+
+#include "cachelib/allocator/BackgroundEvictor.h"
+
+#include <folly/logging/xlog.h>
+
+#include <stdexcept>
+#include <thread>
+
+namespace facebook {
+namespace cachelib {
+
+BackgroundEvictor::BackgroundEvictor(CacheBase& cache,
+                               double targetFree,
+                               unsigned int tid)
+    : cache_(cache),
+      targetFree_(targetFree),
+      tid_(tid) {
+
+}
+
+BackgroundEvictor::~BackgroundEvictor() { stop(std::chrono::seconds(0)); }
+
+void BackgroundEvictor::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
+std::vector<ClassId> BackgrounEvictor::checkAndRun(PoolId pid) const {
+  std::vector<ClassId> classesToEvict;
+  const auto& mpStats = cache_.getPool(pid).getStats();
+  for (auto& id : mpStats.classIds) {
+    size_t totalMem = mpStats.acStats.at(id,tid_).getTotalMemory();
+    size_t freeMem = mpStats.acStats.at(id,tid_).getTotalFreeMemory();
+    double currFree = (double)freeMem/(double)totalMem;
+
+    if (currFree < targetFree_) {
+        size_t targetMem = (targetFree_ * totalMem) - freeMem;
+        size_t batch = (targetMem / mpStats.acStats.at(id,tid_).allocSize);
+        //try evicting BATCH items from the class in order to reach free target
+        tryEvicting(pid,cid,batch);
+    }
+  }
+}
+
+//
+//try evicting a batch of items from a class that is over memory target
+//
+void BackgroundEvictor::tryEvicting(PoolId pid, ClassId cid, size_t batch) {
+  auto& mmContainter = getMMContainer(tid_,pid,cid);
+  // Keep searching for a candidate until we were able to evict it
+  // or until the search limit has been exhausted
+  unsigned int evictions = 0;
+  auto itr = mmContainer.getEvictionIterator();
+  while (evictions < batch && itr) {
+
+    Item* candidate = itr.get();
+    // for chained items, the ownership of the parent can change. We try to
+    // evict what we think as parent and see if the eviction of parent
+    // recycles the child we intend to.
+    
+    ItemHandle toReleaseHandle = tryEvictToNextMemoryTier(tid_, pid, itr);
+    bool movedToNextTier = false;
+    if(toReleaseHandle) {
+      movedToNextTier = true;
+    } else {
+      toReleaseHandle =
+          itr->isChainedItem()
+              ? advanceIteratorAndTryEvictChainedItem(tid_, pid, itr)
+              : advanceIteratorAndTryEvictRegularItem(tid_, pid, mmContainer, itr);
+    }
+
+    if (toReleaseHandle) {
+      if (toReleaseHandle->hasChainedItem()) {
+        (*stats_.chainedItemEvictions)[pid][cid].inc();
+      } else {
+        (*stats_.regularItemEvictions)[pid][cid].inc();
+      }
+      ++evictions;
+
+
+      // we must be the last handle and for chained items, this will be
+      // the parent.
+      XDCHECK(toReleaseHandle.get() == candidate || candidate->isChainedItem());
+      XDCHECK_EQ(1u, toReleaseHandle->getRefCount());
+
+      // We manually release the item here because we don't want to
+      // invoke the Item Handle's destructor which will be decrementing
+      // an already zero refcount, which will throw exception
+      auto& itemToRelease = *toReleaseHandle.release();
+
+      // Decrementing the refcount because we want to recycle the item
+      const auto ref = decRef(itemToRelease);
+      XDCHECK_EQ(0u, ref);
+      
+      // check if by releasing the item we intend to, we actually
+      // recycle the candidate.
+      releaseBackToAllocator(itemToRelease, RemoveContext::kEviction,
+                            /* isNascent */ movedToNextTier, candidate);
+
+    }
+
+    // If we destroyed the itr to possibly evict and failed, we restart
+    // from the beginning again
+    if (!itr) {
+      itr.resetToBegin();
+    }
+  }
+  // Invalidate iterator since later on we may use this mmContainer
+  // again, which cannot be done unless we drop this iterator
+  itr.destroy();
+
+}
+
+} // namespace cachelib
+} // namespace facebook

cachelib/allocator/BackgroundEvictor.h

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <gtest/gtest_prod.h>
+
+#include "cachelib/allocator/Cache.h"
+#include "cachelib/allocator/CacheStats.h"
+#include "cachelib/common/PeriodicWorker.h"
+
+namespace facebook {
+namespace cachelib {
+
+// Periodic worker that evicts items from tiers in batches
+// The primary aim is to reduce insertion times for new items in the
+// cache
+class BackgroundEvictor : public PeriodicWorker {
+ public:
+  // @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
+                    unsigned int tid);
+
+  ~BackgroundEvictor() override;
+
+
+ private:
+  // cache allocator's interface for evicting
+  CacheBase& cache_;
+  double targetFree_;
+  unsigned int tid_;
+
+  // implements the actual logic of running the background evictor
+  void work() final;
+};
+} // namespace cachelib
+} // namespace facebook

cachelib/allocator/MMLruApprox-inl.h

@@ -0,0 +1,149 @@
+/*
+ * 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.
+ */
+
+namespace facebook {
+namespace cachelib {
+namespace detail {
+template <typename T>
+bool areBytesSame(const T& one, const T& two) {
+  return std::memcmp(&one, &two, sizeof(T)) == 0;
+}
+} // namespace detail
+
+/* Container Interface Implementation */
+template <typename T, MMLruApproxApprox::Hook<T> T::*HookPtr>
+MMLruApprox::Container<T, HookPtr>::Container(serialization::MMLruApproxObject object,
+                                        PtrCompressor compressor)
+    : compressor_(std::move(compressor)),
+      lru_(*object.lru_ref(), compressor_),
+      insertionPoint_(compressor_.unCompress(
+          CompressedPtr{*object.compressedInsertionPoint_ref()})),
+      tailSize_(*object.tailSize_ref()),
+      config_(*object.config_ref()) {
+  lruRefreshTime_ = config_.lruRefreshTime;
+  nextReconfigureTime_ = config_.mmReconfigureIntervalSecs.count() == 0
+                             ? std::numeric_limits<Time>::max()
+                             : static_cast<Time>(util::getCurrentTimeSec()) +
+                                   config_.mmReconfigureIntervalSecs.count();
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+bool MMLruApprox::Container<T, HookPtr>::recordAccess(T& node,
+                                                AccessMode mode) noexcept {
+  if ((mode == AccessMode::kWrite && !config_.updateOnWrite) ||
+      (mode == AccessMode::kRead && !config_.updateOnRead)) {
+    return false;
+  }
+
+  const auto curr = static_cast<Time>(util::getCurrentTimeSec());
+  // check if the node is still being memory managed
+  if (node.isInMMContainer() &&
+      ((curr >= getUpdateTime(node) +
+                    lruRefreshTime_.load(std::memory_order_relaxed)) ||
+       !isAccessed(node))) {
+    if (!isAccessed(node)) {
+      markAccessed(node);
+    }
+
+    auto func = [this, &node, curr]() {
+      if (node.isInMMContainer()) {
+        setUpdateTime(node, curr);
+      }
+    };
+
+    return true;
+  }
+  return false;
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+cachelib::EvictionAgeStat MMLruApprox::Container<T, HookPtr>::getEvictionAgeStat(
+    uint64_t projectedLen) const noexcept {
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+cachelib::EvictionAgeStat
+MMLruApprox::Container<T, HookPtr>::getEvictionAgeStatLocked(
+    uint64_t projectedLength) const noexcept {
+  EvictionAgeStat stat{};
+  const auto currTime = static_cast<Time>(util::getCurrentTimeSec());
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+void MMLruApprox::Container<T, HookPtr>::setConfig(const Config& newConfig) {
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+typename MMLruApprox::Config MMLruApprox::Container<T, HookPtr>::getConfig() const {
+    return;
+}
+
+//template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+//bool MMLruApprox::Container<T, HookPtr>::add(T& node) noexcept {
+//  const auto currTime = static_cast<Time>(util::getCurrentTimeSec());
+//
+//  if (node.isInMMContainer()) {
+//    return false;
+//  }
+//  node.markInMMContainer();
+//  setUpdateTime(node, currTime);
+//  unmarkAccessed(node);
+//  return true;
+//}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+typename MMLruApprox::Container<T, HookPtr>::Iterator
+MMLruApprox::Container<T, HookPtr>::getEvictionIterator() const noexcept {
+  //LockHolder l(*lruMutex_);
+  //return Iterator{std::move(l), lru_.rbegin()};
+  //generate a set of candidates for eviction
+
+}
+
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+serialization::MMLruApproxObject MMLruApprox::Container<T, HookPtr>::saveState()
+    const noexcept {
+  serialization::MMLruApproxConfig configObject;
+  *configObject.lruRefreshTime_ref() =
+      lruRefreshTime_.load(std::memory_order_relaxed);
+  *configObject.lruRefreshRatio_ref() = config_.lruRefreshRatio;
+  *configObject.updateOnWrite_ref() = config_.updateOnWrite;
+  *configObject.updateOnRead_ref() = config_.updateOnRead;
+  *configObject.tryLockUpdate_ref() = config_.tryLockUpdate;
+  *configObject.lruInsertionPointSpec_ref() = config_.lruInsertionPointSpec;
+
+  serialization::MMLruApproxObject object;
+  *object.config_ref() = configObject;
+  *object.compressedInsertionPoint_ref() =
+      compressor_.compress(insertionPoint_).saveState();
+  *object.tailSize_ref() = tailSize_;
+  *object.lru_ref() = lru_.saveState();
+  return object;
+}
+
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+MMContainerStat MMLruApprox::Container<T, HookPtr>::getStats() const noexcept {
+}
+
+
+// Iterator Context Implementation
+template <typename T, MMLruApprox::Hook<T> T::*HookPtr>
+MMLruApprox::Container<T, HookPtr>::Iterator::Iterator(
+    LockHolder l, const typename LruList::Iterator& iter) noexcept
+    : LruList::Iterator(iter), l_(std::move(l)) {}
+} // namespace cachelib
+} // namespace facebook