Skip to content

Commit 2cba8dc

Browse files
committed
Increase binary benchmark workloads
Signed-off-by: Connor Tsui <[email protected]>
1 parent 9876921 commit 2cba8dc

1 file changed

Lines changed: 139 additions & 61 deletions

File tree

‎vortex-array/benches/binary_ops.rs‎

Lines changed: 139 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
reason = "benchmark fixtures use indices that fit in the chosen widths"
88
)]
99

10+
use std::mem::size_of;
1011
use std::sync::LazyLock;
1112

1213
use divan::Bencher;
@@ -39,142 +40,210 @@ static SESSION: LazyLock<VortexSession> = LazyLock::new(array_session);
3940
/// Sized to keep CodSpeed simulation under 1ms per benchmark.
4041
const LEN: usize = 4_096;
4142

43+
/// Primitive cases process at least this many rows and this many value bytes per varying input.
44+
/// This lengthens narrow integer cases while keeping the current CodSpeed simulations below 1 ms.
45+
const MIN_PRIMITIVE_LEN: usize = 16_384;
46+
const MIN_PRIMITIVE_INPUT_BYTES: usize = 96 * 1_024;
47+
48+
const I8_LEN: usize = primitive_len::<i8>();
49+
const I16_LEN: usize = primitive_len::<i16>();
50+
const I32_LEN: usize = primitive_len::<i32>();
51+
const I64_LEN: usize = primitive_len::<i64>();
52+
53+
const BINARY_SHAPE_CASES: &[(usize, BinaryShape)] = &[
54+
(128, BinaryShape::PerRowPerRow),
55+
(128, BinaryShape::PerRowConstant),
56+
(128, BinaryShape::ConstantPerRow),
57+
(128, BinaryShape::PerRowNullableConstant),
58+
(I64_LEN, BinaryShape::PerRowPerRow),
59+
(I64_LEN, BinaryShape::PerRowConstant),
60+
(I64_LEN, BinaryShape::ConstantPerRow),
61+
(I64_LEN, BinaryShape::PerRowNullableConstant),
62+
];
63+
64+
#[derive(Clone, Copy, Debug)]
65+
enum BinaryShape {
66+
PerRowPerRow,
67+
PerRowConstant,
68+
ConstantPerRow,
69+
PerRowNullableConstant,
70+
}
71+
4272
/// Decimal Mul and Div cost far more per lane than Add, so they run over a shorter array to keep
4373
/// the instrumented CodSpeed runs quick.
4474
const DECIMAL_MUL_DIV_LEN: usize = 1_024;
4575

76+
#[divan::bench(args = BINARY_SHAPE_CASES)]
77+
fn add_shapes(bencher: Bencher, &(len, shape): &(usize, BinaryShape)) {
78+
bench_binary_shape(bencher, len, shape, Operator::Add);
79+
}
80+
81+
#[divan::bench(args = BINARY_SHAPE_CASES)]
82+
fn subtract_shapes(bencher: Bencher, &(len, shape): &(usize, BinaryShape)) {
83+
bench_binary_shape(bencher, len, shape, Operator::Sub);
84+
}
85+
86+
#[divan::bench(args = BINARY_SHAPE_CASES)]
87+
fn multiply_shapes(bencher: Bencher, &(len, shape): &(usize, BinaryShape)) {
88+
bench_binary_shape(bencher, len, shape, Operator::Mul);
89+
}
90+
91+
fn bench_binary_shape(bencher: Bencher, len: usize, shape: BinaryShape, operator: Operator) {
92+
let per_row =
93+
|| PrimitiveArray::from_iter((0..len).map(|index| (index % 1_024) as i64 + 1)).into_array();
94+
let constant = || ConstantArray::new(17_i64, len).into_array();
95+
let nullable_constant = || ConstantArray::new(Some(17_i64), len).into_array();
96+
97+
let (lhs, rhs) = match shape {
98+
BinaryShape::PerRowPerRow => (per_row(), per_row()),
99+
BinaryShape::PerRowConstant => (per_row(), constant()),
100+
BinaryShape::ConstantPerRow => (constant(), per_row()),
101+
BinaryShape::PerRowNullableConstant => (per_row(), nullable_constant()),
102+
};
103+
104+
bench_primitive(bencher, lhs, rhs, operator);
105+
}
106+
46107
#[divan::bench]
47108
fn add_i64_nonnull(bencher: Bencher) {
48-
let lhs = primitive_nonnull(0).into_array();
49-
let rhs = primitive_nonnull(1_000_000).into_array();
109+
let lhs = primitive_nonnull(0, I64_LEN).into_array();
110+
let rhs = primitive_nonnull(1_000_000, I64_LEN).into_array();
50111

51112
bench_primitive(bencher, lhs, rhs, Operator::Add);
52113
}
53114

54115
#[divan::bench]
55116
fn add_i64_nullable(bencher: Bencher) {
56-
let lhs = primitive_nullable(0, 7).into_array();
57-
let rhs = primitive_nullable(1_000_000, 5).into_array();
117+
let lhs = primitive_nullable(0, 7, I64_LEN).into_array();
118+
let rhs = primitive_nullable(1_000_000, 5, I64_LEN).into_array();
58119

59120
bench_primitive(bencher, lhs, rhs, Operator::Add);
60121
}
61122

62123
#[divan::bench]
63124
fn add_i64_constant(bencher: Bencher) {
64-
let lhs = primitive_nonnull(0).into_array();
65-
let rhs = ConstantArray::new(1_000_000i64, LEN).into_array();
125+
let lhs = primitive_nonnull(0, I64_LEN).into_array();
126+
let rhs = ConstantArray::new(1_000_000i64, I64_LEN).into_array();
66127

67128
bench_primitive(bencher, lhs, rhs, Operator::Add);
68129
}
69130

70131
#[divan::bench]
71132
fn add_i32_nonnull(bencher: Bencher) {
72-
let lhs = primitive_i32_small_nonnull(1).into_array();
73-
let rhs = primitive_i32_small_nonnull(17).into_array();
133+
let lhs = primitive_i32_small_nonnull(1, I32_LEN).into_array();
134+
let rhs = primitive_i32_small_nonnull(17, I32_LEN).into_array();
74135

75136
bench_primitive(bencher, lhs, rhs, Operator::Add);
76137
}
77138

78139
#[divan::bench]
79140
fn add_u32_nonnull(bencher: Bencher) {
80-
let lhs = primitive_u32_small_nonnull(1).into_array();
81-
let rhs = primitive_u32_small_nonnull(17).into_array();
141+
let lhs = primitive_u32_small_nonnull(1, I32_LEN).into_array();
142+
let rhs = primitive_u32_small_nonnull(17, I32_LEN).into_array();
82143

83144
bench_primitive(bencher, lhs, rhs, Operator::Add);
84145
}
85146

86147
#[divan::bench]
87148
fn mul_i64_nonnull(bencher: Bencher) {
88-
let lhs = primitive_small_nonnull(1).into_array();
89-
let rhs = primitive_small_nonnull(17).into_array();
149+
let lhs = primitive_small_nonnull(1, I64_LEN).into_array();
150+
let rhs = primitive_small_nonnull(17, I64_LEN).into_array();
90151

91152
bench_primitive(bencher, lhs, rhs, Operator::Mul);
92153
}
93154

94155
#[divan::bench]
95156
fn mul_i8_nonnull(bencher: Bencher) {
96-
let lhs = primitive_i8_small_nonnull(1).into_array();
97-
let rhs = primitive_i8_small_nonnull(7).into_array();
157+
let lhs = primitive_i8_small_nonnull(1, I8_LEN).into_array();
158+
let rhs = primitive_i8_small_nonnull(7, I8_LEN).into_array();
98159

99160
bench_primitive(bencher, lhs, rhs, Operator::Mul);
100161
}
101162

102163
#[divan::bench]
103164
fn mul_u8_nonnull(bencher: Bencher) {
104-
let lhs = primitive_u8_small_nonnull(1).into_array();
105-
let rhs = primitive_u8_small_nonnull(7).into_array();
165+
let lhs = primitive_u8_small_nonnull(1, I8_LEN).into_array();
166+
let rhs = primitive_u8_small_nonnull(7, I8_LEN).into_array();
106167

107168
bench_primitive(bencher, lhs, rhs, Operator::Mul);
108169
}
109170

110171
#[divan::bench]
111172
fn mul_i16_nonnull(bencher: Bencher) {
112-
let lhs = primitive_i16_small_nonnull(1).into_array();
113-
let rhs = primitive_i16_small_nonnull(17).into_array();
173+
let lhs = primitive_i16_small_nonnull(1, I16_LEN).into_array();
174+
let rhs = primitive_i16_small_nonnull(17, I16_LEN).into_array();
114175

115176
bench_primitive(bencher, lhs, rhs, Operator::Mul);
116177
}
117178

118179
#[divan::bench]
119180
fn mul_u16_nonnull(bencher: Bencher) {
120-
let lhs = primitive_u16_small_nonnull(1).into_array();
121-
let rhs = primitive_u16_small_nonnull(17).into_array();
181+
let lhs = primitive_u16_small_nonnull(1, I16_LEN).into_array();
182+
let rhs = primitive_u16_small_nonnull(17, I16_LEN).into_array();
122183

123184
bench_primitive(bencher, lhs, rhs, Operator::Mul);
124185
}
125186

126187
#[divan::bench]
127188
fn mul_i32_nonnull(bencher: Bencher) {
128-
let lhs = primitive_i32_small_nonnull(1).into_array();
129-
let rhs = primitive_i32_small_nonnull(17).into_array();
189+
let lhs = primitive_i32_small_nonnull(1, I32_LEN).into_array();
190+
let rhs = primitive_i32_small_nonnull(17, I32_LEN).into_array();
130191

131192
bench_primitive(bencher, lhs, rhs, Operator::Mul);
132193
}
133194

134195
#[divan::bench]
135196
fn mul_u32_nonnull(bencher: Bencher) {
136-
let lhs = primitive_u32_small_nonnull(1).into_array();
137-
let rhs = primitive_u32_small_nonnull(17).into_array();
197+
let lhs = primitive_u32_small_nonnull(1, I32_LEN).into_array();
198+
let rhs = primitive_u32_small_nonnull(17, I32_LEN).into_array();
138199

139200
bench_primitive(bencher, lhs, rhs, Operator::Mul);
140201
}
141202

142203
#[divan::bench]
143204
fn mul_u64_nonnull(bencher: Bencher) {
144-
let lhs = primitive_u64_small_nonnull(1).into_array();
145-
let rhs = primitive_u64_small_nonnull(17).into_array();
205+
let lhs = primitive_u64_small_nonnull(1, I64_LEN).into_array();
206+
let rhs = primitive_u64_small_nonnull(17, I64_LEN).into_array();
146207

147208
bench_primitive(bencher, lhs, rhs, Operator::Mul);
148209
}
149210

150211
#[divan::bench]
151212
fn mul_i32_nullable(bencher: Bencher) {
152-
let lhs = primitive_i32_small_nullable(1, 7).into_array();
153-
let rhs = primitive_i32_small_nullable(17, 5).into_array();
213+
let lhs = primitive_i32_small_nullable(1, 7, I32_LEN).into_array();
214+
let rhs = primitive_i32_small_nullable(17, 5, I32_LEN).into_array();
154215

155216
bench_primitive(bencher, lhs, rhs, Operator::Mul);
156217
}
157218

158219
#[divan::bench]
159220
fn mul_i32_constant(bencher: Bencher) {
160-
let lhs = primitive_i32_small_nonnull(1).into_array();
161-
let rhs = ConstantArray::new(31i32, LEN).into_array();
221+
let lhs = primitive_i32_small_nonnull(1, I32_LEN).into_array();
222+
let rhs = ConstantArray::new(31i32, I32_LEN).into_array();
162223

163224
bench_primitive(bencher, lhs, rhs, Operator::Mul);
164225
}
165226

166227
#[divan::bench]
167228
fn div_i64_nonnull(bencher: Bencher) {
168-
let lhs = primitive_nonnull(1_000_000).into_array();
169-
let rhs = primitive_nonzero().into_array();
229+
let lhs = primitive_nonnull(1_000_000, I64_LEN).into_array();
230+
let rhs = primitive_nonzero(I64_LEN).into_array();
231+
232+
bench_primitive(bencher, lhs, rhs, Operator::Div);
233+
}
234+
235+
#[divan::bench]
236+
fn div_i64_nullable(bencher: Bencher) {
237+
let lhs = primitive_nullable(1_000_000, 7, I64_LEN).into_array();
238+
let rhs = primitive_nullable(17, 5, I64_LEN).into_array();
170239

171240
bench_primitive(bencher, lhs, rhs, Operator::Div);
172241
}
173242

174243
#[divan::bench]
175244
fn sub_i64_constant(bencher: Bencher) {
176-
let lhs = primitive_nonnull(0).into_array();
177-
let rhs = ConstantArray::new(37i64, LEN).into_array();
245+
let lhs = primitive_nonnull(0, I64_LEN).into_array();
246+
let rhs = ConstantArray::new(37i64, I64_LEN).into_array();
178247

179248
bench_primitive(bencher, lhs, rhs, Operator::Sub);
180249
}
@@ -229,16 +298,16 @@ fn div_decimal_i128_nullable(bencher: Bencher) {
229298

230299
#[divan::bench]
231300
fn eq_i64_constant(bencher: Bencher) {
232-
let lhs = primitive_nonnull(0).into_array();
301+
let lhs = primitive_nonnull(0, LEN).into_array();
233302
let rhs = ConstantArray::new(1024i64, LEN).into_array();
234303

235304
bench_bool(bencher, lhs, rhs, Operator::Eq);
236305
}
237306

238307
#[divan::bench]
239308
fn lt_i64_nullable(bencher: Bencher) {
240-
let lhs = primitive_nullable(0, 7).into_array();
241-
let rhs = primitive_nullable(1_000_000, 5).into_array();
309+
let lhs = primitive_nullable(0, 7, LEN).into_array();
310+
let rhs = primitive_nullable(1_000_000, 5, LEN).into_array();
242311

243312
bench_bool(bencher, lhs, rhs, Operator::Lt);
244313
}
@@ -289,8 +358,17 @@ fn bench_binary<T: Executable + 'static>(
289358
});
290359
}
291360

292-
fn primitive_nonnull(base: i64) -> PrimitiveArray {
293-
PrimitiveArray::from_iter((0..LEN as i64).map(|i| base + i))
361+
const fn primitive_len<T>() -> usize {
362+
let input_len = MIN_PRIMITIVE_INPUT_BYTES / size_of::<T>();
363+
if input_len > MIN_PRIMITIVE_LEN {
364+
input_len
365+
} else {
366+
MIN_PRIMITIVE_LEN
367+
}
368+
}
369+
370+
fn primitive_nonnull(base: i64, len: usize) -> PrimitiveArray {
371+
PrimitiveArray::from_iter((0..len as i64).map(|i| base + i))
294372
}
295373

296374
fn decimal_i64_nonnull(base: i64, len: usize) -> DecimalArray {
@@ -304,50 +382,50 @@ fn decimal_i128_nullable(base: i128, null_every: usize, len: usize) -> DecimalAr
304382
)
305383
}
306384

307-
fn primitive_small_nonnull(offset: i64) -> PrimitiveArray {
308-
PrimitiveArray::from_iter((0..LEN as i64).map(|i| ((i + offset) % 1024) + 1))
385+
fn primitive_small_nonnull(offset: i64, len: usize) -> PrimitiveArray {
386+
PrimitiveArray::from_iter((0..len as i64).map(|i| ((i + offset) % 1024) + 1))
309387
}
310388

311-
fn primitive_i8_small_nonnull(offset: i8) -> PrimitiveArray {
312-
PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i32 + offset as i32) % 21) - 10) as i8))
389+
fn primitive_i8_small_nonnull(offset: i8, len: usize) -> PrimitiveArray {
390+
PrimitiveArray::from_iter((0..len).map(|i| (((i as i32 + offset as i32) % 21) - 10) as i8))
313391
}
314392

315-
fn primitive_u8_small_nonnull(offset: u8) -> PrimitiveArray {
316-
PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 15 + 1) as u8))
393+
fn primitive_u8_small_nonnull(offset: u8, len: usize) -> PrimitiveArray {
394+
PrimitiveArray::from_iter((0..len).map(|i| ((i + offset as usize) % 15 + 1) as u8))
317395
}
318396

319-
fn primitive_i16_small_nonnull(offset: i16) -> PrimitiveArray {
320-
PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i32 + offset as i32) % 255) - 127) as i16))
397+
fn primitive_i16_small_nonnull(offset: i16, len: usize) -> PrimitiveArray {
398+
PrimitiveArray::from_iter((0..len).map(|i| (((i as i32 + offset as i32) % 255) - 127) as i16))
321399
}
322400

323-
fn primitive_u16_small_nonnull(offset: u16) -> PrimitiveArray {
324-
PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 251 + 1) as u16))
401+
fn primitive_u16_small_nonnull(offset: u16, len: usize) -> PrimitiveArray {
402+
PrimitiveArray::from_iter((0..len).map(|i| ((i + offset as usize) % 251 + 1) as u16))
325403
}
326404

327-
fn primitive_i32_small_nonnull(offset: i32) -> PrimitiveArray {
328-
PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i64 + offset as i64) % 4096) - 2048) as i32))
405+
fn primitive_i32_small_nonnull(offset: i32, len: usize) -> PrimitiveArray {
406+
PrimitiveArray::from_iter((0..len).map(|i| (((i as i64 + offset as i64) % 4096) - 2048) as i32))
329407
}
330408

331-
fn primitive_u32_small_nonnull(offset: u32) -> PrimitiveArray {
332-
PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 4096 + 1) as u32))
409+
fn primitive_u32_small_nonnull(offset: u32, len: usize) -> PrimitiveArray {
410+
PrimitiveArray::from_iter((0..len).map(|i| ((i + offset as usize) % 4096 + 1) as u32))
333411
}
334412

335-
fn primitive_u64_small_nonnull(offset: u64) -> PrimitiveArray {
336-
PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 4096 + 1) as u64))
413+
fn primitive_u64_small_nonnull(offset: u64, len: usize) -> PrimitiveArray {
414+
PrimitiveArray::from_iter((0..len).map(|i| ((i + offset as usize) % 4096 + 1) as u64))
337415
}
338416

339-
fn primitive_nonzero() -> PrimitiveArray {
340-
PrimitiveArray::from_iter((0..LEN as i64).map(|i| (i % 255) + 1))
417+
fn primitive_nonzero(len: usize) -> PrimitiveArray {
418+
PrimitiveArray::from_iter((0..len as i64).map(|i| (i % 255) + 1))
341419
}
342420

343-
fn primitive_nullable(base: i64, null_every: usize) -> PrimitiveArray {
421+
fn primitive_nullable(base: i64, null_every: usize, len: usize) -> PrimitiveArray {
344422
PrimitiveArray::from_option_iter(
345-
(0..LEN as i64).map(|i| (!(i as usize).is_multiple_of(null_every)).then_some(base + i)),
423+
(0..len as i64).map(|i| (!(i as usize).is_multiple_of(null_every)).then_some(base + i)),
346424
)
347425
}
348426

349-
fn primitive_i32_small_nullable(offset: i32, null_every: usize) -> PrimitiveArray {
350-
PrimitiveArray::from_option_iter((0..LEN).map(|i| {
427+
fn primitive_i32_small_nullable(offset: i32, null_every: usize, len: usize) -> PrimitiveArray {
428+
PrimitiveArray::from_option_iter((0..len).map(|i| {
351429
(!i.is_multiple_of(null_every))
352430
.then_some((((i as i64 + offset as i64) % 4096) - 2048) as i32)
353431
}))

0 commit comments

Comments
 (0)