Function BM_WriteInt64Column

cpp/src/parquet/column_io_benchmark.cc:70–102

}

static void BM_WriteInt64Column(::benchmark::State& state, Repetition::type repetition,
                                Compression::type codec, Encoding::type encoding) {
  format::ColumnChunk thrift_metadata;

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

  std::vector<int16_t> definition_levels(state.range(0), 1);
  std::vector<int16_t> repetition_levels(state.range(0), 0);
  std::shared_ptr<ColumnDescriptor> schema = Int64Schema(repetition);
  std::shared_ptr<WriterProperties> properties = WriterProperties::Builder()
                                                     .compression(codec)
                                                     ->encoding(encoding)
                                                     ->disable_dictionary()
                                                     ->build();
  auto metadata = ColumnChunkMetaDataBuilder::Make(
      properties, schema.get(), reinterpret_cast<uint8_t*>(&thrift_metadata));

  int64_t data_size = values->length() * sizeof(int64_t);
  int64_t stream_size = 0;
  for (auto _ : state) {
    auto stream = CreateOutputStream();
    std::shared_ptr<Int64Writer> writer = BuildWriter(
        state.range(0), 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();
    stream_size = stream->Tell().ValueOrDie();
  }
  SetBytesProcessed(state, repetition);
  state.counters["compression_ratio"] = static_cast<double>(data_size) / stream_size;
}

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