Function BM_ReadInt64Column

cpp/src/parquet/column_io_benchmark.cc:170–218

}

static void BM_ReadInt64Column(::benchmark::State& state, Repetition::type repetition,
                               Compression::type codec, Encoding::type encoding) {
  const auto kNumValues = state.range(0);
  const auto kBatchSize = state.range(1);

  ::arrow::random::RandomArrayGenerator rgen(1337);
  auto values = rgen.Int64(kNumValues, 0, 1000000, 0);
  const auto& int64_values = static_cast<const ::arrow::Int64Array&>(*values);

  std::vector<int16_t> definition_levels(kNumValues, 1);
  std::vector<int16_t> repetition_levels(kNumValues, 0);
  std::shared_ptr<ColumnDescriptor> schema = Int64Schema(repetition);
  std::shared_ptr<WriterProperties> properties = WriterProperties::Builder()
                                                     .compression(codec)
                                                     ->encoding(encoding)
                                                     ->disable_dictionary()
                                                     ->build();

  format::ColumnChunk thrift_metadata;
  auto metadata = ColumnChunkMetaDataBuilder::Make(
      properties, schema.get(), reinterpret_cast<uint8_t*>(&thrift_metadata));

  auto stream = CreateOutputStream();
  std::shared_ptr<Int64Writer> writer = BuildWriter(
      kNumValues, stream, metadata.get(), schema.get(), properties.get(), codec);
  writer->WriteBatch(int64_values.length(), definition_levels.data(),
                     repetition_levels.data(), int64_values.raw_values());
  writer->Close();

  PARQUET_ASSIGN_OR_THROW(auto src, stream->Finish());
  int64_t stream_size = src->size();
  int64_t data_size = int64_values.length() * sizeof(int64_t);

  std::vector<int64_t> values_out(kBatchSize);
  std::vector<int16_t> definition_levels_out(kBatchSize);
  std::vector<int16_t> repetition_levels_out(kBatchSize);
  while (state.KeepRunning()) {
    std::shared_ptr<Int64Reader> reader =
        BuildReader(src, kNumValues, codec, schema.get());
    int64_t values_read = 0;
    for (int64_t i = 0; i < kNumValues; i += values_read) {
      reader->ReadBatch(kBatchSize, definition_levels_out.data(),
                        repetition_levels_out.data(), values_out.data(), &values_read);
      ARROW_CHECK_NE(values_read, 0) << "Unexpected end of column";
    }
  }
  SetBytesProcessed(state, repetition);
  state.counters["compression_ratio"] = static_cast<double>(data_size) / stream_size;
}

template <Repetition::type repetition,
          Compression::type codec = Compression::UNCOMPRESSED,