Method evict

bolt/common/caching/AsyncDataCache.cpp:382–488

}

uint64_t CacheShard::evict(
    uint64_t bytesToFree,
    bool evictAllUnpinned,
    MachinePageCount pagesToAcquire,
    memory::Allocation& acquired) {
  auto* ssdCache = cache_->ssdCache();
  const bool skipSsdSaveable = ssdCache && ssdCache->writeInProgress();
  auto now = accessTime();
  std::vector<memory::Allocation> toFree;
  int64_t tinyEvicted = 0;
  int64_t largeEvicted = 0;
  int32_t evictSaveableSkipped = 0;
  {
    std::lock_guard<std::mutex> l(mutex_);
    const size_t size = entries_.size();
    if (size == 0) {
      return 0;
    }
    int32_t counter = 0;
    int32_t numChecked = 0;
    auto entryIndex = (clockHand_ % size);
    auto iter = entries_.begin() + entryIndex;
    while (++counter <= size) {
      if (++iter == entries_.end()) {
        iter = entries_.begin();
        entryIndex = 0;
      } else {
        ++entryIndex;
      }

      ++numEvictChecks_;
      ++clockHand_;
      auto candidate = iter->get();
      if (candidate == nullptr) {
        continue;
      }

      ++numChecked;
      if (evictionThreshold_ == kNoThreshold ||
          eventCounter_ > entries_.size() / 4 ||
          numChecked > entries_.size() / 8) {
        now = accessTime();
        calibrateThreshold();
        numChecked = 0;
        eventCounter_ = 0;
      }

      int32_t score = 0;
      if (candidate->numPins_ == 0 &&
          (!candidate->key_.fileNum.hasValue() || evictAllUnpinned ||
           (score = candidate->score(now)) >= evictionThreshold_)) {
        // split cacheable_ -> cacheEntry(candidate) cacheable_ -> （can skip
        // cache_->saveToSsd() method）->Compliant with soft affinity strategy
        if (skipSsdSaveable && candidate->cacheable_ &&
            candidate->ssdSaveable_ && !evictAllUnpinned) {
          ++evictSaveableSkipped;
          continue;
        }