From 966e87784c26e4ad3e82dd47c1b34c127341f3b0 Mon Sep 17 00:00:00 2001 From: mwish Date: Fri, 24 Feb 2023 11:44:34 +0800 Subject: [PATCH 01/10] Parquet: Introduce basic benchmark --- cpp/src/parquet/encoding_benchmark.cc | 58 +++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index e6a3c2c58ca..ee7b1867529 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -569,6 +569,64 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int64_Narrow)->Range(MIN_RANGE, MAX_RANGE); BENCHMARK(BM_DeltaBitPackingDecode_Int32_Wide)->Range(MIN_RANGE, MAX_RANGE); BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE); +void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { + ::arrow::random::RandomArrayGenerator rag(0); + MemoryPool* allocator = default_memory_pool(); + // Using arrow to write, because we just benchmark decoding here. + auto array = rag.String(1024, 0, 1024, /* null_probability */ 0, 64, allocator); + auto stringArray = dynamic_cast<::arrow::StringArray*>(array.get()); + auto encoder = MakeTypedEncoder(encoding); + std::vector values; + for (int i = 0; i < stringArray->length(); ++i) { + values.emplace_back(stringArray->GetView(i)); + } + + for (auto _ : state) { + encoder->Put(values.data(), static_cast(values.size())); + encoder->FlushValues(); + } +} + +static void BM_DeltaBitLengthEncodingByteArray(benchmark::State& state) { + EncodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); +} + +static void BM_PlainEncodingByteArray(benchmark::State& state) { + EncodingByteArrayBenchmark(state, Encoding::PLAIN); +} + +void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { + ::arrow::random::RandomArrayGenerator rag(0); + MemoryPool* allocator = default_memory_pool(); + // Using arrow to write, because we just benchmark decoding here. + auto array = rag.String(1024, 0, 1024, /* null_probability */ 0, 64, allocator); + auto encoder = MakeTypedEncoder(encoding); + encoder->Put(*array); + std::shared_ptr buf = encoder->FlushValues(); + + std::vector values; + values.resize(array->length()); + for (auto _ : state) { + auto decoder = MakeTypedDecoder(encoding); + decoder->SetData(static_cast(array->length()), buf->data(), + static_cast(buf->size())); + decoder->Decode(values.data(), static_cast(values.size())); + } +} + +static void BM_PlainDecodingByteArray(benchmark::State& state) { + DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); +} + +static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { + DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); +} + +BENCHMARK(BM_PlainEncodingByteArray); +BENCHMARK(BM_DeltaBitLengthEncodingByteArray); +BENCHMARK(BM_PlainDecodingByteArray); +BENCHMARK(BM_DeltaBitLengthDecodingByteArray); + template static void DecodeDict(std::vector& values, benchmark::State& state) { From 5320eec96c48fba2b1929906cfac46254b9cf73e Mon Sep 17 00:00:00 2001 From: mwish Date: Fri, 24 Feb 2023 23:44:09 +0800 Subject: [PATCH 02/10] tiny benchmark spaced --- cpp/src/parquet/encoding_benchmark.cc | 66 ++++++++++++++++++++++----- 1 file changed, 55 insertions(+), 11 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index ee7b1867529..537467509cd 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -123,7 +123,8 @@ static void BM_PlainEncodingDouble(benchmark::State& state) { auto encoder = MakeTypedEncoder(Encoding::PLAIN); for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - encoder->FlushValues(); + std::shared_ptr buf = encoder->FlushValues(); + ::benchmark::DoNotOptimize(buf); } state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(double)); } @@ -483,7 +484,8 @@ static void BM_DeltaBitPackingEncode(benchmark::State& state, NumberGenerator ge auto encoder = MakeTypedEncoder(Encoding::DELTA_BINARY_PACKED); for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - encoder->FlushValues(); + auto buf = encoder->FlushValues(); + ::benchmark::DoNotOptimize(buf); } state.SetBytesProcessed(state.iterations() * values.size() * sizeof(T)); state.SetItemsProcessed(state.iterations() * values.size()); @@ -571,19 +573,19 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE); void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); - MemoryPool* allocator = default_memory_pool(); // Using arrow to write, because we just benchmark decoding here. - auto array = rag.String(1024, 0, 1024, /* null_probability */ 0, 64, allocator); - auto stringArray = dynamic_cast<::arrow::StringArray*>(array.get()); + auto array = rag.String(1024, 0, 1024, /* null_probability */ 0); + auto string_array = ::arrow::internal::checked_cast<::arrow::StringArray*>(array.get()); auto encoder = MakeTypedEncoder(encoding); std::vector values; - for (int i = 0; i < stringArray->length(); ++i) { - values.emplace_back(stringArray->GetView(i)); + for (int i = 0; i < string_array->length(); ++i) { + values.emplace_back(string_array->GetView(i)); } for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - encoder->FlushValues(); + auto buf = encoder->FlushValues(); + ::benchmark::DoNotOptimize(buf); } } @@ -597,9 +599,8 @@ static void BM_PlainEncodingByteArray(benchmark::State& state) { void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); - MemoryPool* allocator = default_memory_pool(); // Using arrow to write, because we just benchmark decoding here. - auto array = rag.String(1024, 0, 1024, /* null_probability */ 0, 64, allocator); + auto array = rag.String(1024, 0, 1024, /* null_probability */ 0); auto encoder = MakeTypedEncoder(encoding); encoder->Put(*array); std::shared_ptr buf = encoder->FlushValues(); @@ -611,11 +612,12 @@ void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding decoder->SetData(static_cast(array->length()), buf->data(), static_cast(buf->size())); decoder->Decode(values.data(), static_cast(values.size())); + ::benchmark::DoNotOptimize(values); } } static void BM_PlainDecodingByteArray(benchmark::State& state) { - DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); + DecodingByteArrayBenchmark(state, Encoding::PLAIN); } static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { @@ -627,6 +629,48 @@ BENCHMARK(BM_DeltaBitLengthEncodingByteArray); BENCHMARK(BM_PlainDecodingByteArray); BENCHMARK(BM_DeltaBitLengthDecodingByteArray); +static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { + const int num_values = 1024; + const double null_percent = 0.02; + + auto rand = ::arrow::random::RandomArrayGenerator(0); + const auto array = rand.String(num_values, 0, 1024, null_percent); + const auto valid_bits = array->null_bitmap_data(); + const int null_count = static_cast(array->null_count()); + const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); + + std::vector byte_arrays; + byte_arrays.reserve(array_actual->length()); + for (int i = 0; i < array_actual->length(); ++i) { + byte_arrays.emplace_back(array_actual->GetView(i)); + } + + auto encoder = MakeTypedEncoder(encoding); + encoder->PutSpaced(byte_arrays.data(), num_values, valid_bits, 0); + std::shared_ptr buf = encoder->FlushValues(); + + auto decoder = MakeTypedDecoder(encoding); + std::vector decode_values(num_values * sizeof(ByteArray)); + auto decode_buf = reinterpret_cast(decode_values.data()); + for (auto _ : state) { + decoder->SetData(num_values - null_count, buf->data(), static_cast(buf->size())); + decoder->DecodeSpaced(decode_buf, num_values, null_count, valid_bits, 0); + } + state.counters["null_percent"] = null_percent * 100; + // state.SetBytesProcessed(state.iterations() * num_values * sizeof(CType)); +} + +static void BM_PlainDecodingSpacedByteArray(benchmark::State& state) { + BM_DecodingByteArraySpaced(state, Encoding::PLAIN); +} + +static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { + BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); +} + +BENCHMARK(BM_PlainDecodingSpacedByteArray); +BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray); + template static void DecodeDict(std::vector& values, benchmark::State& state) { From 86290dd17676668ad76b6e6cb3fc3ab8e21327d8 Mon Sep 17 00:00:00 2001 From: mwish Date: Sat, 25 Feb 2023 00:56:02 +0800 Subject: [PATCH 03/10] add stats --- cpp/src/parquet/encoding_benchmark.cc | 38 ++++++++++++++++++--------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 537467509cd..08cb6eaa733 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -123,8 +123,7 @@ static void BM_PlainEncodingDouble(benchmark::State& state) { auto encoder = MakeTypedEncoder(Encoding::PLAIN); for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - std::shared_ptr buf = encoder->FlushValues(); - ::benchmark::DoNotOptimize(buf); + encoder->FlushValues(); } state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(double)); } @@ -484,8 +483,7 @@ static void BM_DeltaBitPackingEncode(benchmark::State& state, NumberGenerator ge auto encoder = MakeTypedEncoder(Encoding::DELTA_BINARY_PACKED); for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - auto buf = encoder->FlushValues(); - ::benchmark::DoNotOptimize(buf); + encoder->FlushValues(); } state.SetBytesProcessed(state.iterations() * values.size() * sizeof(T)); state.SetItemsProcessed(state.iterations() * values.size()); @@ -575,18 +573,21 @@ void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding ::arrow::random::RandomArrayGenerator rag(0); // Using arrow to write, because we just benchmark decoding here. auto array = rag.String(1024, 0, 1024, /* null_probability */ 0); - auto string_array = ::arrow::internal::checked_cast<::arrow::StringArray*>(array.get()); + const auto array_actual = + ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); auto encoder = MakeTypedEncoder(encoding); std::vector values; - for (int i = 0; i < string_array->length(); ++i) { - values.emplace_back(string_array->GetView(i)); + for (int i = 0; i < array_actual->length(); ++i) { + values.emplace_back(array_actual->GetView(i)); } for (auto _ : state) { encoder->Put(values.data(), static_cast(values.size())); - auto buf = encoder->FlushValues(); - ::benchmark::DoNotOptimize(buf); + encoder->FlushValues(); } + state.SetItemsProcessed(state.iterations() * array_actual->length()); + state.counters["byte_array_bytes"] = + state.iterations() * array_actual->total_values_length(); } static void BM_DeltaBitLengthEncodingByteArray(benchmark::State& state) { @@ -600,7 +601,10 @@ static void BM_PlainEncodingByteArray(benchmark::State& state) { void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); // Using arrow to write, because we just benchmark decoding here. - auto array = rag.String(1024, 0, 1024, /* null_probability */ 0); + auto array = rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ 1024, + /* null_probability */ 0); + const auto array_actual = + ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); auto encoder = MakeTypedEncoder(encoding); encoder->Put(*array); std::shared_ptr buf = encoder->FlushValues(); @@ -614,6 +618,9 @@ void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding decoder->Decode(values.data(), static_cast(values.size())); ::benchmark::DoNotOptimize(values); } + state.SetItemsProcessed(state.iterations() * array->length()); + state.counters["byte_array_bytes"] = + state.iterations() * array_actual->total_values_length(); } static void BM_PlainDecodingByteArray(benchmark::State& state) { @@ -634,10 +641,12 @@ static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type e const double null_percent = 0.02; auto rand = ::arrow::random::RandomArrayGenerator(0); - const auto array = rand.String(num_values, 0, 1024, null_percent); + const auto array = + rand.String(num_values, /* min_length */ 0, /* max_length */ 1024, null_percent); const auto valid_bits = array->null_bitmap_data(); const int null_count = static_cast(array->null_count()); - const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); + const auto array_actual = + ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); std::vector byte_arrays; byte_arrays.reserve(array_actual->length()); @@ -655,9 +664,12 @@ static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type e for (auto _ : state) { decoder->SetData(num_values - null_count, buf->data(), static_cast(buf->size())); decoder->DecodeSpaced(decode_buf, num_values, null_count, valid_bits, 0); + ::benchmark::DoNotOptimize(decode_buf); } state.counters["null_percent"] = null_percent * 100; - // state.SetBytesProcessed(state.iterations() * num_values * sizeof(CType)); + state.SetItemsProcessed(state.iterations() * array_actual->length()); + state.counters["byte_array_bytes"] = + state.iterations() * array_actual->total_values_length(); } static void BM_PlainDecodingSpacedByteArray(benchmark::State& state) { From cac0875885a885351916c21dcec401771bdf90fd Mon Sep 17 00:00:00 2001 From: mwish Date: Sun, 26 Feb 2023 23:52:43 +0800 Subject: [PATCH 04/10] [ADD] adding range for ByteArray benchmark --- cpp/src/parquet/encoding_benchmark.cc | 30 ++++++++++++++++----------- 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 08cb6eaa733..066b50df59c 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -571,8 +571,11 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE); void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); - // Using arrow to write, because we just benchmark decoding here. - auto array = rag.String(1024, 0, 1024, /* null_probability */ 0); + // Using arrow generator to generate random data. + int32_t max_length = state.range(0); + auto array = + rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ max_length, + /* null_probability */ 0); const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); auto encoder = MakeTypedEncoder(encoding); @@ -600,9 +603,11 @@ static void BM_PlainEncodingByteArray(benchmark::State& state) { void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); + int32_t max_length = state.range(0); // Using arrow to write, because we just benchmark decoding here. - auto array = rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ 1024, - /* null_probability */ 0); + auto array = + rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ max_length, + /* null_probability */ 0); const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); auto encoder = MakeTypedEncoder(encoding); @@ -631,18 +636,19 @@ static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainEncodingByteArray); -BENCHMARK(BM_DeltaBitLengthEncodingByteArray); -BENCHMARK(BM_PlainDecodingByteArray); -BENCHMARK(BM_DeltaBitLengthDecodingByteArray); +BENCHMARK(BM_PlainEncodingByteArray)->Range(8, 1024); +BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Range(8, 1024); +BENCHMARK(BM_PlainDecodingByteArray)->Range(8, 1024); +BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Range(8, 1024); static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { const int num_values = 1024; const double null_percent = 0.02; auto rand = ::arrow::random::RandomArrayGenerator(0); - const auto array = - rand.String(num_values, /* min_length */ 0, /* max_length */ 1024, null_percent); + int32_t max_length = state.range(0); + const auto array = rand.String(num_values, /* min_length */ 0, + /* max_length */ max_length, null_percent); const auto valid_bits = array->null_bitmap_data(); const int null_count = static_cast(array->null_count()); const auto array_actual = @@ -680,8 +686,8 @@ static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainDecodingSpacedByteArray); -BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray); +BENCHMARK(BM_PlainDecodingSpacedByteArray)->Range(8, 1024); +BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Range(8, 1024); template static void DecodeDict(std::vector& values, From e0e78cdb6b7c1715cb05a5c61cef3995aef8f7a2 Mon Sep 17 00:00:00 2001 From: mwish Date: Tue, 28 Feb 2023 11:40:50 +0800 Subject: [PATCH 05/10] add ndv and Dict encoding for ByteArray --- cpp/src/parquet/encoding_benchmark.cc | 46 ++++++++++++++++++++------- 1 file changed, 34 insertions(+), 12 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 066b50df59c..4d0bbd6e378 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -572,9 +572,10 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE); void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); // Using arrow generator to generate random data. - int32_t max_length = state.range(0); + int32_t max_length = static_cast(state.range(0)); + int32_t array_size = static_cast(state.range(1)); auto array = - rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ max_length, + rag.String(/* size */ array_size, /* min_length */ 0, /* max_length */ max_length, /* null_probability */ 0); const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); @@ -603,10 +604,11 @@ static void BM_PlainEncodingByteArray(benchmark::State& state) { void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); - int32_t max_length = state.range(0); + int32_t max_length = static_cast(state.range(0)); + int32_t array_size = static_cast(state.range(1)); // Using arrow to write, because we just benchmark decoding here. auto array = - rag.String(/* size */ 1024, /* min_length */ 0, /* max_length */ max_length, + rag.String(/* size */ array_size, /* min_length */ 0, /* max_length */ max_length, /* null_probability */ 0); const auto array_actual = ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); @@ -636,17 +638,17 @@ static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainEncodingByteArray)->Range(8, 1024); -BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Range(8, 1024); -BENCHMARK(BM_PlainDecodingByteArray)->Range(8, 1024); -BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Range(8, 1024); +BENCHMARK(BM_PlainEncodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_PlainDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { - const int num_values = 1024; const double null_percent = 0.02; auto rand = ::arrow::random::RandomArrayGenerator(0); - int32_t max_length = state.range(0); + int32_t max_length = static_cast(state.range(0)); + int32_t num_values = static_cast(state.range(1)); const auto array = rand.String(num_values, /* min_length */ 0, /* max_length */ max_length, null_percent); const auto valid_bits = array->null_bitmap_data(); @@ -686,8 +688,8 @@ static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainDecodingSpacedByteArray)->Range(8, 1024); -BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Range(8, 1024); +BENCHMARK(BM_PlainDecodingSpacedByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Ranges({{8, 1024}, {8, 1024}}); template static void DecodeDict(std::vector& values, @@ -754,6 +756,26 @@ static void BM_DictDecodingInt64_literals(benchmark::State& state) { BENCHMARK(BM_DictDecodingInt64_literals)->Range(MIN_RANGE, MAX_RANGE); +static void BM_DictDecodingByteArray(benchmark::State& state) { + ::arrow::random::RandomArrayGenerator rag(0); + // Using arrow generator to generate random data. + int32_t max_length = static_cast(state.range(0)); + int32_t array_size = static_cast(state.range(1)); + auto array = + rag.String(/* size */ array_size, /* min_length */ 0, /* max_length */ max_length, + /* null_probability */ 0); + const auto array_actual = + ::arrow::internal::checked_pointer_cast<::arrow::StringArray>(array); + auto encoder = MakeDictDecoder(); + std::vector values; + for (int i = 0; i < array_actual->length(); ++i) { + values.emplace_back(array_actual->GetView(i)); + } + DecodeDict(values, state); +} + +BENCHMARK(BM_DictDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); + // ---------------------------------------------------------------------- // Shared benchmarks for decoding using arrow builders From 1bd350d1855c2691cc3b1d2ef492b05484b0c7c5 Mon Sep 17 00:00:00 2001 From: mwish Date: Tue, 28 Feb 2023 12:37:35 +0800 Subject: [PATCH 06/10] add parameter name --- cpp/src/parquet/encoding_benchmark.cc | 28 ++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 4d0bbd6e378..269eed87628 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -638,10 +638,18 @@ static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainEncodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); -BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); -BENCHMARK(BM_PlainDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); -BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_PlainEncodingByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_DeltaBitLengthEncodingByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_PlainDecodingByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_DeltaBitLengthDecodingByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { const double null_percent = 0.02; @@ -688,8 +696,12 @@ static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainDecodingSpacedByteArray)->Ranges({{8, 1024}, {8, 1024}}); -BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_PlainDecodingSpacedByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); template static void DecodeDict(std::vector& values, @@ -774,7 +786,9 @@ static void BM_DictDecodingByteArray(benchmark::State& state) { DecodeDict(values, state); } -BENCHMARK(BM_DictDecodingByteArray)->Ranges({{8, 1024}, {8, 1024}}); +BENCHMARK(BM_DictDecodingByteArray) + ->Ranges({{8, 1024}, {8, 1024}}) + ->ArgNames({"max-string-length", "batch-size"}); // ---------------------------------------------------------------------- // Shared benchmarks for decoding using arrow builders From 63445d762aca5738ffbb76e9cca59686fe30a9ca Mon Sep 17 00:00:00 2001 From: mwish Date: Tue, 28 Feb 2023 13:35:38 +0800 Subject: [PATCH 07/10] fix lint --- cpp/src/parquet/encoding_benchmark.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 269eed87628..72108e4eaa6 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -591,7 +591,7 @@ void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding } state.SetItemsProcessed(state.iterations() * array_actual->length()); state.counters["byte_array_bytes"] = - state.iterations() * array_actual->total_values_length(); + static_cast(state.iterations() * array_actual->total_values_length()); } static void BM_DeltaBitLengthEncodingByteArray(benchmark::State& state) { @@ -627,7 +627,7 @@ void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding } state.SetItemsProcessed(state.iterations() * array->length()); state.counters["byte_array_bytes"] = - state.iterations() * array_actual->total_values_length(); + static_cast(state.iterations() * array_actual->total_values_length()); } static void BM_PlainDecodingByteArray(benchmark::State& state) { @@ -685,7 +685,7 @@ static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type e state.counters["null_percent"] = null_percent * 100; state.SetItemsProcessed(state.iterations() * array_actual->length()); state.counters["byte_array_bytes"] = - state.iterations() * array_actual->total_values_length(); + static_cast(state.iterations() * array_actual->total_values_length()); } static void BM_PlainDecodingSpacedByteArray(benchmark::State& state) { From 0882b93c40b3e5b970602fcceb210b89aea76f3b Mon Sep 17 00:00:00 2001 From: mwish Date: Tue, 28 Feb 2023 19:27:01 +0800 Subject: [PATCH 08/10] change benchmark args --- cpp/src/parquet/encoding_benchmark.cc | 33 ++++++++++----------------- 1 file changed, 12 insertions(+), 21 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index 72108e4eaa6..ef653d2dab9 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -569,6 +569,11 @@ BENCHMARK(BM_DeltaBitPackingDecode_Int64_Narrow)->Range(MIN_RANGE, MAX_RANGE); BENCHMARK(BM_DeltaBitPackingDecode_Int32_Wide)->Range(MIN_RANGE, MAX_RANGE); BENCHMARK(BM_DeltaBitPackingDecode_Int64_Wide)->Range(MIN_RANGE, MAX_RANGE); +static void ByteArrayCustomArguments(benchmark::internal::Benchmark* b) { + b->ArgsProduct({{8, 64, 1024}, {512, 2048}}) + ->ArgNames({"max-string-length", "batch-size"}); +} + void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding) { ::arrow::random::RandomArrayGenerator rag(0); // Using arrow generator to generate random data. @@ -638,18 +643,10 @@ static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainEncodingByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); -BENCHMARK(BM_DeltaBitLengthEncodingByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); -BENCHMARK(BM_PlainDecodingByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); -BENCHMARK(BM_DeltaBitLengthDecodingByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_PlainEncodingByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_PlainDecodingByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Apply(ByteArrayCustomArguments); static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { const double null_percent = 0.02; @@ -696,12 +693,8 @@ static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } -BENCHMARK(BM_PlainDecodingSpacedByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); -BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_PlainDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments); template static void DecodeDict(std::vector& values, @@ -786,9 +779,7 @@ static void BM_DictDecodingByteArray(benchmark::State& state) { DecodeDict(values, state); } -BENCHMARK(BM_DictDecodingByteArray) - ->Ranges({{8, 1024}, {8, 1024}}) - ->ArgNames({"max-string-length", "batch-size"}); +BENCHMARK(BM_DictDecodingByteArray)->Apply(ByteArrayCustomArguments); // ---------------------------------------------------------------------- // Shared benchmarks for decoding using arrow builders From be77f9d670b8117eb8f450e4890a4fe5f688bd26 Mon Sep 17 00:00:00 2001 From: mwish Date: Tue, 28 Feb 2023 22:53:57 +0800 Subject: [PATCH 09/10] update: solve comments --- cpp/src/parquet/encoding_benchmark.cc | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index ef653d2dab9..cd75976d1ea 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -595,11 +595,10 @@ void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding encoder->FlushValues(); } state.SetItemsProcessed(state.iterations() * array_actual->length()); - state.counters["byte_array_bytes"] = - static_cast(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); } -static void BM_DeltaBitLengthEncodingByteArray(benchmark::State& state) { +static void BM_DeltaLengthEncodingByteArray(benchmark::State& state) { EncodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } @@ -631,22 +630,21 @@ void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding ::benchmark::DoNotOptimize(values); } state.SetItemsProcessed(state.iterations() * array->length()); - state.counters["byte_array_bytes"] = - static_cast(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); } static void BM_PlainDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::PLAIN); } -static void BM_DeltaBitLengthDecodingByteArray(benchmark::State& state) { +static void BM_DeltaLengthDecodingByteArray(benchmark::State& state) { DecodingByteArrayBenchmark(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } BENCHMARK(BM_PlainEncodingByteArray)->Apply(ByteArrayCustomArguments); -BENCHMARK(BM_DeltaBitLengthEncodingByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaLengthEncodingByteArray)->Apply(ByteArrayCustomArguments); BENCHMARK(BM_PlainDecodingByteArray)->Apply(ByteArrayCustomArguments); -BENCHMARK(BM_DeltaBitLengthDecodingByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaLengthDecodingByteArray)->Apply(ByteArrayCustomArguments); static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type encoding) { const double null_percent = 0.02; @@ -681,20 +679,19 @@ static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type e } state.counters["null_percent"] = null_percent * 100; state.SetItemsProcessed(state.iterations() * array_actual->length()); - state.counters["byte_array_bytes"] = - static_cast(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); } static void BM_PlainDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::PLAIN); } -static void BM_DeltaBitLengthDecodingSpacedByteArray(benchmark::State& state) { +static void BM_DeltaLengthDecodingSpacedByteArray(benchmark::State& state) { BM_DecodingByteArraySpaced(state, Encoding::DELTA_LENGTH_BYTE_ARRAY); } BENCHMARK(BM_PlainDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments); -BENCHMARK(BM_DeltaBitLengthDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments); +BENCHMARK(BM_DeltaLengthDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments); template static void DecodeDict(std::vector& values, @@ -777,6 +774,8 @@ static void BM_DictDecodingByteArray(benchmark::State& state) { values.emplace_back(array_actual->GetView(i)); } DecodeDict(values, state); + state.SetItemsProcessed(state.iterations() * array_actual->length()); + state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); } BENCHMARK(BM_DictDecodingByteArray)->Apply(ByteArrayCustomArguments); From 803de33a3e3e32790734af42f5269c458973734f Mon Sep 17 00:00:00 2001 From: mwish Date: Wed, 8 Mar 2023 02:42:04 +0800 Subject: [PATCH 10/10] address comment --- cpp/src/parquet/encoding_benchmark.cc | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc index cd75976d1ea..405549054e0 100644 --- a/cpp/src/parquet/encoding_benchmark.cc +++ b/cpp/src/parquet/encoding_benchmark.cc @@ -595,7 +595,8 @@ void EncodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding encoder->FlushValues(); } state.SetItemsProcessed(state.iterations() * array_actual->length()); - state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * (array_actual->value_data()->size() + + array_actual->value_offsets()->size())); } static void BM_DeltaLengthEncodingByteArray(benchmark::State& state) { @@ -630,7 +631,8 @@ void DecodingByteArrayBenchmark(benchmark::State& state, Encoding::type encoding ::benchmark::DoNotOptimize(values); } state.SetItemsProcessed(state.iterations() * array->length()); - state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * (array_actual->value_data()->size() + + array_actual->value_offsets()->size())); } static void BM_PlainDecodingByteArray(benchmark::State& state) { @@ -679,7 +681,8 @@ static void BM_DecodingByteArraySpaced(benchmark::State& state, Encoding::type e } state.counters["null_percent"] = null_percent * 100; state.SetItemsProcessed(state.iterations() * array_actual->length()); - state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * (array_actual->value_data()->size() + + array_actual->value_offsets()->size())); } static void BM_PlainDecodingSpacedByteArray(benchmark::State& state) { @@ -775,7 +778,8 @@ static void BM_DictDecodingByteArray(benchmark::State& state) { } DecodeDict(values, state); state.SetItemsProcessed(state.iterations() * array_actual->length()); - state.SetBytesProcessed(state.iterations() * array_actual->total_values_length()); + state.SetBytesProcessed(state.iterations() * (array_actual->value_data()->size() + + array_actual->value_offsets()->size())); } BENCHMARK(BM_DictDecodingByteArray)->Apply(ByteArrayCustomArguments);