Remove LEGACY_SESSION from benchmarks and back compat tests (#8554)

Author: robert3005

fuzz/src/gpu/mod.rs

@@ -12,7 +12,6 @@ use arbitrary::Unstructured;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::dict::ArbitraryDictArray;
 use vortex_array::dtype::Nullability;
@@ -110,13 +109,11 @@ pub async fn run_compress_gpu(fuzz: FuzzCompressGpu) -> VortexFuzzResult<bool> {
     }
 
     let FuzzCompressGpu { array } = fuzz;
+    let mut ctx = SESSION.create_execution_ctx();
 
     let original_len = array.len();
 
-    let cpu_canonical = match array
-        .clone()
-        .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-    {
+    let cpu_canonical = match array.clone().execute::<Canonical>(&mut ctx) {
         Ok(c) => c,
         Err(e) => {
             return Err(VortexFuzzError::VortexError(e, Backtrace::capture()));
@@ -165,10 +162,10 @@ pub async fn run_compress_gpu(fuzz: FuzzCompressGpu) -> VortexFuzzResult<bool> {
 
     for i in 0..original_len {
         let cpu_scalar = cpu_array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut ctx)
             .map_err(|e| VortexFuzzError::VortexError(e, Backtrace::capture()))?;
         let gpu_scalar = gpu_array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut ctx)
             .map_err(|e| VortexFuzzError::VortexError(e, Backtrace::capture()))?;
 
         if cpu_scalar != gpu_scalar {

vortex-array/benches/aggregate_grouped.rs

@@ -4,13 +4,14 @@
 #![expect(clippy::cast_possible_truncation)]
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::aggregate_fn::AggregateFnVTable;
 use vortex_array::aggregate_fn::DynGroupedAccumulator;
@@ -24,11 +25,14 @@ use vortex_array::arrays::VarBinViewArray;
 use vortex_array::dtype::DType;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> = LazyLock::new(vortex_array::array_session);
+
 const GROUP_COUNT: usize = 128;
 const GROUP_SIZE_SEED: u64 = 42;
 const MIN_VALUES_PER_GROUP: usize = 1;
@@ -157,7 +161,7 @@ where
         list_element_dtype(list_view),
     )
     .unwrap();
-    acc.accumulate_list(list_view, &mut LEGACY_SESSION.create_execution_ctx())
+    acc.accumulate_list(list_view, &mut SESSION.create_execution_ctx())
         .unwrap();
     divan::black_box(acc.finish().unwrap())
 }

vortex-array/benches/bool_zip.rs

@@ -3,20 +3,24 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> = LazyLock::new(vortex_array::array_session);
+
 const LEN: usize = 65_536;
 
 /// Fragmented (alternating) mask: the worst case for the generic per-run builder this kernel
@@ -53,7 +57,7 @@ fn run(bencher: Bencher, if_true: ArrayRef, if_false: ArrayRef) {
                 if_true.clone(),
                 if_false.clone(),
                 mask.clone().into_array(),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(t, f, m, ctx)| {

vortex-array/benches/primitive_zip.rs

@@ -7,20 +7,24 @@
     reason = "benchmark fixtures use indices that fit in the chosen widths"
 )]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_buffer::BufferMut;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> = LazyLock::new(vortex_array::array_session);
+
 // Sized so the bench stays well under a few hundred microseconds under CodSpeed's instruction-count
 // simulation, which runs ~10x the local walltime; the branchless value blend is still exercised.
 const LEN: usize = 16_384;
@@ -53,7 +57,7 @@ fn run(bencher: Bencher, if_true: vortex_array::ArrayRef, if_false: vortex_array
                 if_true.clone(),
                 if_false.clone(),
                 mask.clone().into_array(),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(t, f, m, ctx)| {

vortex-cuda/benches/alp_cuda.rs

@@ -21,8 +21,8 @@ use criterion::Throughput;
 use cudarc::driver::DeviceRepr;
 use futures::executor::block_on;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::VortexSessionExecute;
+use vortex::array::array_session;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity::NonNullable;
 use vortex::buffer::Buffer;
@@ -74,7 +74,7 @@ where
     let encoded = alp_encode(
         primitive_array.as_view(),
         None,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut array_session().create_execution_ctx(),
     )
     .vortex_expect("failed to ALP-encode array");
 

vortex-cuda/benches/bitpacked_cuda.rs

@@ -21,8 +21,8 @@ use criterion::Throughput;
 use cudarc::driver::DeviceRepr;
 use futures::executor::block_on;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::VortexSessionExecute;
+use vortex::array::array_session;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity::NonNullable;
 use vortex::buffer::Buffer;
@@ -57,7 +57,7 @@ where
         .collect();
 
     let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable);
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     BitPackedData::encode(&primitive_array.into_array(), bit_width, &mut ctx)
         .vortex_expect("failed to create BitPacked array")
 }
@@ -98,7 +98,7 @@ where
         .collect();
 
     let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     BitPackedData::encode(&primitive_array, bit_width, &mut ctx)
         .vortex_expect("failed to create BitPacked array with patches")
 }