Method Store

be/src/codegen/llvm-codegen-cache.cc:191–221

}

Status CodeGenCache::Store(const CodeGenCacheKey& cache_key, LlvmCodeGen* codegen,
    TCodeGenCacheMode::type mode, TCodeGenOptLevel::type opt_level) {
  DCHECK(!is_closed_);
  DCHECK(cache_ != nullptr);
  DCHECK(codegen != nullptr);
  Status status = Status::OK();
  pair<unordered_set<CodeGenCacheKey::HashCode>::iterator, bool> key_to_insert_it;
  {
    // The Cache::Insert() suggests the caller to avoid multiple handles for the same
    // key to insert because it can be inefficient to keep the entry from being evicted.
    // So use the keys_to_insert_ set to reduce the chance of multiple insertion of the
    // same cache entry.
    // Before insertion, we will try to insert the hash code of the key to the set, if
    // succeeds, the thread is allowed to do the insertion, and is responsible to erase
    // the hash code in the set when insertion finishes.
    // Otherwise, if the thread fails to insert the hash code, that means one other thread
    // is doing the insertion on the same key, in that case, the current thread would give
    // up the task and return with an okay status, because we assume the other thread
    // would get the cache entry in. Even that thread fails, the system won't hurt without
    // only one cache entry, and the cache entry can be inserted again next time.
    lock_guard<mutex> lock(to_insert_set_lock_);
    key_to_insert_it = keys_to_insert_.insert(cache_key.hash_code());
    // If hash code exists, return an okay immediately.
    if (!key_to_insert_it.second) return status;
  }
  status = StoreInternal(cache_key, codegen, mode, opt_level);
  // Remove the hash code of the key from the to_insert_keys set.
  lock_guard<mutex> lock(to_insert_set_lock_);
  keys_to_insert_.erase(key_to_insert_it.first);
  return status;
}

void CodeGenCache::StoreEngine(LlvmCodeGen* codegen) {
  DCHECK(codegen != nullptr);