zanmato1984 commented on code in PR #44053:
URL: https://github.com/apache/arrow/pull/44053#discussion_r1764372039
##########
cpp/src/arrow/acero/aggregate_benchmark.cc:
##########
@@ -866,5 +887,61 @@
BENCHMARK(TDigestKernelDoubleMedian)->Apply(QuantileKernelArgs);
BENCHMARK(TDigestKernelDoubleDeciles)->Apply(QuantileKernelArgs);
BENCHMARK(TDigestKernelDoubleCentiles)->Apply(QuantileKernelArgs);
+//
+// Segmented Aggregate
+//
+
+static void BenchmarkSegmentedAggregate(
+ benchmark::State& state, int64_t num_rows, std::vector<Aggregate>
aggregates,
+ const std::vector<std::shared_ptr<Array>>& arguments,
+ const std::vector<std::shared_ptr<Array>>& keys, int64_t num_segment_keys,
+ int64_t num_segments) {
+ ASSERT_GT(num_segments, 0);
+
+ auto rng = random::RandomArrayGenerator(42);
+ auto segment_key = rng.Int64(num_rows, /*min=*/0, /*max=*/num_segments - 1);
+ int64_t* values = segment_key->data()->GetMutableValues<int64_t>(1);
+ std::sort(values, values + num_rows);
+ // num_segment_keys copies of the segment key.
+ ArrayVector segment_keys(num_segment_keys, segment_key);
+
+ BenchmarkAggregate(state, std::move(aggregates), arguments, keys,
segment_keys);
+}
+
+template <typename... Args>
+static void CountScalarSegmentedByInts(benchmark::State& state, Args&&...) {
+ constexpr int64_t num_rows = 32 * 1024;
+
+ // A trivial column to count from.
+ auto arg = ConstantArrayGenerator::Zeroes(num_rows, int32());
+
+ BenchmarkSegmentedAggregate(state, num_rows, {{"count", ""}}, {arg}, {},
state.range(0),
+ state.range(1));
+}
+BENCHMARK(CountScalarSegmentedByInts)
+ ->ArgNames({"SegmentKeys", "Segments"})
+ ->ArgsProduct({{0, 1, 2}, benchmark::CreateRange(1, 256, 8)});
+
+template <typename... Args>
+static void CountGroupByIntsSegmentedByInts(benchmark::State& state,
Args&&...) {
+ constexpr int64_t num_rows = 32 * 1024;
+
+ // A trivial column to count from.
+ auto arg = ConstantArrayGenerator::Zeroes(num_rows, int32());
+
+ auto rng = random::RandomArrayGenerator(42);
+ int64_t num_keys = state.range(0);
+ ArrayVector keys(num_keys);
+ for (auto& key : keys) {
+ key = rng.Int64(num_rows, /*min=*/0, /*max=*/64);
Review Comment:
In these two particular benchmarks, they are to show how the number of
segment keys and the number of segments perform with a predefined group by
setup. In other words, the group by portion of the benchmark is merely to make
the benchmark more realistic. They are not designed for the comparison you
suggested.
IIUC, an apple to apple comparison though might be: a segmented scalar agg
(N segment keys and 0 group by keys) VS. a non-segmented group by agg (0
segment keys and N group by keys), with the same key distribution. In this
comparison, we can answer how a group by can be done more efficiently by taking
advantage of the segmented nature of the key(s) (i.e., using segmented agg). If
you are suggesting such a comparison, yes that makes sense. I think I can add a
new benchmark for it.
What do you think? Thanks.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
