Function HashFixedLengthFrom

cpp/src/arrow/compute/key_hash_test.cc:259–307

TEST(VectorHash, BasicLargeString) { RunTestVectorHash<LargeStringType>(); }

void HashFixedLengthFrom(int key_length, int num_rows, int start_row) {
  int num_rows_to_hash = num_rows - start_row;
  auto num_bytes_aligned = arrow::bit_util::RoundUpToMultipleOf64(key_length * num_rows);

  const auto hardware_flags_for_testing = HardwareFlagsForTesting();
  ASSERT_GT(hardware_flags_for_testing.size(), 0);

  std::vector<std::vector<uint32_t>> hashes32(hardware_flags_for_testing.size());
  std::vector<std::vector<uint64_t>> hashes64(hardware_flags_for_testing.size());
  for (auto& h : hashes32) {
    h.resize(num_rows_to_hash);
  }
  for (auto& h : hashes64) {
    h.resize(num_rows_to_hash);
  }

  FixedSizeBinaryBuilder keys_builder(fixed_size_binary(key_length));
  for (int j = 0; j < num_rows; ++j) {
    ASSERT_OK(keys_builder.Append(std::string(key_length, 42)));
  }
  ASSERT_OK_AND_ASSIGN(auto keys, keys_builder.Finish());
  // Make sure the buffer is aligned as expected.
  ASSERT_EQ(keys->data()->buffers[1]->capacity(), num_bytes_aligned);

  constexpr int mini_batch_size = 1024;
  std::vector<uint32_t> temp_buffer;
  temp_buffer.resize(mini_batch_size * 4);

  for (size_t i = 0; i < hardware_flags_for_testing.size(); ++i) {
    const auto hardware_flags = hardware_flags_for_testing[i];
    Hashing32::HashFixed(hardware_flags,
                         /*combine_hashes=*/false, num_rows_to_hash, key_length,
                         keys->data()->GetValues<uint8_t>(1) + start_row * key_length,
                         hashes32[i].data(), temp_buffer.data());
    Hashing64::HashFixed(
        /*combine_hashes=*/false, num_rows_to_hash, key_length,
        keys->data()->GetValues<uint8_t>(1) + start_row * key_length, hashes64[i].data());
  }

  // Verify that all implementations (scalar, SIMD) give the same hashes.
  for (size_t i = 1; i < hardware_flags_for_testing.size(); ++i) {
    for (int j = 0; j < num_rows_to_hash; ++j) {
      ASSERT_EQ(hashes32[i][j], hashes32[0][j])
          << "scalar and simd approaches yielded different 32-bit hashes";
      ASSERT_EQ(hashes64[i][j], hashes64[0][j])
          << "scalar and simd approaches yielded different 64-bit hashes";
    }
  }
}

// Some carefully chosen cases that may cause troubles like GH-39778.
TEST(VectorHash, FixedLengthTailByteSafety) {