Class UnaryBitBlockBenchmark

cpp/src/arrow/util/bit_block_counter_benchmark.cc:34–114

namespace internal {

struct UnaryBitBlockBenchmark {
  benchmark::State& state;
  int64_t offset;
  int64_t bitmap_length;
  std::shared_ptr<Array> arr;
  int64_t expected;

  explicit UnaryBitBlockBenchmark(benchmark::State& state, int64_t offset = 0)
      : state(state), offset(offset), bitmap_length(1 << 20) {
    random::RandomArrayGenerator rng(/*seed=*/0);
    // State parameter is the average number of total values for each null
    // value. So 100 means that 1 out of 100 on average are null.
    double null_probability = 1. / static_cast<double>(state.range(0));
    arr = rng.Int8(bitmap_length, 0, 100, null_probability);

    // Compute the expected result
    this->expected = 0;
    const auto& int8_arr = static_cast<const Int8Array&>(*arr);
    for (int64_t i = this->offset; i < bitmap_length; ++i) {
      if (int8_arr.IsValid(i)) {
        this->expected += int8_arr.Value(i);
      }
    }
  }

  template <typename NextBlockFunc>
  void BenchBitBlockCounter(NextBlockFunc&& next_block) {
    const auto& int8_arr = static_cast<const Int8Array&>(*arr);
    const uint8_t* bitmap = arr->null_bitmap_data();
    for (auto _ : state) {
      BitBlockCounter scanner(bitmap, this->offset, bitmap_length - this->offset);
      int64_t result = 0;
      int64_t position = this->offset;
      while (true) {
        BitBlockCount block = next_block(&scanner);
        if (block.length == 0) {
          break;
        }
        if (block.length == block.popcount) {
          // All not-null
          for (int64_t i = 0; i < block.length; ++i) {
            result += int8_arr.Value(position + i);
          }
        } else if (block.popcount > 0) {
          // Some but not all not-null
          for (int64_t i = 0; i < block.length; ++i) {
            if (bit_util::GetBit(bitmap, position + i)) {
              result += int8_arr.Value(position + i);
            }
          }
        }
        position += block.length;
      }
      // Sanity check
      if (result != expected) {
        std::abort();
      }
    }