Method Lookup

be/src/util/cache/lirs-cache.cc:897–954

}

HandleBase* LIRSCacheShard::Lookup(const Slice& key, uint32_t hash,
    bool no_updates) {
  DCHECK(initialized_);
  LIRSHandle* e;
  LIRSThreadState tstate;
  {
    std::lock_guard<MutexType> l(mutex_);
    e = static_cast<LIRSHandle*>(table_.Lookup(key, hash));
    if (e != nullptr) {
      CHECK_NE(e->state(), UNINITIALIZED);
      // If the handle is a TOMBSTONE, Lookup() should pretend the entry doesn't exist.
      // TOMBSTONE has special treatment in Insert(); no other action is necessary here.
      if (e->state() == TOMBSTONE) return nullptr;
      e->get_reference();
      // If this is a no update lookup, nothing has changed. We can just return the
      // entry.
      if (no_updates) return e;
      switch (e->state()) {
      case UNINITIALIZED:
        // Needed to keep clang-tidy happy
        CHECK(false);
      case PROTECTED:
        // The PROTECTED entry is in the recency list, and the only action is to make
        // it the most recent element in the list. This can result in evictions if it is
        // currently the oldest entry.
        MoveToRecencyListBack(&tstate, e);
        break;
      case UNPROTECTED:
        if (e->recency_list_hook_.is_linked()) {
          // If an UNPROTECTED entry is in the recency list when it is referenced,
          // then we know that its new reuse distance is shorter than the last PROTECTED
          // entry in the list. So, this entry is upgraded from UNPROTECTED to
          // PROTECTED.
          UnprotectedToProtected(&tstate, e);
        } else {
          // If an UNPROTECTED entry is not on the recency list, then its new reuse
          // distance is longer than any of the PROTECTED entries. So, it remains
          // an UNPROTECTED entry, but it should be added back to the recency list and
          // readded as the most recent entry on the unprotected list.
          DCHECK_GT(num_unprotected_, 0);
          MoveToRecencyListBack(&tstate, e, false);
          if (num_unprotected_ != 1) {
            RemoveFromUnprotectedList(e);
            AddToUnprotectedList(e);
          }
        }
        break;
      default:
        CHECK(false) << "Unexpected state for Lookup: " << e->state();
      }
    }
  }

  // This happens when not holding the mutex for performance reasons.
  CleanupThreadState(&tstate);

  return e;
}