Function TableToTensorSimple

cpp/src/arrow/tensor_benchmark.cc:56–84

template <typename ValueType, bool row_major>
static void TableToTensorSimple(benchmark::State& state) {
  using CType = typename ValueType::c_type;
  std::shared_ptr<DataType> ty = TypeTraits<ValueType>::type_singleton();

  const int64_t num_cols = state.range(1);
  const int64_t num_rows = state.range(0) / num_cols / sizeof(CType);
  arrow::random::RandomArrayGenerator gen_{42};

  std::vector<std::shared_ptr<Field>> fields = {};
  std::vector<std::shared_ptr<ChunkedArray>> columns = {};

  for (int64_t i = 0; i < num_cols; ++i) {
    fields.push_back(field("f" + std::to_string(i), ty));
    const int64_t chunk1_len = num_rows / 2;
    const int64_t chunk2_len = num_rows - chunk1_len;
    ArrayVector arrays = {gen_.ArrayOf(ty, chunk1_len), gen_.ArrayOf(ty, chunk2_len)};
    auto chunks = std::make_shared<ChunkedArray>(arrays, ty);
    columns.push_back(chunks);
  }
  auto schema = std::make_shared<Schema>(std::move(fields));
  auto table = Table::Make(schema, columns);

  for (auto _ : state) {
    ASSERT_OK_AND_ASSIGN(auto tensor,
                         table->ToTensor(/*null_to_nan=*/false, /*row_major=*/row_major));
  }
  state.SetItemsProcessed(state.iterations() * num_rows * num_cols);
  state.SetBytesProcessed(state.iterations() * ty->byte_width() * num_rows * num_cols);
}

void SetArgs(benchmark::internal::Benchmark* bench) {
  for (int64_t size : {kL1Size, kL2Size}) {