Method UnprotectedToTombstone

be/src/util/cache/lirs-cache.cc:715–752

}

void LIRSCacheShard::UnprotectedToTombstone(LIRSThreadState* tstate, LIRSHandle* e) {
  // Decrement unprotected usage
  DCHECK(e->unprotected_tombstone_list_hook_.is_linked());
  DCHECK(e->recency_list_hook_.is_linked());

  // Optimized code to go from UNPROTECTED to TOMBSTONE without adding/removing
  // it from a list. Only the unprotected_list_front_ moves.
  DCHECK_EQ(e, unprotected_list_front_);
  if (num_unprotected_ > 1) {
    // There is some other UNPROTECTED entry
    auto it = unprotected_tombstone_list_.iterator_to(*e);
    ++it;
    unprotected_list_front_ = &*it;
  } else {
    // This was the only UNPROTECTED entry, the unprotected list is empty
    unprotected_list_front_ = nullptr;
  }

  // Set state to TOMBSTONE. If there are currently no references, this thread is
  // responsible for eviction, so it must also set the residency to EVICTING.
  auto state_transition = e->modify_atomic_state([](AtomicState& cur_state) {
      DCHECK_EQ(cur_state.state, UNPROTECTED);
      DCHECK_EQ(cur_state.residency, RESIDENT);
      cur_state.state = TOMBSTONE;
      if (cur_state.ref_count == 0) cur_state.residency = EVICTING;
    });
  // Look at the old state. If there are no references, then we can immediately evict.
  if (state_transition.before.ref_count == 0) {
    tstate->handles_to_evict.push_back(e);
  }
  // List operations happen before changes to the counts/usage
  --num_unprotected_;
  ++num_tombstones_;

  // This will be evicted, so the charge disappears
  unprotected_usage_ -= e->charge();
  EnforceTombstoneLimit(tstate);
}

void LIRSCacheShard::UninitializedToProtected(LIRSThreadState* tstate, LIRSHandle* e) {
  DCHECK(!e->unprotected_tombstone_list_hook_.is_linked());