Method Lookup

be/src/runtime/tuple-cache-mgr.cc:362–402

If the entry exists, the Handle pins it so it doesn't go away, but the entry may be in any state (IN PROGRESS, TOMBSTONE, COMPLETE_UNSYNCED, COMPLETE). If the entry doesn't exist and acquire_write is true, it's created with the state IN_PROGRESS.

// any state (IN PROGRESS, TOMBSTONE, COMPLETE_UNSYNCED, COMPLETE). If the entry doesn't
// exist and acquire_write is true, it's created with the state IN_PROGRESS.
TupleCacheMgr::UniqueHandle TupleCacheMgr::Lookup(
    const Slice& key, bool acquire_write) {
  if (!enabled_) return nullptr;

  UniqueHandle handle{new Handle()};
  if (Cache::UniqueHandle pos = cache_->Lookup(key); pos) {
    handle->cache_handle = move(pos);
  } else if (acquire_write) {
    lock_guard<mutex> guard(creation_lock_);
    // Retry lookup under the creation lock in case another thread added an entry.
    if (Cache::UniqueHandle pos = cache_->Lookup(key); pos) {
      handle->cache_handle = move(pos);
    } else {
      // Entry not found, create a new one.
      filesystem::path path =
          filesystem::path(cache_dir_) / (CACHE_FILE_PREFIX + key.ToString());
      Cache::UniquePendingHandle pending = CreateEntry(cache_.get(), key, path.string());
      if (UNLIKELY(!pending || debug_pos_ & DebugPos::FAIL_ALLOCATE)) {
        VLOG_FILE << "Tuple Cache: CreateEntry failed for " << path;
        return handle;
      }

      // Insert into the cache. If immediately evicted, evict_callback_ handles cleanup
      // and decrements the counter.
      tuple_cache_entries_in_use_->Increment(1);
      Cache::UniqueHandle chandle = cache_->Insert(move(pending), this);
      if (UNLIKELY(!chandle || debug_pos_ & DebugPos::FAIL_INSERT)) {
        // This shouldn't happen normally because the cache is recency-based and initial
        // handle is small.
        LOG(WARNING) << "Tuple Cache Entry was immediately evicted";
        return handle;
      }
      VLOG_FILE << "Tuple Cache Entry created for " << path;
      handle->cache_handle = move(chandle);
      handle->is_writer = true;
      handle->base_charge = sizeof(TupleCacheEntry) + path.size() + 1;
    }
  }

  return handle;
}

bool TupleCacheMgr::IsAvailableForRead(UniqueHandle& handle) const {
  if (!handle || !handle->cache_handle) return false;