Method GrowTableTest

be/src/exec/hash-table-test.cc:463–550

This test continues adding tuples to the hash table and exercises the resize code paths.

  // This test continues adding tuples to the hash table and exercises the resize code
  // paths.
  void GrowTableTest(bool quadratic) {
    uint64_t num_to_add = 4;
    int expected_size = 0;

    // Need enough memory for two hash table bucket directories during resize.
    const int64_t mem_limit_mb = 128 + 64;
    HashTable* hash_table;
    ASSERT_TRUE(
        CreateHashTable(quadratic, num_to_add, &hash_table, 1024 * 1024, mem_limit_mb));
    scoped_ptr<HashTableCtx> ht_ctx;
    Status status = HashTableCtx::Create(&pool_, runtime_state_, build_exprs_,
        probe_exprs_, false /* !stores_nulls_ */,
        vector<bool>(build_exprs_.size(), false), 1, 0, 1, &mem_pool_, &mem_pool_,
        &mem_pool_, &ht_ctx);
    EXPECT_OK(status);

    // Inserts num_to_add + (num_to_add^2) + (num_to_add^4) + ... + (num_to_add^20)
    // entries. When num_to_add == 4, then the total number of inserts is 4194300.
    int build_row_val = 0;
    for (int i = 0; i < 20; ++i) {
      bool success;
      EXPECT_OK(hash_table->CheckAndResize(num_to_add, ht_ctx.get(), &success));
      EXPECT_TRUE(success) << " failed to resize: " << num_to_add << "\n"
                           << tracker_.LogUsage(MemTracker::UNLIMITED_DEPTH) << "\n"
                           << clients_.back()->DebugString();
      for (int j = 0; j < num_to_add; ++build_row_val, ++j) {
        TupleRow* row = CreateTupleRow(build_row_val);
        if (!ht_ctx->EvalAndHashBuild(row)) continue;
        BufferedTupleStream::FlatRowPtr dummy_flat_row = nullptr;
        EXPECT_TRUE(hash_table->stores_tuples_);
        bool inserted = hash_table->Insert(ht_ctx.get(), dummy_flat_row, row, &status);
        ASSERT_OK(status);
        if (!inserted) goto done_inserting;
      }
      expected_size += num_to_add;
      num_to_add *= 2;
    }
  done_inserting:
    EXPECT_EQ(hash_table->size(), 4194300);

    // The next allocation should put us over the limit, since we'll need 128MB for
    // the old buckets and 256MB for the new buckets.
    bool success;
    EXPECT_OK(hash_table->CheckAndResize(num_to_add * 2, ht_ctx.get(), &success));
    EXPECT_FALSE(success);

    // Validate that we can find the entries before we went over the limit
    for (int i = 0; i < expected_size * 5; i += 100000) {
      TupleRow* probe_row = CreateTupleRow(i);
      if (!ht_ctx->EvalAndHashProbe(probe_row)) continue;
      HashTable::Iterator iter = hash_table->FindProbeRow(ht_ctx.get());
      if (i < hash_table->size()) {
        EXPECT_TRUE(!iter.AtEnd()) << " i: " << i;
        ValidateMatch(probe_row, iter.GetRow());
      } else {
        EXPECT_TRUE(iter.AtEnd()) << " i: " << i;
      }
    }