This is an automated email from the ASF dual-hosted git repository.
mbrobbel pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/main by this push:
new 31ea84453b chore(deps): update criterion requirement from 0.5 to 0.6
(#7527)
31ea84453b is described below
commit 31ea84453b2f7ed7aa4e85825bd6cbf7ecd45f3a
Author: Matthijs Brobbel <[email protected]>
AuthorDate: Tue May 20 09:56:06 2025 +0200
chore(deps): update criterion requirement from 0.5 to 0.6 (#7527)
---
arrow-array/benches/decimal_overflow.rs | 9 ++++----
arrow-array/benches/fixed_size_list_array.rs | 4 ++--
arrow-array/benches/gc_view_types.rs | 5 +++--
arrow-array/benches/occupancy.rs | 4 ++--
arrow-array/benches/union_array.rs | 3 ++-
arrow-buffer/benches/bit_mask.rs | 13 ++++++-----
arrow-buffer/benches/i256.rs | 8 +++----
arrow-buffer/benches/offset.rs | 5 +++--
arrow-cast/benches/parse_date.rs | 3 ++-
arrow-cast/benches/parse_decimal.rs | 3 ++-
arrow-cast/benches/parse_time.rs | 3 ++-
arrow-cast/benches/parse_timestamp.rs | 3 ++-
arrow/Cargo.toml | 2 +-
arrow/benches/arithmetic_kernels.rs | 27 ++++++++++++-----------
arrow/benches/array_from_vec.rs | 12 +++++-----
arrow/benches/bit_length_kernel.rs | 3 ++-
arrow/benches/bitwise_kernel.rs | 31 +++++++++++++-------------
arrow/benches/boolean_kernels.rs | 7 +++---
arrow/benches/buffer_bit_ops.rs | 13 ++++++-----
arrow/benches/buffer_create.rs | 33 ++++++++++++++--------------
arrow/benches/builder.rs | 13 ++++++-----
arrow/benches/cast_kernels.rs | 3 ++-
arrow/benches/comparison_kernels.rs | 15 +++----------
arrow/benches/concatenate_kernel.rs | 5 +++--
arrow/benches/csv_writer.rs | 3 ++-
arrow/benches/equal.rs | 3 ++-
arrow/benches/filter_kernels.rs | 5 +++--
arrow/benches/interleave_kernels.rs | 3 ++-
arrow/benches/json_reader.rs | 3 ++-
arrow/benches/length_kernel.rs | 3 ++-
arrow/benches/lexsort.rs | 6 ++---
arrow/benches/partition_kernels.rs | 4 ++--
arrow/benches/primitive_run_take.rs | 3 ++-
arrow/benches/regexp_kernels.rs | 3 ++-
arrow/benches/row_format.rs | 12 +++++-----
arrow/benches/sort_kernel.rs | 17 +++++++-------
arrow/benches/substring_kernels.rs | 5 +++--
arrow/benches/take_kernels.rs | 5 +++--
parquet/benches/compression.rs | 7 +++++-
parquet/benches/row_selector.rs | 9 ++++----
40 files changed, 171 insertions(+), 147 deletions(-)
diff --git a/arrow-array/benches/decimal_overflow.rs
b/arrow-array/benches/decimal_overflow.rs
index 8f22b4b47c..f9438b76de 100644
--- a/arrow-array/benches/decimal_overflow.rs
+++ b/arrow-array/benches/decimal_overflow.rs
@@ -18,6 +18,7 @@
use arrow_array::builder::{Decimal128Builder, Decimal256Builder};
use arrow_buffer::i256;
use criterion::*;
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let len = 8192;
@@ -36,16 +37,16 @@ fn criterion_benchmark(c: &mut Criterion) {
let array_256 = builder_256.finish();
c.bench_function("validate_decimal_precision_128", |b| {
- b.iter(|| black_box(array_128.validate_decimal_precision(8)));
+ b.iter(|| hint::black_box(array_128.validate_decimal_precision(8)));
});
c.bench_function("null_if_overflow_precision_128", |b| {
- b.iter(|| black_box(array_128.null_if_overflow_precision(8)));
+ b.iter(|| hint::black_box(array_128.null_if_overflow_precision(8)));
});
c.bench_function("validate_decimal_precision_256", |b| {
- b.iter(|| black_box(array_256.validate_decimal_precision(8)));
+ b.iter(|| hint::black_box(array_256.validate_decimal_precision(8)));
});
c.bench_function("null_if_overflow_precision_256", |b| {
- b.iter(|| black_box(array_256.null_if_overflow_precision(8)));
+ b.iter(|| hint::black_box(array_256.null_if_overflow_precision(8)));
});
}
diff --git a/arrow-array/benches/fixed_size_list_array.rs
b/arrow-array/benches/fixed_size_list_array.rs
index f9b862f880..2bdb0c252b 100644
--- a/arrow-array/benches/fixed_size_list_array.rs
+++ b/arrow-array/benches/fixed_size_list_array.rs
@@ -19,7 +19,7 @@ use arrow_array::{Array, FixedSizeListArray, Int32Array};
use arrow_schema::Field;
use criterion::*;
use rand::{rng, Rng};
-use std::sync::Arc;
+use std::{hint, sync::Arc};
fn gen_fsl(len: usize, value_len: usize) -> FixedSizeListArray {
let mut rng = rng();
@@ -39,7 +39,7 @@ fn criterion_benchmark(c: &mut Criterion) {
|b| {
b.iter(|| {
for i in 0..len / value_len {
- black_box(fsl.value(i));
+ hint::black_box(fsl.value(i));
}
});
},
diff --git a/arrow-array/benches/gc_view_types.rs
b/arrow-array/benches/gc_view_types.rs
index 4b74a8f60b..cab60b47af 100644
--- a/arrow-array/benches/gc_view_types.rs
+++ b/arrow-array/benches/gc_view_types.rs
@@ -17,6 +17,7 @@
use arrow_array::StringViewArray;
use criterion::*;
+use std::hint;
fn gen_view_array(size: usize) -> StringViewArray {
StringViewArray::from_iter((0..size).map(|v| match v % 3 {
@@ -32,14 +33,14 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("gc view types all", |b| {
b.iter(|| {
- black_box(array.gc());
+ hint::black_box(array.gc());
});
});
let sliced = array.slice(0, 100_000 / 2);
c.bench_function("gc view types slice half", |b| {
b.iter(|| {
- black_box(sliced.gc());
+ hint::black_box(sliced.gc());
});
});
}
diff --git a/arrow-array/benches/occupancy.rs b/arrow-array/benches/occupancy.rs
index fd334b6132..2830203641 100644
--- a/arrow-array/benches/occupancy.rs
+++ b/arrow-array/benches/occupancy.rs
@@ -20,7 +20,7 @@ use arrow_array::{DictionaryArray, Int32Array};
use arrow_buffer::NullBuffer;
use criterion::*;
use rand::{rng, Rng};
-use std::sync::Arc;
+use std::{hint, sync::Arc};
fn gen_dict(
len: usize,
@@ -45,7 +45,7 @@ fn criterion_benchmark(c: &mut Criterion) {
let dict = gen_dict(1024, values, occupancy, null_percent);
c.bench_function(&format!("occupancy(values: {values},
occupancy: {occupancy}, null_percent: {null_percent})"), |b| {
b.iter(|| {
- black_box(&dict).occupancy()
+ hint::black_box(&dict).occupancy()
});
});
}
diff --git a/arrow-array/benches/union_array.rs
b/arrow-array/benches/union_array.rs
index 753cc8148e..f3894e249f 100644
--- a/arrow-array/benches/union_array.rs
+++ b/arrow-array/benches/union_array.rs
@@ -16,6 +16,7 @@
// under the License.
use std::{
+ hint,
iter::{repeat, repeat_with},
sync::Arc,
};
@@ -73,7 +74,7 @@ fn criterion_benchmark(c: &mut Criterion) {
)
.unwrap();
- b.iter(|| black_box(array.logical_nulls()))
+ b.iter(|| hint::black_box(array.logical_nulls()))
},
);
}
diff --git a/arrow-buffer/benches/bit_mask.rs b/arrow-buffer/benches/bit_mask.rs
index 6907e336a4..545528724e 100644
--- a/arrow-buffer/benches/bit_mask.rs
+++ b/arrow-buffer/benches/bit_mask.rs
@@ -16,7 +16,8 @@
// under the License.
use arrow_buffer::bit_mask::set_bits;
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId,
Criterion};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let mut group = c.benchmark_group("bit_mask");
@@ -38,11 +39,11 @@ fn criterion_benchmark(c: &mut Criterion) {
|b, &x| {
b.iter(|| {
set_bits(
- black_box(&mut [0u8; 9]),
- black_box(&[x.3; 9]),
- black_box(x.0),
- black_box(x.1),
- black_box(x.2),
+ hint::black_box(&mut [0u8; 9]),
+ hint::black_box(&[x.3; 9]),
+ hint::black_box(x.0),
+ hint::black_box(x.1),
+ hint::black_box(x.2),
)
});
},
diff --git a/arrow-buffer/benches/i256.rs b/arrow-buffer/benches/i256.rs
index f94ca6951e..7dec226bbc 100644
--- a/arrow-buffer/benches/i256.rs
+++ b/arrow-buffer/benches/i256.rs
@@ -19,7 +19,7 @@ use arrow_buffer::i256;
use criterion::*;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
-use std::str::FromStr;
+use std::{hint, str::FromStr};
const SIZE: usize = 1024;
@@ -37,7 +37,7 @@ fn criterion_benchmark(c: &mut Criterion) {
];
for number in numbers {
- let t = black_box(number.to_string());
+ let t = hint::black_box(number.to_string());
c.bench_function(&format!("i256_parse({t})"), |b| {
b.iter(|| i256::from_str(&t).unwrap());
});
@@ -64,7 +64,7 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("i256_div_rem small quotient", |b| {
b.iter(|| {
for (n, d) in numerators.iter().zip(&divisors) {
- black_box(n.wrapping_div(*d));
+ hint::black_box(n.wrapping_div(*d));
}
});
});
@@ -76,7 +76,7 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("i256_div_rem small divisor", |b| {
b.iter(|| {
for (n, d) in numerators.iter().zip(&divisors) {
- black_box(n.wrapping_div(*d));
+ hint::black_box(n.wrapping_div(*d));
}
});
});
diff --git a/arrow-buffer/benches/offset.rs b/arrow-buffer/benches/offset.rs
index 12c00a60c5..0d6128b692 100644
--- a/arrow-buffer/benches/offset.rs
+++ b/arrow-buffer/benches/offset.rs
@@ -19,12 +19,13 @@ use arrow_buffer::{OffsetBuffer, OffsetBufferBuilder};
use criterion::*;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
+use std::hint;
const SIZE: usize = 1024;
fn criterion_benchmark(c: &mut Criterion) {
let mut rng = StdRng::seed_from_u64(42);
- let lengths: Vec<usize> = black_box((0..SIZE).map(|_|
rng.random_range(0..40)).collect());
+ let lengths: Vec<usize> = hint::black_box((0..SIZE).map(|_|
rng.random_range(0..40)).collect());
c.bench_function("OffsetBuffer::from_lengths", |b| {
b.iter(|| OffsetBuffer::<i32>::from_lengths(lengths.iter().copied()));
@@ -41,7 +42,7 @@ fn criterion_benchmark(c: &mut Criterion) {
let offsets =
OffsetBuffer::<i32>::from_lengths(lengths.iter().copied()).into_inner();
c.bench_function("OffsetBuffer::new", |b| {
- b.iter(|| OffsetBuffer::new(black_box(offsets.clone())));
+ b.iter(|| OffsetBuffer::new(hint::black_box(offsets.clone())));
});
}
diff --git a/arrow-cast/benches/parse_date.rs b/arrow-cast/benches/parse_date.rs
index e05d38d2f8..0fdc139118 100644
--- a/arrow-cast/benches/parse_date.rs
+++ b/arrow-cast/benches/parse_date.rs
@@ -18,12 +18,13 @@
use arrow_array::types::Date32Type;
use arrow_cast::parse::Parser;
use criterion::*;
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let timestamps = ["2020-09-08", "2020-9-8", "2020-09-8", "2020-9-08"];
for timestamp in timestamps {
- let t = black_box(timestamp);
+ let t = hint::black_box(timestamp);
c.bench_function(t, |b| {
b.iter(|| Date32Type::parse(t).unwrap());
});
diff --git a/arrow-cast/benches/parse_decimal.rs
b/arrow-cast/benches/parse_decimal.rs
index 5682859dd2..28364b733c 100644
--- a/arrow-cast/benches/parse_decimal.rs
+++ b/arrow-cast/benches/parse_decimal.rs
@@ -18,6 +18,7 @@
use arrow_array::types::Decimal256Type;
use arrow_cast::parse::parse_decimal;
use criterion::*;
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let decimals = [
@@ -45,7 +46,7 @@ fn criterion_benchmark(c: &mut Criterion) {
];
for decimal in decimals {
- let d = black_box(decimal);
+ let d = hint::black_box(decimal);
c.bench_function(d, |b| {
b.iter(|| parse_decimal::<Decimal256Type>(d, 20, 3).unwrap());
});
diff --git a/arrow-cast/benches/parse_time.rs b/arrow-cast/benches/parse_time.rs
index d28b9c7c61..8d3915bdaf 100644
--- a/arrow-cast/benches/parse_time.rs
+++ b/arrow-cast/benches/parse_time.rs
@@ -17,6 +17,7 @@
use arrow_cast::parse::string_to_time_nanoseconds;
use criterion::*;
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let timestamps = [
@@ -31,7 +32,7 @@ fn criterion_benchmark(c: &mut Criterion) {
];
for timestamp in timestamps {
- let t = black_box(timestamp);
+ let t = hint::black_box(timestamp);
c.bench_function(t, |b| {
b.iter(|| string_to_time_nanoseconds(t).unwrap());
});
diff --git a/arrow-cast/benches/parse_timestamp.rs
b/arrow-cast/benches/parse_timestamp.rs
index d3ab41863e..12cad5b78e 100644
--- a/arrow-cast/benches/parse_timestamp.rs
+++ b/arrow-cast/benches/parse_timestamp.rs
@@ -17,6 +17,7 @@
use arrow_cast::parse::string_to_timestamp_nanos;
use criterion::*;
+use std::hint;
fn criterion_benchmark(c: &mut Criterion) {
let timestamps = [
@@ -33,7 +34,7 @@ fn criterion_benchmark(c: &mut Criterion) {
];
for timestamp in timestamps {
- let t = black_box(timestamp);
+ let t = hint::black_box(timestamp);
c.bench_function(t, |b| {
b.iter(|| string_to_timestamp_nanos(t).unwrap());
});
diff --git a/arrow/Cargo.toml b/arrow/Cargo.toml
index 31398b462e..45d6018286 100644
--- a/arrow/Cargo.toml
+++ b/arrow/Cargo.toml
@@ -84,7 +84,7 @@ canonical_extension_types =
["arrow-schema/canonical_extension_types"]
[dev-dependencies]
chrono = { workspace = true }
-criterion = { version = "0.5", default-features = false }
+criterion = { version = "0.6", default-features = false }
half = { version = "2.1", default-features = false }
rand = { version = "0.9", default-features = false, features = ["std",
"std_rng", "thread_rng"] }
serde = { version = "1.0", default-features = false, features = ["derive"] }
diff --git a/arrow/benches/arithmetic_kernels.rs
b/arrow/benches/arithmetic_kernels.rs
index e982b0eb4b..af2db62ccd 100644
--- a/arrow/benches/arithmetic_kernels.rs
+++ b/arrow/benches/arithmetic_kernels.rs
@@ -23,6 +23,7 @@ use arrow::compute::kernels::numeric::*;
use arrow::datatypes::Float32Type;
use arrow::util::bench_util::*;
use arrow_array::Scalar;
+use std::hint;
fn add_benchmark(c: &mut Criterion) {
const BATCH_SIZE: usize = 64 * 1024;
@@ -33,43 +34,43 @@ fn add_benchmark(c: &mut Criterion) {
let scalar = Scalar::new(&scalar_a);
c.bench_function(&format!("add({null_density})"), |b| {
- b.iter(|| criterion::black_box(add_wrapping(&arr_a,
&arr_b).unwrap()))
+ b.iter(|| hint::black_box(add_wrapping(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("add_checked({null_density})"), |b| {
- b.iter(|| criterion::black_box(add(&arr_a, &arr_b).unwrap()))
+ b.iter(|| hint::black_box(add(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("add_scalar({null_density})"), |b| {
- b.iter(|| criterion::black_box(add_wrapping(&arr_a,
&scalar).unwrap()))
+ b.iter(|| hint::black_box(add_wrapping(&arr_a, &scalar).unwrap()))
});
c.bench_function(&format!("subtract({null_density})"), |b| {
- b.iter(|| criterion::black_box(sub_wrapping(&arr_a,
&arr_b).unwrap()))
+ b.iter(|| hint::black_box(sub_wrapping(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("subtract_checked({null_density})"), |b| {
- b.iter(|| criterion::black_box(sub(&arr_a, &arr_b).unwrap()))
+ b.iter(|| hint::black_box(sub(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("subtract_scalar({null_density})"), |b| {
- b.iter(|| criterion::black_box(sub_wrapping(&arr_a,
&scalar).unwrap()))
+ b.iter(|| hint::black_box(sub_wrapping(&arr_a, &scalar).unwrap()))
});
c.bench_function(&format!("multiply({null_density})"), |b| {
- b.iter(|| criterion::black_box(mul_wrapping(&arr_a,
&arr_b).unwrap()))
+ b.iter(|| hint::black_box(mul_wrapping(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("multiply_checked({null_density})"), |b| {
- b.iter(|| criterion::black_box(mul(&arr_a, &arr_b).unwrap()))
+ b.iter(|| hint::black_box(mul(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("multiply_scalar({null_density})"), |b| {
- b.iter(|| criterion::black_box(mul_wrapping(&arr_a,
&scalar).unwrap()))
+ b.iter(|| hint::black_box(mul_wrapping(&arr_a, &scalar).unwrap()))
});
c.bench_function(&format!("divide({null_density})"), |b| {
- b.iter(|| criterion::black_box(div(&arr_a, &arr_b).unwrap()))
+ b.iter(|| hint::black_box(div(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("divide_scalar({null_density})"), |b| {
- b.iter(|| criterion::black_box(div(&arr_a, &scalar).unwrap()))
+ b.iter(|| hint::black_box(div(&arr_a, &scalar).unwrap()))
});
c.bench_function(&format!("modulo({null_density})"), |b| {
- b.iter(|| criterion::black_box(rem(&arr_a, &arr_b).unwrap()))
+ b.iter(|| hint::black_box(rem(&arr_a, &arr_b).unwrap()))
});
c.bench_function(&format!("modulo_scalar({null_density})"), |b| {
- b.iter(|| criterion::black_box(rem(&arr_a, &scalar).unwrap()))
+ b.iter(|| hint::black_box(rem(&arr_a, &scalar).unwrap()))
});
}
}
diff --git a/arrow/benches/array_from_vec.rs b/arrow/benches/array_from_vec.rs
index c256d1523b..2850eae5d7 100644
--- a/arrow/benches/array_from_vec.rs
+++ b/arrow/benches/array_from_vec.rs
@@ -25,11 +25,11 @@ extern crate arrow;
use arrow::array::*;
use arrow_buffer::i256;
use rand::Rng;
-use std::sync::Arc;
+use std::{hint, sync::Arc};
fn array_from_vec(n: usize) {
let v: Vec<i32> = (0..n as i32).collect();
- criterion::black_box(Int32Array::from(v));
+ hint::black_box(Int32Array::from(v));
}
fn array_string_from_vec(n: usize) {
@@ -41,7 +41,7 @@ fn array_string_from_vec(n: usize) {
v.push(None);
}
}
- criterion::black_box(StringArray::from(v));
+ hint::black_box(StringArray::from(v));
}
fn struct_array_values(
@@ -70,11 +70,11 @@ fn struct_array_from_vec(
let strings: ArrayRef = Arc::new(StringArray::from(strings.to_owned()));
let ints: ArrayRef = Arc::new(Int32Array::from(ints.to_owned()));
- criterion::black_box(StructArray::try_from(vec![(field1, strings),
(field2, ints)]).unwrap());
+ hint::black_box(StructArray::try_from(vec![(field1, strings), (field2,
ints)]).unwrap());
}
fn decimal128_array_from_vec(array: &[Option<i128>]) {
- criterion::black_box(
+ hint::black_box(
array
.iter()
.copied()
@@ -85,7 +85,7 @@ fn decimal128_array_from_vec(array: &[Option<i128>]) {
}
fn decimal256_array_from_vec(array: &[Option<i256>]) {
- criterion::black_box(
+ hint::black_box(
array
.iter()
.copied()
diff --git a/arrow/benches/bit_length_kernel.rs
b/arrow/benches/bit_length_kernel.rs
index 51d3134571..a8368bf3d2 100644
--- a/arrow/benches/bit_length_kernel.rs
+++ b/arrow/benches/bit_length_kernel.rs
@@ -22,9 +22,10 @@ use criterion::Criterion;
extern crate arrow;
use arrow::{array::*, compute::kernels::length::bit_length};
+use std::hint;
fn bench_bit_length(array: &StringArray) {
- criterion::black_box(bit_length(array).unwrap());
+ hint::black_box(bit_length(array).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/bitwise_kernel.rs b/arrow/benches/bitwise_kernel.rs
index 8604ea97eb..f8a1c6bec1 100644
--- a/arrow/benches/bitwise_kernel.rs
+++ b/arrow/benches/bitwise_kernel.rs
@@ -23,8 +23,9 @@ use arrow::compute::kernels::bitwise::{
bitwise_xor_scalar,
};
use arrow::datatypes::Int64Type;
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
use rand::RngCore;
+use std::hint;
extern crate arrow;
@@ -40,37 +41,37 @@ fn bitwise_array_benchmark(c: &mut Criterion) {
// array and
let mut group = c.benchmark_group("bench bitwise array: and");
group.bench_function("bitwise array and, no nulls", |b| {
- b.iter(|| black_box(bitwise_and(&left_without_null,
&right_without_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_and(&left_without_null,
&right_without_null).unwrap()))
});
group.bench_function("bitwise array and, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_and(&left_with_null,
&right_with_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_and(&left_with_null,
&right_with_null).unwrap()))
});
group.finish();
// array or
let mut group = c.benchmark_group("bench bitwise: or");
group.bench_function("bitwise array or, no nulls", |b| {
- b.iter(|| black_box(bitwise_or(&left_without_null,
&right_without_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_or(&left_without_null,
&right_without_null).unwrap()))
});
group.bench_function("bitwise array or, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_or(&left_with_null,
&right_with_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_or(&left_with_null,
&right_with_null).unwrap()))
});
group.finish();
// xor
let mut group = c.benchmark_group("bench bitwise: xor");
group.bench_function("bitwise array xor, no nulls", |b| {
- b.iter(|| black_box(bitwise_xor(&left_without_null,
&right_without_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_xor(&left_without_null,
&right_without_null).unwrap()))
});
group.bench_function("bitwise array xor, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_xor(&left_with_null,
&right_with_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_xor(&left_with_null,
&right_with_null).unwrap()))
});
group.finish();
// not
let mut group = c.benchmark_group("bench bitwise: not");
group.bench_function("bitwise array not, no nulls", |b| {
- b.iter(|| black_box(bitwise_not(&left_without_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_not(&left_without_null).unwrap()))
});
group.bench_function("bitwise array not, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_not(&left_with_null).unwrap()))
+ b.iter(|| hint::black_box(bitwise_not(&left_with_null).unwrap()))
});
group.finish();
}
@@ -83,28 +84,28 @@ fn bitwise_array_scalar_benchmark(c: &mut Criterion) {
// array scalar and
let mut group = c.benchmark_group("bench bitwise array scalar: and");
group.bench_function("bitwise array scalar and, no nulls", |b| {
- b.iter(|| black_box(bitwise_and_scalar(&array_without_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_and_scalar(&array_without_null,
scalar).unwrap()))
});
group.bench_function("bitwise array and, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_and_scalar(&array_with_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_and_scalar(&array_with_null,
scalar).unwrap()))
});
group.finish();
// array scalar or
let mut group = c.benchmark_group("bench bitwise array scalar: or");
group.bench_function("bitwise array scalar or, no nulls", |b| {
- b.iter(|| black_box(bitwise_or_scalar(&array_without_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_or_scalar(&array_without_null,
scalar).unwrap()))
});
group.bench_function("bitwise array scalar or, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_or_scalar(&array_with_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_or_scalar(&array_with_null,
scalar).unwrap()))
});
group.finish();
// array scalar xor
let mut group = c.benchmark_group("bench bitwise array scalar: xor");
group.bench_function("bitwise array scalar xor, no nulls", |b| {
- b.iter(|| black_box(bitwise_xor_scalar(&array_without_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_xor_scalar(&array_without_null,
scalar).unwrap()))
});
group.bench_function("bitwise array scalar xor, 20% nulls", |b| {
- b.iter(|| black_box(bitwise_xor_scalar(&array_with_null,
scalar).unwrap()))
+ b.iter(|| hint::black_box(bitwise_xor_scalar(&array_with_null,
scalar).unwrap()))
});
group.finish();
}
diff --git a/arrow/benches/boolean_kernels.rs b/arrow/benches/boolean_kernels.rs
index ba085e2959..8d1d51242a 100644
--- a/arrow/benches/boolean_kernels.rs
+++ b/arrow/benches/boolean_kernels.rs
@@ -25,17 +25,18 @@ extern crate arrow;
use arrow::array::*;
use arrow::compute::kernels::boolean as boolean_kernels;
+use std::hint;
fn bench_and(lhs: &BooleanArray, rhs: &BooleanArray) {
- criterion::black_box(boolean_kernels::and(lhs, rhs).unwrap());
+ hint::black_box(boolean_kernels::and(lhs, rhs).unwrap());
}
fn bench_or(lhs: &BooleanArray, rhs: &BooleanArray) {
- criterion::black_box(boolean_kernels::or(lhs, rhs).unwrap());
+ hint::black_box(boolean_kernels::or(lhs, rhs).unwrap());
}
fn bench_not(array: &BooleanArray) {
- criterion::black_box(boolean_kernels::not(array).unwrap());
+ hint::black_box(boolean_kernels::not(array).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/buffer_bit_ops.rs b/arrow/benches/buffer_bit_ops.rs
index ab122ac941..b46544b1f8 100644
--- a/arrow/benches/buffer_bit_ops.rs
+++ b/arrow/benches/buffer_bit_ops.rs
@@ -23,6 +23,7 @@ use criterion::{Criterion, Throughput};
extern crate arrow;
use arrow::buffer::{buffer_bin_and, buffer_bin_or, buffer_unary_not, Buffer,
MutableBuffer};
+use std::hint;
/// Helper function to create arrays
fn create_buffer(size: usize) -> Buffer {
@@ -36,15 +37,15 @@ fn create_buffer(size: usize) -> Buffer {
}
fn bench_buffer_and(left: &Buffer, right: &Buffer) {
- criterion::black_box(buffer_bin_and(left, 0, right, 0, left.len() * 8));
+ hint::black_box(buffer_bin_and(left, 0, right, 0, left.len() * 8));
}
fn bench_buffer_or(left: &Buffer, right: &Buffer) {
- criterion::black_box(buffer_bin_or(left, 0, right, 0, left.len() * 8));
+ hint::black_box(buffer_bin_or(left, 0, right, 0, left.len() * 8));
}
fn bench_buffer_not(buffer: &Buffer) {
- criterion::black_box(buffer_unary_not(buffer, 0, buffer.len() * 8));
+ hint::black_box(buffer_unary_not(buffer, 0, buffer.len() * 8));
}
fn bench_buffer_and_with_offsets(
@@ -54,7 +55,7 @@ fn bench_buffer_and_with_offsets(
right_offset: usize,
len: usize,
) {
- criterion::black_box(buffer_bin_and(left, left_offset, right,
right_offset, len));
+ hint::black_box(buffer_bin_and(left, left_offset, right, right_offset,
len));
}
fn bench_buffer_or_with_offsets(
@@ -64,11 +65,11 @@ fn bench_buffer_or_with_offsets(
right_offset: usize,
len: usize,
) {
- criterion::black_box(buffer_bin_or(left, left_offset, right, right_offset,
len));
+ hint::black_box(buffer_bin_or(left, left_offset, right, right_offset,
len));
}
fn bench_buffer_not_with_offsets(buffer: &Buffer, offset: usize, len: usize) {
- criterion::black_box(buffer_unary_not(buffer, offset, len));
+ hint::black_box(buffer_unary_not(buffer, offset, len));
}
fn bit_ops_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/buffer_create.rs b/arrow/benches/buffer_create.rs
index 2c4d0d6a99..690327e86f 100644
--- a/arrow/benches/buffer_create.rs
+++ b/arrow/benches/buffer_create.rs
@@ -28,9 +28,10 @@ use arrow::{
buffer::{Buffer, MutableBuffer},
datatypes::ToByteSlice,
};
+use std::hint;
fn mutable_buffer_from_iter(data: &[Vec<bool>]) -> Vec<Buffer> {
- criterion::black_box(
+ hint::black_box(
data.iter()
.map(|vec| vec.iter().copied().collect::<MutableBuffer>().into())
.collect::<Vec<_>>(),
@@ -38,7 +39,7 @@ fn mutable_buffer_from_iter(data: &[Vec<bool>]) ->
Vec<Buffer> {
}
fn buffer_from_iter(data: &[Vec<bool>]) -> Vec<Buffer> {
- criterion::black_box(
+ hint::black_box(
data.iter()
.map(|vec| vec.iter().copied().collect::<Buffer>())
.collect::<Vec<_>>(),
@@ -46,7 +47,7 @@ fn buffer_from_iter(data: &[Vec<bool>]) -> Vec<Buffer> {
}
fn mutable_buffer_iter_bitset(data: &[Vec<bool>]) -> Vec<Buffer> {
- criterion::black_box({
+ hint::black_box({
data.iter()
.map(|datum| {
let mut result =
@@ -65,7 +66,7 @@ fn mutable_buffer_iter_bitset(data: &[Vec<bool>]) ->
Vec<Buffer> {
}
fn mutable_iter_extend_from_slice(data: &[Vec<u32>], capacity: usize) ->
Buffer {
- criterion::black_box({
+ hint::black_box({
let mut result = MutableBuffer::new(capacity);
data.iter().for_each(|vec| {
@@ -78,7 +79,7 @@ fn mutable_iter_extend_from_slice(data: &[Vec<u32>],
capacity: usize) -> Buffer
}
fn mutable_buffer(data: &[Vec<u32>], capacity: usize) -> Buffer {
- criterion::black_box({
+ hint::black_box({
let mut result = MutableBuffer::new(capacity);
data.iter().for_each(|vec| result.extend_from_slice(vec));
@@ -88,7 +89,7 @@ fn mutable_buffer(data: &[Vec<u32>], capacity: usize) ->
Buffer {
}
fn mutable_buffer_extend(data: &[Vec<u32>], capacity: usize) -> Buffer {
- criterion::black_box({
+ hint::black_box({
let mut result = MutableBuffer::new(capacity);
data.iter()
@@ -99,7 +100,7 @@ fn mutable_buffer_extend(data: &[Vec<u32>], capacity: usize)
-> Buffer {
}
fn from_slice(data: &[Vec<u32>], capacity: usize) -> Buffer {
- criterion::black_box({
+ hint::black_box({
let mut a = Vec::<u32>::with_capacity(capacity);
data.iter().for_each(|vec| a.extend(vec));
@@ -147,12 +148,10 @@ fn benchmark(c: &mut Criterion) {
let byte_cap = cap * std::mem::size_of::<u32>();
c.bench_function("mutable iter extend_from_slice", |b| {
- b.iter(|| {
- mutable_iter_extend_from_slice(criterion::black_box(&data),
criterion::black_box(0))
- })
+ b.iter(|| mutable_iter_extend_from_slice(hint::black_box(&data),
hint::black_box(0)))
});
c.bench_function("mutable", |b| {
- b.iter(|| mutable_buffer(criterion::black_box(&data),
criterion::black_box(0)))
+ b.iter(|| mutable_buffer(hint::black_box(&data), hint::black_box(0)))
});
c.bench_function("mutable extend", |b| {
@@ -160,24 +159,24 @@ fn benchmark(c: &mut Criterion) {
});
c.bench_function("mutable prepared", |b| {
- b.iter(|| mutable_buffer(criterion::black_box(&data),
criterion::black_box(byte_cap)))
+ b.iter(|| mutable_buffer(hint::black_box(&data),
hint::black_box(byte_cap)))
});
c.bench_function("from_slice", |b| {
- b.iter(|| from_slice(criterion::black_box(&data),
criterion::black_box(0)))
+ b.iter(|| from_slice(hint::black_box(&data), hint::black_box(0)))
});
c.bench_function("from_slice prepared", |b| {
- b.iter(|| from_slice(criterion::black_box(&data),
criterion::black_box(cap)))
+ b.iter(|| from_slice(hint::black_box(&data), hint::black_box(cap)))
});
c.bench_function("MutableBuffer iter bitset", |b| {
- b.iter(|| mutable_buffer_iter_bitset(criterion::black_box(&bool_data)))
+ b.iter(|| mutable_buffer_iter_bitset(hint::black_box(&bool_data)))
});
c.bench_function("MutableBuffer::from_iter bool", |b| {
- b.iter(|| mutable_buffer_from_iter(criterion::black_box(&bool_data)))
+ b.iter(|| mutable_buffer_from_iter(hint::black_box(&bool_data)))
});
c.bench_function("Buffer::from_iter bool", |b| {
- b.iter(|| buffer_from_iter(criterion::black_box(&bool_data)))
+ b.iter(|| buffer_from_iter(hint::black_box(&bool_data)))
});
}
diff --git a/arrow/benches/builder.rs b/arrow/benches/builder.rs
index 4f5f38eadf..46dd18c0fa 100644
--- a/arrow/benches/builder.rs
+++ b/arrow/benches/builder.rs
@@ -28,6 +28,7 @@ use arrow::array::*;
use arrow::util::test_util::seedable_rng;
use arrow_buffer::i256;
use rand::Rng;
+use std::hint;
// Build arrays with 512k elements.
const BATCH_SIZE: usize = 8 << 10;
@@ -46,7 +47,7 @@ fn bench_primitive(c: &mut Criterion) {
for _ in 0..NUM_BATCHES {
builder.append_slice(&data[..]);
}
- black_box(builder.finish());
+ hint::black_box(builder.finish());
})
});
group.finish();
@@ -60,7 +61,7 @@ fn bench_primitive_nulls(c: &mut Criterion) {
for _ in 0..NUM_BATCHES * BATCH_SIZE {
builder.append_null();
}
- black_box(builder.finish());
+ hint::black_box(builder.finish());
})
});
group.finish();
@@ -83,7 +84,7 @@ fn bench_bool(c: &mut Criterion) {
for _ in 0..NUM_BATCHES {
builder.append_slice(&data[..]);
}
- black_box(builder.finish());
+ hint::black_box(builder.finish());
})
});
group.finish();
@@ -101,7 +102,7 @@ fn bench_string(c: &mut Criterion) {
for _ in 0..NUM_BATCHES * BATCH_SIZE {
builder.append_value(SAMPLE_STRING);
}
- black_box(builder.finish());
+ hint::black_box(builder.finish());
})
});
group.finish();
@@ -115,7 +116,7 @@ fn bench_decimal128(c: &mut Criterion) {
for _ in 0..BATCH_SIZE {
decimal_builder.append_value(rng.random_range::<i128,
_>(0..9999999999));
}
- black_box(
+ hint::black_box(
decimal_builder
.finish()
.with_precision_and_scale(38, 0)
@@ -134,7 +135,7 @@ fn bench_decimal256(c: &mut Criterion) {
decimal_builder
.append_value(i256::from_i128(rng.random_range::<i128,
_>(0..99999999999)));
}
- black_box(
+ hint::black_box(
decimal_builder
.finish()
.with_precision_and_scale(76, 10)
diff --git a/arrow/benches/cast_kernels.rs b/arrow/benches/cast_kernels.rs
index a68fc48d30..d01031be5f 100644
--- a/arrow/benches/cast_kernels.rs
+++ b/arrow/benches/cast_kernels.rs
@@ -20,6 +20,7 @@ extern crate criterion;
use criterion::Criterion;
use rand::distr::{Distribution, StandardUniform, Uniform};
use rand::Rng;
+use std::hint;
use chrono::DateTime;
use std::sync::Arc;
@@ -139,7 +140,7 @@ fn build_dict_array(size: usize) -> ArrayRef {
// cast array from specified primitive array type to desired data type
fn cast_array(array: &ArrayRef, to_type: DataType) {
- criterion::black_box(cast(array, &to_type).unwrap());
+ hint::black_box(cast(array, &to_type).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/comparison_kernels.rs
b/arrow/benches/comparison_kernels.rs
index c12fd2ad35..c29200d800 100644
--- a/arrow/benches/comparison_kernels.rs
+++ b/arrow/benches/comparison_kernels.rs
@@ -29,6 +29,7 @@ use arrow_string::regexp::regexp_is_match_scalar;
use criterion::Criterion;
use rand::rngs::StdRng;
use rand::Rng;
+use std::hint;
const SIZE: usize = 65536;
@@ -53,21 +54,11 @@ fn bench_nilike_utf8_scalar(arr_a: &StringArray, value_b:
&str) {
}
fn bench_stringview_regexp_is_match_scalar(arr_a: &StringViewArray, value_b:
&str) {
- regexp_is_match_scalar(
- criterion::black_box(arr_a),
- criterion::black_box(value_b),
- None,
- )
- .unwrap();
+ regexp_is_match_scalar(hint::black_box(arr_a), hint::black_box(value_b),
None).unwrap();
}
fn bench_string_regexp_is_match_scalar(arr_a: &StringArray, value_b: &str) {
- regexp_is_match_scalar(
- criterion::black_box(arr_a),
- criterion::black_box(value_b),
- None,
- )
- .unwrap();
+ regexp_is_match_scalar(hint::black_box(arr_a), hint::black_box(value_b),
None).unwrap();
}
fn make_string_array(size: usize, rng: &mut StdRng) -> impl Iterator<Item =
Option<String>> + '_ {
diff --git a/arrow/benches/concatenate_kernel.rs
b/arrow/benches/concatenate_kernel.rs
index ee7b170b36..cf2a91b1e4 100644
--- a/arrow/benches/concatenate_kernel.rs
+++ b/arrow/benches/concatenate_kernel.rs
@@ -26,13 +26,14 @@ use arrow::array::*;
use arrow::compute::concat;
use arrow::datatypes::*;
use arrow::util::bench_util::*;
+use std::hint;
fn bench_concat(v1: &dyn Array, v2: &dyn Array) {
- criterion::black_box(concat(&[v1, v2]).unwrap());
+ hint::black_box(concat(&[v1, v2]).unwrap());
}
fn bench_concat_arrays(arrays: &[&dyn Array]) {
- criterion::black_box(concat(arrays).unwrap());
+ hint::black_box(concat(arrays).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/csv_writer.rs b/arrow/benches/csv_writer.rs
index 85bd8ca383..030494aaf9 100644
--- a/arrow/benches/csv_writer.rs
+++ b/arrow/benches/csv_writer.rs
@@ -25,6 +25,7 @@ use arrow::csv;
use arrow::datatypes::*;
use std::env;
use std::fs::File;
+use std::hint;
use std::sync::Arc;
fn criterion_benchmark(c: &mut Criterion) {
@@ -57,7 +58,7 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("record_batches_to_csv", |b| {
b.iter(|| {
#[allow(clippy::unit_arg)]
- criterion::black_box(for batch in &batches {
+ hint::black_box(for batch in &batches {
writer.write(batch).unwrap()
});
});
diff --git a/arrow/benches/equal.rs b/arrow/benches/equal.rs
index 4e99bf3071..0d6075f392 100644
--- a/arrow/benches/equal.rs
+++ b/arrow/benches/equal.rs
@@ -26,9 +26,10 @@ extern crate arrow;
use arrow::util::bench_util::*;
use arrow::{array::*, datatypes::Float32Type};
+use std::hint;
fn bench_equal<A: Array + PartialEq<A>>(arr_a: &A) {
- criterion::black_box(arr_a == arr_a);
+ hint::black_box(arr_a == arr_a);
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/filter_kernels.rs b/arrow/benches/filter_kernels.rs
index 18b6e2a938..354fe606dd 100644
--- a/arrow/benches/filter_kernels.rs
+++ b/arrow/benches/filter_kernels.rs
@@ -27,13 +27,14 @@ use arrow::datatypes::{Field, Float32Type, Int32Type,
Int64Type, Schema, UInt8Ty
use arrow_array::types::Decimal128Type;
use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint;
fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) {
- criterion::black_box(filter(data_array, filter_array).unwrap());
+ hint::black_box(filter(data_array, filter_array).unwrap());
}
fn bench_built_filter(filter: &FilterPredicate, array: &dyn Array) {
- criterion::black_box(filter.filter(array).unwrap());
+ hint::black_box(filter.filter(array).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/interleave_kernels.rs
b/arrow/benches/interleave_kernels.rs
index ed7ac12379..77dc9500ea 100644
--- a/arrow/benches/interleave_kernels.rs
+++ b/arrow/benches/interleave_kernels.rs
@@ -29,6 +29,7 @@ use arrow::datatypes::*;
use arrow::util::test_util::seedable_rng;
use arrow::{array::*, util::bench_util::*};
use arrow_select::interleave::interleave;
+use std::hint;
fn do_bench(
c: &mut Criterion,
@@ -61,7 +62,7 @@ fn bench_values(c: &mut Criterion, name: &str, len: usize,
values: &[&dyn Array]
.collect();
c.bench_function(name, |b| {
- b.iter(|| criterion::black_box(interleave(values, &indices).unwrap()))
+ b.iter(|| hint::black_box(interleave(values, &indices).unwrap()))
});
}
diff --git a/arrow/benches/json_reader.rs b/arrow/benches/json_reader.rs
index e0e46d3d78..09786bd4c5 100644
--- a/arrow/benches/json_reader.rs
+++ b/arrow/benches/json_reader.rs
@@ -23,6 +23,7 @@ use arrow::util::bench_util::{
};
use arrow_array::RecordBatch;
use arrow_json::{LineDelimitedWriter, ReaderBuilder};
+use std::hint;
use std::io::Cursor;
use std::sync::Arc;
@@ -30,7 +31,7 @@ use std::sync::Arc;
fn do_bench(c: &mut Criterion, name: &str, json: &str, schema: SchemaRef) {
c.bench_function(name, |b| {
b.iter(|| {
- let cursor = Cursor::new(black_box(json));
+ let cursor = Cursor::new(hint::black_box(json));
let builder =
ReaderBuilder::new(schema.clone()).with_batch_size(64);
let reader = builder.build(cursor).unwrap();
for next in reader {
diff --git a/arrow/benches/length_kernel.rs b/arrow/benches/length_kernel.rs
index b70f6374f8..338dd58952 100644
--- a/arrow/benches/length_kernel.rs
+++ b/arrow/benches/length_kernel.rs
@@ -23,9 +23,10 @@ extern crate arrow;
use arrow::array::*;
use arrow::compute::kernels::length::length;
+use std::hint;
fn bench_length(array: &StringArray) {
- criterion::black_box(length(array).unwrap());
+ hint::black_box(length(array).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/lexsort.rs b/arrow/benches/lexsort.rs
index bb1c6081ea..6e6f607f7b 100644
--- a/arrow/benches/lexsort.rs
+++ b/arrow/benches/lexsort.rs
@@ -25,7 +25,7 @@ use arrow_array::types::Int32Type;
use arrow_array::{Array, ArrayRef, UInt32Array};
use arrow_schema::{DataType, Field};
use criterion::{criterion_group, criterion_main, Criterion};
-use std::sync::Arc;
+use std::{hint, sync::Arc};
#[derive(Copy, Clone)]
enum Column {
@@ -128,12 +128,12 @@ fn do_bench(c: &mut Criterion, columns: &[Column], len:
usize) {
.collect();
c.bench_function(&format!("lexsort_to_indices({columns:?}): {len}"), |b| {
- b.iter(|| criterion::black_box(lexsort_to_indices(&sort_columns,
None).unwrap()))
+ b.iter(|| hint::black_box(lexsort_to_indices(&sort_columns,
None).unwrap()))
});
c.bench_function(&format!("lexsort_rows({columns:?}): {len}"), |b| {
b.iter(|| {
- criterion::black_box({
+ hint::black_box({
let fields = arrays
.iter()
.map(|a| SortField::new(a.data_type().clone()))
diff --git a/arrow/benches/partition_kernels.rs
b/arrow/benches/partition_kernels.rs
index e6a067def2..82de6e0f00 100644
--- a/arrow/benches/partition_kernels.rs
+++ b/arrow/benches/partition_kernels.rs
@@ -28,7 +28,7 @@ use arrow::{
};
use arrow_ord::partition::partition;
use rand::distr::{Distribution, StandardUniform};
-use std::iter;
+use std::{hint, iter};
fn create_array<T: ArrowPrimitiveType>(size: usize, with_nulls: bool) ->
ArrayRef
where
@@ -40,7 +40,7 @@ where
}
fn bench_partition(sorted_columns: &[ArrayRef]) {
- criterion::black_box(partition(sorted_columns).unwrap().ranges());
+ hint::black_box(partition(sorted_columns).unwrap().ranges());
}
fn create_sorted_low_cardinality_data(length: usize) -> Vec<ArrayRef> {
diff --git a/arrow/benches/primitive_run_take.rs
b/arrow/benches/primitive_run_take.rs
index cabf9c118f..8e5dbced62 100644
--- a/arrow/benches/primitive_run_take.rs
+++ b/arrow/benches/primitive_run_take.rs
@@ -23,6 +23,7 @@ use arrow::util::test_util::seedable_rng;
use arrow_array::UInt32Array;
use criterion::{criterion_group, criterion_main, Criterion};
use rand::Rng;
+use std::hint;
fn create_random_index(size: usize, null_density: f32, max_value: usize) ->
UInt32Array {
let mut rng = seedable_rng();
@@ -52,7 +53,7 @@ fn criterion_benchmark(c: &mut Criterion) {
"(run_array_len:{logical_array_len},
physical_array_len:{physical_array_len}, take_len:{take_len})"),
|b| {
b.iter(|| {
- criterion::black_box(take(&run_array, &indices,
None).unwrap());
+ hint::black_box(take(&run_array, &indices, None).unwrap());
})
},
);
diff --git a/arrow/benches/regexp_kernels.rs b/arrow/benches/regexp_kernels.rs
index d5ffbcb997..c48cf7de02 100644
--- a/arrow/benches/regexp_kernels.rs
+++ b/arrow/benches/regexp_kernels.rs
@@ -24,9 +24,10 @@ extern crate arrow;
use arrow::array::*;
use arrow::compute::kernels::regexp::*;
use arrow::util::bench_util::*;
+use std::hint;
fn bench_regexp(arr: &GenericStringArray<i32>, regex_array: &dyn Datum) {
- regexp_match(criterion::black_box(arr), regex_array, None).unwrap();
+ regexp_match(hint::black_box(arr), regex_array, None).unwrap();
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/row_format.rs b/arrow/benches/row_format.rs
index 773cdc6520..5b1ce05f2a 100644
--- a/arrow/benches/row_format.rs
+++ b/arrow/benches/row_format.rs
@@ -28,8 +28,8 @@ use arrow::util::bench_util::{
};
use arrow_array::types::Int32Type;
use arrow_array::Array;
-use criterion::{black_box, Criterion};
-use std::sync::Arc;
+use criterion::Criterion;
+use std::{hint, sync::Arc};
fn do_bench(c: &mut Criterion, name: &str, cols: Vec<ArrayRef>) {
let fields: Vec<_> = cols
@@ -40,7 +40,7 @@ fn do_bench(c: &mut Criterion, name: &str, cols:
Vec<ArrayRef>) {
c.bench_function(&format!("convert_columns {name}"), |b| {
b.iter(|| {
let converter = RowConverter::new(fields.clone()).unwrap();
- black_box(converter.convert_columns(&cols).unwrap())
+ hint::black_box(converter.convert_columns(&cols).unwrap())
});
});
@@ -48,11 +48,11 @@ fn do_bench(c: &mut Criterion, name: &str, cols:
Vec<ArrayRef>) {
let rows = converter.convert_columns(&cols).unwrap();
// using a pre-prepared row converter should be faster than the first time
c.bench_function(&format!("convert_columns_prepared {name}"), |b| {
- b.iter(|| black_box(converter.convert_columns(&cols).unwrap()));
+ b.iter(|| hint::black_box(converter.convert_columns(&cols).unwrap()));
});
c.bench_function(&format!("convert_rows {name}"), |b| {
- b.iter(|| black_box(converter.convert_rows(&rows).unwrap()));
+ b.iter(|| hint::black_box(converter.convert_rows(&rows).unwrap()));
});
}
@@ -66,7 +66,7 @@ fn bench_iter(c: &mut Criterion) {
c.bench_function("iterate rows", |b| {
b.iter(|| {
for r in rows.iter() {
- std::hint::black_box(r.as_ref());
+ hint::black_box(r.as_ref());
}
})
});
diff --git a/arrow/benches/sort_kernel.rs b/arrow/benches/sort_kernel.rs
index b6578d8d80..012babd15d 100644
--- a/arrow/benches/sort_kernel.rs
+++ b/arrow/benches/sort_kernel.rs
@@ -17,7 +17,7 @@
#[macro_use]
extern crate criterion;
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
use std::sync::Arc;
@@ -28,6 +28,7 @@ use arrow::datatypes::{Int16Type, Int32Type};
use arrow::util::bench_util::*;
use arrow::{array::*, datatypes::Float32Type};
use arrow_ord::rank::rank;
+use std::hint;
fn create_f32_array(size: usize, with_nulls: bool) -> ArrayRef {
let null_density = if with_nulls { 0.5 } else { 0.0 };
@@ -43,7 +44,7 @@ fn create_bool_array(size: usize, with_nulls: bool) ->
ArrayRef {
}
fn bench_sort(array: &dyn Array) {
- black_box(sort(array, None).unwrap());
+ hint::black_box(sort(array, None).unwrap());
}
fn bench_lexsort(array_a: &ArrayRef, array_b: &ArrayRef, limit: Option<usize>)
{
@@ -58,11 +59,11 @@ fn bench_lexsort(array_a: &ArrayRef, array_b: &ArrayRef,
limit: Option<usize>) {
},
];
- black_box(lexsort(&columns, limit).unwrap());
+ hint::black_box(lexsort(&columns, limit).unwrap());
}
fn bench_sort_to_indices(array: &dyn Array, limit: Option<usize>) {
- black_box(sort_to_indices(array, None, limit).unwrap());
+ hint::black_box(sort_to_indices(array, None, limit).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
@@ -215,22 +216,22 @@ fn add_benchmark(c: &mut Criterion) {
let arr = create_f32_array(2usize.pow(12), false);
c.bench_function("rank f32 2^12", |b| {
- b.iter(|| black_box(rank(&arr, None).unwrap()))
+ b.iter(|| hint::black_box(rank(&arr, None).unwrap()))
});
let arr = create_f32_array(2usize.pow(12), true);
c.bench_function("rank f32 nulls 2^12", |b| {
- b.iter(|| black_box(rank(&arr, None).unwrap()))
+ b.iter(|| hint::black_box(rank(&arr, None).unwrap()))
});
let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.0, 10);
c.bench_function("rank string[10] 2^12", |b| {
- b.iter(|| black_box(rank(&arr, None).unwrap()))
+ b.iter(|| hint::black_box(rank(&arr, None).unwrap()))
});
let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.5, 10);
c.bench_function("rank string[10] nulls 2^12", |b| {
- b.iter(|| black_box(rank(&arr, None).unwrap()))
+ b.iter(|| hint::black_box(rank(&arr, None).unwrap()))
});
}
diff --git a/arrow/benches/substring_kernels.rs
b/arrow/benches/substring_kernels.rs
index 6bbfc9c098..bf910e7aaf 100644
--- a/arrow/benches/substring_kernels.rs
+++ b/arrow/benches/substring_kernels.rs
@@ -24,9 +24,10 @@ extern crate arrow;
use arrow::array::*;
use arrow::compute::kernels::substring::*;
use arrow::util::bench_util::*;
+use std::hint;
fn bench_substring(arr: &dyn Array, start: i64, length: Option<u64>) {
- substring(criterion::black_box(arr), start, length).unwrap();
+ substring(hint::black_box(arr), start, length).unwrap();
}
fn bench_substring_by_char<O: OffsetSizeTrait>(
@@ -34,7 +35,7 @@ fn bench_substring_by_char<O: OffsetSizeTrait>(
start: i64,
length: Option<u64>,
) {
- substring_by_char(criterion::black_box(arr), start, length).unwrap();
+ substring_by_char(hint::black_box(arr), start, length).unwrap();
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/arrow/benches/take_kernels.rs b/arrow/benches/take_kernels.rs
index a09064839f..a7e70d2b03 100644
--- a/arrow/benches/take_kernels.rs
+++ b/arrow/benches/take_kernels.rs
@@ -27,6 +27,7 @@ use arrow::compute::{take, TakeOptions};
use arrow::datatypes::*;
use arrow::util::test_util::seedable_rng;
use arrow::{array::*, util::bench_util::*};
+use std::hint;
fn create_random_index(size: usize, null_density: f32) -> UInt32Array {
let mut rng = seedable_rng();
@@ -43,11 +44,11 @@ fn create_random_index(size: usize, null_density: f32) ->
UInt32Array {
}
fn bench_take(values: &dyn Array, indices: &UInt32Array) {
- criterion::black_box(take(values, indices, None).unwrap());
+ hint::black_box(take(values, indices, None).unwrap());
}
fn bench_take_bounds_check(values: &dyn Array, indices: &UInt32Array) {
- criterion::black_box(take(values, indices, Some(TakeOptions {
check_bounds: true })).unwrap());
+ hint::black_box(take(values, indices, Some(TakeOptions { check_bounds:
true })).unwrap());
}
fn add_benchmark(c: &mut Criterion) {
diff --git a/parquet/benches/compression.rs b/parquet/benches/compression.rs
index 5c9b0d1f75..b90c048ca1 100644
--- a/parquet/benches/compression.rs
+++ b/parquet/benches/compression.rs
@@ -20,6 +20,7 @@ use parquet::basic::{BrotliLevel, Compression, GzipLevel,
ZstdLevel};
use parquet::compression::create_codec;
use rand::distr::Alphanumeric;
use rand::prelude::*;
+use std::hint;
fn do_bench(c: &mut Criterion, name: &str, uncompressed: &[u8]) {
let codecs = [
@@ -57,7 +58,11 @@ fn do_bench(c: &mut Criterion, name: &str, uncompressed:
&[u8]) {
b.iter(|| {
let mut out = Vec::new();
codec
- .decompress(black_box(&compressed), &mut out,
Some(uncompressed.len()))
+ .decompress(
+ hint::black_box(&compressed),
+ &mut out,
+ Some(uncompressed.len()),
+ )
.unwrap();
out
});
diff --git a/parquet/benches/row_selector.rs b/parquet/benches/row_selector.rs
index 9fa634d09d..38fb7122ab 100644
--- a/parquet/benches/row_selector.rs
+++ b/parquet/benches/row_selector.rs
@@ -19,6 +19,7 @@ use arrow_array::BooleanArray;
use criterion::*;
use parquet::arrow::arrow_reader::RowSelection;
use rand::Rng;
+use std::hint;
/// Generates a random RowSelection with a specified selection ratio.
///
@@ -52,14 +53,14 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("intersection", |b| {
b.iter(|| {
let intersection = row_selection_a.intersection(&row_selection_b);
- criterion::black_box(intersection);
+ hint::black_box(intersection);
})
});
c.bench_function("union", |b| {
b.iter(|| {
let union = row_selection_a.union(&row_selection_b);
- criterion::black_box(union);
+ hint::black_box(union);
})
});
@@ -68,7 +69,7 @@ fn criterion_benchmark(c: &mut Criterion) {
b.iter(|| {
let array = boolean_array.clone();
let selection = RowSelection::from_filters(&[array]);
- criterion::black_box(selection);
+ hint::black_box(selection);
})
});
@@ -78,7 +79,7 @@ fn criterion_benchmark(c: &mut Criterion) {
RowSelection::from_filters(&[generate_random_row_selection(selected,
selection_ratio)]);
b.iter(|| {
let result = row_selection_a.and_then(&sub_selection);
- criterion::black_box(result);
+ hint::black_box(result);
})
});
}
