Method TestAtCapacity

be/src/codegen/llvm-codegen-cache-test.cc:353–430

Test the situation that the codegen cache hits the limit of capacity, in this case, eviction is needed when new insertion comes.

/// Test the situation that the codegen cache hits the limit of capacity, in this case,
/// eviction is needed when new insertion comes.
void LlvmCodeGenCacheTest::TestAtCapacity(TCodeGenCacheMode::type mode) {
  // Allocates memory for small examples.
  int64_t codegen_cache_capacity = ENGINE_CACHE_SIZE + sizeof(CodeGenObjectCache)
      + sizeof(CodeGenCacheEntry) + CodeGenCacheKey::OptimalKeySize + sizeof(std::string);
  bool is_normal_mode = !CodeGenCacheModeAnalyzer::is_optimal(mode);

  // Create two LlvmCodeGen objects containing a different codegen function separately.
  scoped_ptr<LlvmCodeGen> codegen;

  test_env_->ResetCodegenCache(metrics_.get());
  CodeGenCache* cache = test_env_->codegen_cache();
  EXPECT_OK(cache->Init(codegen_cache_capacity));

  ASSERT_OK(LlvmCodeGen::CreateImpalaCodegen(fragment_state_, nullptr, "test", &codegen));
  AddLlvmCodegenEcho(codegen.get());
  codegen->GenerateFunctionNamesHashCode();
  scoped_ptr<LlvmCodeGen> codegen_double;
  ASSERT_OK(LlvmCodeGen::CreateImpalaCodegen(
      fragment_state_, nullptr, "test_double", &codegen_double));
  AddLlvmCodegenDouble(codegen_double.get());
  codegen_double->GenerateFunctionNamesHashCode();
  CheckObjCacheExists(codegen.get());
  CheckObjCacheExists(codegen_double.get());

  CodeGenCacheKey cache_key_1;
  CodeGenCacheKey cache_key_2;
  string key_1 = "key1";
  string key_2 = "key2";
  CodeGenCacheKeyConstructor::construct(key_1, &cache_key_1);
  CodeGenCacheKeyConstructor::construct(key_2, &cache_key_2);
  int64_t mem_charge_1 = GetMemCharge(codegen.get(), cache_key_1.data(), is_normal_mode);
  int64_t mem_charge_2 = GetMemCharge(codegen.get(), cache_key_2.data(), is_normal_mode);
  // Make sure the memory charge of two keys is larger than capacity for testing the
  // eviction.
  ASSERT_LE(mem_charge_1, codegen_cache_capacity);
  ASSERT_LE(mem_charge_2, codegen_cache_capacity);
  ASSERT_GE(mem_charge_1 + mem_charge_2, codegen_cache_capacity);

  scoped_ptr<MetricGroup> metrics;
  metrics.reset(new MetricGroup("codegen-test-capacity"));
  test_env_->ResetCodegenCache(metrics.get());
  cache = test_env_->codegen_cache();
  EXPECT_OK(cache->Init(codegen_cache_capacity));

  // Expect init metrics.
  CheckMetrics(cache, 0 /*hit*/, 0 /*miss*/, 0 /*evict*/);

  // Store key_1 and lookup.
  EXPECT_OK(codegen->StoreCache(cache_key_1));
  EXPECT_TRUE(codegen->LookupCache(cache_key_1));
  CheckResult(codegen.get());
  CheckMetrics(cache, 1 /*hit*/, 0 /*miss*/, 0 /*evict*/);

  // Store key_2, key_1 should be evicted due to hitting the capaticy limit.
  EXPECT_OK(codegen_double->StoreCache(cache_key_2));
  CheckMetrics(cache, 1 /*hit*/, 0 /*miss*/, 1 /*evict*/);

  // Lookup key_1, should be gone. Lookup key_2, should be successful.