chore(deps): update criterion requirement from 0.5 to 0.6 (#7527)

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)));
     });
 }
 

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));
                     }
                 });
             },

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());
         });
     });
 }

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()
                     });
                 });
             }

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()))
                 },
             );
         }

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),
                                 )
                             });
                         },

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));
             }
         });
     });

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())));
     });
 }
 

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());
         });

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());
         });

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());
         });

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());
         });

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"] }

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()))
         });
     }
 }

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()

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) {

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();
 }

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) {

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) {

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)))
     });
 }
 

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)

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) {

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>> + '_ {

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) {

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()
             });
         });

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) {

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) {

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()))
     });
 }
 

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 {

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) {

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()))

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> {

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());
                 })
             },
         );

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) {

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());
             }
         })
     });

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()))
     });
 }
 

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) {

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) {

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
             });

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);
         })
     });
 }