Method CreateHashTable

be/src/benchmarks/hash-table-benchmark.cc:166–204

Construct hash table and buffer pool client. Created objects and resources (e.g. reservations) are automatically freed in TearDown().

  /// Created objects and resources (e.g. reservations) are automatically freed
  /// in TearDown().
  bool CreateHashTable(int64_t block_size = 8 * 1024 * 1024, int max_num_blocks = 100,
      int initial_reserved_blocks = 10, int64_t suballocator_buffer_len = 64 * 1024) {
    ExecEnv* exec_env = test_env_->exec_env();
    BufferPool* buffer_pool = exec_env->buffer_pool();
    RuntimeProfile* profile = RuntimeProfile::Create(&pool_, "ht");

    // Set up memory tracking for the hash table.
    MemTracker* client_tracker =
        pool_.Add(new MemTracker(-1, "client", runtime_state_->instance_mem_tracker()));
    int64_t initial_reservation_bytes = block_size * initial_reserved_blocks;
    int64_t max_reservation_bytes = block_size * max_num_blocks;

    // Set up the memory allocator.
    BufferPool::ClientHandle* client = pool_.Add(new BufferPool::ClientHandle);
    clients_.push_back(client);
    Status status = buffer_pool->RegisterClient("htbenchmark", nullptr,
        runtime_state_->instance_buffer_reservation(), client_tracker,
        max_reservation_bytes, profile, client);
    if (!status.ok()) {
      std::cout << "Registering client to buffer pool failed" << std::endl;
      return false;
    }
    bool success = client->IncreaseReservation(initial_reservation_bytes);
    if (!success) {
      std::cout << "Client increasing reservation failed" << std::endl;
      return false;
    }
    Suballocator* allocator =
        pool_.Add(new Suballocator(buffer_pool, client, suballocator_buffer_len));

    int64_t max_num_buckets = 1L << 31;
    hash_table_ = pool_.Add(HashTable::Create(
        allocator, true, 1, nullptr, max_num_buckets, initial_num_buckets));
    status = hash_table_->Init(&success);
    if (!(status.ok() && success)) {
      std::cout << "HashTable Init failed" << std::endl;
    }
    return status.ok() && success;
  }
  TupleRow* CreateTupleRow(int32_t val) {
    uint8_t* tuple_row_mem = mem_pool_.Allocate(sizeof(int32_t*));
    Tuple* tuple_mem = Tuple::Create(sizeof(char) + sizeof(int32_t), &mem_pool_);