diff --git a/encodings/fastlanes/benches/canonicalize_bench.rs b/encodings/fastlanes/benches/canonicalize_bench.rs
index e6942067fca..666bf1420a9 100644
--- a/encodings/fastlanes/benches/canonicalize_bench.rs
+++ b/encodings/fastlanes/benches/canonicalize_bench.rs
@@ -78,11 +78,11 @@ fn canonical_into_non_nullable(
                 chunked.dtype().nullability(),
                 chunk_len * chunk_count,
             );
-            (chunked, primitive_builder)
+            (chunked, primitive_builder, SESSION.create_execution_ctx())
         })
-        .bench_refs(|(chunked, primitive_builder)| {
+        .bench_refs(|(chunked, primitive_builder, ctx)| {
             chunked
-                .append_to_builder(primitive_builder, &mut SESSION.create_execution_ctx())
+                .append_to_builder(primitive_builder, ctx)
                 .vortex_expect("append failed");
             primitive_builder.finish()
         });
@@ -114,8 +114,13 @@ fn into_canonical_nullable(
         .collect::<Vec<_>>();
 
     bencher
-        .with_inputs(|| ChunkedArray::from_iter(chunks.clone()).into_array())
-        .bench_values(|chunked| chunked.execute::<Canonical>(&mut SESSION.create_execution_ctx()));
+        .with_inputs(|| {
+            (
+                ChunkedArray::from_iter(chunks.clone()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_values(|(chunked, mut ctx)| chunked.execute::<Canonical>(&mut ctx));
 }
 
 #[cfg(not(codspeed))]
@@ -140,11 +145,11 @@ fn canonical_into_nullable(
                 chunked.dtype().nullability(),
                 chunk_len * chunk_count,
             );
-            (chunked, primitive_builder)
+            (chunked, primitive_builder, SESSION.create_execution_ctx())
         })
-        .bench_refs(|(chunked, primitive_builder)| {
+        .bench_refs(|(chunked, primitive_builder, ctx)| {
             chunked
-                .append_to_builder(primitive_builder, &mut SESSION.create_execution_ctx())
+                .append_to_builder(primitive_builder, ctx)
                 .vortex_expect("append failed");
             primitive_builder.finish()
         });
diff --git a/encodings/fsst/benches/chunked_dict_fsst_builder.rs b/encodings/fsst/benches/chunked_dict_fsst_builder.rs
index 50e2488d360..fbc959cfd41 100644
--- a/encodings/fsst/benches/chunked_dict_fsst_builder.rs
+++ b/encodings/fsst/benches/chunked_dict_fsst_builder.rs
@@ -49,13 +49,15 @@ fn chunked_dict_fsst_canonical_into(
 ) {
     let chunk = make_dict_fsst_chunks::<u16>(len, unique_values, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
diff --git a/encodings/fsst/benches/fsst_like.rs b/encodings/fsst/benches/fsst_like.rs
index 57489ba158e..2771b558ccc 100644
--- a/encodings/fsst/benches/fsst_like.rs
+++ b/encodings/fsst/benches/fsst_like.rs
@@ -109,13 +109,15 @@ fn bench_like(bencher: Bencher, fsst: &FSSTArray, pattern: &str) {
     let len = fsst.len();
     let arr = fsst.clone().into_array();
     let pattern = ConstantArray::new(pattern, len).into_array();
-    bencher.bench_local(|| {
-        Like.try_new_array(len, LikeOptions::default(), [arr.clone(), pattern.clone()])
-            .unwrap()
-            .into_array()
-            .execute::<Canonical>(&mut SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_refs(|ctx| {
+            Like.try_new_array(len, LikeOptions::default(), [arr.clone(), pattern.clone()])
+                .unwrap()
+                .into_array()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench(args = [
diff --git a/vortex-array/benches/chunk_array_builder.rs b/vortex-array/benches/chunk_array_builder.rs
index b334b65e9e6..7d1e360c7ce 100644
--- a/vortex-array/benches/chunk_array_builder.rs
+++ b/vortex-array/benches/chunk_array_builder.rs
@@ -39,26 +39,30 @@ static SESSION: LazyLock<VortexSession> =
 fn chunked_bool_canonical_into(bencher: Bencher, (len, chunk_count): (usize, usize)) {
     let chunk = make_bool_chunks(len, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
 fn chunked_opt_bool_canonical_into(bencher: Bencher, (len, chunk_count): (usize, usize)) {
     let chunk = make_opt_bool_chunks(len, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -74,16 +78,18 @@ fn chunked_opt_bool_into_canonical(bencher: Bencher, (len, chunk_count): (usize,
 fn chunked_varbinview_canonical_into(bencher: Bencher, (len, chunk_count): (usize, usize)) {
     let chunks = make_string_chunks(false, len, chunk_count);
 
-    bencher.with_inputs(|| &chunks).bench_refs(|chunk| {
-        let mut builder = VarBinViewBuilder::with_capacity(
-            DType::Utf8(chunk.dtype().nullability()),
-            len * chunk_count,
-        );
-        chunk
-            .append_to_builder(&mut builder, &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunks, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = VarBinViewBuilder::with_capacity(
+                DType::Utf8(chunk.dtype().nullability()),
+                len * chunk_count,
+            );
+            chunk
+                .append_to_builder(&mut builder, ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -99,16 +105,18 @@ fn chunked_varbinview_into_canonical(bencher: Bencher, (len, chunk_count): (usiz
 fn chunked_varbinview_opt_canonical_into(bencher: Bencher, (len, chunk_count): (usize, usize)) {
     let chunks = make_string_chunks(true, len, chunk_count);
 
-    bencher.with_inputs(|| &chunks).bench_refs(|chunk| {
-        let mut builder = VarBinViewBuilder::with_capacity(
-            DType::Utf8(chunk.dtype().nullability()),
-            len * chunk_count,
-        );
-        chunk
-            .append_to_builder(&mut builder, &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunks, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = VarBinViewBuilder::with_capacity(
+                DType::Utf8(chunk.dtype().nullability()),
+                len * chunk_count,
+            );
+            chunk
+                .append_to_builder(&mut builder, ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -124,13 +132,15 @@ fn chunked_varbinview_opt_into_canonical(bencher: Bencher, (len, chunk_count): (
 fn chunked_constant_i32_append_to_builder(bencher: Bencher, (len, chunk_count): (usize, usize)) {
     let chunk = make_constant_i32_chunks(len, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 const CONSTANT_UTF8_BENCH_ARGS: &[(&str, usize, usize)] = &[
@@ -146,13 +156,15 @@ fn chunked_constant_utf8_append_to_builder(
 ) {
     let chunk = make_constant_utf8_chunks(value, len, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 fn make_constant_utf8_chunks(value: &str, len: usize, chunk_count: usize) -> ArrayRef {
diff --git a/vortex-array/benches/chunked_dict_builder.rs b/vortex-array/benches/chunked_dict_builder.rs
index b42514fcf19..85c8737356f 100644
--- a/vortex-array/benches/chunked_dict_builder.rs
+++ b/vortex-array/benches/chunked_dict_builder.rs
@@ -40,13 +40,15 @@ fn chunked_dict_primitive_canonical_into<T: NativePType>(
 {
     let chunk = gen_dict_primitive_chunks::<T, u16>(len, unique_values, chunk_count);
 
-    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
-        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
-        chunk
-            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
-            .vortex_expect("append failed");
-        builder.finish()
-    })
+    bencher
+        .with_inputs(|| (&chunk, SESSION.create_execution_ctx()))
+        .bench_refs(|(chunk, ctx)| {
+            let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+            chunk
+                .append_to_builder(builder.as_mut(), ctx)
+                .vortex_expect("append failed");
+            builder.finish()
+        })
 }
 
 #[divan::bench(types = [u32, u64, f32, f64], args = BENCH_ARGS)]
@@ -59,6 +61,6 @@ fn chunked_dict_primitive_into_canonical<T: NativePType>(
     let chunk = gen_dict_primitive_chunks::<T, u16>(len, unique_values, chunk_count);
 
     bencher
-        .with_inputs(|| chunk.clone())
-        .bench_values(|chunk| chunk.execute::<Canonical>(&mut SESSION.create_execution_ctx()))
+        .with_inputs(|| (chunk.clone(), SESSION.create_execution_ctx()))
+        .bench_values(|(chunk, mut ctx)| chunk.execute::<Canonical>(&mut ctx))
 }
diff --git a/vortex-array/benches/dict_mask.rs b/vortex-array/benches/dict_mask.rs
index 6f60691cc97..1951e610a51 100644
--- a/vortex-array/benches/dict_mask.rs
+++ b/vortex-array/benches/dict_mask.rs
@@ -62,14 +62,13 @@ fn bench_dict_mask(bencher: Bencher, (fraction_valid, fraction_masked): (f64, f6
     let filter_mask = filter_mask(len, fraction_masked, &mut rng);
     let session = VortexSession::empty();
     bencher
-        .with_inputs(|| (&array, &filter_mask))
-        .bench_refs(|(array, filter_mask)| {
-            let mut ctx = session.create_execution_ctx();
+        .with_inputs(|| (&array, &filter_mask, session.create_execution_ctx()))
+        .bench_refs(|(array, filter_mask, ctx)| {
             array
                 .clone()
                 .mask(filter_mask.clone().into_array())
                 .unwrap()
-                .execute::<RecursiveCanonical>(&mut ctx)
+                .execute::<RecursiveCanonical>(ctx)
                 .unwrap()
         });
 }
diff --git a/vortex-array/benches/expr/case_when_bench.rs b/vortex-array/benches/expr/case_when_bench.rs
index 7ab1d3d4bfc..f37daa2b304 100644
--- a/vortex-array/benches/expr/case_when_bench.rs
+++ b/vortex-array/benches/expr/case_when_bench.rs
@@ -70,14 +70,13 @@ fn case_when_simple(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -98,14 +97,13 @@ fn case_when_nary_3_conditions(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -127,14 +125,13 @@ fn case_when_nary_10_conditions(bencher: Bencher, size: usize) {
     let expr = nested_case_when(pairs, Some(lit(0i32)));
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -151,14 +148,13 @@ fn case_when_nary_equality_lookup(bencher: Bencher, size: usize) {
     let expr = nested_case_when(pairs, Some(lit(-1i32)));
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -172,14 +168,13 @@ fn case_when_without_else(bencher: Bencher, size: usize) {
     let expr = case_when_no_else(gt(get_item("value", root()), lit(500i32)), lit(100i32));
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -197,14 +192,13 @@ fn case_when_all_true(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -231,14 +225,13 @@ fn case_when_nary_early_dominant(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -256,14 +249,13 @@ fn case_when_all_false(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
@@ -284,14 +276,13 @@ fn case_when_fragmented(bencher: Bencher, size: usize) {
     );
 
     bencher
-        .with_inputs(|| (&expr, &array))
-        .bench_refs(|(expr, array)| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (&expr, &array, SESSION.create_execution_ctx()))
+        .bench_refs(|(expr, array, ctx)| {
             array
                 .clone()
                 .apply(expr)
                 .unwrap()
-                .execute::<Canonical>(&mut ctx)
+                .execute::<Canonical>(ctx)
                 .unwrap()
         });
 }
diff --git a/vortex/benches/single_encoding_throughput.rs b/vortex/benches/single_encoding_throughput.rs
index 9b7e069d963..e82f5fdd87a 100644
--- a/vortex/benches/single_encoding_throughput.rs
+++ b/vortex/benches/single_encoding_throughput.rs
@@ -152,9 +152,9 @@ fn bench_delta_compress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
-        .with_inputs(|| &uint_array)
-        .bench_refs(|a| {
-            let (_bases, _deltas) = delta_compress(a, &mut SESSION.create_execution_ctx()).unwrap();
+        .with_inputs(|| (&uint_array, SESSION.create_execution_ctx()))
+        .bench_refs(|(a, ctx)| {
+            let (_bases, _deltas) = delta_compress(a, ctx).unwrap();
             DeltaData::try_new(0).unwrap()
         });
 }
@@ -512,16 +512,15 @@ mod turboquant_benches {
                     let normalized_ext = setup_normalized_vector_ext($dim);
                     let config = turboquant_config($bits);
                     with_byte_counter(bencher, (NUM_VECTORS * $dim * 4) as u64)
-                        .with_inputs(|| normalized_ext.clone())
-                        .bench_refs(|a| {
-                            let mut ctx = SESSION.create_execution_ctx();
+                        .with_inputs(|| (normalized_ext.clone(), SESSION.create_execution_ctx()))
+                        .bench_refs(|(a, ctx)| {
                             let normalized = a
                                 .as_ref()
                                 .as_opt::<Extension>()
                                 .expect("normalized benchmark input should be an Extension array");
                             // SAFETY: Benchmark inputs are normalized once up front so the timed
                             // region measures only TurboQuant encoding.
-                            unsafe { turboquant_encode_unchecked(normalized, &config, &mut ctx) }
+                            unsafe { turboquant_encode_unchecked(normalized, &config, ctx) }
                                 .unwrap()
                         });
                 }
@@ -539,12 +538,11 @@ mod turboquant_benches {
                     }
                     .unwrap();
                     with_byte_counter(bencher, (NUM_VECTORS * $dim * 4) as u64)
-                        .with_inputs(|| &compressed)
-                        .bench_refs(|a| {
-                            let mut ctx = SESSION.create_execution_ctx();
-                            a.clone()
+                        .with_inputs(|| (&compressed, SESSION.create_execution_ctx()))
+                        .bench_refs(|(a, ctx)| {
+                            (*a).clone()
                                 .into_array()
-                                .execute::<ExtensionArray>(&mut ctx)
+                                .execute::<ExtensionArray>(ctx)
                                 .unwrap()
                         });
                 }