Class TakeBenchmark

cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc:111–266

};

struct TakeBenchmark {
  benchmark::State& state;
  RegressionArgs args;
  random::RandomArrayGenerator rand;
  double selection_factor;
  bool indices_have_nulls;
  bool monotonic_indices = false;

  TakeBenchmark(benchmark::State& state, bool indices_have_nulls,
                bool monotonic_indices = false)
      : TakeBenchmark(state, /*selection_factor=*/kDefaultTakeSelectionFactor,
                      indices_have_nulls, monotonic_indices) {}

  TakeBenchmark(benchmark::State& state, double selection_factor, bool indices_have_nulls,
                bool monotonic_indices = false)
      : state(state),
        args(state, /*size_is_bytes=*/false),
        rand(kSeed),
        selection_factor(selection_factor),
        indices_have_nulls(indices_have_nulls),
        monotonic_indices(monotonic_indices) {}

  static constexpr int kStringMinLength = 0;
  static constexpr int kStringMaxLength = 32;
  static constexpr int kByteWidthRange = 2;

  template <typename GenChunk>
  std::shared_ptr<ChunkedArray> GenChunkedArray(int64_t num_chunks,
                                                GenChunk&& gen_chunk) {
    const int64_t chunk_length =
        std::llround(args.size / static_cast<double>(num_chunks));
    ArrayVector chunks;
    for (int64_t i = 0; i < num_chunks; ++i) {
      const int64_t fitting_chunk_length =
          std::min(chunk_length, args.size - i * chunk_length);
      chunks.push_back(gen_chunk(fitting_chunk_length));
    }
    return std::make_shared<ChunkedArray>(std::move(chunks));
  }

  void Int64() {
    auto values = rand.Int64(args.size, -100, 100, args.null_proportion);
    Bench(values);
  }

  void FSLInt64() {
    auto int_array = rand.Int64(args.size, -100, 100, args.null_proportion);
    auto values = std::make_shared<FixedSizeListArray>(
        fixed_size_list(int64(), 1), args.size, int_array, int_array->null_bitmap(),
        int_array->null_count());
    Bench(values);
  }

  void FixedSizeBinary() {
    const auto byte_width = static_cast<int32_t>(state.range(kByteWidthRange));
    auto values = rand.FixedSizeBinary(args.size, byte_width, args.null_proportion);
    Bench(values);
    state.counters["byte_width"] = byte_width;