]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | // Licensed to the Apache Software Foundation (ASF) under one |
2 | // or more contributor license agreements. See the NOTICE file | |
3 | // distributed with this work for additional information | |
4 | // regarding copyright ownership. The ASF licenses this file | |
5 | // to you under the Apache License, Version 2.0 (the | |
6 | // "License"); you may not use this file except in compliance | |
7 | // with the License. You may obtain a copy of the License at | |
8 | // | |
9 | // http://www.apache.org/licenses/LICENSE-2.0 | |
10 | // | |
11 | // Unless required by applicable law or agreed to in writing, | |
12 | // software distributed under the License is distributed on an | |
13 | // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
14 | // KIND, either express or implied. See the License for the | |
15 | // specific language governing permissions and limitations | |
16 | // under the License. | |
17 | ||
18 | #include <memory> | |
19 | #include <string> | |
20 | #include <vector> | |
21 | ||
22 | #include "benchmark/benchmark.h" | |
23 | ||
24 | #include "arrow/array.h" | |
25 | #include "arrow/compare.h" | |
26 | #include "arrow/testing/gtest_util.h" | |
27 | #include "arrow/testing/random.h" | |
28 | #include "arrow/util/benchmark_util.h" | |
29 | #include "arrow/util/logging.h" | |
30 | #include "arrow/util/macros.h" | |
31 | ||
32 | namespace arrow { | |
33 | ||
34 | constexpr auto kSeed = 0x94378165; | |
35 | ||
36 | static void BenchmarkArrayRangeEquals(const std::shared_ptr<Array>& array, | |
37 | benchmark::State& state) { | |
38 | const auto left_array = array; | |
39 | // Make sure pointer equality can't be used as a shortcut | |
40 | // (should we would deep-copy child_data and buffers?) | |
41 | const auto right_array = | |
42 | MakeArray(array->data()->Copy())->Slice(1, array->length() - 1); | |
43 | ||
44 | for (auto _ : state) { | |
45 | const bool are_ok = ArrayRangeEquals(*left_array, *right_array, | |
46 | /*left_start_idx=*/1, | |
47 | /*left_end_idx=*/array->length() - 2, | |
48 | /*right_start_idx=*/0); | |
49 | if (ARROW_PREDICT_FALSE(!are_ok)) { | |
50 | ARROW_LOG(FATAL) << "Arrays should have compared equal"; | |
51 | } | |
52 | } | |
53 | } | |
54 | ||
55 | static void ArrayRangeEqualsInt32(benchmark::State& state) { | |
56 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
57 | ||
58 | auto rng = random::RandomArrayGenerator(kSeed); | |
59 | auto array = rng.Int32(args.size, 0, 100, args.null_proportion); | |
60 | ||
61 | BenchmarkArrayRangeEquals(array, state); | |
62 | } | |
63 | ||
64 | static void ArrayRangeEqualsFloat32(benchmark::State& state) { | |
65 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
66 | ||
67 | auto rng = random::RandomArrayGenerator(kSeed); | |
68 | auto array = rng.Float32(args.size, 0, 100, args.null_proportion); | |
69 | ||
70 | BenchmarkArrayRangeEquals(array, state); | |
71 | } | |
72 | ||
73 | static void ArrayRangeEqualsBoolean(benchmark::State& state) { | |
74 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
75 | ||
76 | auto rng = random::RandomArrayGenerator(kSeed); | |
77 | auto array = rng.Boolean(args.size, /*true_probability=*/0.3, args.null_proportion); | |
78 | ||
79 | BenchmarkArrayRangeEquals(array, state); | |
80 | } | |
81 | ||
82 | static void ArrayRangeEqualsString(benchmark::State& state) { | |
83 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
84 | ||
85 | auto rng = random::RandomArrayGenerator(kSeed); | |
86 | auto array = | |
87 | rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion); | |
88 | ||
89 | BenchmarkArrayRangeEquals(array, state); | |
90 | } | |
91 | ||
92 | static void ArrayRangeEqualsFixedSizeBinary(benchmark::State& state) { | |
93 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
94 | ||
95 | auto rng = random::RandomArrayGenerator(kSeed); | |
96 | auto array = rng.FixedSizeBinary(args.size, /*byte_width=*/8, args.null_proportion); | |
97 | ||
98 | BenchmarkArrayRangeEquals(array, state); | |
99 | } | |
100 | ||
101 | static void ArrayRangeEqualsListOfInt32(benchmark::State& state) { | |
102 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
103 | ||
104 | auto rng = random::RandomArrayGenerator(kSeed); | |
105 | auto values = rng.Int32(args.size * 10, 0, 100, args.null_proportion); | |
106 | // Force empty list null entries, since it is overwhelmingly the common case. | |
107 | auto array = rng.List(*values, /*size=*/args.size, args.null_proportion, | |
108 | /*force_empty_nulls=*/true); | |
109 | ||
110 | BenchmarkArrayRangeEquals(array, state); | |
111 | } | |
112 | ||
113 | static void ArrayRangeEqualsStruct(benchmark::State& state) { | |
114 | // struct<int32, utf8> | |
115 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
116 | ||
117 | auto rng = random::RandomArrayGenerator(kSeed); | |
118 | auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion); | |
119 | auto values2 = | |
120 | rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion); | |
121 | auto null_bitmap = rng.NullBitmap(args.size, args.null_proportion); | |
122 | auto array = *StructArray::Make({values1, values2}, | |
123 | std::vector<std::string>{"ints", "strs"}, null_bitmap); | |
124 | ||
125 | BenchmarkArrayRangeEquals(array, state); | |
126 | } | |
127 | ||
128 | static void ArrayRangeEqualsSparseUnion(benchmark::State& state) { | |
129 | // sparse_union<int32, utf8> | |
130 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
131 | ||
132 | auto rng = random::RandomArrayGenerator(kSeed); | |
133 | auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion); | |
134 | auto values2 = | |
135 | rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion); | |
136 | auto array = rng.SparseUnion({values1, values2}, args.size); | |
137 | ||
138 | BenchmarkArrayRangeEquals(array, state); | |
139 | } | |
140 | ||
141 | static void ArrayRangeEqualsDenseUnion(benchmark::State& state) { | |
142 | // dense_union<int32, utf8> | |
143 | RegressionArgs args(state, /*size_is_bytes=*/false); | |
144 | ||
145 | auto rng = random::RandomArrayGenerator(kSeed); | |
146 | auto values1 = rng.Int32(args.size, 0, 100, args.null_proportion); | |
147 | auto values2 = | |
148 | rng.String(args.size, /*min_length=*/0, /*max_length=*/15, args.null_proportion); | |
149 | auto array = rng.DenseUnion({values1, values2}, args.size); | |
150 | ||
151 | BenchmarkArrayRangeEquals(array, state); | |
152 | } | |
153 | ||
154 | BENCHMARK(ArrayRangeEqualsInt32)->Apply(RegressionSetArgs); | |
155 | BENCHMARK(ArrayRangeEqualsFloat32)->Apply(RegressionSetArgs); | |
156 | BENCHMARK(ArrayRangeEqualsBoolean)->Apply(RegressionSetArgs); | |
157 | BENCHMARK(ArrayRangeEqualsString)->Apply(RegressionSetArgs); | |
158 | BENCHMARK(ArrayRangeEqualsFixedSizeBinary)->Apply(RegressionSetArgs); | |
159 | BENCHMARK(ArrayRangeEqualsListOfInt32)->Apply(RegressionSetArgs); | |
160 | BENCHMARK(ArrayRangeEqualsStruct)->Apply(RegressionSetArgs); | |
161 | BENCHMARK(ArrayRangeEqualsSparseUnion)->Apply(RegressionSetArgs); | |
162 | BENCHMARK(ArrayRangeEqualsDenseUnion)->Apply(RegressionSetArgs); | |
163 | ||
164 | } // namespace arrow |