diff --git a/arrow/benches/boolean_kernels.rs b/arrow/benches/boolean_kernels.rs
index 6ec507c958b2..a7231c031aaf 100644
--- a/arrow/benches/boolean_kernels.rs
+++ b/arrow/benches/boolean_kernels.rs
@@ -40,38 +40,43 @@ fn bench_not(array: &BooleanArray) {
 }
 
 fn add_benchmark(c: &mut Criterion) {
+    // allocate arrays of 32K elements
     let size = 2usize.pow(15);
+
+    // Note we allocate all arrays before the benchmark to ensure the allocation of the arrays
+    // is not affected by allocations that happen during the benchmarked operation.
     let array1 = create_boolean_array(size, 0.0, 0.5);
     let array2 = create_boolean_array(size, 0.0, 0.5);
-    c.bench_function("and", |b| b.iter(|| bench_and(&array1, &array2)));
-    c.bench_function("or", |b| b.iter(|| bench_or(&array1, &array2)));
-    c.bench_function("not", |b| b.iter(|| bench_not(&array1)));
 
     // Slice by 1 (not aligned to byte (8 bit) or word (64 bit) boundaries)
     let offset = 1;
-    let array1_slice = array1.slice(offset, size - offset);
-    let array2_slice = array2.slice(offset, size - offset);
+    let array1_sliced_1 = array1.slice(offset, size - offset);
+    let array2_sliced_1 = array2.slice(offset, size - offset);
+
+    // Slice by 24 (aligned on byte (8 bit) but not word (64 bit) boundaries)
+    let offset = 24;
+    let array1_sliced_24 = array1.slice(offset, size - offset);
+    let array2_sliced_24 = array2.slice(offset, size - offset);
+
+    c.bench_function("and", |b| b.iter(|| bench_and(&array1, &array2)));
+    c.bench_function("or", |b| b.iter(|| bench_or(&array1, &array2)));
+    c.bench_function("not", |b| b.iter(|| bench_not(&array1)));
 
     c.bench_function("and_sliced_1", |b| {
-        b.iter(|| bench_and(&array1_slice, &array2_slice))
+        b.iter(|| bench_and(&array1_sliced_1, &array2_sliced_1))
     });
     c.bench_function("or_sliced_1", |b| {
-        b.iter(|| bench_or(&array1_slice, &array2_slice))
+        b.iter(|| bench_or(&array1_sliced_1, &array2_sliced_1))
     });
-    c.bench_function("not_sliced_1", |b| b.iter(|| bench_not(&array1_slice)));
-
-    // Slice by 24 (aligned on byte (8 bit) but not word (64 bit) boundaries)
-    let offset = 24;
-    let array1_slice = array1.slice(offset, size - offset);
-    let array2_slice = array2.slice(offset, size - offset);
+    c.bench_function("not_sliced_1", |b| b.iter(|| bench_not(&array1_sliced_1)));
 
     c.bench_function("and_sliced_24", |b| {
-        b.iter(|| bench_and(&array1_slice, &array2_slice))
+        b.iter(|| bench_and(&array1_sliced_24, &array2_sliced_24))
     });
     c.bench_function("or_sliced_24", |b| {
-        b.iter(|| bench_or(&array1_slice, &array2_slice))
+        b.iter(|| bench_or(&array1_sliced_24, &array2_sliced_24))
     });
-    c.bench_function("not_slice_24", |b| b.iter(|| bench_not(&array1_slice)));
+    c.bench_function("not_slice_24", |b| b.iter(|| bench_not(&array1_sliced_24)));
 }
 
 criterion_group!(benches, add_benchmark);