Method UpdateCharge

be/src/util/cache/lirs-cache.cc:956–995

}

void LIRSCacheShard::UpdateCharge(HandleBase* handle, size_t charge) {
  DCHECK(initialized_);
  LIRSThreadState tstate;
  {
    // Hold the lock to avoid concurrent evictions
    std::lock_guard<MutexType> l(mutex_);
    LIRSHandle* e = static_cast<LIRSHandle*>(handle);
    // Entries that are UNINITIALIZED or TOMBSTONE do not count towards
    // the usage and will be destroyed without interacting with the usage.
    // Skip modifying the charge.
    //
    // In the case of UNINITIALIZED, we know that the caller has a handle
    // for the entry, so it needs to have been in the cache previously
    // (i.e. it was found via Lookup() or added via Insert()). So, in this
    // context, UNINITIALIZED can only mean that it has been evicted.
    if (e->state() == UNINITIALIZED || e->state() == TOMBSTONE) {
      return;
    }
    DCHECK(e->state() == PROTECTED || e->state() == UNPROTECTED);
    int64_t delta = charge - handle->charge();
    handle->set_charge(charge);
    UpdateMemTracker(delta);
    // Update usage in existing state, then evict as needed.
    switch (e->state()) {
    case PROTECTED:
      protected_usage_ += delta;
      EnforceProtectedCapacity(&tstate);
      break;
    case UNPROTECTED:
      unprotected_usage_ += delta;
      EnforceUnprotectedCapacity(&tstate);
      break;
    default:
      // This can't happen.
      CHECK(false) << "Unexpected state for UpdateCharge: " << e->state();
      break;
    }
  }
  CleanupThreadState(&tstate);
}

void LIRSCacheShard::Release(HandleBase* handle) {
  DCHECK(initialized_);