bench(arrow): add fsl/map interleave benchmark (#10322)

Add benchmark test cases for FixedSizeList and Map array interleave
along with helper functions to create test arrays.

# Which issue does this PR close?

- Closes #10321 .

# Rationale for this change

Add benchmark for fsl/map interleave

# What changes are included in this PR?

Add benchmark for fsl/map interleave

# Are these changes tested?

No

# Are there any user-facing changes?

No

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mapleFU

arrow/benches/interleave_kernels.rs

@@ -150,6 +150,12 @@ fn add_benchmark(c: &mut Criterion) {
         )
     };
 
+    let fsl_i64 = create_primitive_fixed_size_list_array::<Int64Type>(8192, 0.0, 0.0, 5);
+    let fsl_i64_nulls = create_primitive_fixed_size_list_array::<Int64Type>(8192, 0.1, 0.1, 5);
+
+    let map_str_i64 = create_string_map_array::<Int64Type>(8192, 0.0, 5, 8);
+    let map_str_i64_nulls = create_string_map_array::<Int64Type>(8192, 0.1, 5, 8);
+
     let ree_run_ends = Int32Array::from_iter_values((1..=64).map(|i| i * 16));
     let ree_i64_values = create_primitive_array::<Int64Type>(64, 0.0);
     let ree_i64 = RunArray::<Int32Type>::try_new(&ree_run_ends, &ree_i64_values).unwrap();
@@ -183,6 +189,10 @@ fn add_benchmark(c: &mut Criterion) {
         ("list_view<i64>(0.1,0.1,20)", &list_view_i64),
         ("list_view<i64>(0.0,0.0,20)", &list_view_i64_no_nulls),
         ("list_view_overlapping<i64>(80x,20)", &list_view_overlapping),
+        ("fixed_size_list<i64,5>(0.0,0.0)", &fsl_i64),
+        ("fixed_size_list<i64,5>(0.1,0.1)", &fsl_i64_nulls),
+        ("map<utf8,i64>(0.0,5,8)", &map_str_i64),
+        ("map<utf8,i64>(0.1,5,8)", &map_str_i64_nulls),
         ("ree_i32<i64>(64 runs)", &ree_i64),
         ("ree_i32<dict<u32,utf8>>(64 runs)", &ree_dict),
     ];

arrow/src/util/bench_util.rs

@@ -20,17 +20,19 @@
 use crate::array::*;
 use crate::datatypes::*;
 use crate::util::test_util::seedable_rng;
-use arrow_buffer::{Buffer, IntervalMonthDayNano};
+use arrow_buffer::{Buffer, IntervalMonthDayNano, NullBuffer};
+use arrow_schema::Field;
 use half::f16;
 use rand::Rng;
 use rand::SeedableRng;
 use rand::distr::uniform::SampleUniform;
 use rand::rng;
 use rand::{
-    distr::{Alphanumeric, Distribution, StandardUniform},
+    distr::{Alphanumeric, Distribution, SampleString, StandardUniform},
     prelude::StdRng,
 };
 use std::ops::Range;
+use std::sync::Arc;
 
 /// Creates an random (but fixed-seeded) array of a given size and null density
 pub fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
@@ -871,3 +873,77 @@ pub fn create_f64_array_with_seed(size: usize, nan_density: f32, seed: u64) -> F
         })
         .collect()
 }
+
+/// Create a FixedSizeList array of primitive values
+///
+/// Arguments:
+/// - `size`: number of fixed-size lists in the array
+/// - `null_density`: density of nulls in the fixed-size list array (row-level nulls)
+/// - `value_null_density`: density of nulls in the primitive values inside each list
+/// - `list_size`: fixed size of each list element
+pub fn create_primitive_fixed_size_list_array<T>(
+    size: usize,
+    null_density: f32,
+    value_null_density: f32,
+    list_size: i32,
+) -> FixedSizeListArray
+where
+    T: ArrowPrimitiveType,
+    StandardUniform: Distribution<T::Native>,
+{
+    let mut rng = seedable_rng();
+    let list_size_usize = usize::try_from(list_size).expect("list_size must be non-negative");
+    let values: PrimitiveArray<T> = (0..size * list_size_usize)
+        .map(|_| {
+            if rng.random::<f32>() < value_null_density {
+                None
+            } else {
+                Some(rng.random())
+            }
+        })
+        .collect();
+    let field = Arc::new(Field::new("item", T::DATA_TYPE, value_null_density > 0.0));
+    let nulls = (null_density > 0.0).then(|| {
+        NullBuffer::new(arrow_buffer::BooleanBuffer::collect_bool(size, |_| {
+            rng.random::<f32>() >= null_density
+        }))
+    });
+    FixedSizeListArray::new(field, list_size, Arc::new(values), nulls)
+}
+
+/// Create a Map array with string keys and primitive values
+///
+/// Arguments:
+/// - `size`: number of map entries in the array
+/// - `null_density`: density of nulls in the map array (row-level nulls)
+/// - `max_map_size`: maximum number of key-value pairs per map entry
+///   (actual size is random between 0 and max_map_size)
+/// - `key_len`: length of each random string key
+pub fn create_string_map_array<T>(
+    size: usize,
+    null_density: f32,
+    max_map_size: usize,
+    key_len: usize,
+) -> MapArray
+where
+    T: ArrowPrimitiveType,
+    StandardUniform: Distribution<T::Native>,
+{
+    let mut rng = seedable_rng();
+    let mut builder = MapBuilder::new(None, StringBuilder::new(), PrimitiveBuilder::<T>::new());
+    for _ in 0..size {
+        if rng.random::<f32>() < null_density {
+            builder.append(false).unwrap();
+        } else {
+            let n = rng.random_range(0..=max_map_size);
+            for _ in 0..n {
+                builder
+                    .keys()
+                    .append_value(Alphanumeric.sample_string(&mut rng, key_len));
+                builder.values().append_value(rng.random());
+            }
+            builder.append(true).unwrap();
+        }
+    }
+    builder.finish()
+}