Method Insert

be/src/util/cache/lirs-cache.cc:1023–1091

}

HandleBase* LIRSCacheShard::Insert(HandleBase* e_in,
    Cache::EvictionCallback *eviction_callback) {
  DCHECK(initialized_);
  LIRSHandle* e = static_cast<LIRSHandle*>(e_in);
  CHECK_EQ(e->state(), UNINITIALIZED);
  // Set the remaining LIRSHandle members which were not already set in the constructor.
  e->eviction_callback_ = eviction_callback;
  // The caller has already stored the value in the handle (and any underlying storage).
  // Whether the Insert() is ultimately successful or not, this handle is currently
  // resident.
  e->set_resident();

  // Insert() can fail. A failed insert is equivalent to a successful insert followed
  // by an immediate eviction of that entry, so much of the setup code is identical.
  bool success = true;
  LIRSThreadState tstate;
  {
    std::lock_guard<MutexType> l(mutex_);

    // Cases:
    // 1. There is no existing entry.
    // 2. There is a tombstone entry.
    // 3. There is a non-tombstone entry (rare)
    // In any case, the existing entry will be replaced, so go ahead and remove it.
    LIRSHandle* existing_entry =
        static_cast<LIRSHandle*>(table_.Remove(e->key(), e->hash()));

    // The entry is always resident at the start of Insert(), so incorporate this
    // entry's charge into the memtracker. If Insert() fails, this is decremented as
    // part of eviction.
    UpdateMemTracker(e->charge());
    // All of these paths can result in evictions
    if (existing_entry != nullptr) {
      // Priorities are modified in Lookup, but priorities are not changed in Insert.
      // The exception is TOMBSTONE entries, which are not impacted by Lookup.
      // So:
      // 1. TOMBSTONE becomes PROTECTED.
      // 2. PROTECTED remains PROTECTED.
      // 3. UNPROTECTED remains UNPROTECTED.
      LIRSState existing_state = existing_entry->state();
      ToUninitialized(&tstate, existing_entry);
      if (existing_state == PROTECTED || existing_state == TOMBSTONE) {
        UninitializedToProtected(&tstate, e);
      } else {
        DCHECK_EQ(existing_state, UNPROTECTED);
        // UninitializedToUnprotected can fail (i.e. the entry inserted may not remain
        // in the cache).
        success = UninitializedToUnprotected(&tstate, e);
      }
    } else if (protected_usage_ + e->charge() <= protected_capacity_) {
      // There is available space in the protected area, so add it directly there.
      UninitializedToProtected(&tstate, e);
    } else {
      // UninitializedToUnprotected can fail (i.e. the entry inserted may not remain in
      // the cache).
      success = UninitializedToUnprotected(&tstate, e);
    }
    // If success=false, the entry is scheduled for eviction and won't be returned.