bench: use seedable rng for reproducibility

benchmarks/src/cancellation.rs

@@ -39,9 +39,8 @@ use futures::TryStreamExt;
 use object_store::ObjectStore;
 use parquet::arrow::AsyncArrowWriter;
 use parquet::arrow::async_writer::ParquetObjectWriter;
-use rand::Rng;
 use rand::distr::Alphanumeric;
-use rand::rngs::ThreadRng;
+use rand::prelude::*;
 use tokio::runtime::Runtime;
 use tokio_util::sync::CancellationToken;
 
@@ -312,12 +311,12 @@ async fn generate_data(
 }
 
 fn random_data(column_type: &DataType, rows: usize) -> Arc<dyn Array> {
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let values = (0..rows).map(|_| random_value(&mut rng, column_type));
     ScalarValue::iter_to_array(values).unwrap()
 }
 
-fn random_value(rng: &mut ThreadRng, column_type: &DataType) -> ScalarValue {
+fn random_value(rng: &mut StdRng, column_type: &DataType) -> ScalarValue {
     match column_type {
         DataType::Float64 => ScalarValue::Float64(Some(rng.random())),
         DataType::Boolean => ScalarValue::Boolean(Some(rng.random())),

datafusion/core/benches/map_query_sql.rs

@@ -22,8 +22,7 @@ use std::sync::Arc;
 use arrow::array::{ArrayRef, Int32Array, RecordBatch};
 use criterion::{Criterion, criterion_group, criterion_main};
 use parking_lot::Mutex;
-use rand::Rng;
-use rand::prelude::ThreadRng;
+use rand::prelude::*;
 use tokio::runtime::Runtime;
 
 use datafusion::prelude::SessionContext;
@@ -33,7 +32,7 @@ use datafusion_functions_nested::map::map;
 
 mod data_utils;
 
-fn build_keys(rng: &mut ThreadRng) -> Vec<String> {
+fn build_keys(rng: &mut StdRng) -> Vec<String> {
     let mut keys = HashSet::with_capacity(1000);
     while keys.len() < 1000 {
         let key = rng.random_range(0..9999).to_string();
@@ -42,7 +41,7 @@ fn build_keys(rng: &mut ThreadRng) -> Vec<String> {
     keys.into_iter().collect()
 }
 
-fn build_values(rng: &mut ThreadRng) -> Vec<i32> {
+fn build_values(rng: &mut StdRng) -> Vec<i32> {
     let mut values = vec![];
     for _ in 0..1000 {
         values.push(rng.random_range(0..9999));
@@ -67,7 +66,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     let rt = Runtime::new().unwrap();
     let df = rt.block_on(ctx.lock().table("t")).unwrap();
 
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let keys = build_keys(&mut rng);
     let values = build_values(&mut rng);
     let mut key_buffer = Vec::new();

datafusion/core/benches/parquet_query_sql.rs

@@ -32,7 +32,6 @@ use parquet::file::properties::{WriterProperties, WriterVersion};
 use rand::distr::Alphanumeric;
 use rand::distr::uniform::SampleUniform;
 use rand::prelude::*;
-use rand::rng;
 use std::fs::File;
 use std::io::Read;
 use std::ops::Range;
@@ -98,7 +97,7 @@ fn generate_string_dictionary(
     len: usize,
     valid_percent: f64,
 ) -> ArrayRef {
-    let mut rng = rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let strings: Vec<_> = (0..cardinality).map(|x| format!("{prefix}#{x}")).collect();
 
     Arc::new(DictionaryArray::<Int32Type>::from_iter((0..len).map(
@@ -114,7 +113,7 @@ fn generate_strings(
     len: usize,
     valid_percent: f64,
 ) -> ArrayRef {
-    let mut rng = rng();
+    let mut rng = StdRng::seed_from_u64(0);
     Arc::new(StringArray::from_iter((0..len).map(|_| {
         rng.random_bool(valid_percent).then(|| {
             let string_len = rng.random_range(string_length_range.clone());
@@ -134,7 +133,7 @@ where
     T: ArrowPrimitiveType,
     T::Native: SampleUniform,
 {
-    let mut rng = rng();
+    let mut rng = StdRng::seed_from_u64(0);
     Arc::new(PrimitiveArray::<T>::from_iter((0..len).map(|_| {
         rng.random_bool(valid_percent)
             .then(|| rng.random_range(range.clone()))

datafusion/core/benches/parquet_struct_query.rs

@@ -27,7 +27,6 @@ use parquet::arrow::ArrowWriter;
 use parquet::file::properties::{WriterProperties, WriterVersion};
 use rand::distr::Alphanumeric;
 use rand::prelude::*;
-use rand::rng;
 use std::hint::black_box;
 use std::ops::Range;
 use std::path::Path;
@@ -60,7 +59,7 @@ fn schema() -> SchemaRef {
 }
 
 fn generate_strings(len: usize) -> ArrayRef {
-    let mut rng = rng();
+    let mut rng = StdRng::seed_from_u64(0);
     Arc::new(StringArray::from_iter((0..len).map(|_| {
         let string_len = rng.random_range(STRING_LENGTH_RANGE.clone());
         Some(

datafusion/functions-nested/benches/map.rs

@@ -28,8 +28,7 @@ use datafusion_expr::planner::ExprPlanner;
 use datafusion_expr::{ColumnarValue, Expr, ScalarFunctionArgs};
 use datafusion_functions_nested::map::map_udf;
 use datafusion_functions_nested::planner::NestedFunctionPlanner;
-use rand::Rng;
-use rand::prelude::ThreadRng;
+use rand::prelude::*;
 use std::collections::HashSet;
 use std::hash::Hash;
 use std::hint::black_box;
@@ -38,10 +37,7 @@ use std::sync::Arc;
 const MAP_ROWS: usize = 1000;
 const MAP_KEYS_PER_ROW: usize = 1000;
 
-fn gen_unique_values<T>(
-    rng: &mut ThreadRng,
-    mut make_value: impl FnMut(i32) -> T,
-) -> Vec<T>
+fn gen_unique_values<T>(rng: &mut StdRng, mut make_value: impl FnMut(i32) -> T) -> Vec<T>
 where
     T: Eq + Hash,
 {
@@ -64,15 +60,15 @@ fn gen_repeat_values<T: Clone>(values: &[T], repeats: usize) -> Vec<T> {
     repeated
 }
 
-fn gen_utf8_values(rng: &mut ThreadRng) -> Vec<String> {
+fn gen_utf8_values(rng: &mut StdRng) -> Vec<String> {
     gen_unique_values(rng, |value| value.to_string())
 }
 
-fn gen_binary_values(rng: &mut ThreadRng) -> Vec<Vec<u8>> {
+fn gen_binary_values(rng: &mut StdRng) -> Vec<Vec<u8>> {
     gen_unique_values(rng, |value| value.to_le_bytes().to_vec())
 }
 
-fn gen_primitive_values(rng: &mut ThreadRng) -> Vec<i32> {
+fn gen_primitive_values(rng: &mut StdRng) -> Vec<i32> {
     gen_unique_values(rng, |value| value)
 }
 
@@ -122,7 +118,7 @@ fn bench_map_case(c: &mut Criterion, name: &str, keys: ArrayRef, values: ArrayRe
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("make_map_1000", |b| {
-        let mut rng = rand::rng();
+        let mut rng = StdRng::seed_from_u64(0);
         let keys = gen_utf8_values(&mut rng);
         let values = gen_primitive_values(&mut rng);
         let mut buffer = Vec::new();
@@ -143,7 +139,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         });
     });
 
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let values = Arc::new(Int32Array::from(gen_repeat_values(
         &gen_primitive_values(&mut rng),
         MAP_ROWS,

datafusion/functions/benches/concat.rs

@@ -23,8 +23,8 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::string::concat;
-use rand::Rng;
 use rand::distr::Alphanumeric;
+use rand::prelude::*;
 use std::hint::black_box;
 use std::sync::Arc;
 
@@ -49,7 +49,7 @@ fn create_array_args_view(size: usize) -> Vec<ColumnarValue> {
 }
 
 fn generate_random_string(str_len: usize) -> String {
-    rand::rng()
+    StdRng::seed_from_u64(0)
         .sample_iter(&Alphanumeric)
         .take(str_len)
         .map(char::from)

datafusion/functions/benches/concat_ws.rs

@@ -23,8 +23,8 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::string::concat_ws;
-use rand::Rng;
 use rand::distr::Alphanumeric;
+use rand::prelude::*;
 use std::hint::black_box;
 use std::sync::Arc;
 
@@ -39,7 +39,7 @@ fn create_array_args(size: usize, str_len: usize) -> Vec<ColumnarValue> {
 }
 
 fn generate_random_string(str_len: usize) -> String {
-    rand::rng()
+    StdRng::seed_from_u64(0)
         .sample_iter(&Alphanumeric)
         .take(str_len)
         .map(char::from)

datafusion/functions/benches/date_bin.rs

@@ -25,10 +25,9 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::datetime::date_bin;
-use rand::Rng;
-use rand::rngs::ThreadRng;
+use rand::prelude::*;
 
-fn timestamps(rng: &mut ThreadRng) -> TimestampSecondArray {
+fn timestamps(rng: &mut StdRng) -> TimestampSecondArray {
     let mut seconds = vec![];
     for _ in 0..1000 {
         seconds.push(rng.random_range(0..1_000_000));
@@ -39,7 +38,7 @@ fn timestamps(rng: &mut ThreadRng) -> TimestampSecondArray {
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("date_bin_1000", |b| {
-        let mut rng = rand::rng();
+        let mut rng = StdRng::seed_from_u64(0);
         let timestamps_array = Arc::new(timestamps(&mut rng)) as ArrayRef;
         let batch_len = timestamps_array.len();
         let interval = ColumnarValue::Scalar(ScalarValue::new_interval_dt(0, 1_000_000));

datafusion/functions/benches/gcd.rs

@@ -25,12 +25,12 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::math::gcd;
-use rand::Rng;
+use rand::prelude::*;
 use std::hint::black_box;
 use std::sync::Arc;
 
 fn generate_i64_array(n_rows: usize) -> ArrayRef {
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let values = (0..n_rows)
         .map(|_| rng.random_range(0..1000))
         .collect::<Vec<_>>();

datafusion/functions/benches/lcm.rs

@@ -24,12 +24,12 @@ use criterion::{Criterion, criterion_group, criterion_main};
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::math::lcm;
-use rand::Rng;
+use rand::prelude::*;
 use std::hint::black_box;
 use std::sync::Arc;
 
 fn generate_i64_array(n_rows: usize) -> ArrayRef {
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let values = (0..n_rows)
         .map(|_| rng.random_range(0..1000))
         .collect::<Vec<_>>();

datafusion/functions/benches/make_date.rs

@@ -25,10 +25,9 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::datetime::make_date;
-use rand::Rng;
-use rand::rngs::ThreadRng;
+use rand::prelude::*;
 
-fn years(rng: &mut ThreadRng) -> Int32Array {
+fn years(rng: &mut StdRng) -> Int32Array {
     let mut years = vec![];
     for _ in 0..8192 {
         years.push(rng.random_range(1900..2050));
@@ -37,7 +36,7 @@ fn years(rng: &mut ThreadRng) -> Int32Array {
     Int32Array::from(years)
 }
 
-fn months(rng: &mut ThreadRng) -> Int32Array {
+fn months(rng: &mut StdRng) -> Int32Array {
     let mut months = vec![];
     for _ in 0..8192 {
         months.push(rng.random_range(1..13));
@@ -46,7 +45,7 @@ fn months(rng: &mut ThreadRng) -> Int32Array {
     Int32Array::from(months)
 }
 
-fn days(rng: &mut ThreadRng) -> Int32Array {
+fn days(rng: &mut StdRng) -> Int32Array {
     let mut days = vec![];
     for _ in 0..8192 {
         days.push(rng.random_range(1..29));
@@ -56,7 +55,7 @@ fn days(rng: &mut ThreadRng) -> Int32Array {
 }
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("make_date_col_col_col_8192", |b| {
-        let mut rng = rand::rng();
+        let mut rng = StdRng::seed_from_u64(0);
         let years_array = Arc::new(years(&mut rng)) as ArrayRef;
         let batch_len = years_array.len();
         let years = ColumnarValue::Array(years_array);
@@ -86,7 +85,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 
     c.bench_function("make_date_scalar_col_col_8192", |b| {
-        let mut rng = rand::rng();
+        let mut rng = StdRng::seed_from_u64(0);
         let year = ColumnarValue::Scalar(ScalarValue::Int32(Some(2025)));
         let months_arr = Arc::new(months(&mut rng)) as ArrayRef;
         let batch_len = months_arr.len();
@@ -116,7 +115,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 
     c.bench_function("make_date_scalar_scalar_col_8192", |b| {
-        let mut rng = rand::rng();
+        let mut rng = StdRng::seed_from_u64(0);
         let year = ColumnarValue::Scalar(ScalarValue::Int32(Some(2025)));
         let month = ColumnarValue::Scalar(ScalarValue::Int32(Some(11)));
         let day_arr = Arc::new(days(&mut rng));

datafusion/functions/benches/pad.rs

@@ -28,8 +28,8 @@ use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_functions::unicode;
-use rand::Rng;
-use rand::distr::{Distribution, Uniform};
+use rand::distr::Uniform;
+use rand::prelude::*;
 use std::hint::black_box;
 use std::sync::Arc;
 use std::time::Duration;
@@ -51,7 +51,7 @@ fn create_unicode_string_array<O: OffsetSizeTrait>(
     size: usize,
     null_density: f32,
 ) -> arrow::array::GenericStringArray<O> {
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let mut builder = GenericStringBuilder::<O>::new();
     for i in 0..size {
         if rng.random::<f32>() < null_density {
@@ -67,7 +67,7 @@ fn create_unicode_string_view_array(
     size: usize,
     null_density: f32,
 ) -> arrow::array::StringViewArray {
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     let mut builder = StringViewBuilder::with_capacity(size);
     for i in 0..size {
         if rng.random::<f32>() < null_density {
@@ -104,7 +104,7 @@ where
         dist: Uniform::new_inclusive::<i64, i64>(0, len as i64),
     };
 
-    let mut rng = rand::rng();
+    let mut rng = StdRng::seed_from_u64(0);
     (0..size)
         .map(|_| {
             if rng.random::<f32>() < null_density {