Skip to content

Commit 32a44e2

Browse files
0ax10ax1
committed
fix: black box input handling
Signed-off-by: Alexander Droste <[email protected]>
1 parent 563dc61 commit 32a44e2

File tree

1 file changed

+40
-50
lines changed

1 file changed

+40
-50
lines changed

‎vortex-buffer/benches/vortex_bitbuffer.rs‎

Lines changed: 40 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -37,45 +37,43 @@ fn from_iter<B: FromIterator<bool>>(n: usize) {
3737
#[divan::bench(args = INPUT_SIZE)]
3838
fn append_vortex_buffer(bencher: Bencher, length: usize) {
3939
bencher
40-
.with_inputs(|| BitBufferMut::with_capacity(length))
41-
.bench_refs(|buffer| {
42-
for idx in 0..length {
43-
buffer.append(divan::black_box(idx % 2 == 0));
40+
.with_inputs(|| (BitBufferMut::with_capacity(length), length))
41+
.bench_refs(|(buffer, length)| {
42+
for idx in 0..*length {
43+
buffer.append(idx % 2 == 0);
4444
}
4545
});
4646
}
4747

4848
#[divan::bench(args = INPUT_SIZE)]
4949
fn append_arrow_buffer(bencher: Bencher, length: usize) {
5050
bencher
51-
.with_inputs(|| Arrow(BooleanBufferBuilder::new(length)))
52-
.bench_refs(|buffer| {
53-
for idx in 0..length {
54-
buffer.0.append(divan::black_box(idx % 2 == 0));
51+
.with_inputs(|| (Arrow(BooleanBufferBuilder::new(length)), length))
52+
.bench_refs(|(buffer, length)| {
53+
for idx in 0..*length {
54+
buffer.0.append(idx % 2 == 0);
5555
}
5656
});
5757
}
5858

5959
#[divan::bench(args = INPUT_SIZE)]
6060
fn append_n_vortex_buffer(bencher: Bencher, length: usize) {
6161
bencher
62-
.with_inputs(|| BitBufferMut::with_capacity(length))
63-
.bench_refs(|buffer| {
62+
.with_inputs(|| (BitBufferMut::with_capacity(length), length, true))
63+
.bench_refs(|(buffer, length, boolean)| {
6464
for _ in 0..100 {
65-
buffer.append_n(divan::black_box(true), divan::black_box(length / 100));
65+
buffer.append_n(*boolean, *length / 100);
6666
}
6767
});
6868
}
6969

7070
#[divan::bench(args = INPUT_SIZE)]
7171
fn append_n_arrow_buffer(bencher: Bencher, length: usize) {
7272
bencher
73-
.with_inputs(|| Arrow(BooleanBufferBuilder::new(length)))
74-
.bench_refs(|buffer| {
73+
.with_inputs(|| (Arrow(BooleanBufferBuilder::new(length)), length, true))
74+
.bench_refs(|(buffer, length, boolean)| {
7575
for _ in 0..100 {
76-
buffer
77-
.0
78-
.append_n(divan::black_box(length / 100), divan::black_box(true));
76+
buffer.0.append_n(*length / 100, *boolean);
7977
}
8078
});
8179
}
@@ -90,7 +88,7 @@ fn append_buffer_vortex_buffer(bencher: Bencher, length: usize) {
9088
})
9189
.bench_refs(|(source, dest)| {
9290
for _ in 0..100 {
93-
dest.append_buffer(divan::black_box(source));
91+
dest.append_buffer(source);
9492
}
9593
});
9694
}
@@ -107,7 +105,7 @@ fn append_buffer_arrow_buffer(bencher: Bencher, length: usize) {
107105
})
108106
.bench_refs(|(source, dest)| {
109107
for _ in 0..100 {
110-
for value in divan::black_box(&source.0).iter() {
108+
for value in source.0.iter() {
111109
dest.0.append(value);
112110
}
113111
}
@@ -141,33 +139,35 @@ fn slice_vortex_buffer(bencher: Bencher, length: usize) {
141139
.with_inputs(|| (&buffer, length / 2))
142140
.bench_refs(|(buffer, mid)| {
143141
let mid = *mid;
144-
divan::black_box(buffer.slice(mid / 2..mid + mid / 2));
142+
buffer.slice(mid / 2..mid + mid / 2)
145143
});
146144
}
147145

148146
#[divan::bench(args = INPUT_SIZE)]
149147
fn slice_arrow_buffer(bencher: Bencher, length: usize) {
150148
let buffer = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
151-
bencher.with_inputs(|| &buffer).bench_refs(|buffer| {
152-
let mid = length / 2;
153-
divan::black_box(buffer.0.slice(mid / 2, mid / 2));
154-
});
149+
bencher
150+
.with_inputs(|| (&buffer, length / 2))
151+
.bench_refs(|(buffer, mid)| {
152+
let mid = *mid;
153+
buffer.0.slice(mid / 2, mid / 2)
154+
});
155155
}
156156

157157
#[divan::bench(args = INPUT_SIZE)]
158158
fn true_count_vortex_buffer(bencher: Bencher, length: usize) {
159159
let buffer = BitBuffer::from_iter((0..length).map(|i| i % 2 == 0));
160-
bencher.with_inputs(|| &buffer).bench_refs(|buffer| {
161-
divan::black_box(buffer.true_count());
162-
})
160+
bencher
161+
.with_inputs(|| &buffer)
162+
.bench_refs(|buffer| buffer.true_count())
163163
}
164164

165165
#[divan::bench(args = INPUT_SIZE)]
166166
fn true_count_arrow_buffer(bencher: Bencher, length: usize) {
167167
let buffer = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
168-
bencher.with_inputs(|| &buffer).bench_refs(|buffer| {
169-
divan::black_box(buffer.0.count_set_bits());
170-
});
168+
bencher
169+
.with_inputs(|| &buffer)
170+
.bench_refs(|buffer| buffer.0.count_set_bits());
171171
}
172172

173173
#[divan::bench(args = INPUT_SIZE)]
@@ -178,18 +178,16 @@ fn bitwise_and_vortex_buffer(bencher: Bencher, length: usize) {
178178
let b = BitBuffer::from_iter((0..length).map(|i| i % 3 == 0));
179179
(a, b)
180180
})
181-
.bench_values(|(a, b)| {
182-
divan::black_box(&a & &b);
183-
});
181+
.bench_values(|(a, b)| &a & &b);
184182
}
185183

186184
#[divan::bench(args = INPUT_SIZE)]
187185
fn bitwise_and_arrow_buffer(bencher: Bencher, length: usize) {
188186
let a = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
189187
let b = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 3 == 0)));
190-
bencher.with_inputs(|| (&a, &b)).bench_refs(|(a, b)| {
191-
divan::black_box(&a.0 & &b.0);
192-
});
188+
bencher
189+
.with_inputs(|| (&a, &b))
190+
.bench_refs(|(a, b)| &a.0 & &b.0);
193191
}
194192

195193
#[divan::bench(args = INPUT_SIZE)]
@@ -200,45 +198,37 @@ fn bitwise_or_vortex_buffer(bencher: Bencher, length: usize) {
200198
let b = BitBuffer::from_iter((0..length).map(|i| i % 3 == 0));
201199
(a, b)
202200
})
203-
.bench_values(|(a, b)| {
204-
divan::black_box(&a | &b);
205-
});
201+
.bench_values(|(a, b)| &a | &b);
206202
}
207203

208204
#[divan::bench(args = INPUT_SIZE)]
209205
fn bitwise_or_arrow_buffer(bencher: Bencher, length: usize) {
210206
let a = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
211207
let b = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 3 == 0)));
212-
bencher.with_inputs(|| (&a, &b)).bench_refs(|(a, b)| {
213-
divan::black_box(&a.0 | &b.0);
214-
});
208+
bencher
209+
.with_inputs(|| (&a, &b))
210+
.bench_refs(|(a, b)| &a.0 | &b.0);
215211
}
216212

217213
#[divan::bench(args = INPUT_SIZE)]
218214
fn bitwise_not_vortex_buffer(bencher: Bencher, length: usize) {
219215
bencher
220216
.with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
221-
.bench_values(|buffer| {
222-
divan::black_box(!&buffer);
223-
});
217+
.bench_values(|buffer| !&buffer);
224218
}
225219

226220
#[divan::bench(args = INPUT_SIZE)]
227221
fn bitwise_not_vortex_buffer_mut(bencher: Bencher, length: usize) {
228222
bencher
229223
.with_inputs(|| BitBufferMut::from_iter((0..length).map(|i| i % 2 == 0)))
230-
.bench_values(|buffer| {
231-
divan::black_box(!buffer);
232-
});
224+
.bench_values(|buffer| !buffer);
233225
}
234226

235227
#[divan::bench(args = INPUT_SIZE)]
236228
fn bitwise_not_arrow_buffer(bencher: Bencher, length: usize) {
237229
bencher
238230
.with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
239-
.bench_values(|buffer| {
240-
divan::black_box(!&buffer.0);
241-
});
231+
.bench_values(|buffer| !&buffer.0);
242232
}
243233

244234
#[divan::bench(args = INPUT_SIZE)]

0 commit comments

Comments
 (0)