From 44fd21b19a70e5e5b1c0db5c1d49a3de1636de1e Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Tue, 7 Apr 2026 23:13:40 -0400
Subject: [PATCH 01/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 .../src/arrays/chunked/vtable/canonical.rs    | 99 +++++++++++++++++--
 vortex-array/src/builders/mod.rs              | 12 +++
 vortex-array/src/executor.rs                  |  7 ++
 vortex-array/src/lib.rs                       |  1 +
 vortex-datafusion/src/persistent/format.rs    |  7 +-
 vortex-datafusion/src/persistent/reader.rs    |  4 +-
 vortex-file/src/open.rs                       | 81 ++++++++++++++-
 vortex-io/src/object_store/read_at.rs         | 39 ++++++--
 vortex-io/src/std_file/read_at.rs             | 26 ++++-
 9 files changed, 247 insertions(+), 29 deletions(-)

diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs
index 73a9b1c856a..a090b8b7928 100644
--- a/vortex-array/src/arrays/chunked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_buffer::BufferMut;
+use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
@@ -19,12 +19,13 @@ use crate::arrays::chunked::ChunkedArrayExt;
 use crate::arrays::listview::ListViewArrayExt;
 use crate::arrays::listview::ListViewRebuildMode;
 use crate::arrays::struct_::StructArrayExt;
-use crate::builders::builder_with_capacity;
+use crate::builders::builder_with_capacity_in;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::dtype::StructFields;
+use crate::memory::BufferAllocatorExt;
 use crate::validity::Validity;
 
 pub(super) fn _canonicalize(
@@ -56,7 +57,7 @@ pub(super) fn _canonicalize(
             ctx,
         )?),
         _ => {
-            let mut builder = builder_with_capacity(array.dtype(), array.len());
+            let mut builder = builder_with_capacity_in(ctx.allocator(), array.dtype(), array.len());
             array.array().append_to_builder(builder.as_mut(), ctx)?;
             builder.finish_into_canonical()
         }
@@ -131,8 +132,12 @@ fn swizzle_list_chunks(
     // this much more complicated.
     // We (somewhat arbitrarily) choose `u64` for our offsets and sizes here. These can always be
     // narrowed later by the compressor.
-    let mut offsets = BufferMut::<u64>::with_capacity(len);
-    let mut sizes = BufferMut::<u64>::with_capacity(len);
+    let allocator = ctx.allocator();
+    let mut offsets = allocator.allocate_host_typed::<u64>(len)?;
+    let mut sizes = allocator.allocate_host_typed::<u64>(len)?;
+    let offsets_out: &mut [u64] = offsets.as_mut_slice_typed::<u64>()?;
+    let sizes_slice_out: &mut [u64] = sizes.as_mut_slice_typed::<u64>()?;
+    let mut next_list = 0usize;
 
     for chunk in chunks {
         let chunk_array = chunk.clone().execute::<ListViewArray>(ctx)?;
@@ -162,19 +167,31 @@ fn swizzle_list_chunks(
         let sizes_slice = sizes_arr.as_slice::<u64>();
 
         // Append offsets and sizes, adjusting offsets to point into the combined array.
-        offsets.extend(offsets_slice.iter().map(|o| o + num_elements));
-        sizes.extend(sizes_slice);
+        for (&offset, &size) in offsets_slice.iter().zip(sizes_slice.iter()) {
+            offsets_out[next_list] = offset + num_elements;
+            sizes_slice_out[next_list] = size;
+            next_list += 1;
+        }
 
         num_elements += chunk_array.elements().len() as u64;
     }
+    debug_assert_eq!(next_list, len);
 
     // SAFETY: elements are sliced from valid `ListViewArray`s (from `to_listview()`).
     let chunked_elements =
         unsafe { ChunkedArray::new_unchecked(list_elements_chunks, elem_dtype.clone()) }
             .into_array();
 
-    let offsets = PrimitiveArray::new(offsets.freeze(), Validity::NonNullable).into_array();
-    let sizes = PrimitiveArray::new(sizes.freeze(), Validity::NonNullable).into_array();
+    let offsets = PrimitiveArray::new(
+        Buffer::<u64>::from_byte_buffer(offsets.freeze()),
+        Validity::NonNullable,
+    )
+    .into_array();
+    let sizes = PrimitiveArray::new(
+        Buffer::<u64>::from_byte_buffer(sizes.freeze()),
+        Validity::NonNullable,
+    )
+    .into_array();
 
     // SAFETY:
     // - `offsets` and `sizes` are non-nullable u64 arrays of the same length
@@ -192,9 +209,15 @@ fn swizzle_list_chunks(
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
 
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
+    use crate::Canonical;
+    use crate::ExecutionCtx;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::accessor::ArrayAccessor;
@@ -207,8 +230,28 @@ mod tests {
     use crate::dtype::DType::Primitive;
     use crate::dtype::Nullability::NonNullable;
     use crate::dtype::PType::I32;
+    use crate::memory::BufferAllocator;
+    use crate::memory::DefaultBufferAllocator;
+    use crate::memory::MemorySessionExt;
+    use crate::memory::WritableHostBuffer;
     use crate::validity::Validity;
 
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl BufferAllocator for CountingAllocator {
+        fn allocate_host(
+            &self,
+            len: usize,
+            alignment: vortex_buffer::Alignment,
+        ) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultBufferAllocator.allocate_host(len, alignment)
+        }
+    }
+
     #[test]
     pub fn pack_nested_structs() {
         let struct_array = StructArray::try_new(
@@ -265,4 +308,42 @@ mod tests {
         assert_eq!(l1.scalar_at(0).unwrap(), canon_values.scalar_at(0).unwrap());
         assert_eq!(l2.scalar_at(0).unwrap(), canon_values.scalar_at(1).unwrap());
     }
+
+    #[test]
+    fn list_canonicalize_uses_memory_session_allocator() {
+        let allocations = Arc::new(AtomicUsize::new(0));
+        let session = VortexSession::empty();
+        session
+            .memory_mut()
+            .set_allocator(Arc::new(CountingAllocator {
+                allocations: Arc::clone(&allocations),
+            }));
+        let mut ctx = ExecutionCtx::new(session);
+
+        let l1 = ListArray::try_new(
+            buffer![1, 2, 3, 4].into_array(),
+            buffer![0, 3].into_array(),
+            Validity::NonNullable,
+        )
+        .unwrap();
+        let l2 = ListArray::try_new(
+            buffer![5, 6].into_array(),
+            buffer![0, 2].into_array(),
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let chunked_list = ChunkedArray::try_new(
+            vec![l1.into_array(), l2.into_array()],
+            List(Arc::new(Primitive(I32, NonNullable)), NonNullable),
+        )
+        .unwrap()
+        .into_array();
+
+        drop(chunked_list.execute::<Canonical>(&mut ctx).unwrap());
+        assert!(
+            allocations.load(Ordering::Relaxed) >= 2,
+            "expected offset+size allocations through MemorySession"
+        );
+    }
 }
diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs
index f9914c8fb84..44edb4ebfa7 100644
--- a/vortex-array/src/builders/mod.rs
+++ b/vortex-array/src/builders/mod.rs
@@ -39,6 +39,7 @@ use crate::canonical::Canonical;
 use crate::dtype::DType;
 use crate::match_each_decimal_value_type;
 use crate::match_each_native_ptype;
+use crate::memory::BufferAllocatorRef;
 use crate::scalar::Scalar;
 
 mod lazy_null_builder;
@@ -285,3 +286,14 @@ pub fn builder_with_capacity(dtype: &DType, capacity: usize) -> Box<dyn ArrayBui
         }
     }
 }
+
+/// Construct a new canonical builder for the given [`DType`] using a host
+/// [`crate::memory::BufferAllocator`].
+pub fn builder_with_capacity_in(
+    allocator: BufferAllocatorRef,
+    dtype: &DType,
+    capacity: usize,
+) -> Box<dyn ArrayBuilder> {
+    let _allocator = allocator;
+    builder_with_capacity(dtype, capacity)
+}
diff --git a/vortex-array/src/executor.rs b/vortex-array/src/executor.rs
index 623410938d2..591c8e0c45c 100644
--- a/vortex-array/src/executor.rs
+++ b/vortex-array/src/executor.rs
@@ -34,6 +34,8 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
 use crate::matcher::Matcher;
+use crate::memory::BufferAllocatorRef;
+use crate::memory::MemorySessionExt;
 use crate::optimizer::ArrayOptimizer;
 
 /// Maximum number of iterations to attempt when executing an array before giving up and returning
@@ -210,6 +212,11 @@ impl ExecutionCtx {
         &self.session
     }
 
+    /// Get the session-scoped host allocator for this execution context.
+    pub fn allocator(&self) -> BufferAllocatorRef {
+        self.session.allocator()
+    }
+
     /// Log an execution step at the current depth.
     ///
     /// Steps are accumulated and dumped as a single trace on Drop at DEBUG level.
diff --git a/vortex-array/src/lib.rs b/vortex-array/src/lib.rs
index cb0956b8f47..e84c83c0cf6 100644
--- a/vortex-array/src/lib.rs
+++ b/vortex-array/src/lib.rs
@@ -52,6 +52,7 @@ pub mod kernel;
 pub mod mask;
 mod mask_future;
 pub mod matcher;
+pub mod memory;
 mod metadata;
 pub mod normalize;
 pub mod optimizer;
diff --git a/vortex-datafusion/src/persistent/format.rs b/vortex-datafusion/src/persistent/format.rs
index 0be2086c885..9b16cfd85aa 100644
--- a/vortex-datafusion/src/persistent/format.rs
+++ b/vortex-datafusion/src/persistent/format.rs
@@ -43,6 +43,7 @@ use futures::stream;
 use object_store::ObjectMeta;
 use object_store::ObjectStore;
 use vortex::VortexSessionDefault;
+use vortex::array::memory::MemorySessionExt;
 use vortex::dtype::DType;
 use vortex::dtype::Nullability;
 use vortex::dtype::PType;
@@ -265,10 +266,11 @@ impl FileFormat for VortexFormat {
                     }
 
                     // Not entry or invalid - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new(
+                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
                         store,
                         object.location.clone(),
                         session.handle(),
+                        session.allocator(),
                     ));
 
                     let vxf = session
@@ -337,10 +339,11 @@ impl FileFormat for VortexFormat {
                 Some(metadata) => metadata,
                 None => {
                     // Not entry - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new(
+                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
                         store,
                         object.location.clone(),
                         session.handle(),
+                        session.allocator(),
                     ));
 
                     let vxf = session
diff --git a/vortex-datafusion/src/persistent/reader.rs b/vortex-datafusion/src/persistent/reader.rs
index 4e480ca374f..8b87c29e8a2 100644
--- a/vortex-datafusion/src/persistent/reader.rs
+++ b/vortex-datafusion/src/persistent/reader.rs
@@ -10,6 +10,7 @@ use std::sync::Arc;
 use datafusion_common::Result as DFResult;
 use datafusion_datasource::PartitionedFile;
 use object_store::ObjectStore;
+use vortex::array::memory::MemorySessionExt;
 use vortex::io::VortexReadAt;
 use vortex::io::object_store::ObjectStoreReadAt;
 use vortex::io::session::RuntimeSessionExt;
@@ -45,10 +46,11 @@ impl VortexReaderFactory for DefaultVortexReaderFactory {
         file: &PartitionedFile,
         session: &VortexSession,
     ) -> DFResult<Arc<dyn VortexReadAt>> {
-        Ok(Arc::new(ObjectStoreReadAt::new(
+        Ok(Arc::new(ObjectStoreReadAt::new_with_allocator(
             self.object_store.clone(),
             file.path().as_ref().into(),
             session.handle(),
+            session.allocator(),
         )) as _)
     }
 }
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 049010f0d71..54ecc74c32c 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -6,6 +6,7 @@ use std::sync::Arc;
 use futures::executor::block_on;
 use parking_lot::RwLock;
 use vortex_array::dtype::DType;
+use vortex_array::memory::MemorySessionExt;
 use vortex_array::session::ArraySessionExt;
 use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
@@ -61,7 +62,9 @@ pub struct VortexOpenOptions {
     labels: Vec<Label>,
 }
 
-pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt {
+pub trait OpenOptionsSessionExt:
+    ArraySessionExt + LayoutSessionExt + RuntimeSessionExt + MemorySessionExt
+{
     /// Create a new [`VortexOpenOptions`] using the provided session to open a file.
     fn open_options(&self) -> VortexOpenOptions {
         VortexOpenOptions {
@@ -77,7 +80,10 @@ pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSes
         }
     }
 }
-impl<S: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt> OpenOptionsSessionExt for S {}
+impl<S: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt + MemorySessionExt>
+    OpenOptionsSessionExt for S
+{
+}
 
 impl VortexOpenOptions {
     /// Configure the initial read size for the Vortex file.
@@ -157,7 +163,8 @@ impl VortexOpenOptions {
     pub async fn open_path(self, path: impl AsRef<std::path::Path>) -> VortexResult<VortexFile> {
         use vortex_io::std_file::FileReadAt;
         let handle = self.session.handle();
-        let source = Arc::new(FileReadAt::open(path, handle)?);
+        let allocator = self.session.allocator();
+        let source = Arc::new(FileReadAt::open_with_allocator(path, handle, allocator)?);
         self.open(source).await
     }
 
@@ -329,10 +336,12 @@ impl VortexOpenOptions {
         use vortex_io::object_store::ObjectStoreReadAt;
 
         let handle = self.session.handle();
-        let source = Arc::new(ObjectStoreReadAt::new(
+        let allocator = self.session.allocator();
+        let source = Arc::new(ObjectStoreReadAt::new_with_allocator(
             object_store.clone(),
             path.into(),
             handle,
+            allocator,
         ));
         self.open(source).await
     }
@@ -347,9 +356,15 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::buffer::BufferHandle;
     use vortex_array::dtype::session::DTypeSession;
+    use vortex_array::memory::BufferAllocator;
+    use vortex_array::memory::DefaultBufferAllocator;
+    use vortex_array::memory::MemorySessionExt;
+    use vortex_array::memory::WritableHostBuffer;
     use vortex_array::scalar_fn::session::ScalarFnSession;
     use vortex_array::session::ArraySession;
+    use vortex_buffer::Alignment;
     use vortex_buffer::Buffer;
+    use vortex_buffer::ByteBuffer;
     use vortex_buffer::ByteBufferMut;
     use vortex_io::session::RuntimeSession;
     use vortex_layout::session::LayoutSession;
@@ -391,6 +406,22 @@ mod tests {
         }
     }
 
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl BufferAllocator for CountingAllocator {
+        fn allocate_host(
+            &self,
+            len: usize,
+            alignment: Alignment,
+        ) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultBufferAllocator.allocate_host(len, alignment)
+        }
+    }
+
     #[tokio::test]
     async fn test_initial_read_size() {
         let session = VortexSession::empty()
@@ -447,4 +478,46 @@ mod tests {
         let read = total_read.load(Ordering::Relaxed);
         assert!(read < 1024 * 1024, "Read {} bytes, expected < 1MB", read);
     }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test]
+    async fn test_open_path_uses_memory_session_allocator() {
+        let session = VortexSession::empty()
+            .with::<DTypeSession>()
+            .with::<ArraySession>()
+            .with::<LayoutSession>()
+            .with::<ScalarFnSession>()
+            .with::<RuntimeSession>();
+
+        crate::register_default_encodings(&session);
+
+        let mut buf = ByteBufferMut::empty();
+        let array = Buffer::from((0i32..16_384).collect::<Vec<i32>>()).into_array();
+        session
+            .write_options()
+            .write(&mut buf, array.to_array_stream())
+            .await
+            .unwrap();
+
+        let file_path = std::env::temp_dir().join(format!(
+            "vortex-open-memory-session-{}.vx",
+            std::process::id()
+        ));
+        std::fs::write(&file_path, ByteBuffer::from(buf).as_slice()).unwrap();
+
+        let allocations = Arc::new(AtomicUsize::new(0));
+        session
+            .memory_mut()
+            .set_allocator(Arc::new(CountingAllocator {
+                allocations: Arc::clone(&allocations),
+            }));
+
+        let _file = session.open_options().open_path(&file_path).await.unwrap();
+        std::fs::remove_file(&file_path).unwrap();
+
+        assert!(
+            allocations.load(Ordering::Relaxed) > 0,
+            "expected at least one host allocation from MemorySession"
+        );
+    }
 }
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index a4957199565..20be0dbdb3f 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -14,8 +14,9 @@ use object_store::ObjectStore;
 use object_store::ObjectStoreExt;
 use object_store::path::Path as ObjectPath;
 use vortex_array::buffer::BufferHandle;
+use vortex_array::memory::BufferAllocatorRef;
+use vortex_array::memory::DefaultBufferAllocator;
 use vortex_buffer::Alignment;
-use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
@@ -35,6 +36,7 @@ pub struct ObjectStoreReadAt {
     path: ObjectPath,
     uri: Arc<str>,
     handle: Handle,
+    allocator: BufferAllocatorRef,
     concurrency: usize,
     coalesce_config: Option<CoalesceConfig>,
 }
@@ -42,12 +44,23 @@ pub struct ObjectStoreReadAt {
 impl ObjectStoreReadAt {
     /// Create a new object store source.
     pub fn new(store: Arc<dyn ObjectStore>, path: ObjectPath, handle: Handle) -> Self {
+        Self::new_with_allocator(store, path, handle, Arc::new(DefaultBufferAllocator))
+    }
+
+    /// Create a new object store source with a custom writable buffer allocator.
+    pub fn new_with_allocator(
+        store: Arc<dyn ObjectStore>,
+        path: ObjectPath,
+        handle: Handle,
+        allocator: BufferAllocatorRef,
+    ) -> Self {
         let uri = Arc::from(path.to_string());
         Self {
             store,
             path,
             uri,
             handle,
+            allocator,
             concurrency: DEFAULT_CONCURRENCY,
             coalesce_config: Some(CoalesceConfig::object_storage()),
         }
@@ -101,10 +114,11 @@ impl VortexReadAt for ObjectStoreReadAt {
         let store = self.store.clone();
         let path = self.path.clone();
         let handle = self.handle.clone();
+        let allocator = Arc::clone(&self.allocator);
         let range = offset..(offset + length as u64);
 
         async move {
-            let mut buffer = ByteBufferMut::with_capacity_aligned(length, alignment);
+            let mut buffer = allocator.allocate_host(length, alignment)?;
 
             let response = store
                 .get_opts(
@@ -119,11 +133,9 @@ impl VortexReadAt for ObjectStoreReadAt {
             let buffer = match response.payload {
                 #[cfg(not(target_arch = "wasm32"))]
                 GetResultPayload::File(file, _) => {
-                    unsafe { buffer.set_len(length) };
-
                     handle
                         .spawn_blocking(move || {
-                            read_exact_at(&file, &mut buffer, range.start)?;
+                            read_exact_at(&file, buffer.as_mut_slice(), range.start)?;
                             Ok::<_, io::Error>(buffer)
                         })
                         .await
@@ -134,14 +146,25 @@ impl VortexReadAt for ObjectStoreReadAt {
                     unreachable!("File payload not supported on wasm32")
                 }
                 GetResultPayload::Stream(mut byte_stream) => {
+                    let mut written = 0usize;
                     while let Some(bytes) = byte_stream.next().await {
-                        buffer.extend_from_slice(&bytes?);
+                        let bytes = bytes?;
+                        let end = written + bytes.len();
+                        vortex_ensure!(
+                            end <= length,
+                            "Object store stream returned too many bytes: {} > expected {} (range: {:?})",
+                            end,
+                            length,
+                            range
+                        );
+                        buffer.as_mut_slice()[written..end].copy_from_slice(&bytes);
+                        written = end;
                     }
 
                     vortex_ensure!(
-                        buffer.len() == length,
+                        written == length,
                         "Object store stream returned {} bytes but expected {} bytes (range: {:?})",
-                        buffer.len(),
+                        written,
                         length,
                         range
                     );
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index 13d3b3f5501..cb85a099f5c 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -17,8 +17,9 @@ use std::sync::Arc;
 use futures::FutureExt;
 use futures::future::BoxFuture;
 use vortex_array::buffer::BufferHandle;
+use vortex_array::memory::BufferAllocatorRef;
+use vortex_array::memory::DefaultBufferAllocator;
 use vortex_buffer::Alignment;
-use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexResult;
 
 use crate::CoalesceConfig;
@@ -65,15 +66,30 @@ pub struct FileReadAt {
     uri: Arc<str>,
     file: Arc<File>,
     handle: Handle,
+    allocator: BufferAllocatorRef,
 }
 
 impl FileReadAt {
     /// Open a file for reading.
     pub fn open(path: impl AsRef<Path>, handle: Handle) -> VortexResult<Self> {
+        Self::open_with_allocator(path, handle, Arc::new(DefaultBufferAllocator))
+    }
+
+    /// Open a file for reading using a custom writable buffer allocator.
+    pub fn open_with_allocator(
+        path: impl AsRef<Path>,
+        handle: Handle,
+        allocator: BufferAllocatorRef,
+    ) -> VortexResult<Self> {
         let path = path.as_ref();
         let uri = path.to_string_lossy().to_string().into();
         let file = Arc::new(File::open(path)?);
-        Ok(Self { uri, file, handle })
+        Ok(Self {
+            uri,
+            file,
+            handle,
+            allocator,
+        })
     }
 }
 
@@ -107,12 +123,12 @@ impl VortexReadAt for FileReadAt {
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
         let file = self.file.clone();
         let handle = self.handle.clone();
+        let allocator = Arc::clone(&self.allocator);
         async move {
             handle
                 .spawn_blocking(move || {
-                    let mut buffer = ByteBufferMut::with_capacity_aligned(length, alignment);
-                    unsafe { buffer.set_len(length) };
-                    read_exact_at(&file, &mut buffer, offset)?;
+                    let mut buffer = allocator.allocate_host(length, alignment)?;
+                    read_exact_at(&file, buffer.as_mut_slice(), offset)?;
                     Ok(BufferHandle::new_host(buffer.freeze()))
                 })
                 .await

From fcc7a39574c3394022869d7a967c746cb4fcbc94 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Tue, 7 Apr 2026 23:13:45 -0400
Subject: [PATCH 02/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/src/memory.rs | 334 +++++++++++++++++++++++++++++++++++++
 1 file changed, 334 insertions(+)
 create mode 100644 vortex-array/src/memory.rs

diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
new file mode 100644
index 00000000000..25c06f6265a
--- /dev/null
+++ b/vortex-array/src/memory.rs
@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Session-scoped memory allocation for host-side buffers.
+
+use std::fmt::Debug;
+use std::mem::align_of;
+use std::mem::size_of;
+use std::sync::Arc;
+
+use bytes::Bytes;
+use vortex_buffer::Alignment;
+use vortex_buffer::ByteBuffer;
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+use vortex_error::vortex_ensure;
+use vortex_session::Ref;
+use vortex_session::RefMut;
+use vortex_session::SessionExt;
+
+/// Mutable host buffer contract used by [`WritableHostBuffer`].
+pub trait HostBufferMut: Send + 'static {
+    /// Returns the logical byte length of the buffer.
+    fn len(&self) -> usize;
+
+    /// Returns the alignment of the buffer.
+    fn alignment(&self) -> Alignment;
+
+    /// Returns mutable access to the writable byte range.
+    fn as_mut_slice(&mut self) -> &mut [u8];
+
+    /// Freeze the buffer into an immutable [`ByteBuffer`].
+    fn freeze(self: Box<Self>) -> ByteBuffer;
+}
+
+/// Exact-size writable host buffer returned by a [`BufferAllocator`].
+pub struct WritableHostBuffer {
+    inner: Box<dyn HostBufferMut>,
+}
+
+impl WritableHostBuffer {
+    /// Create a writable host buffer from an implementation of [`HostBufferMut`].
+    pub fn new(inner: Box<dyn HostBufferMut>) -> Self {
+        Self { inner }
+    }
+
+    /// Returns the logical byte length of the buffer.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true when the buffer has zero bytes.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the alignment of the buffer.
+    pub fn alignment(&self) -> Alignment {
+        self.inner.alignment()
+    }
+
+    /// Returns mutable access to the writable byte range.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.inner.as_mut_slice()
+    }
+
+    /// Returns mutable access to the buffer as a typed slice.
+    pub fn as_mut_slice_typed<T>(&mut self) -> VortexResult<&mut [T]> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot create typed mutable slice for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+
+        let bytes = self.as_mut_slice();
+        let byte_len = bytes.len();
+        let ptr = bytes.as_mut_ptr();
+        let type_size = size_of::<T>();
+        let type_align = align_of::<T>();
+
+        vortex_ensure!(
+            byte_len % type_size == 0,
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            (ptr as usize) % type_align == 0,
+            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
+            type_align,
+            std::any::type_name::<T>()
+        );
+
+        // SAFETY: We checked size divisibility and pointer alignment for `T`,
+        // and we have exclusive mutable access to the underlying bytes.
+        Ok(unsafe { std::slice::from_raw_parts_mut(ptr.cast::<T>(), byte_len / type_size) })
+    }
+
+    /// Freeze the writable buffer into an immutable [`ByteBuffer`].
+    pub fn freeze(self) -> ByteBuffer {
+        self.inner.freeze()
+    }
+}
+
+impl Debug for WritableHostBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WritableHostBuffer")
+            .field("len", &self.len())
+            .field("alignment", &self.alignment())
+            .finish()
+    }
+}
+
+/// Allocator for exact-size writable host buffers.
+pub trait BufferAllocator: Debug + Send + Sync + 'static {
+    /// Allocate a writable host buffer with the requested byte length and alignment.
+    fn allocate_host(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
+}
+
+/// Shared allocator reference used throughout session-scoped memory APIs.
+pub type BufferAllocatorRef = Arc<dyn BufferAllocator>;
+
+/// Extension methods for [`BufferAllocator`]s.
+pub trait BufferAllocatorExt: BufferAllocator {
+    /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
+    fn allocate_host_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
+        let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
+            vortex_err!(
+                "Typed host allocation overflow for type {} and len {}",
+                std::any::type_name::<T>(),
+                len
+            )
+        })?;
+        self.allocate_host(bytes, Alignment::of::<T>())
+    }
+}
+
+impl<A: BufferAllocator + ?Sized> BufferAllocatorExt for A {}
+
+/// Session-scoped memory configuration for Vortex arrays.
+#[derive(Debug)]
+pub struct MemorySession {
+    allocator: BufferAllocatorRef,
+}
+
+impl MemorySession {
+    /// Creates a new session memory configuration using the provided allocator.
+    pub fn new(allocator: BufferAllocatorRef) -> Self {
+        Self { allocator }
+    }
+
+    /// Returns the configured allocator.
+    pub fn allocator(&self) -> BufferAllocatorRef {
+        Arc::clone(&self.allocator)
+    }
+
+    /// Updates the configured allocator.
+    pub fn set_allocator(&mut self, allocator: BufferAllocatorRef) {
+        self.allocator = allocator;
+    }
+}
+
+impl Default for MemorySession {
+    fn default() -> Self {
+        Self::new(Arc::new(DefaultBufferAllocator))
+    }
+}
+
+/// Extension trait for accessing session-scoped memory configuration.
+pub trait MemorySessionExt: SessionExt {
+    /// Returns the memory session for this execution/session context.
+    fn memory(&self) -> Ref<'_, MemorySession> {
+        self.get::<MemorySession>()
+    }
+
+    /// Returns the configured host allocator for this execution/session context.
+    fn allocator(&self) -> BufferAllocatorRef {
+        self.memory().allocator()
+    }
+
+    /// Returns mutable access to the memory session.
+    fn memory_mut(&self) -> RefMut<'_, MemorySession> {
+        self.get_mut::<MemorySession>()
+    }
+}
+
+impl<S: SessionExt> MemorySessionExt for S {}
+
+/// Default host allocator.
+#[derive(Debug, Default)]
+pub struct DefaultBufferAllocator;
+
+impl BufferAllocator for DefaultBufferAllocator {
+    fn allocate_host(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+        let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
+        // SAFETY: We fully initialize this slice before freezing it.
+        unsafe {
+            buffer.set_len(len);
+        }
+        Ok(WritableHostBuffer::new(Box::new(
+            DefaultWritableHostBuffer { buffer, alignment },
+        )))
+    }
+}
+
+#[derive(Debug)]
+struct DefaultWritableHostBuffer {
+    buffer: ByteBufferMut,
+    alignment: Alignment,
+}
+
+#[derive(Debug)]
+struct HostBufferOwner {
+    buffer: ByteBufferMut,
+}
+
+impl AsRef<[u8]> for HostBufferOwner {
+    fn as_ref(&self) -> &[u8] {
+        self.buffer.as_slice()
+    }
+}
+
+impl HostBufferMut for DefaultWritableHostBuffer {
+    fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    fn alignment(&self) -> Alignment {
+        self.alignment
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer.as_mut_slice()
+    }
+
+    fn freeze(self: Box<Self>) -> ByteBuffer {
+        let Self { buffer, alignment } = *self;
+        let bytes = Bytes::from_owner(HostBufferOwner { buffer });
+        ByteBuffer::from_bytes_aligned(bytes, alignment)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
+
+    use super::*;
+
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl BufferAllocator for CountingAllocator {
+        fn allocate_host(
+            &self,
+            len: usize,
+            alignment: Alignment,
+        ) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultBufferAllocator.allocate_host(len, alignment)
+        }
+    }
+
+    #[test]
+    fn writable_host_buffer_freeze_round_trip() {
+        let allocator = DefaultBufferAllocator;
+        let mut writable = allocator.allocate_host(16, Alignment::new(8)).unwrap();
+        for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
+            *byte = idx as u8;
+        }
+
+        let host = writable.freeze();
+        assert_eq!(host.len(), 16);
+        assert!(host.is_aligned(Alignment::new(8)));
+        assert_eq!(host.as_slice(), (0u8..16).collect::<Vec<_>>().as_slice());
+    }
+
+    #[test]
+    fn memory_session_replaces_allocator() {
+        let allocations = Arc::new(AtomicUsize::new(0));
+        let allocator = Arc::new(CountingAllocator {
+            allocations: Arc::clone(&allocations),
+        });
+        let mut session = MemorySession::default();
+        session.set_allocator(allocator);
+        drop(
+            session
+                .allocator()
+                .allocate_host(4, Alignment::none())
+                .unwrap(),
+        );
+        assert_eq!(allocations.load(Ordering::Relaxed), 1);
+    }
+
+    #[test]
+    fn typed_allocation_uses_type_alignment() {
+        let allocator = DefaultBufferAllocator;
+        let writable = allocator.allocate_host_typed::<u64>(4).unwrap();
+        assert_eq!(writable.len(), 4 * size_of::<u64>());
+        assert_eq!(writable.alignment(), Alignment::of::<u64>());
+    }
+
+    #[test]
+    fn typed_mut_slice_round_trip() {
+        let allocator = DefaultBufferAllocator;
+        let mut writable = allocator.allocate_host_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[10, 20, 30, 40]);
+
+        let frozen = writable.freeze();
+        let values = unsafe {
+            std::slice::from_raw_parts(
+                frozen.as_slice().as_ptr().cast::<u64>(),
+                frozen.len() / size_of::<u64>(),
+            )
+        };
+        assert_eq!(values, [10, 20, 30, 40]);
+    }
+
+    #[test]
+    fn typed_mut_slice_rejects_length_mismatch() {
+        let allocator = DefaultBufferAllocator;
+        let mut writable = allocator.allocate_host(7, Alignment::none()).unwrap();
+        let err = writable.as_mut_slice_typed::<u32>().unwrap_err();
+        let msg = format!("{err}");
+        assert!(msg.contains("not a multiple of"));
+    }
+}

From 283950239cee9326f751d09c49ce7b310630ae1c Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 07:46:46 -0400
Subject: [PATCH 03/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 .../src/arrays/chunked/vtable/canonical.rs    |  8 ++--
 vortex-array/src/memory.rs                    | 37 +++++++------------
 vortex-file/src/open.rs                       |  8 +---
 vortex-io/src/object_store/read_at.rs         |  2 +-
 vortex-io/src/std_file/read_at.rs             |  2 +-
 5 files changed, 21 insertions(+), 36 deletions(-)

diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs
index a090b8b7928..13b2bd45ae1 100644
--- a/vortex-array/src/arrays/chunked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs
@@ -133,8 +133,8 @@ fn swizzle_list_chunks(
     // We (somewhat arbitrarily) choose `u64` for our offsets and sizes here. These can always be
     // narrowed later by the compressor.
     let allocator = ctx.allocator();
-    let mut offsets = allocator.allocate_host_typed::<u64>(len)?;
-    let mut sizes = allocator.allocate_host_typed::<u64>(len)?;
+    let mut offsets = allocator.allocate_typed::<u64>(len)?;
+    let mut sizes = allocator.allocate_typed::<u64>(len)?;
     let offsets_out: &mut [u64] = offsets.as_mut_slice_typed::<u64>()?;
     let sizes_slice_out: &mut [u64] = sizes.as_mut_slice_typed::<u64>()?;
     let mut next_list = 0usize;
@@ -242,13 +242,13 @@ mod tests {
     }
 
     impl BufferAllocator for CountingAllocator {
-        fn allocate_host(
+        fn allocate(
             &self,
             len: usize,
             alignment: vortex_buffer::Alignment,
         ) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate_host(len, alignment)
+            DefaultBufferAllocator.allocate(len, alignment)
         }
     }
 
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index 25c06f6265a..ce6130945b3 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -13,8 +13,8 @@ use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexResult;
-use vortex_error::vortex_err;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
 use vortex_session::Ref;
 use vortex_session::RefMut;
 use vortex_session::SessionExt;
@@ -115,7 +115,7 @@ impl Debug for WritableHostBuffer {
 /// Allocator for exact-size writable host buffers.
 pub trait BufferAllocator: Debug + Send + Sync + 'static {
     /// Allocate a writable host buffer with the requested byte length and alignment.
-    fn allocate_host(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
 }
 
 /// Shared allocator reference used throughout session-scoped memory APIs.
@@ -124,7 +124,7 @@ pub type BufferAllocatorRef = Arc<dyn BufferAllocator>;
 /// Extension methods for [`BufferAllocator`]s.
 pub trait BufferAllocatorExt: BufferAllocator {
     /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
-    fn allocate_host_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
+    fn allocate_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
         let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
             vortex_err!(
                 "Typed host allocation overflow for type {} and len {}",
@@ -132,7 +132,7 @@ pub trait BufferAllocatorExt: BufferAllocator {
                 len
             )
         })?;
-        self.allocate_host(bytes, Alignment::of::<T>())
+        self.allocate(bytes, Alignment::of::<T>())
     }
 }
 
@@ -192,12 +192,10 @@ impl<S: SessionExt> MemorySessionExt for S {}
 pub struct DefaultBufferAllocator;
 
 impl BufferAllocator for DefaultBufferAllocator {
-    fn allocate_host(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
         let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
         // SAFETY: We fully initialize this slice before freezing it.
-        unsafe {
-            buffer.set_len(len);
-        }
+        unsafe { buffer.set_len(len) };
         Ok(WritableHostBuffer::new(Box::new(
             DefaultWritableHostBuffer { buffer, alignment },
         )))
@@ -255,20 +253,16 @@ mod tests {
     }
 
     impl BufferAllocator for CountingAllocator {
-        fn allocate_host(
-            &self,
-            len: usize,
-            alignment: Alignment,
-        ) -> VortexResult<WritableHostBuffer> {
+        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate_host(len, alignment)
+            DefaultBufferAllocator.allocate(len, alignment)
         }
     }
 
     #[test]
     fn writable_host_buffer_freeze_round_trip() {
         let allocator = DefaultBufferAllocator;
-        let mut writable = allocator.allocate_host(16, Alignment::new(8)).unwrap();
+        let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
         for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
             *byte = idx as u8;
         }
@@ -287,19 +281,14 @@ mod tests {
         });
         let mut session = MemorySession::default();
         session.set_allocator(allocator);
-        drop(
-            session
-                .allocator()
-                .allocate_host(4, Alignment::none())
-                .unwrap(),
-        );
+        drop(session.allocator().allocate(4, Alignment::none()).unwrap());
         assert_eq!(allocations.load(Ordering::Relaxed), 1);
     }
 
     #[test]
     fn typed_allocation_uses_type_alignment() {
         let allocator = DefaultBufferAllocator;
-        let writable = allocator.allocate_host_typed::<u64>(4).unwrap();
+        let writable = allocator.allocate_typed::<u64>(4).unwrap();
         assert_eq!(writable.len(), 4 * size_of::<u64>());
         assert_eq!(writable.alignment(), Alignment::of::<u64>());
     }
@@ -307,7 +296,7 @@ mod tests {
     #[test]
     fn typed_mut_slice_round_trip() {
         let allocator = DefaultBufferAllocator;
-        let mut writable = allocator.allocate_host_typed::<u64>(4).unwrap();
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
         writable
             .as_mut_slice_typed::<u64>()
             .unwrap()
@@ -326,7 +315,7 @@ mod tests {
     #[test]
     fn typed_mut_slice_rejects_length_mismatch() {
         let allocator = DefaultBufferAllocator;
-        let mut writable = allocator.allocate_host(7, Alignment::none()).unwrap();
+        let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
         let err = writable.as_mut_slice_typed::<u32>().unwrap_err();
         let msg = format!("{err}");
         assert!(msg.contains("not a multiple of"));
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 54ecc74c32c..ab2a51f473d 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -412,13 +412,9 @@ mod tests {
     }
 
     impl BufferAllocator for CountingAllocator {
-        fn allocate_host(
-            &self,
-            len: usize,
-            alignment: Alignment,
-        ) -> VortexResult<WritableHostBuffer> {
+        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate_host(len, alignment)
+            DefaultBufferAllocator.allocate(len, alignment)
         }
     }
 
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index 20be0dbdb3f..3815ebc6bad 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -118,7 +118,7 @@ impl VortexReadAt for ObjectStoreReadAt {
         let range = offset..(offset + length as u64);
 
         async move {
-            let mut buffer = allocator.allocate_host(length, alignment)?;
+            let mut buffer = allocator.allocate(length, alignment)?;
 
             let response = store
                 .get_opts(
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index cb85a099f5c..26f154f1fc7 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -127,7 +127,7 @@ impl VortexReadAt for FileReadAt {
         async move {
             handle
                 .spawn_blocking(move || {
-                    let mut buffer = allocator.allocate_host(length, alignment)?;
+                    let mut buffer = allocator.allocate(length, alignment)?;
                     read_exact_at(&file, buffer.as_mut_slice(), offset)?;
                     Ok(BufferHandle::new_host(buffer.freeze()))
                 })

From 32f6da75b2916fb85b5a2ec1a27a220dbeb6912f Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 09:28:03 -0400
Subject: [PATCH 04/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/public-api.lock | 108 +++++++++++++++++++++++++++++++++++
 vortex-array/src/memory.rs   |  71 ++++++++++++++++++++---
 vortex-file/public-api.lock  |   4 +-
 vortex-io/public-api.lock    |   4 ++
 4 files changed, 177 insertions(+), 10 deletions(-)

diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index 687b9d33fef..ef7ec5527ec 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -8388,6 +8388,8 @@ pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecke
 
 pub fn vortex_array::builders::builder_with_capacity(dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
 
+pub fn vortex_array::builders::builder_with_capacity_in(allocator: vortex_array::memory::BufferAllocatorRef, dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
+
 pub mod vortex_array::builtins
 
 pub trait vortex_array::builtins::ArrayBuiltins: core::marker::Sized
@@ -13262,6 +13264,110 @@ pub fn V::matches(array: &vortex_array::ArrayRef) -> bool
 
 pub fn V::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<vortex_array::ArrayView<'a, V>>
 
+pub mod vortex_array::memory
+
+pub struct vortex_array::memory::DefaultBufferAllocator
+
+impl core::default::Default for vortex_array::memory::DefaultBufferAllocator
+
+pub fn vortex_array::memory::DefaultBufferAllocator::default() -> vortex_array::memory::DefaultBufferAllocator
+
+impl core::fmt::Debug for vortex_array::memory::DefaultBufferAllocator
+
+pub fn vortex_array::memory::DefaultBufferAllocator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::memory::BufferAllocator for vortex_array::memory::DefaultBufferAllocator
+
+pub fn vortex_array::memory::DefaultBufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub struct vortex_array::memory::MemorySession
+
+impl vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+
+pub fn vortex_array::memory::MemorySession::new(allocator: vortex_array::memory::BufferAllocatorRef) -> Self
+
+pub fn vortex_array::memory::MemorySession::set_allocator(&mut self, allocator: vortex_array::memory::BufferAllocatorRef)
+
+impl core::default::Default for vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::default() -> Self
+
+impl core::fmt::Debug for vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::memory::WritableHostBuffer
+
+impl vortex_array::memory::WritableHostBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::alignment(&self) -> vortex_buffer::alignment::Alignment
+
+pub fn vortex_array::memory::WritableHostBuffer::as_mut_slice(&mut self) -> &mut [u8]
+
+pub fn vortex_array::memory::WritableHostBuffer::as_mut_slice_typed<T>(&mut self) -> vortex_error::VortexResult<&mut [T]>
+
+pub fn vortex_array::memory::WritableHostBuffer::freeze(self) -> vortex_buffer::ByteBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::freeze_typed<T>(self) -> vortex_error::VortexResult<vortex_buffer::buffer::Buffer<T>>
+
+pub fn vortex_array::memory::WritableHostBuffer::is_empty(&self) -> bool
+
+pub fn vortex_array::memory::WritableHostBuffer::len(&self) -> usize
+
+pub fn vortex_array::memory::WritableHostBuffer::new(inner: alloc::boxed::Box<dyn vortex_array::memory::HostBufferMut>) -> Self
+
+impl core::fmt::Debug for vortex_array::memory::WritableHostBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub trait vortex_array::memory::BufferAllocator: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub fn vortex_array::memory::BufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+impl vortex_array::memory::BufferAllocator for vortex_array::memory::DefaultBufferAllocator
+
+pub fn vortex_array::memory::DefaultBufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub trait vortex_array::memory::BufferAllocatorExt: vortex_array::memory::BufferAllocator
+
+pub fn vortex_array::memory::BufferAllocatorExt::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+impl<A: vortex_array::memory::BufferAllocator + ?core::marker::Sized> vortex_array::memory::BufferAllocatorExt for A
+
+pub fn A::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub trait vortex_array::memory::HostBufferMut: core::marker::Send + 'static
+
+pub fn vortex_array::memory::HostBufferMut::alignment(&self) -> vortex_buffer::alignment::Alignment
+
+pub fn vortex_array::memory::HostBufferMut::as_mut_slice(&mut self) -> &mut [u8]
+
+pub fn vortex_array::memory::HostBufferMut::freeze(self: alloc::boxed::Box<Self>) -> vortex_buffer::ByteBuffer
+
+pub fn vortex_array::memory::HostBufferMut::is_empty(&self) -> bool
+
+pub fn vortex_array::memory::HostBufferMut::len(&self) -> usize
+
+pub trait vortex_array::memory::MemorySessionExt: vortex_session::SessionExt
+
+pub fn vortex_array::memory::MemorySessionExt::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+
+pub fn vortex_array::memory::MemorySessionExt::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
+
+pub fn vortex_array::memory::MemorySessionExt::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
+
+impl<S: vortex_session::SessionExt> vortex_array::memory::MemorySessionExt for S
+
+pub fn S::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+
+pub fn S::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
+
+pub fn S::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
+
+pub type vortex_array::memory::BufferAllocatorRef = alloc::sync::Arc<dyn vortex_array::memory::BufferAllocator>
+
 pub mod vortex_array::normalize
 
 pub enum vortex_array::normalize::Operation<'a>
@@ -22362,6 +22468,8 @@ pub struct vortex_array::ExecutionCtx
 
 impl vortex_array::ExecutionCtx
 
+pub fn vortex_array::ExecutionCtx::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+
 pub fn vortex_array::ExecutionCtx::log(&mut self, msg: core::fmt::Arguments<'_>)
 
 pub fn vortex_array::ExecutionCtx::new(session: vortex_session::VortexSession) -> Self
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index ce6130945b3..c8092e7c4a6 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -10,6 +10,7 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 use vortex_buffer::Alignment;
+use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexResult;
@@ -24,6 +25,11 @@ pub trait HostBufferMut: Send + 'static {
     /// Returns the logical byte length of the buffer.
     fn len(&self) -> usize;
 
+    /// Whether the buffer is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Returns the alignment of the buffer.
     fn alignment(&self) -> Alignment;
 
@@ -72,25 +78,23 @@ impl WritableHostBuffer {
             InvalidArgument: "Cannot create typed mutable slice for zero-sized type {}",
             std::any::type_name::<T>()
         );
+        vortex_ensure!(
+            self.alignment().is_aligned_to(Alignment::of::<T>()),
+            InvalidArgument: "Buffer is not sufficiently aligned for type {}",
+            std::any::type_name::<T>()
+        );
 
         let bytes = self.as_mut_slice();
         let byte_len = bytes.len();
         let ptr = bytes.as_mut_ptr();
         let type_size = size_of::<T>();
-        let type_align = align_of::<T>();
 
         vortex_ensure!(
-            byte_len % type_size == 0,
+            byte_len.is_multiple_of(type_size),
             InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
             type_size,
             std::any::type_name::<T>()
         );
-        vortex_ensure!(
-            (ptr as usize) % type_align == 0,
-            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
-            type_align,
-            std::any::type_name::<T>()
-        );
 
         // SAFETY: We checked size divisibility and pointer alignment for `T`,
         // and we have exclusive mutable access to the underlying bytes.
@@ -101,6 +105,35 @@ impl WritableHostBuffer {
     pub fn freeze(self) -> ByteBuffer {
         self.inner.freeze()
     }
+
+    /// Freeze the writable buffer into a typed immutable [`Buffer<T>`].
+    pub fn freeze_typed<T>(self) -> VortexResult<Buffer<T>> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot freeze typed buffer for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+
+        let buffer = self.freeze();
+        let byte_len = buffer.len();
+        let type_size = size_of::<T>();
+        let type_align = Alignment::of::<T>();
+
+        vortex_ensure!(
+            byte_len % type_size == 0,
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            buffer.is_aligned(type_align),
+            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
+            type_align,
+            std::any::type_name::<T>()
+        );
+
+        Ok(Buffer::from_byte_buffer(buffer))
+    }
 }
 
 impl Debug for WritableHostBuffer {
@@ -320,4 +353,26 @@ mod tests {
         let msg = format!("{err}");
         assert!(msg.contains("not a multiple of"));
     }
+
+    #[test]
+    fn freeze_typed_round_trip() {
+        let allocator = DefaultBufferAllocator;
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[1, 3, 5, 7]);
+
+        let frozen = writable.freeze_typed::<u64>().unwrap();
+        assert_eq!(frozen.as_slice(), [1, 3, 5, 7]);
+    }
+
+    #[test]
+    fn freeze_typed_rejects_length_mismatch() {
+        let allocator = DefaultBufferAllocator;
+        let writable = allocator.allocate(7, Alignment::none()).unwrap();
+        let err = writable.freeze_typed::<u32>().unwrap_err();
+        let msg = format!("{err}");
+        assert!(msg.contains("not a multiple of"));
+    }
 }
diff --git a/vortex-file/public-api.lock b/vortex-file/public-api.lock
index fe545cfb26a..59ec83b7fe9 100644
--- a/vortex-file/public-api.lock
+++ b/vortex-file/public-api.lock
@@ -398,11 +398,11 @@ pub const vortex_file::VORTEX_FILE_EXTENSION: &str
 
 pub static vortex_file::ALLOWED_ENCODINGS: std::sync::lazy_lock::LazyLock<vortex_utils::aliases::hash_set::HashSet<vortex_array::array::ArrayId>>
 
-pub trait vortex_file::OpenOptionsSessionExt: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt
+pub trait vortex_file::OpenOptionsSessionExt: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt + vortex_array::memory::MemorySessionExt
 
 pub fn vortex_file::OpenOptionsSessionExt::open_options(&self) -> vortex_file::VortexOpenOptions
 
-impl<S: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt> vortex_file::OpenOptionsSessionExt for S
+impl<S: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt + vortex_array::memory::MemorySessionExt> vortex_file::OpenOptionsSessionExt for S
 
 pub fn S::open_options(&self) -> vortex_file::VortexOpenOptions
 
diff --git a/vortex-io/public-api.lock b/vortex-io/public-api.lock
index 2037e272e3b..ab291cd52dc 100644
--- a/vortex-io/public-api.lock
+++ b/vortex-io/public-api.lock
@@ -150,6 +150,8 @@ impl vortex_io::object_store::ObjectStoreReadAt
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle) -> Self
 
+pub fn vortex_io::object_store::ObjectStoreReadAt::new_with_allocator(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::BufferAllocatorRef) -> Self
+
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_coalesce_config(self, config: vortex_io::CoalesceConfig) -> Self
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_concurrency(self, concurrency: usize) -> Self
@@ -466,6 +468,8 @@ impl vortex_io::std_file::FileReadAt
 
 pub fn vortex_io::std_file::FileReadAt::open(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle) -> vortex_error::VortexResult<Self>
 
+pub fn vortex_io::std_file::FileReadAt::open_with_allocator(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::BufferAllocatorRef) -> vortex_error::VortexResult<Self>
+
 impl vortex_io::VortexReadAt for vortex_io::std_file::FileReadAt
 
 pub fn vortex_io::std_file::FileReadAt::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>

From 098474a75e67811333c2c14bf56adac067415e3d Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 09:30:39 -0400
Subject: [PATCH 05/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/src/memory.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index c8092e7c4a6..0821ca65406 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -4,7 +4,6 @@
 //! Session-scoped memory allocation for host-side buffers.
 
 use std::fmt::Debug;
-use std::mem::align_of;
 use std::mem::size_of;
 use std::sync::Arc;
 
@@ -120,7 +119,7 @@ impl WritableHostBuffer {
         let type_align = Alignment::of::<T>();
 
         vortex_ensure!(
-            byte_len % type_size == 0,
+            byte_len.is_multiple_of(type_size),
             InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
             type_size,
             std::any::type_name::<T>()

From 102a891d4295b1bdda471a3751687ac1ef64de45 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 09:31:41 -0400
Subject: [PATCH 06/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/src/memory.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index 0821ca65406..3fdc5b96ff8 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -348,9 +348,7 @@ mod tests {
     fn typed_mut_slice_rejects_length_mismatch() {
         let allocator = DefaultBufferAllocator;
         let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
-        let err = writable.as_mut_slice_typed::<u32>().unwrap_err();
-        let msg = format!("{err}");
-        assert!(msg.contains("not a multiple of"));
+        assert!(writable.as_mut_slice_typed::<u32>().is_err());
     }
 
     #[test]

From b4b67743fd3a4a3295abfc260b6fc204d6bbbafb Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 10:28:11 -0400
Subject: [PATCH 07/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/src/memory.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index 3fdc5b96ff8..f36891450a1 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -296,7 +296,7 @@ mod tests {
         let allocator = DefaultBufferAllocator;
         let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
         for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
-            *byte = idx as u8;
+            *byte = u8::try_from(idx).unwrap();
         }
 
         let host = writable.freeze();

From 49aaadad34bc37e3dcf297694176872db24f9533 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 10:40:10 -0400
Subject: [PATCH 08/17] Initial buffer allocator

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 .../src/arrays/chunked/vtable/canonical.rs    | 10 ++---
 vortex-array/src/builders/mod.rs              |  6 +--
 vortex-array/src/executor.rs                  |  4 +-
 vortex-array/src/memory.rs                    | 44 +++++++++----------
 vortex-file/src/open.rs                       |  8 ++--
 vortex-io/src/object_store/read_at.rs         | 10 ++---
 vortex-io/src/std_file/read_at.rs             | 10 ++---
 7 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs
index 13b2bd45ae1..63bb4132eca 100644
--- a/vortex-array/src/arrays/chunked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs
@@ -25,7 +25,7 @@ use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::dtype::StructFields;
-use crate::memory::BufferAllocatorExt;
+use crate::memory::HostAllocatorExt;
 use crate::validity::Validity;
 
 pub(super) fn _canonicalize(
@@ -230,8 +230,8 @@ mod tests {
     use crate::dtype::DType::Primitive;
     use crate::dtype::Nullability::NonNullable;
     use crate::dtype::PType::I32;
-    use crate::memory::BufferAllocator;
-    use crate::memory::DefaultBufferAllocator;
+    use crate::memory::DefaultHostAllocator;
+    use crate::memory::HostAllocator;
     use crate::memory::MemorySessionExt;
     use crate::memory::WritableHostBuffer;
     use crate::validity::Validity;
@@ -241,14 +241,14 @@ mod tests {
         allocations: Arc<AtomicUsize>,
     }
 
-    impl BufferAllocator for CountingAllocator {
+    impl HostAllocator for CountingAllocator {
         fn allocate(
             &self,
             len: usize,
             alignment: vortex_buffer::Alignment,
         ) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate(len, alignment)
+            DefaultHostAllocator.allocate(len, alignment)
         }
     }
 
diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs
index 44edb4ebfa7..1d4dfdf574d 100644
--- a/vortex-array/src/builders/mod.rs
+++ b/vortex-array/src/builders/mod.rs
@@ -39,7 +39,7 @@ use crate::canonical::Canonical;
 use crate::dtype::DType;
 use crate::match_each_decimal_value_type;
 use crate::match_each_native_ptype;
-use crate::memory::BufferAllocatorRef;
+use crate::memory::HostAllocatorRef;
 use crate::scalar::Scalar;
 
 mod lazy_null_builder;
@@ -288,9 +288,9 @@ pub fn builder_with_capacity(dtype: &DType, capacity: usize) -> Box<dyn ArrayBui
 }
 
 /// Construct a new canonical builder for the given [`DType`] using a host
-/// [`crate::memory::BufferAllocator`].
+/// [`crate::memory::HostAllocator`].
 pub fn builder_with_capacity_in(
-    allocator: BufferAllocatorRef,
+    allocator: HostAllocatorRef,
     dtype: &DType,
     capacity: usize,
 ) -> Box<dyn ArrayBuilder> {
diff --git a/vortex-array/src/executor.rs b/vortex-array/src/executor.rs
index 591c8e0c45c..176ec2c953a 100644
--- a/vortex-array/src/executor.rs
+++ b/vortex-array/src/executor.rs
@@ -34,7 +34,7 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
 use crate::matcher::Matcher;
-use crate::memory::BufferAllocatorRef;
+use crate::memory::HostAllocatorRef;
 use crate::memory::MemorySessionExt;
 use crate::optimizer::ArrayOptimizer;
 
@@ -213,7 +213,7 @@ impl ExecutionCtx {
     }
 
     /// Get the session-scoped host allocator for this execution context.
-    pub fn allocator(&self) -> BufferAllocatorRef {
+    pub fn allocator(&self) -> HostAllocatorRef {
         self.session.allocator()
     }
 
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index f36891450a1..47030b18131 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -39,7 +39,7 @@ pub trait HostBufferMut: Send + 'static {
     fn freeze(self: Box<Self>) -> ByteBuffer;
 }
 
-/// Exact-size writable host buffer returned by a [`BufferAllocator`].
+/// Exact-size writable host buffer returned by a [`HostAllocator`].
 pub struct WritableHostBuffer {
     inner: Box<dyn HostBufferMut>,
 }
@@ -145,16 +145,16 @@ impl Debug for WritableHostBuffer {
 }
 
 /// Allocator for exact-size writable host buffers.
-pub trait BufferAllocator: Debug + Send + Sync + 'static {
+pub trait HostAllocator: Debug + Send + Sync + 'static {
     /// Allocate a writable host buffer with the requested byte length and alignment.
     fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
 }
 
 /// Shared allocator reference used throughout session-scoped memory APIs.
-pub type BufferAllocatorRef = Arc<dyn BufferAllocator>;
+pub type HostAllocatorRef = Arc<dyn HostAllocator>;
 
-/// Extension methods for [`BufferAllocator`]s.
-pub trait BufferAllocatorExt: BufferAllocator {
+/// Extension methods for [`HostAllocator`]s.
+pub trait HostAllocatorExt: HostAllocator {
     /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
     fn allocate_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
         let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
@@ -168,34 +168,34 @@ pub trait BufferAllocatorExt: BufferAllocator {
     }
 }
 
-impl<A: BufferAllocator + ?Sized> BufferAllocatorExt for A {}
+impl<A: HostAllocator + ?Sized> HostAllocatorExt for A {}
 
 /// Session-scoped memory configuration for Vortex arrays.
 #[derive(Debug)]
 pub struct MemorySession {
-    allocator: BufferAllocatorRef,
+    allocator: HostAllocatorRef,
 }
 
 impl MemorySession {
     /// Creates a new session memory configuration using the provided allocator.
-    pub fn new(allocator: BufferAllocatorRef) -> Self {
+    pub fn new(allocator: HostAllocatorRef) -> Self {
         Self { allocator }
     }
 
     /// Returns the configured allocator.
-    pub fn allocator(&self) -> BufferAllocatorRef {
+    pub fn allocator(&self) -> HostAllocatorRef {
         Arc::clone(&self.allocator)
     }
 
     /// Updates the configured allocator.
-    pub fn set_allocator(&mut self, allocator: BufferAllocatorRef) {
+    pub fn set_allocator(&mut self, allocator: HostAllocatorRef) {
         self.allocator = allocator;
     }
 }
 
 impl Default for MemorySession {
     fn default() -> Self {
-        Self::new(Arc::new(DefaultBufferAllocator))
+        Self::new(Arc::new(DefaultHostAllocator))
     }
 }
 
@@ -207,7 +207,7 @@ pub trait MemorySessionExt: SessionExt {
     }
 
     /// Returns the configured host allocator for this execution/session context.
-    fn allocator(&self) -> BufferAllocatorRef {
+    fn allocator(&self) -> HostAllocatorRef {
         self.memory().allocator()
     }
 
@@ -221,9 +221,9 @@ impl<S: SessionExt> MemorySessionExt for S {}
 
 /// Default host allocator.
 #[derive(Debug, Default)]
-pub struct DefaultBufferAllocator;
+pub struct DefaultHostAllocator;
 
-impl BufferAllocator for DefaultBufferAllocator {
+impl HostAllocator for DefaultHostAllocator {
     fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
         let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
         // SAFETY: We fully initialize this slice before freezing it.
@@ -284,16 +284,16 @@ mod tests {
         allocations: Arc<AtomicUsize>,
     }
 
-    impl BufferAllocator for CountingAllocator {
+    impl HostAllocator for CountingAllocator {
         fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate(len, alignment)
+            DefaultHostAllocator.allocate(len, alignment)
         }
     }
 
     #[test]
     fn writable_host_buffer_freeze_round_trip() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
         for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
             *byte = u8::try_from(idx).unwrap();
@@ -319,7 +319,7 @@ mod tests {
 
     #[test]
     fn typed_allocation_uses_type_alignment() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let writable = allocator.allocate_typed::<u64>(4).unwrap();
         assert_eq!(writable.len(), 4 * size_of::<u64>());
         assert_eq!(writable.alignment(), Alignment::of::<u64>());
@@ -327,7 +327,7 @@ mod tests {
 
     #[test]
     fn typed_mut_slice_round_trip() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
         writable
             .as_mut_slice_typed::<u64>()
@@ -346,14 +346,14 @@ mod tests {
 
     #[test]
     fn typed_mut_slice_rejects_length_mismatch() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
         assert!(writable.as_mut_slice_typed::<u32>().is_err());
     }
 
     #[test]
     fn freeze_typed_round_trip() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
         writable
             .as_mut_slice_typed::<u64>()
@@ -366,7 +366,7 @@ mod tests {
 
     #[test]
     fn freeze_typed_rejects_length_mismatch() {
-        let allocator = DefaultBufferAllocator;
+        let allocator = DefaultHostAllocator;
         let writable = allocator.allocate(7, Alignment::none()).unwrap();
         let err = writable.freeze_typed::<u32>().unwrap_err();
         let msg = format!("{err}");
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index ab2a51f473d..0d937000e75 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -356,8 +356,8 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::buffer::BufferHandle;
     use vortex_array::dtype::session::DTypeSession;
-    use vortex_array::memory::BufferAllocator;
-    use vortex_array::memory::DefaultBufferAllocator;
+    use vortex_array::memory::DefaultHostAllocator;
+    use vortex_array::memory::HostAllocator;
     use vortex_array::memory::MemorySessionExt;
     use vortex_array::memory::WritableHostBuffer;
     use vortex_array::scalar_fn::session::ScalarFnSession;
@@ -411,10 +411,10 @@ mod tests {
         allocations: Arc<AtomicUsize>,
     }
 
-    impl BufferAllocator for CountingAllocator {
+    impl HostAllocator for CountingAllocator {
         fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
             self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultBufferAllocator.allocate(len, alignment)
+            DefaultHostAllocator.allocate(len, alignment)
         }
     }
 
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index 3815ebc6bad..06dff78378f 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -14,8 +14,8 @@ use object_store::ObjectStore;
 use object_store::ObjectStoreExt;
 use object_store::path::Path as ObjectPath;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::memory::BufferAllocatorRef;
-use vortex_array::memory::DefaultBufferAllocator;
+use vortex_array::memory::DefaultHostAllocator;
+use vortex_array::memory::HostAllocatorRef;
 use vortex_buffer::Alignment;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
@@ -36,7 +36,7 @@ pub struct ObjectStoreReadAt {
     path: ObjectPath,
     uri: Arc<str>,
     handle: Handle,
-    allocator: BufferAllocatorRef,
+    allocator: HostAllocatorRef,
     concurrency: usize,
     coalesce_config: Option<CoalesceConfig>,
 }
@@ -44,7 +44,7 @@ pub struct ObjectStoreReadAt {
 impl ObjectStoreReadAt {
     /// Create a new object store source.
     pub fn new(store: Arc<dyn ObjectStore>, path: ObjectPath, handle: Handle) -> Self {
-        Self::new_with_allocator(store, path, handle, Arc::new(DefaultBufferAllocator))
+        Self::new_with_allocator(store, path, handle, Arc::new(DefaultHostAllocator))
     }
 
     /// Create a new object store source with a custom writable buffer allocator.
@@ -52,7 +52,7 @@ impl ObjectStoreReadAt {
         store: Arc<dyn ObjectStore>,
         path: ObjectPath,
         handle: Handle,
-        allocator: BufferAllocatorRef,
+        allocator: HostAllocatorRef,
     ) -> Self {
         let uri = Arc::from(path.to_string());
         Self {
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index 26f154f1fc7..c0ac11f5622 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -17,8 +17,8 @@ use std::sync::Arc;
 use futures::FutureExt;
 use futures::future::BoxFuture;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::memory::BufferAllocatorRef;
-use vortex_array::memory::DefaultBufferAllocator;
+use vortex_array::memory::DefaultHostAllocator;
+use vortex_array::memory::HostAllocatorRef;
 use vortex_buffer::Alignment;
 use vortex_error::VortexResult;
 
@@ -66,20 +66,20 @@ pub struct FileReadAt {
     uri: Arc<str>,
     file: Arc<File>,
     handle: Handle,
-    allocator: BufferAllocatorRef,
+    allocator: HostAllocatorRef,
 }
 
 impl FileReadAt {
     /// Open a file for reading.
     pub fn open(path: impl AsRef<Path>, handle: Handle) -> VortexResult<Self> {
-        Self::open_with_allocator(path, handle, Arc::new(DefaultBufferAllocator))
+        Self::open_with_allocator(path, handle, Arc::new(DefaultHostAllocator))
     }
 
     /// Open a file for reading using a custom writable buffer allocator.
     pub fn open_with_allocator(
         path: impl AsRef<Path>,
         handle: Handle,
-        allocator: BufferAllocatorRef,
+        allocator: HostAllocatorRef,
     ) -> VortexResult<Self> {
         let path = path.as_ref();
         let uri = path.to_string_lossy().to_string().into();

From 4e5615684ea0211d037476a21d18913b0bc00ba6 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 14:49:14 -0400
Subject: [PATCH 09/17] merge

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/public-api.lock | 44 ++++++++++++++++++------------------
 vortex-io/public-api.lock    |  4 ++--
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index 9784dc762f7..885e2add71e 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -8388,7 +8388,7 @@ pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecke
 
 pub fn vortex_array::builders::builder_with_capacity(dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
 
-pub fn vortex_array::builders::builder_with_capacity_in(allocator: vortex_array::memory::BufferAllocatorRef, dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
+pub fn vortex_array::builders::builder_with_capacity_in(allocator: vortex_array::memory::HostAllocatorRef, dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
 
 pub mod vortex_array::builtins
 
@@ -13266,29 +13266,29 @@ pub fn V::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Opti
 
 pub mod vortex_array::memory
 
-pub struct vortex_array::memory::DefaultBufferAllocator
+pub struct vortex_array::memory::DefaultHostAllocator
 
-impl core::default::Default for vortex_array::memory::DefaultBufferAllocator
+impl core::default::Default for vortex_array::memory::DefaultHostAllocator
 
-pub fn vortex_array::memory::DefaultBufferAllocator::default() -> vortex_array::memory::DefaultBufferAllocator
+pub fn vortex_array::memory::DefaultHostAllocator::default() -> vortex_array::memory::DefaultHostAllocator
 
-impl core::fmt::Debug for vortex_array::memory::DefaultBufferAllocator
+impl core::fmt::Debug for vortex_array::memory::DefaultHostAllocator
 
-pub fn vortex_array::memory::DefaultBufferAllocator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::memory::DefaultHostAllocator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::memory::BufferAllocator for vortex_array::memory::DefaultBufferAllocator
+impl vortex_array::memory::HostAllocator for vortex_array::memory::DefaultHostAllocator
 
-pub fn vortex_array::memory::DefaultBufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+pub fn vortex_array::memory::DefaultHostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
 pub struct vortex_array::memory::MemorySession
 
 impl vortex_array::memory::MemorySession
 
-pub fn vortex_array::memory::MemorySession::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+pub fn vortex_array::memory::MemorySession::allocator(&self) -> vortex_array::memory::HostAllocatorRef
 
-pub fn vortex_array::memory::MemorySession::new(allocator: vortex_array::memory::BufferAllocatorRef) -> Self
+pub fn vortex_array::memory::MemorySession::new(allocator: vortex_array::memory::HostAllocatorRef) -> Self
 
-pub fn vortex_array::memory::MemorySession::set_allocator(&mut self, allocator: vortex_array::memory::BufferAllocatorRef)
+pub fn vortex_array::memory::MemorySession::set_allocator(&mut self, allocator: vortex_array::memory::HostAllocatorRef)
 
 impl core::default::Default for vortex_array::memory::MemorySession
 
@@ -13322,19 +13322,19 @@ impl core::fmt::Debug for vortex_array::memory::WritableHostBuffer
 
 pub fn vortex_array::memory::WritableHostBuffer::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub trait vortex_array::memory::BufferAllocator: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+pub trait vortex_array::memory::HostAllocator: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
 
-pub fn vortex_array::memory::BufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+pub fn vortex_array::memory::HostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
-impl vortex_array::memory::BufferAllocator for vortex_array::memory::DefaultBufferAllocator
+impl vortex_array::memory::HostAllocator for vortex_array::memory::DefaultHostAllocator
 
-pub fn vortex_array::memory::DefaultBufferAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+pub fn vortex_array::memory::DefaultHostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
-pub trait vortex_array::memory::BufferAllocatorExt: vortex_array::memory::BufferAllocator
+pub trait vortex_array::memory::HostAllocatorExt: vortex_array::memory::HostAllocator
 
-pub fn vortex_array::memory::BufferAllocatorExt::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+pub fn vortex_array::memory::HostAllocatorExt::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
-impl<A: vortex_array::memory::BufferAllocator + ?core::marker::Sized> vortex_array::memory::BufferAllocatorExt for A
+impl<A: vortex_array::memory::HostAllocator + ?core::marker::Sized> vortex_array::memory::HostAllocatorExt for A
 
 pub fn A::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
@@ -13352,7 +13352,7 @@ pub fn vortex_array::memory::HostBufferMut::len(&self) -> usize
 
 pub trait vortex_array::memory::MemorySessionExt: vortex_session::SessionExt
 
-pub fn vortex_array::memory::MemorySessionExt::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+pub fn vortex_array::memory::MemorySessionExt::allocator(&self) -> vortex_array::memory::HostAllocatorRef
 
 pub fn vortex_array::memory::MemorySessionExt::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
 
@@ -13360,13 +13360,13 @@ pub fn vortex_array::memory::MemorySessionExt::memory_mut(&self) -> vortex_sessi
 
 impl<S: vortex_session::SessionExt> vortex_array::memory::MemorySessionExt for S
 
-pub fn S::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+pub fn S::allocator(&self) -> vortex_array::memory::HostAllocatorRef
 
 pub fn S::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
 
 pub fn S::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
 
-pub type vortex_array::memory::BufferAllocatorRef = alloc::sync::Arc<dyn vortex_array::memory::BufferAllocator>
+pub type vortex_array::memory::HostAllocatorRef = alloc::sync::Arc<dyn vortex_array::memory::HostAllocator>
 
 pub mod vortex_array::normalize
 
@@ -22468,7 +22468,7 @@ pub struct vortex_array::ExecutionCtx
 
 impl vortex_array::ExecutionCtx
 
-pub fn vortex_array::ExecutionCtx::allocator(&self) -> vortex_array::memory::BufferAllocatorRef
+pub fn vortex_array::ExecutionCtx::allocator(&self) -> vortex_array::memory::HostAllocatorRef
 
 pub fn vortex_array::ExecutionCtx::log(&mut self, msg: core::fmt::Arguments<'_>)
 
diff --git a/vortex-io/public-api.lock b/vortex-io/public-api.lock
index ab291cd52dc..08d74ffc830 100644
--- a/vortex-io/public-api.lock
+++ b/vortex-io/public-api.lock
@@ -150,7 +150,7 @@ impl vortex_io::object_store::ObjectStoreReadAt
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle) -> Self
 
-pub fn vortex_io::object_store::ObjectStoreReadAt::new_with_allocator(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::BufferAllocatorRef) -> Self
+pub fn vortex_io::object_store::ObjectStoreReadAt::new_with_allocator(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_coalesce_config(self, config: vortex_io::CoalesceConfig) -> Self
 
@@ -468,7 +468,7 @@ impl vortex_io::std_file::FileReadAt
 
 pub fn vortex_io::std_file::FileReadAt::open(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_io::std_file::FileReadAt::open_with_allocator(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::BufferAllocatorRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_io::std_file::FileReadAt::open_with_allocator(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> vortex_error::VortexResult<Self>
 
 impl vortex_io::VortexReadAt for vortex_io::std_file::FileReadAt
 

From 53b300dfb7c88d8cef44ceae6a79f2db7e913469 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 16:12:23 -0400
Subject: [PATCH 10/17] Add pooled host allocator

---
 Cargo.lock                            |   2 +
 Cargo.toml                            |   1 +
 vortex-array/Cargo.toml               |   2 +
 vortex-array/public-api.lock          |  24 ++
 vortex-array/src/memory.rs            | 484 +++++++++++++++++++++++++-
 vortex-io/src/object_store/read_at.rs |   9 +-
 vortex-io/src/std_file/read_at.rs     |   4 +-
 7 files changed, 509 insertions(+), 17 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9778e8403bc..fdfa78c72ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10157,6 +10157,7 @@ dependencies = [
  "inventory",
  "itertools 0.14.0",
  "jiff",
+ "libc",
  "multiversion",
  "num-traits",
  "num_enum",
@@ -10184,6 +10185,7 @@ dependencies = [
  "vortex-error",
  "vortex-flatbuffers",
  "vortex-mask",
+ "vortex-metrics",
  "vortex-proto",
  "vortex-session",
  "vortex-utils",
diff --git a/Cargo.toml b/Cargo.toml
index 6bb0413546a..b8bedd2cfbe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -164,6 +164,7 @@ jiff = "0.2.0"
 kanal = "0.1.1"
 lending-iterator = "0.1.7"
 libfuzzer-sys = "0.4"
+libc = "0.2.177"
 libloading = "0.8"
 liblzma = "0.4"
 log = { version = "0.4.21" }
diff --git a/vortex-array/Cargo.toml b/vortex-array/Cargo.toml
index dbdfd5a2cd9..2b740025fe5 100644
--- a/vortex-array/Cargo.toml
+++ b/vortex-array/Cargo.toml
@@ -45,6 +45,7 @@ humansize = { workspace = true }
 inventory = { workspace = true }
 itertools = { workspace = true }
 jiff = { workspace = true }
+libc = { workspace = true }
 multiversion = { workspace = true }
 num-traits = { workspace = true }
 num_enum = { workspace = true }
@@ -72,6 +73,7 @@ vortex-buffer = { workspace = true, features = ["arrow"] }
 vortex-error = { workspace = true, features = ["flatbuffers"] }
 vortex-flatbuffers = { workspace = true, features = ["array", "dtype"] }
 vortex-mask = { workspace = true }
+vortex-metrics = { workspace = true }
 vortex-proto = { workspace = true, features = ["dtype", "expr", "scalar"] }
 vortex-session = { workspace = true }
 vortex-utils = { workspace = true, features = ["dyn-traits"] }
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index 885e2add71e..e0583aa4871 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -13298,6 +13298,26 @@ impl core::fmt::Debug for vortex_array::memory::MemorySession
 
 pub fn vortex_array::memory::MemorySession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
+pub struct vortex_array::memory::PooledHostAllocator
+
+impl vortex_array::memory::PooledHostAllocator
+
+pub fn vortex_array::memory::PooledHostAllocator::max_bytes_per_thread(&self) -> usize
+
+pub fn vortex_array::memory::PooledHostAllocator::new(max_bytes_per_thread: usize, metrics_registry: alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>) -> Self
+
+impl core::default::Default for vortex_array::memory::PooledHostAllocator
+
+pub fn vortex_array::memory::PooledHostAllocator::default() -> Self
+
+impl core::fmt::Debug for vortex_array::memory::PooledHostAllocator
+
+pub fn vortex_array::memory::PooledHostAllocator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::memory::HostAllocator for vortex_array::memory::PooledHostAllocator
+
+pub fn vortex_array::memory::PooledHostAllocator::allocate(&self, len: usize, requested_alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
 pub struct vortex_array::memory::WritableHostBuffer
 
 impl vortex_array::memory::WritableHostBuffer
@@ -13330,6 +13350,10 @@ impl vortex_array::memory::HostAllocator for vortex_array::memory::DefaultHostAl
 
 pub fn vortex_array::memory::DefaultHostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
 
+impl vortex_array::memory::HostAllocator for vortex_array::memory::PooledHostAllocator
+
+pub fn vortex_array::memory::PooledHostAllocator::allocate(&self, len: usize, requested_alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
 pub trait vortex_array::memory::HostAllocatorExt: vortex_array::memory::HostAllocator
 
 pub fn vortex_array::memory::HostAllocatorExt::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index 47030b18131..41446a782d9 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -3,21 +3,57 @@
 
 //! Session-scoped memory allocation for host-side buffers.
 
+use std::cell::RefCell;
 use std::fmt::Debug;
 use std::mem::size_of;
 use std::sync::Arc;
+use std::sync::OnceLock;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
 
 use bytes::Bytes;
 use vortex_buffer::Alignment;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_metrics::Counter;
+use vortex_metrics::DefaultMetricsRegistry;
+use vortex_metrics::Gauge;
+use vortex_metrics::Histogram;
+use vortex_metrics::Label;
+use vortex_metrics::MetricBuilder;
+use vortex_metrics::MetricsRegistry;
 use vortex_session::Ref;
 use vortex_session::RefMut;
 use vortex_session::SessionExt;
+use vortex_utils::aliases::hash_map::HashMap;
+
+const DEFAULT_MAX_BYTES_PER_THREAD: usize = 64 * 1024 * 1024;
+const FALLBACK_POOL_ALIGNMENT_BYTES: usize = 4 * 1024;
+
+// (bucket_size_bytes, max_entries_per_thread)
+const POOL_BUCKETS: &[(usize, usize)] = &[
+    (4 * 1024, 256),
+    (16 * 1024, 128),
+    (64 * 1024, 64),
+    (128 * 1024, 32),
+    (256 * 1024, 16),
+    (512 * 1024, 8),
+    (1024 * 1024, 8),
+    (2 * 1024 * 1024, 4),
+    (4 * 1024 * 1024, 2),
+];
+
+static NEXT_POOLED_ALLOCATOR_ID: AtomicU64 = AtomicU64::new(1);
+
+thread_local! {
+    static POOLED_HOST_ALLOCATOR_POOLS: RefCell<HashMap<u64, ThreadLocalAllocatorPool>> =
+        RefCell::new(HashMap::new());
+}
 
 /// Mutable host buffer contract used by [`WritableHostBuffer`].
 pub trait HostBufferMut: Send + 'static {
@@ -195,7 +231,7 @@ impl MemorySession {
 
 impl Default for MemorySession {
     fn default() -> Self {
-        Self::new(Arc::new(DefaultHostAllocator))
+        Self::new(Arc::new(PooledHostAllocator::default()))
     }
 }
 
@@ -225,35 +261,402 @@ pub struct DefaultHostAllocator;
 
 impl HostAllocator for DefaultHostAllocator {
     fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
-        let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
+        allocate_unpooled(len, alignment)
+    }
+}
+
+/// A pooled host allocator with thread-local buckets and metric instrumentation.
+#[derive(Debug)]
+pub struct PooledHostAllocator {
+    id: u64,
+    max_bytes_per_thread: usize,
+    metrics: Arc<PooledAllocatorMetrics>,
+}
+
+impl PooledHostAllocator {
+    /// Create a pooled allocator.
+    ///
+    /// `max_bytes_per_thread` controls the maximum total capacity retained in the thread-local
+    /// pool for this allocator. Set it to `0` to disable pooling while still recording metrics.
+    pub fn new(max_bytes_per_thread: usize, metrics_registry: Arc<dyn MetricsRegistry>) -> Self {
+        let id = NEXT_POOLED_ALLOCATOR_ID.fetch_add(1, Ordering::Relaxed);
+        let labels = vec![
+            Label::new("allocator", "pooled_host"),
+            Label::new("allocator_id", id.to_string()),
+        ];
+
+        Self {
+            id,
+            max_bytes_per_thread,
+            metrics: Arc::new(PooledAllocatorMetrics::new(
+                metrics_registry.as_ref(),
+                labels,
+            )),
+        }
+    }
+
+    /// Maximum retained bytes per thread for this allocator.
+    pub fn max_bytes_per_thread(&self) -> usize {
+        self.max_bytes_per_thread
+    }
+}
+
+impl Default for PooledHostAllocator {
+    fn default() -> Self {
+        Self::new(
+            DEFAULT_MAX_BYTES_PER_THREAD,
+            Arc::new(DefaultMetricsRegistry::default()),
+        )
+    }
+}
+
+impl HostAllocator for PooledHostAllocator {
+    fn allocate(
+        &self,
+        len: usize,
+        requested_alignment: Alignment,
+    ) -> VortexResult<WritableHostBuffer> {
+        self.metrics.alloc_requests.add(1);
+        self.metrics.request_bytes.update(len as f64);
+
+        if self.max_bytes_per_thread == 0 {
+            self.metrics.bypass_disabled.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let pool_alignment = pooled_alignment();
+        if !pool_alignment.is_aligned_to(requested_alignment) {
+            self.metrics.bypass_alignment.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let Some(bucket_idx) = bucket_index_for_len(len) else {
+            self.metrics.bypass_size.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        };
+
+        let (bucket_size, _) = POOL_BUCKETS[bucket_idx];
+        if bucket_size > self.max_bytes_per_thread {
+            self.metrics.bypass_size.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let (pooled, retained_bytes, retained_buffers) = with_allocator_pool(self.id, |pool| {
+            let pooled = pool.take_buffer(bucket_idx);
+            (pooled, pool.retained_bytes, pool.buffer_count())
+        });
+
+        self.metrics.retained_bytes.set(retained_bytes as f64);
+        self.metrics.retained_buffers.set(retained_buffers as f64);
+        self.metrics.bucket_bytes.update(bucket_size as f64);
+
+        let mut buffer = if let Some(buffer) = pooled {
+            self.metrics.hits.add(1);
+            buffer
+        } else {
+            self.metrics.misses.add(1);
+            ByteBufferMut::with_capacity_aligned(bucket_size, pool_alignment)
+        };
+
         // SAFETY: We fully initialize this slice before freezing it.
         unsafe { buffer.set_len(len) };
+
         Ok(WritableHostBuffer::new(Box::new(
-            DefaultWritableHostBuffer { buffer, alignment },
+            DefaultWritableHostBuffer::with_pool(
+                buffer,
+                requested_alignment,
+                PooledReturn {
+                    allocator_id: self.id,
+                    bucket_idx,
+                    max_bytes_per_thread: self.max_bytes_per_thread,
+                    metrics: Arc::clone(&self.metrics),
+                },
+            ),
         )))
     }
 }
 
+fn allocate_unpooled(len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+    let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
+    // SAFETY: We fully initialize this slice before freezing it.
+    unsafe { buffer.set_len(len) };
+    Ok(WritableHostBuffer::new(Box::new(
+        DefaultWritableHostBuffer::new(buffer, alignment),
+    )))
+}
+
+#[derive(Debug)]
+struct PooledAllocatorMetrics {
+    alloc_requests: Counter,
+    hits: Counter,
+    misses: Counter,
+    puts: Counter,
+    drops: Counter,
+    bypass_alignment: Counter,
+    bypass_size: Counter,
+    bypass_disabled: Counter,
+    request_bytes: Histogram,
+    bucket_bytes: Histogram,
+    retained_bytes: Gauge,
+    retained_buffers: Gauge,
+}
+
+impl PooledAllocatorMetrics {
+    fn new(metrics_registry: &dyn MetricsRegistry, labels: Vec<Label>) -> Self {
+        Self {
+            alloc_requests: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.alloc_requests"),
+            hits: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.hits"),
+            misses: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.misses"),
+            puts: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.puts"),
+            drops: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.drops"),
+            bypass_alignment: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_alignment"),
+            bypass_size: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_size"),
+            bypass_disabled: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_disabled"),
+            request_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .histogram("memory.host_pool.request_bytes"),
+            bucket_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .histogram("memory.host_pool.bucket_bytes"),
+            retained_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .gauge("memory.host_pool.retained_bytes"),
+            retained_buffers: MetricBuilder::new(metrics_registry)
+                .add_labels(labels)
+                .gauge("memory.host_pool.retained_buffers"),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct PooledReturn {
+    allocator_id: u64,
+    bucket_idx: usize,
+    max_bytes_per_thread: usize,
+    metrics: Arc<PooledAllocatorMetrics>,
+}
+
+#[derive(Debug, Default)]
+struct ThreadLocalAllocatorPool {
+    retained_bytes: usize,
+    buckets: Vec<Vec<ByteBufferMut>>,
+}
+
+impl ThreadLocalAllocatorPool {
+    fn new() -> Self {
+        Self {
+            retained_bytes: 0,
+            buckets: (0..POOL_BUCKETS.len()).map(|_| Vec::new()).collect(),
+        }
+    }
+
+    fn take_buffer(&mut self, bucket_idx: usize) -> Option<ByteBufferMut> {
+        let buffer = self.buckets.get_mut(bucket_idx)?.pop()?;
+        self.retained_bytes = self.retained_bytes.saturating_sub(buffer.capacity());
+        Some(buffer)
+    }
+
+    fn try_put_buffer(
+        &mut self,
+        bucket_idx: usize,
+        mut buffer: ByteBufferMut,
+        max_bytes_per_thread: usize,
+    ) -> bool {
+        if bucket_idx >= self.buckets.len() {
+            return false;
+        }
+
+        let (_, max_entries) = POOL_BUCKETS[bucket_idx];
+        if self.buckets[bucket_idx].len() >= max_entries {
+            return false;
+        }
+
+        let capacity = buffer.capacity();
+        if self.retained_bytes.saturating_add(capacity) > max_bytes_per_thread {
+            return false;
+        }
+
+        buffer.clear();
+        self.retained_bytes = self.retained_bytes.saturating_add(capacity);
+        self.buckets[bucket_idx].push(buffer);
+        true
+    }
+
+    fn buffer_count(&self) -> usize {
+        self.buckets.iter().map(Vec::len).sum()
+    }
+
+    #[cfg(test)]
+    fn bucket_len(&self, bucket_idx: usize) -> usize {
+        self.buckets[bucket_idx].len()
+    }
+}
+
+fn with_allocator_pool<R>(
+    allocator_id: u64,
+    f: impl FnOnce(&mut ThreadLocalAllocatorPool) -> R,
+) -> R {
+    POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
+        let mut pools = pools.borrow_mut();
+        let pool = pools
+            .entry(allocator_id)
+            .or_insert_with(ThreadLocalAllocatorPool::new);
+        f(pool)
+    })
+}
+
+fn return_buffer_to_pool(buffer: ByteBufferMut, pooled: PooledReturn) {
+    let (stored, retained_bytes, retained_buffers) =
+        with_allocator_pool(pooled.allocator_id, |pool| {
+            let stored =
+                pool.try_put_buffer(pooled.bucket_idx, buffer, pooled.max_bytes_per_thread);
+            (stored, pool.retained_bytes, pool.buffer_count())
+        });
+
+    pooled.metrics.retained_bytes.set(retained_bytes as f64);
+    pooled.metrics.retained_buffers.set(retained_buffers as f64);
+
+    if stored {
+        pooled.metrics.puts.add(1);
+    } else {
+        pooled.metrics.drops.add(1);
+    }
+}
+
+fn bucket_index_for_len(len: usize) -> Option<usize> {
+    POOL_BUCKETS
+        .iter()
+        .position(|(bucket_size, _)| len <= *bucket_size)
+}
+
+fn pooled_alignment() -> Alignment {
+    static CACHED: OnceLock<Alignment> = OnceLock::new();
+
+    *CACHED.get_or_init(|| {
+        let page_size = os_page_size().unwrap_or(FALLBACK_POOL_ALIGNMENT_BYTES);
+        if page_size != 0 && page_size.is_power_of_two() && page_size <= (u16::MAX as usize) {
+            Alignment::new(page_size)
+        } else {
+            Alignment::new(FALLBACK_POOL_ALIGNMENT_BYTES)
+        }
+    })
+}
+
+#[cfg(unix)]
+fn os_page_size() -> Option<usize> {
+    // SAFETY: `sysconf` is thread-safe for `_SC_PAGESIZE` and has no aliasing requirements.
+    let value = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
+    if value <= 0 {
+        return None;
+    }
+
+    usize::try_from(value).ok()
+}
+
+#[cfg(not(unix))]
+fn os_page_size() -> Option<usize> {
+    None
+}
+
 #[derive(Debug)]
 struct DefaultWritableHostBuffer {
-    buffer: ByteBufferMut,
+    buffer: Option<ByteBufferMut>,
     alignment: Alignment,
+    pooled: Option<PooledReturn>,
+}
+
+impl DefaultWritableHostBuffer {
+    fn new(buffer: ByteBufferMut, alignment: Alignment) -> Self {
+        Self {
+            buffer: Some(buffer),
+            alignment,
+            pooled: None,
+        }
+    }
+
+    fn with_pool(buffer: ByteBufferMut, alignment: Alignment, pooled: PooledReturn) -> Self {
+        Self {
+            buffer: Some(buffer),
+            alignment,
+            pooled: Some(pooled),
+        }
+    }
+
+    fn take_parts(&mut self) -> (ByteBufferMut, Option<PooledReturn>) {
+        (
+            self.buffer
+                .take()
+                .vortex_expect("buffer must exist until freeze/drop"),
+            self.pooled.take(),
+        )
+    }
+}
+
+impl Drop for DefaultWritableHostBuffer {
+    fn drop(&mut self) {
+        let Some(pooled) = self.pooled.take() else {
+            return;
+        };
+
+        let Some(buffer) = self.buffer.take() else {
+            return;
+        };
+
+        return_buffer_to_pool(buffer, pooled);
+    }
 }
 
 #[derive(Debug)]
 struct HostBufferOwner {
-    buffer: ByteBufferMut,
+    buffer: Option<ByteBufferMut>,
+    pooled: Option<PooledReturn>,
 }
 
 impl AsRef<[u8]> for HostBufferOwner {
     fn as_ref(&self) -> &[u8] {
-        self.buffer.as_slice()
+        self.buffer
+            .as_ref()
+            .vortex_expect("buffer must exist while bytes owner is alive")
+            .as_slice()
+    }
+}
+
+impl Drop for HostBufferOwner {
+    fn drop(&mut self) {
+        let Some(pooled) = self.pooled.take() else {
+            return;
+        };
+
+        let Some(buffer) = self.buffer.take() else {
+            return;
+        };
+
+        return_buffer_to_pool(buffer, pooled);
     }
 }
 
 impl HostBufferMut for DefaultWritableHostBuffer {
     fn len(&self) -> usize {
-        self.buffer.len()
+        self.buffer
+            .as_ref()
+            .vortex_expect("buffer must exist until freeze/drop")
+            .len()
     }
 
     fn alignment(&self) -> Alignment {
@@ -261,12 +664,19 @@ impl HostBufferMut for DefaultWritableHostBuffer {
     }
 
     fn as_mut_slice(&mut self) -> &mut [u8] {
-        self.buffer.as_mut_slice()
-    }
-
-    fn freeze(self: Box<Self>) -> ByteBuffer {
-        let Self { buffer, alignment } = *self;
-        let bytes = Bytes::from_owner(HostBufferOwner { buffer });
+        self.buffer
+            .as_mut()
+            .vortex_expect("buffer must exist until freeze/drop")
+            .as_mut_slice()
+    }
+
+    fn freeze(mut self: Box<Self>) -> ByteBuffer {
+        let alignment = self.alignment;
+        let (buffer, pooled) = self.take_parts();
+        let bytes = Bytes::from_owner(HostBufferOwner {
+            buffer: Some(buffer),
+            pooled,
+        });
         ByteBuffer::from_bytes_aligned(bytes, alignment)
     }
 }
@@ -291,6 +701,16 @@ mod tests {
         }
     }
 
+    fn clear_allocator_pool(allocator_id: u64) {
+        POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
+            pools.borrow_mut().remove(&allocator_id);
+        });
+    }
+
+    fn allocator_pool_bucket_len(allocator_id: u64, bucket_idx: usize) -> usize {
+        with_allocator_pool(allocator_id, |pool| pool.bucket_len(bucket_idx))
+    }
+
     #[test]
     fn writable_host_buffer_freeze_round_trip() {
         let allocator = DefaultHostAllocator;
@@ -372,4 +792,42 @@ mod tests {
         let msg = format!("{err}");
         assert!(msg.contains("not a multiple of"));
     }
+
+    #[test]
+    fn pooled_allocator_reuses_bucket() {
+        let allocator =
+            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
+        clear_allocator_pool(allocator.id);
+
+        let bucket_idx = bucket_index_for_len(100).unwrap();
+        {
+            let writable = allocator.allocate(100, Alignment::new(8)).unwrap();
+            drop(writable);
+        }
+
+        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
+
+        {
+            let writable = allocator.allocate(100, Alignment::new(8)).unwrap();
+            // Reuse pops from pool.
+            assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 0);
+            drop(writable);
+        }
+
+        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
+    }
+
+    #[test]
+    fn pooled_allocator_bypasses_large_requests() {
+        let allocator =
+            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
+        clear_allocator_pool(allocator.id);
+
+        let too_large = POOL_BUCKETS.last().unwrap().0 + 1;
+        let writable = allocator.allocate(too_large, Alignment::new(8)).unwrap();
+        drop(writable);
+
+        let pooled_count = with_allocator_pool(allocator.id, |pool| pool.buffer_count());
+        assert_eq!(pooled_count, 0);
+    }
 }
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index fd0f979c187..9fe30891495 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -14,8 +14,8 @@ use object_store::ObjectStore;
 use object_store::ObjectStoreExt;
 use object_store::path::Path as ObjectPath;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::memory::DefaultHostAllocator;
 use vortex_array::memory::HostAllocatorRef;
+use vortex_array::memory::PooledHostAllocator;
 use vortex_buffer::Alignment;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
@@ -44,7 +44,12 @@ pub struct ObjectStoreReadAt {
 impl ObjectStoreReadAt {
     /// Create a new object store source.
     pub fn new(store: Arc<dyn ObjectStore>, path: ObjectPath, handle: Handle) -> Self {
-        Self::new_with_allocator(store, path, handle, Arc::new(DefaultHostAllocator))
+        Self::new_with_allocator(
+            store,
+            path,
+            handle,
+            Arc::new(PooledHostAllocator::default()),
+        )
     }
 
     /// Create a new object store source with a custom writable buffer allocator.
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index 3d59a595f70..26d812f306b 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -17,8 +17,8 @@ use std::sync::Arc;
 use futures::FutureExt;
 use futures::future::BoxFuture;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::memory::DefaultHostAllocator;
 use vortex_array::memory::HostAllocatorRef;
+use vortex_array::memory::PooledHostAllocator;
 use vortex_buffer::Alignment;
 use vortex_error::VortexResult;
 
@@ -72,7 +72,7 @@ pub struct FileReadAt {
 impl FileReadAt {
     /// Open a file for reading.
     pub fn open(path: impl AsRef<Path>, handle: Handle) -> VortexResult<Self> {
-        Self::open_with_allocator(path, handle, Arc::new(DefaultHostAllocator))
+        Self::open_with_allocator(path, handle, Arc::new(PooledHostAllocator::default()))
     }
 
     /// Open a file for reading using a custom writable buffer allocator.

From da95517ce8534f1bcd85f3c7f2aa4683e92f9aa3 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 16:52:45 -0400
Subject: [PATCH 11/17] More Blobs

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 .github/scripts/run-sql-bench.sh                  |  3 +++
 bench-orchestrator/bench_orchestrator/cli.py      |  4 ++++
 .../bench_orchestrator/runner/executor.py         |  4 ++++
 benchmarks/datafusion-bench/src/main.rs           |  7 +++++++
 benchmarks/duckdb-bench/src/main.rs               |  7 +++++++
 benchmarks/lance-bench/src/main.rs                |  7 +++++++
 vortex-array/public-api.lock                      |  2 ++
 vortex-array/src/memory.rs                        | 15 ++++++++++++++-
 vortex-bench/src/lib.rs                           |  1 +
 vortex-bench/src/utils/mod.rs                     |  1 +
 10 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/.github/scripts/run-sql-bench.sh b/.github/scripts/run-sql-bench.sh
index 96c2e2f19dc..4c8ec687d42 100755
--- a/.github/scripts/run-sql-bench.sh
+++ b/.github/scripts/run-sql-bench.sh
@@ -107,6 +107,7 @@ if [[ -n "$df_formats" ]]; then
     # shellcheck disable=SC2086
     target/release_debug/datafusion-bench "$subcommand" \
         -d gh-json \
+        --show-session-metrics \
         --formats "$df_formats" \
         $opts \
         -o df-results.json
@@ -118,6 +119,7 @@ if [[ -n "$ddb_formats" ]]; then
     # shellcheck disable=SC2086
     target/release_debug/duckdb-bench "$subcommand" \
         -d gh-json \
+        --show-session-metrics \
         --formats "$ddb_formats" \
         $opts \
         --delete-duckdb-database \
@@ -131,6 +133,7 @@ if ! $is_remote && [[ "$has_lance" == "true" ]] && [[ -f "target/release_debug/l
     # shellcheck disable=SC2086
     target/release_debug/lance-bench "$subcommand" \
         -d gh-json \
+        --show-session-metrics \
         $opts \
         -o lance-results.json
 
diff --git a/bench-orchestrator/bench_orchestrator/cli.py b/bench-orchestrator/bench_orchestrator/cli.py
index eba7521fe9f..5adf1a0a0de 100644
--- a/bench-orchestrator/bench_orchestrator/cli.py
+++ b/bench-orchestrator/bench_orchestrator/cli.py
@@ -76,6 +76,9 @@ def run(
     iterations: Annotated[int, typer.Option("--iterations", "-i", help="Iterations per query")] = 5,
     label: Annotated[str | None, typer.Option("--label", "-l", help="Label for this run")] = None,
     track_memory: Annotated[bool, typer.Option("--track-memory", help="Track memory usage")] = False,
+    show_session_metrics: Annotated[
+        bool, typer.Option("--show-session-metrics", help="Print session metrics after each engine run")
+    ] = False,
     samply: Annotated[bool, typer.Option("--samply", help="Record a profile using samply")] = False,
     sample_rate: Annotated[int, typer.Option("--sample-rate", help="Sample rate to run samply with")] = None,
     tracing: Annotated[bool, typer.Option("--tracing", help="Record a trace for use with perfetto")] = False,
@@ -161,6 +164,7 @@ def run(
                     iterations=iterations,
                     options=bench_opts,
                     track_memory=track_memory,
+                    show_session_metrics=show_session_metrics,
                     samply=samply,
                     sample_rate=sample_rate,
                     tracing=tracing,
diff --git a/bench-orchestrator/bench_orchestrator/runner/executor.py b/bench-orchestrator/bench_orchestrator/runner/executor.py
index a80080d8d5a..ba0af654d11 100644
--- a/bench-orchestrator/bench_orchestrator/runner/executor.py
+++ b/bench-orchestrator/bench_orchestrator/runner/executor.py
@@ -34,6 +34,7 @@ def run(
         iterations: int = 5,
         options: dict[str, str] | None = None,
         track_memory: bool = False,
+        show_session_metrics: bool = False,
         samply: bool = False,
         sample_rate: int | None = None,
         tracing: bool = False,
@@ -50,6 +51,7 @@ def run(
             iterations: Number of runs per query
             options: Additional options (e.g., scale_factor)
             track_memory: Enable memory tracking
+            show_session_metrics: Print session metrics at the end of the benchmark process
             on_result: Callback for each result line (for streaming)
 
         Returns:
@@ -73,6 +75,8 @@ def run(
             cmd.extend(["--exclude-queries", ",".join(map(str, exclude_queries))])
         if track_memory:
             cmd.append("--track-memory")
+        if show_session_metrics:
+            cmd.append("--show-session-metrics")
         if tracing:
             cmd.append("--tracing")
         if options:
diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs
index 8d85dd8f4eb..cefced27c70 100644
--- a/benchmarks/datafusion-bench/src/main.rs
+++ b/benchmarks/datafusion-bench/src/main.rs
@@ -97,6 +97,9 @@ struct Args {
     #[arg(long, default_value_t = false)]
     explain: bool,
 
+    #[arg(long, default_value_t = false)]
+    show_session_metrics: bool,
+
     #[arg(long, value_delimiter = ',', value_parser = value_parser!(Format))]
     formats: Vec<Format>,
 
@@ -227,6 +230,10 @@ async fn main() -> anyhow::Result<()> {
         runner.export_to(&args.display_format, writer)?;
     }
 
+    if args.show_session_metrics {
+        vortex_bench::print_session_metrics();
+    }
+
     Ok(())
 }
 
diff --git a/benchmarks/duckdb-bench/src/main.rs b/benchmarks/duckdb-bench/src/main.rs
index 7ab8f1ac7ab..9a1ec92a86e 100644
--- a/benchmarks/duckdb-bench/src/main.rs
+++ b/benchmarks/duckdb-bench/src/main.rs
@@ -81,6 +81,9 @@ struct Args {
         to keep all work on the same threads"
     )]
     reuse: bool,
+
+    #[arg(long, default_value_t = false)]
+    show_session_metrics: bool,
 }
 
 fn main() -> anyhow::Result<()> {
@@ -191,5 +194,9 @@ fn main() -> anyhow::Result<()> {
         runner.export_to(&args.display_format, writer)?;
     }
 
+    if args.show_session_metrics {
+        vortex_bench::print_session_metrics();
+    }
+
     Ok(())
 }
diff --git a/benchmarks/lance-bench/src/main.rs b/benchmarks/lance-bench/src/main.rs
index 73fa8426ffe..2cc0bb056dd 100644
--- a/benchmarks/lance-bench/src/main.rs
+++ b/benchmarks/lance-bench/src/main.rs
@@ -65,6 +65,9 @@ struct Args {
     #[arg(long, default_value_t = false)]
     track_memory: bool,
 
+    #[arg(long, default_value_t = false)]
+    show_session_metrics: bool,
+
     #[arg(long = "opt", value_delimiter = ',', value_parser = value_parser!(Opt))]
     options: Vec<Opt>,
 }
@@ -124,6 +127,10 @@ async fn main() -> anyhow::Result<()> {
     let writer = create_output_writer(&args.display_format, args.output_path, &benchmark_id)?;
     runner.export_to(&args.display_format, writer)?;
 
+    if args.show_session_metrics {
+        vortex_bench::print_session_metrics();
+    }
+
     Ok(())
 }
 
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index e0583aa4871..25b9248d98c 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -13390,6 +13390,8 @@ pub fn S::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemoryS
 
 pub fn S::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
 
+pub fn vortex_array::memory::default_pooled_allocator_metrics_snapshot() -> alloc::vec::Vec<vortex_metrics::Metric>
+
 pub type vortex_array::memory::HostAllocatorRef = alloc::sync::Arc<dyn vortex_array::memory::HostAllocator>
 
 pub mod vortex_array::normalize
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
index 41446a782d9..57ab79f95c4 100644
--- a/vortex-array/src/memory.rs
+++ b/vortex-array/src/memory.rs
@@ -25,6 +25,7 @@ use vortex_metrics::DefaultMetricsRegistry;
 use vortex_metrics::Gauge;
 use vortex_metrics::Histogram;
 use vortex_metrics::Label;
+use vortex_metrics::Metric;
 use vortex_metrics::MetricBuilder;
 use vortex_metrics::MetricsRegistry;
 use vortex_session::Ref;
@@ -55,6 +56,18 @@ thread_local! {
         RefCell::new(HashMap::new());
 }
 
+fn default_pooled_metrics_registry() -> DefaultMetricsRegistry {
+    static REGISTRY: OnceLock<DefaultMetricsRegistry> = OnceLock::new();
+    REGISTRY
+        .get_or_init(DefaultMetricsRegistry::default)
+        .clone()
+}
+
+/// Returns a snapshot of metrics recorded by default-constructed pooled host allocators.
+pub fn default_pooled_allocator_metrics_snapshot() -> Vec<Metric> {
+    default_pooled_metrics_registry().snapshot()
+}
+
 /// Mutable host buffer contract used by [`WritableHostBuffer`].
 pub trait HostBufferMut: Send + 'static {
     /// Returns the logical byte length of the buffer.
@@ -305,7 +318,7 @@ impl Default for PooledHostAllocator {
     fn default() -> Self {
         Self::new(
             DEFAULT_MAX_BYTES_PER_THREAD,
-            Arc::new(DefaultMetricsRegistry::default()),
+            Arc::new(default_pooled_metrics_registry()),
         )
     }
 }
diff --git a/vortex-bench/src/lib.rs b/vortex-bench/src/lib.rs
index a1b7c46bb16..3834fe79556 100644
--- a/vortex-bench/src/lib.rs
+++ b/vortex-bench/src/lib.rs
@@ -59,6 +59,7 @@ pub use benchmark::TableSpec;
 pub use datasets::BenchmarkDataset;
 pub use output::BenchmarkOutput;
 pub use output::create_output_writer;
+pub use utils::metrics::print_session_metrics;
 use vortex::VortexSessionDefault;
 pub use vortex::error::vortex_panic;
 use vortex::io::session::RuntimeSessionExt;
diff --git a/vortex-bench/src/utils/mod.rs b/vortex-bench/src/utils/mod.rs
index 66ec135e237..b2abd3a7a06 100644
--- a/vortex-bench/src/utils/mod.rs
+++ b/vortex-bench/src/utils/mod.rs
@@ -4,6 +4,7 @@
 pub mod constants;
 pub mod file;
 pub mod logging;
+pub mod metrics;
 
 use std::process::Command;
 use std::sync::LazyLock;

From 964f27a74c2bd98546d9a22dc267d40524f64152 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 16:52:48 -0400
Subject: [PATCH 12/17] More Blobs

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-bench/src/utils/metrics.rs | 92 +++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 vortex-bench/src/utils/metrics.rs

diff --git a/vortex-bench/src/utils/metrics.rs b/vortex-bench/src/utils/metrics.rs
new file mode 100644
index 00000000000..2a9168ee391
--- /dev/null
+++ b/vortex-bench/src/utils/metrics.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::time::Duration;
+
+use itertools::Itertools;
+use vortex::array::memory::default_pooled_allocator_metrics_snapshot;
+use vortex::metrics::MetricValue;
+
+/// Prints a snapshot of session metrics to stderr.
+pub fn print_session_metrics() {
+    let mut metrics = default_pooled_allocator_metrics_snapshot();
+    if metrics.is_empty() {
+        eprintln!("session metrics: no metrics recorded");
+        return;
+    }
+
+    metrics.sort_by(|left, right| {
+        left.name()
+            .cmp(right.name())
+            .then_with(|| format_labels(left.labels()).cmp(&format_labels(right.labels())))
+    });
+
+    eprintln!("session metrics:");
+    for metric in metrics {
+        let labels = format_labels(metric.labels());
+        let value = format_metric_value(metric.value());
+        eprintln!("  {}{} = {}", metric.name(), labels, value);
+    }
+}
+
+fn format_labels(labels: &[vortex::metrics::Label]) -> String {
+    if labels.is_empty() {
+        return String::new();
+    }
+    format!("{{{}}}", labels.iter().map(ToString::to_string).join(","))
+}
+
+fn format_metric_value(value: &MetricValue) -> String {
+    match value {
+        MetricValue::Counter(counter) => counter.value().to_string(),
+        MetricValue::Gauge(gauge) => format!("{:.6}", gauge.value()),
+        MetricValue::Histogram(histogram) => {
+            if histogram.is_empty() {
+                return "hist(count=0)".to_string();
+            }
+            format!(
+                "hist(count={}, min={}, p95={}, p99={}, max={}, total={:.6})",
+                histogram.count(),
+                histogram
+                    .quantile(0.0)
+                    .map_or_else(|| "n/a".to_string(), |v| format!("{v:.6}")),
+                histogram
+                    .quantile(0.95)
+                    .map_or_else(|| "n/a".to_string(), |v| format!("{v:.6}")),
+                histogram
+                    .quantile(0.99)
+                    .map_or_else(|| "n/a".to_string(), |v| format!("{v:.6}")),
+                histogram
+                    .quantile(1.0)
+                    .map_or_else(|| "n/a".to_string(), |v| format!("{v:.6}")),
+                histogram.total(),
+            )
+        }
+        MetricValue::Timer(timer) => {
+            if timer.is_empty() {
+                return "timer(count=0)".to_string();
+            }
+            format!(
+                "timer(count={}, min={}, p95={}, p99={}, max={}, total={})",
+                timer.count(),
+                timer
+                    .quantile(0.0)
+                    .map_or_else(|| "n/a".to_string(), format_duration),
+                timer
+                    .quantile(0.95)
+                    .map_or_else(|| "n/a".to_string(), format_duration),
+                timer
+                    .quantile(0.99)
+                    .map_or_else(|| "n/a".to_string(), format_duration),
+                timer
+                    .quantile(1.0)
+                    .map_or_else(|| "n/a".to_string(), format_duration),
+                format_duration(timer.total()),
+            )
+        }
+    }
+}
+
+fn format_duration(duration: Duration) -> String {
+    format!("{:.3}ms", duration.as_secs_f64() * 1_000.0)
+}

From 7bacbcbb74be64bae298cc4e96696a6ce6957884 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 17:12:25 -0400
Subject: [PATCH 13/17] More Blobs

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 Cargo.lock | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index fdfa78c72ed..cd1288cb763 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10157,7 +10157,6 @@ dependencies = [
  "inventory",
  "itertools 0.14.0",
  "jiff",
- "libc",
  "multiversion",
  "num-traits",
  "num_enum",

From cdb3c7c72b4e4bd8f0b1293eea30d04ddee14b74 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 19:52:06 -0400
Subject: [PATCH 14/17] Buffer pools

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 benchmarks/datafusion-bench/src/main.rs  |   2 +
 vortex-array/src/memory.rs               | 822 -----------------------
 vortex-duckdb/src/filesystem.rs          |   3 +
 vortex-file/src/multi/mod.rs             |   7 +-
 vortex-file/src/open.rs                  |   4 +-
 vortex-io/src/object_store/filesystem.rs |  14 +-
 vortex-io/src/object_store/read_at.rs    |  13 +-
 vortex-io/src/runtime/tests.rs           |  21 +-
 vortex-io/src/std_file/read_at.rs        |   8 +-
 9 files changed, 43 insertions(+), 851 deletions(-)
 delete mode 100644 vortex-array/src/memory.rs

diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs
index cefced27c70..ac914454ea9 100644
--- a/benchmarks/datafusion-bench/src/main.rs
+++ b/benchmarks/datafusion-bench/src/main.rs
@@ -26,6 +26,7 @@ use datafusion_physical_plan::collect;
 use futures::StreamExt;
 use parking_lot::Mutex;
 use tokio::fs::File;
+use vortex::array::memory::MemorySessionExt;
 use vortex::scan::DataSourceRef;
 use vortex_bench::Benchmark;
 use vortex_bench::BenchmarkArg;
@@ -314,6 +315,7 @@ async fn register_v2_tables<B: Benchmark + ?Sized>(
         let fs: vortex::io::filesystem::FileSystemRef = Arc::new(ObjectStoreFileSystem::new(
             Arc::clone(&store),
             SESSION.handle(),
+            SESSION.allocator(),
         ));
         let base_prefix = benchmark_base.path().trim_start_matches('/').to_string();
         let fs = fs.with_prefix(base_prefix);
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
deleted file mode 100644
index 832712a929d..00000000000
--- a/vortex-array/src/memory.rs
+++ /dev/null
@@ -1,822 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Session-scoped memory allocation for host-side buffers.
-
-use std::cell::RefCell;
-use std::fmt::Debug;
-use std::mem::size_of;
-use std::sync::Arc;
-use std::sync::OnceLock;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-
-use bytes::Bytes;
-use vortex_buffer::Alignment;
-use vortex_buffer::Buffer;
-use vortex_buffer::ByteBuffer;
-use vortex_buffer::ByteBufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-use vortex_metrics::Counter;
-use vortex_metrics::DefaultMetricsRegistry;
-use vortex_metrics::Gauge;
-use vortex_metrics::Histogram;
-use vortex_metrics::Label;
-use vortex_metrics::Metric;
-use vortex_metrics::MetricBuilder;
-use vortex_metrics::MetricsRegistry;
-use vortex_session::Ref;
-use vortex_session::RefMut;
-use vortex_session::SessionExt;
-use vortex_utils::aliases::hash_map::HashMap;
-
-const DEFAULT_MAX_BYTES_PER_THREAD: usize = 64 * 1024 * 1024;
-const POOL_ALIGNMENT_BYTES: usize = 4 * 1024;
-
-// (bucket_size_bytes, max_entries_per_thread)
-const POOL_BUCKETS: &[(usize, usize)] = &[
-    (4 * 1024, 256),
-    (16 * 1024, 128),
-    (64 * 1024, 64),
-    (128 * 1024, 32),
-    (256 * 1024, 16),
-    (512 * 1024, 8),
-    (1024 * 1024, 8),
-    (2 * 1024 * 1024, 4),
-    (4 * 1024 * 1024, 2),
-];
-
-static NEXT_POOLED_ALLOCATOR_ID: AtomicU64 = AtomicU64::new(1);
-
-thread_local! {
-    static POOLED_HOST_ALLOCATOR_POOLS: RefCell<HashMap<u64, ThreadLocalAllocatorPool>> =
-        RefCell::new(HashMap::new());
-}
-
-fn default_pooled_metrics_registry() -> DefaultMetricsRegistry {
-    static REGISTRY: OnceLock<DefaultMetricsRegistry> = OnceLock::new();
-    REGISTRY
-        .get_or_init(DefaultMetricsRegistry::default)
-        .clone()
-}
-
-/// Returns a snapshot of metrics recorded by default-constructed pooled host allocators.
-pub fn default_pooled_allocator_metrics_snapshot() -> Vec<Metric> {
-    default_pooled_metrics_registry().snapshot()
-}
-
-/// Mutable host buffer contract used by [`WritableHostBuffer`].
-pub trait HostBufferMut: Send + 'static {
-    /// Returns the logical byte length of the buffer.
-    fn len(&self) -> usize;
-
-    /// Whether the buffer is empty.
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Returns the alignment of the buffer.
-    fn alignment(&self) -> Alignment;
-
-    /// Returns mutable access to the writable byte range.
-    fn as_mut_slice(&mut self) -> &mut [u8];
-
-    /// Freeze the buffer into an immutable [`ByteBuffer`].
-    fn freeze(self: Box<Self>) -> ByteBuffer;
-}
-
-/// Exact-size writable host buffer returned by a [`HostAllocator`].
-pub struct WritableHostBuffer {
-    inner: Box<dyn HostBufferMut>,
-}
-
-impl WritableHostBuffer {
-    /// Create a writable host buffer from an implementation of [`HostBufferMut`].
-    pub fn new(inner: Box<dyn HostBufferMut>) -> Self {
-        Self { inner }
-    }
-
-    /// Returns the logical byte length of the buffer.
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Returns true when the buffer has zero bytes.
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Returns the alignment of the buffer.
-    pub fn alignment(&self) -> Alignment {
-        self.inner.alignment()
-    }
-
-    /// Returns mutable access to the writable byte range.
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        self.inner.as_mut_slice()
-    }
-
-    /// Returns mutable access to the buffer as a typed slice.
-    pub fn as_mut_slice_typed<T>(&mut self) -> VortexResult<&mut [T]> {
-        vortex_ensure!(
-            size_of::<T>() != 0,
-            InvalidArgument: "Cannot create typed mutable slice for zero-sized type {}",
-            std::any::type_name::<T>()
-        );
-        vortex_ensure!(
-            self.alignment().is_aligned_to(Alignment::of::<T>()),
-            InvalidArgument: "Buffer is not sufficiently aligned for type {}",
-            std::any::type_name::<T>()
-        );
-
-        let bytes = self.as_mut_slice();
-        let byte_len = bytes.len();
-        let ptr = bytes.as_mut_ptr();
-        let type_size = size_of::<T>();
-
-        vortex_ensure!(
-            byte_len.is_multiple_of(type_size),
-            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
-            type_size,
-            std::any::type_name::<T>()
-        );
-
-        // SAFETY: We checked size divisibility and pointer alignment for `T`,
-        // and we have exclusive mutable access to the underlying bytes.
-        Ok(unsafe { std::slice::from_raw_parts_mut(ptr.cast::<T>(), byte_len / type_size) })
-    }
-
-    /// Freeze the writable buffer into an immutable [`ByteBuffer`].
-    pub fn freeze(self) -> ByteBuffer {
-        self.inner.freeze()
-    }
-
-    /// Freeze the writable buffer into a typed immutable [`Buffer<T>`].
-    pub fn freeze_typed<T>(self) -> VortexResult<Buffer<T>> {
-        vortex_ensure!(
-            size_of::<T>() != 0,
-            InvalidArgument: "Cannot freeze typed buffer for zero-sized type {}",
-            std::any::type_name::<T>()
-        );
-
-        let buffer = self.freeze();
-        let byte_len = buffer.len();
-        let type_size = size_of::<T>();
-        let type_align = Alignment::of::<T>();
-
-        vortex_ensure!(
-            byte_len.is_multiple_of(type_size),
-            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
-            type_size,
-            std::any::type_name::<T>()
-        );
-        vortex_ensure!(
-            buffer.is_aligned(type_align),
-            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
-            type_align,
-            std::any::type_name::<T>()
-        );
-
-        Ok(Buffer::from_byte_buffer(buffer))
-    }
-}
-
-impl Debug for WritableHostBuffer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("WritableHostBuffer")
-            .field("len", &self.len())
-            .field("alignment", &self.alignment())
-            .finish()
-    }
-}
-
-/// Allocator for exact-size writable host buffers.
-pub trait HostAllocator: Debug + Send + Sync + 'static {
-    /// Allocate a writable host buffer with the requested byte length and alignment.
-    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
-}
-
-/// Shared allocator reference used throughout session-scoped memory APIs.
-pub type HostAllocatorRef = Arc<dyn HostAllocator>;
-
-/// Extension methods for [`HostAllocator`]s.
-pub trait HostAllocatorExt: HostAllocator {
-    /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
-    fn allocate_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
-        let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
-            vortex_err!(
-                "Typed host allocation overflow for type {} and len {}",
-                std::any::type_name::<T>(),
-                len
-            )
-        })?;
-        self.allocate(bytes, Alignment::of::<T>())
-    }
-}
-
-impl<A: HostAllocator + ?Sized> HostAllocatorExt for A {}
-
-/// Session-scoped memory configuration for Vortex arrays.
-#[derive(Debug)]
-pub struct MemorySession {
-    allocator: HostAllocatorRef,
-}
-
-impl MemorySession {
-    /// Creates a new session memory configuration using the provided allocator.
-    pub fn new(allocator: HostAllocatorRef) -> Self {
-        Self { allocator }
-    }
-
-    /// Returns the configured allocator.
-    pub fn allocator(&self) -> HostAllocatorRef {
-        Arc::clone(&self.allocator)
-    }
-
-    /// Updates the configured allocator.
-    pub fn set_allocator(&mut self, allocator: HostAllocatorRef) {
-        self.allocator = allocator;
-    }
-}
-
-impl Default for MemorySession {
-    fn default() -> Self {
-        Self::new(Arc::new(PooledHostAllocator::default()))
-    }
-}
-
-/// Extension trait for accessing session-scoped memory configuration.
-pub trait MemorySessionExt: SessionExt {
-    /// Returns the memory session for this execution/session context.
-    fn memory(&self) -> Ref<'_, MemorySession> {
-        self.get::<MemorySession>()
-    }
-
-    /// Returns the configured host allocator for this execution/session context.
-    fn allocator(&self) -> HostAllocatorRef {
-        self.memory().allocator()
-    }
-
-    /// Returns mutable access to the memory session.
-    fn memory_mut(&self) -> RefMut<'_, MemorySession> {
-        self.get_mut::<MemorySession>()
-    }
-}
-
-impl<S: SessionExt> MemorySessionExt for S {}
-
-/// Default host allocator.
-#[derive(Debug, Default)]
-pub struct DefaultHostAllocator;
-
-impl HostAllocator for DefaultHostAllocator {
-    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
-        allocate_unpooled(len, alignment)
-    }
-}
-
-/// A pooled host allocator with thread-local buckets and metric instrumentation.
-#[derive(Debug)]
-pub struct PooledHostAllocator {
-    id: u64,
-    max_bytes_per_thread: usize,
-    metrics: Arc<PooledAllocatorMetrics>,
-}
-
-impl PooledHostAllocator {
-    /// Create a pooled allocator.
-    ///
-    /// `max_bytes_per_thread` controls the maximum total capacity retained in the thread-local
-    /// pool for this allocator. Set it to `0` to disable pooling while still recording metrics.
-    pub fn new(max_bytes_per_thread: usize, metrics_registry: Arc<dyn MetricsRegistry>) -> Self {
-        let id = NEXT_POOLED_ALLOCATOR_ID.fetch_add(1, Ordering::Relaxed);
-        let labels = vec![
-            Label::new("allocator", "pooled_host"),
-            Label::new("allocator_id", id.to_string()),
-        ];
-
-        Self {
-            id,
-            max_bytes_per_thread,
-            metrics: Arc::new(PooledAllocatorMetrics::new(
-                metrics_registry.as_ref(),
-                labels,
-            )),
-        }
-    }
-
-    /// Maximum retained bytes per thread for this allocator.
-    pub fn max_bytes_per_thread(&self) -> usize {
-        self.max_bytes_per_thread
-    }
-}
-
-impl Default for PooledHostAllocator {
-    fn default() -> Self {
-        Self::new(
-            DEFAULT_MAX_BYTES_PER_THREAD,
-            Arc::new(default_pooled_metrics_registry()),
-        )
-    }
-}
-
-impl HostAllocator for PooledHostAllocator {
-    fn allocate(
-        &self,
-        len: usize,
-        requested_alignment: Alignment,
-    ) -> VortexResult<WritableHostBuffer> {
-        self.metrics.alloc_requests.add(1);
-        self.metrics.request_bytes.update(len as f64);
-
-        if self.max_bytes_per_thread == 0 {
-            self.metrics.bypass_disabled.add(1);
-            return allocate_unpooled(len, requested_alignment);
-        }
-
-        let pool_alignment = pooled_alignment();
-        if !pool_alignment.is_aligned_to(requested_alignment) {
-            self.metrics.bypass_alignment.add(1);
-            return allocate_unpooled(len, requested_alignment);
-        }
-
-        let Some(bucket_idx) = bucket_index_for_len(len) else {
-            self.metrics.bypass_size.add(1);
-            return allocate_unpooled(len, requested_alignment);
-        };
-
-        let (bucket_size, _) = POOL_BUCKETS[bucket_idx];
-        if bucket_size > self.max_bytes_per_thread {
-            self.metrics.bypass_size.add(1);
-            return allocate_unpooled(len, requested_alignment);
-        }
-
-        let (pooled, retained_bytes, retained_buffers) = with_allocator_pool(self.id, |pool| {
-            let pooled = pool.take_buffer(bucket_idx);
-            (pooled, pool.retained_bytes, pool.buffer_count())
-        });
-
-        self.metrics.retained_bytes.set(retained_bytes as f64);
-        self.metrics.retained_buffers.set(retained_buffers as f64);
-        self.metrics.bucket_bytes.update(bucket_size as f64);
-
-        let mut buffer = if let Some(buffer) = pooled {
-            self.metrics.hits.add(1);
-            buffer
-        } else {
-            self.metrics.misses.add(1);
-            ByteBufferMut::with_capacity_aligned(bucket_size, pool_alignment)
-        };
-
-        // SAFETY: We fully initialize this slice before freezing it.
-        unsafe { buffer.set_len(len) };
-
-        Ok(WritableHostBuffer::new(Box::new(
-            DefaultWritableHostBuffer::with_pool(
-                buffer,
-                requested_alignment,
-                PooledReturn {
-                    allocator_id: self.id,
-                    bucket_idx,
-                    max_bytes_per_thread: self.max_bytes_per_thread,
-                    metrics: Arc::clone(&self.metrics),
-                },
-            ),
-        )))
-    }
-}
-
-fn allocate_unpooled(len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
-    let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
-    // SAFETY: We fully initialize this slice before freezing it.
-    unsafe { buffer.set_len(len) };
-    Ok(WritableHostBuffer::new(Box::new(
-        DefaultWritableHostBuffer::new(buffer, alignment),
-    )))
-}
-
-#[derive(Debug)]
-struct PooledAllocatorMetrics {
-    alloc_requests: Counter,
-    hits: Counter,
-    misses: Counter,
-    puts: Counter,
-    drops: Counter,
-    bypass_alignment: Counter,
-    bypass_size: Counter,
-    bypass_disabled: Counter,
-    request_bytes: Histogram,
-    bucket_bytes: Histogram,
-    retained_bytes: Gauge,
-    retained_buffers: Gauge,
-}
-
-impl PooledAllocatorMetrics {
-    fn new(metrics_registry: &dyn MetricsRegistry, labels: Vec<Label>) -> Self {
-        Self {
-            alloc_requests: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.alloc_requests"),
-            hits: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.hits"),
-            misses: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.misses"),
-            puts: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.puts"),
-            drops: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.drops"),
-            bypass_alignment: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.bypass_alignment"),
-            bypass_size: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.bypass_size"),
-            bypass_disabled: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .counter("memory.host_pool.bypass_disabled"),
-            request_bytes: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .histogram("memory.host_pool.request_bytes"),
-            bucket_bytes: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .histogram("memory.host_pool.bucket_bytes"),
-            retained_bytes: MetricBuilder::new(metrics_registry)
-                .add_labels(labels.clone())
-                .gauge("memory.host_pool.retained_bytes"),
-            retained_buffers: MetricBuilder::new(metrics_registry)
-                .add_labels(labels)
-                .gauge("memory.host_pool.retained_buffers"),
-        }
-    }
-}
-
-#[derive(Debug)]
-struct PooledReturn {
-    allocator_id: u64,
-    bucket_idx: usize,
-    max_bytes_per_thread: usize,
-    metrics: Arc<PooledAllocatorMetrics>,
-}
-
-#[derive(Debug, Default)]
-struct ThreadLocalAllocatorPool {
-    retained_bytes: usize,
-    buckets: Vec<Vec<ByteBufferMut>>,
-}
-
-impl ThreadLocalAllocatorPool {
-    fn new() -> Self {
-        Self {
-            retained_bytes: 0,
-            buckets: (0..POOL_BUCKETS.len()).map(|_| Vec::new()).collect(),
-        }
-    }
-
-    fn take_buffer(&mut self, bucket_idx: usize) -> Option<ByteBufferMut> {
-        let buffer = self.buckets.get_mut(bucket_idx)?.pop()?;
-        self.retained_bytes = self.retained_bytes.saturating_sub(buffer.capacity());
-        Some(buffer)
-    }
-
-    fn try_put_buffer(
-        &mut self,
-        bucket_idx: usize,
-        mut buffer: ByteBufferMut,
-        max_bytes_per_thread: usize,
-    ) -> bool {
-        if bucket_idx >= self.buckets.len() {
-            return false;
-        }
-
-        let (_, max_entries) = POOL_BUCKETS[bucket_idx];
-        if self.buckets[bucket_idx].len() >= max_entries {
-            return false;
-        }
-
-        let capacity = buffer.capacity();
-        if self.retained_bytes.saturating_add(capacity) > max_bytes_per_thread {
-            return false;
-        }
-
-        buffer.clear();
-        self.retained_bytes = self.retained_bytes.saturating_add(capacity);
-        self.buckets[bucket_idx].push(buffer);
-        true
-    }
-
-    fn buffer_count(&self) -> usize {
-        self.buckets.iter().map(Vec::len).sum()
-    }
-
-    #[cfg(test)]
-    fn bucket_len(&self, bucket_idx: usize) -> usize {
-        self.buckets[bucket_idx].len()
-    }
-}
-
-fn with_allocator_pool<R>(
-    allocator_id: u64,
-    f: impl FnOnce(&mut ThreadLocalAllocatorPool) -> R,
-) -> R {
-    POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
-        let mut pools = pools.borrow_mut();
-        let pool = pools
-            .entry(allocator_id)
-            .or_insert_with(ThreadLocalAllocatorPool::new);
-        f(pool)
-    })
-}
-
-fn return_buffer_to_pool(buffer: ByteBufferMut, pooled: PooledReturn) {
-    let (stored, retained_bytes, retained_buffers) =
-        with_allocator_pool(pooled.allocator_id, |pool| {
-            let stored =
-                pool.try_put_buffer(pooled.bucket_idx, buffer, pooled.max_bytes_per_thread);
-            (stored, pool.retained_bytes, pool.buffer_count())
-        });
-
-    pooled.metrics.retained_bytes.set(retained_bytes as f64);
-    pooled.metrics.retained_buffers.set(retained_buffers as f64);
-
-    if stored {
-        pooled.metrics.puts.add(1);
-    } else {
-        pooled.metrics.drops.add(1);
-    }
-}
-
-fn bucket_index_for_len(len: usize) -> Option<usize> {
-    POOL_BUCKETS
-        .iter()
-        .position(|(bucket_size, _)| len <= *bucket_size)
-}
-
-fn pooled_alignment() -> Alignment {
-    static CACHED: OnceLock<Alignment> = OnceLock::new();
-    *CACHED.get_or_init(|| Alignment::new(POOL_ALIGNMENT_BYTES))
-}
-
-#[derive(Debug)]
-struct DefaultWritableHostBuffer {
-    buffer: Option<ByteBufferMut>,
-    alignment: Alignment,
-    pooled: Option<PooledReturn>,
-}
-
-impl DefaultWritableHostBuffer {
-    fn new(buffer: ByteBufferMut, alignment: Alignment) -> Self {
-        Self {
-            buffer: Some(buffer),
-            alignment,
-            pooled: None,
-        }
-    }
-
-    fn with_pool(buffer: ByteBufferMut, alignment: Alignment, pooled: PooledReturn) -> Self {
-        Self {
-            buffer: Some(buffer),
-            alignment,
-            pooled: Some(pooled),
-        }
-    }
-
-    fn take_parts(&mut self) -> (ByteBufferMut, Option<PooledReturn>) {
-        (
-            self.buffer
-                .take()
-                .vortex_expect("buffer must exist until freeze/drop"),
-            self.pooled.take(),
-        )
-    }
-}
-
-impl Drop for DefaultWritableHostBuffer {
-    fn drop(&mut self) {
-        let Some(pooled) = self.pooled.take() else {
-            return;
-        };
-
-        let Some(buffer) = self.buffer.take() else {
-            return;
-        };
-
-        return_buffer_to_pool(buffer, pooled);
-    }
-}
-
-#[derive(Debug)]
-struct HostBufferOwner {
-    buffer: Option<ByteBufferMut>,
-    pooled: Option<PooledReturn>,
-}
-
-impl AsRef<[u8]> for HostBufferOwner {
-    fn as_ref(&self) -> &[u8] {
-        self.buffer
-            .as_ref()
-            .vortex_expect("buffer must exist while bytes owner is alive")
-            .as_slice()
-    }
-}
-
-impl Drop for HostBufferOwner {
-    fn drop(&mut self) {
-        let Some(pooled) = self.pooled.take() else {
-            return;
-        };
-
-        let Some(buffer) = self.buffer.take() else {
-            return;
-        };
-
-        return_buffer_to_pool(buffer, pooled);
-    }
-}
-
-impl HostBufferMut for DefaultWritableHostBuffer {
-    fn len(&self) -> usize {
-        self.buffer
-            .as_ref()
-            .vortex_expect("buffer must exist until freeze/drop")
-            .len()
-    }
-
-    fn alignment(&self) -> Alignment {
-        self.alignment
-    }
-
-    fn as_mut_slice(&mut self) -> &mut [u8] {
-        self.buffer
-            .as_mut()
-            .vortex_expect("buffer must exist until freeze/drop")
-            .as_mut_slice()
-    }
-
-    fn freeze(mut self: Box<Self>) -> ByteBuffer {
-        let alignment = self.alignment;
-        let (buffer, pooled) = self.take_parts();
-        let bytes = Bytes::from_owner(HostBufferOwner {
-            buffer: Some(buffer),
-            pooled,
-        });
-        ByteBuffer::from_bytes_aligned(bytes, alignment)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-    use std::sync::atomic::AtomicUsize;
-    use std::sync::atomic::Ordering;
-
-    use super::*;
-
-    #[derive(Debug)]
-    struct CountingAllocator {
-        allocations: Arc<AtomicUsize>,
-    }
-
-    impl HostAllocator for CountingAllocator {
-        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
-            self.allocations.fetch_add(1, Ordering::Relaxed);
-            DefaultHostAllocator.allocate(len, alignment)
-        }
-    }
-
-    fn clear_allocator_pool(allocator_id: u64) {
-        POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
-            pools.borrow_mut().remove(&allocator_id);
-        });
-    }
-
-    fn allocator_pool_bucket_len(allocator_id: u64, bucket_idx: usize) -> usize {
-        with_allocator_pool(allocator_id, |pool| pool.bucket_len(bucket_idx))
-    }
-
-    #[test]
-    fn writable_host_buffer_freeze_round_trip() {
-        let allocator = DefaultHostAllocator;
-        let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
-        for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
-            *byte = u8::try_from(idx).unwrap();
-        }
-
-        let host = writable.freeze();
-        assert_eq!(host.len(), 16);
-        assert!(host.is_aligned(Alignment::new(8)));
-        assert_eq!(host.as_slice(), (0u8..16).collect::<Vec<_>>().as_slice());
-    }
-
-    #[test]
-    fn memory_session_replaces_allocator() {
-        let allocations = Arc::new(AtomicUsize::new(0));
-        let allocator = Arc::new(CountingAllocator {
-            allocations: Arc::clone(&allocations),
-        });
-        let mut session = MemorySession::default();
-        session.set_allocator(allocator);
-        drop(session.allocator().allocate(4, Alignment::none()).unwrap());
-        assert_eq!(allocations.load(Ordering::Relaxed), 1);
-    }
-
-    #[test]
-    fn typed_allocation_uses_type_alignment() {
-        let allocator = DefaultHostAllocator;
-        let writable = allocator.allocate_typed::<u64>(4).unwrap();
-        assert_eq!(writable.len(), 4 * size_of::<u64>());
-        assert_eq!(writable.alignment(), Alignment::of::<u64>());
-    }
-
-    #[test]
-    fn typed_mut_slice_round_trip() {
-        let allocator = DefaultHostAllocator;
-        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
-        writable
-            .as_mut_slice_typed::<u64>()
-            .unwrap()
-            .copy_from_slice(&[10, 20, 30, 40]);
-
-        let frozen = writable.freeze();
-        let values = unsafe {
-            std::slice::from_raw_parts(
-                frozen.as_slice().as_ptr().cast::<u64>(),
-                frozen.len() / size_of::<u64>(),
-            )
-        };
-        assert_eq!(values, [10, 20, 30, 40]);
-    }
-
-    #[test]
-    fn typed_mut_slice_rejects_length_mismatch() {
-        let allocator = DefaultHostAllocator;
-        let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
-        assert!(writable.as_mut_slice_typed::<u32>().is_err());
-    }
-
-    #[test]
-    fn freeze_typed_round_trip() {
-        let allocator = DefaultHostAllocator;
-        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
-        writable
-            .as_mut_slice_typed::<u64>()
-            .unwrap()
-            .copy_from_slice(&[1, 3, 5, 7]);
-
-        let frozen = writable.freeze_typed::<u64>().unwrap();
-        assert_eq!(frozen.as_slice(), [1, 3, 5, 7]);
-    }
-
-    #[test]
-    fn freeze_typed_rejects_length_mismatch() {
-        let allocator = DefaultHostAllocator;
-        let writable = allocator.allocate(7, Alignment::none()).unwrap();
-        let err = writable.freeze_typed::<u32>().unwrap_err();
-        let msg = format!("{err}");
-        assert!(msg.contains("not a multiple of"));
-    }
-
-    #[test]
-    fn pooled_allocator_reuses_bucket() {
-        let allocator =
-            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
-        clear_allocator_pool(allocator.id);
-
-        let bucket_idx = bucket_index_for_len(100).unwrap();
-        {
-            let writable = allocator.allocate(100, Alignment::new(8)).unwrap();
-            drop(writable);
-        }
-
-        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
-
-        {
-            let writable = allocator.allocate(100, Alignment::new(8)).unwrap();
-            // Reuse pops from pool.
-            assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 0);
-            drop(writable);
-        }
-
-        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
-    }
-
-    #[test]
-    fn pooled_allocator_bypasses_large_requests() {
-        let allocator =
-            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
-        clear_allocator_pool(allocator.id);
-
-        let too_large = POOL_BUCKETS.last().unwrap().0 + 1;
-        let writable = allocator.allocate(too_large, Alignment::new(8)).unwrap();
-        drop(writable);
-
-        let pooled_count = with_allocator_pool(allocator.id, |pool| pool.buffer_count());
-        assert_eq!(pooled_count, 0);
-    }
-}
diff --git a/vortex-duckdb/src/filesystem.rs b/vortex-duckdb/src/filesystem.rs
index e6d5c7c9750..cc819c8809e 100644
--- a/vortex-duckdb/src/filesystem.rs
+++ b/vortex-duckdb/src/filesystem.rs
@@ -19,6 +19,7 @@ use object_store::aws::AmazonS3Builder;
 use object_store::local::LocalFileSystem;
 use url::Url;
 use vortex::array::buffer::BufferHandle;
+use vortex::array::memory::MemorySessionExt;
 use vortex::buffer::Alignment;
 use vortex::buffer::ByteBufferMut;
 use vortex::error::VortexError;
@@ -35,6 +36,7 @@ use vortex::io::object_store::ObjectStoreFileSystem;
 use vortex::io::runtime::BlockingRuntime;
 
 use crate::RUNTIME;
+use crate::SESSION;
 use crate::cpp;
 use crate::duckdb::ClientContextRef;
 use crate::duckdb::FsFileHandle;
@@ -97,6 +99,7 @@ fn object_store_fs(base_url: &Url) -> VortexResult<FileSystemRef> {
     Ok(Arc::new(Compat::new(ObjectStoreFileSystem::new(
         object_store,
         RUNTIME.handle(),
+        SESSION.allocator(),
     ))))
 }
 
diff --git a/vortex-file/src/multi/mod.rs b/vortex-file/src/multi/mod.rs
index 2e0c3735499..a1144e529d1 100644
--- a/vortex-file/src/multi/mod.rs
+++ b/vortex-file/src/multi/mod.rs
@@ -11,6 +11,7 @@ use async_trait::async_trait;
 use futures::TryStreamExt;
 use session::MultiFileSessionExt;
 use tracing::debug;
+use vortex_array::memory::MemorySessionExt;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
@@ -153,7 +154,11 @@ fn create_local_filesystem(session: &VortexSession) -> VortexResult<FileSystemRe
     use vortex_io::session::RuntimeSessionExt;
 
     let store = Arc::new(object_store::local::LocalFileSystem::default());
-    let fs: FileSystemRef = Arc::new(ObjectStoreFileSystem::new(store, session.handle()));
+    let fs: FileSystemRef = Arc::new(ObjectStoreFileSystem::new(
+        store,
+        session.handle(),
+        session.allocator(),
+    ));
     Ok(fs)
 }
 
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 3a5d3cf90e5..06bfbbbdfac 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -164,7 +164,7 @@ impl VortexOpenOptions {
         use vortex_io::std_file::FileReadAt;
         let handle = self.session.handle();
         let allocator = self.session.allocator();
-        let source = Arc::new(FileReadAt::open_with_allocator(path, handle, allocator)?);
+        let source = Arc::new(FileReadAt::open(path, handle, allocator)?);
         self.open(source).await
     }
 
@@ -337,7 +337,7 @@ impl VortexOpenOptions {
 
         let handle = self.session.handle();
         let allocator = self.session.allocator();
-        let source = Arc::new(ObjectStoreReadAt::new_with_allocator(
+        let source = Arc::new(ObjectStoreReadAt::new(
             Arc::clone(object_store),
             path.into(),
             handle,
diff --git a/vortex-io/src/object_store/filesystem.rs b/vortex-io/src/object_store/filesystem.rs
index 6fdbc23caa3..e6089776e66 100644
--- a/vortex-io/src/object_store/filesystem.rs
+++ b/vortex-io/src/object_store/filesystem.rs
@@ -12,6 +12,7 @@ use futures::StreamExt;
 use futures::stream::BoxStream;
 use object_store::ObjectStore;
 use object_store::path::Path;
+use vortex_array::memory::HostAllocatorRef;
 use vortex_error::VortexResult;
 
 use crate::VortexReadAt;
@@ -27,6 +28,7 @@ use crate::runtime::Handle;
 pub struct ObjectStoreFileSystem {
     store: Arc<dyn ObjectStore>,
     handle: Handle,
+    allocator: HostAllocatorRef,
 }
 
 impl Debug for ObjectStoreFileSystem {
@@ -39,16 +41,21 @@ impl Debug for ObjectStoreFileSystem {
 
 impl ObjectStoreFileSystem {
     /// Create a new filesystem backed by the given object store and runtime handle.
-    pub fn new(store: Arc<dyn ObjectStore>, handle: Handle) -> Self {
-        Self { store, handle }
+    pub fn new(store: Arc<dyn ObjectStore>, handle: Handle, allocator: HostAllocatorRef) -> Self {
+        Self {
+            store,
+            handle,
+            allocator,
+        }
     }
 
     /// Create a new filesystem backed by a local file system object store and the given runtime
     /// handle.
-    pub fn local(handle: Handle) -> Self {
+    pub fn local(handle: Handle, allocator: HostAllocatorRef) -> Self {
         Self::new(
             Arc::new(object_store::local::LocalFileSystem::new()),
             handle,
+            allocator,
         )
     }
 }
@@ -79,6 +86,7 @@ impl FileSystem for ObjectStoreFileSystem {
             Arc::clone(&self.store),
             path.into(),
             self.handle.clone(),
+            self.allocator.clone(),
         )))
     }
 }
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index 9fe30891495..069390cdce0 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -15,7 +15,6 @@ use object_store::ObjectStoreExt;
 use object_store::path::Path as ObjectPath;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::memory::HostAllocatorRef;
-use vortex_array::memory::PooledHostAllocator;
 use vortex_buffer::Alignment;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
@@ -42,18 +41,8 @@ pub struct ObjectStoreReadAt {
 }
 
 impl ObjectStoreReadAt {
-    /// Create a new object store source.
-    pub fn new(store: Arc<dyn ObjectStore>, path: ObjectPath, handle: Handle) -> Self {
-        Self::new_with_allocator(
-            store,
-            path,
-            handle,
-            Arc::new(PooledHostAllocator::default()),
-        )
-    }
-
     /// Create a new object store source with a custom writable buffer allocator.
-    pub fn new_with_allocator(
+    pub fn new(
         store: Arc<dyn ObjectStore>,
         path: ObjectPath,
         handle: Handle,
diff --git a/vortex-io/src/runtime/tests.rs b/vortex-io/src/runtime/tests.rs
index 8b342f4242d..8fcdad53f43 100644
--- a/vortex-io/src/runtime/tests.rs
+++ b/vortex-io/src/runtime/tests.rs
@@ -12,6 +12,7 @@ use futures::FutureExt;
 use futures::future::BoxFuture;
 use tempfile::NamedTempFile;
 use vortex_array::buffer::BufferHandle;
+use vortex_array::memory::DefaultHostAllocator;
 use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
@@ -99,8 +100,14 @@ fn test_file_read_with_real_file_single_thread() {
             temp_file.flush().unwrap();
 
             // Open and read the file
-            let file_read: Arc<dyn VortexReadAt> =
-                Arc::new(FileReadAt::open(temp_file.path(), handle.clone()).unwrap());
+            let file_read: Arc<dyn VortexReadAt> = Arc::new(
+                FileReadAt::open(
+                    temp_file.path(),
+                    handle.clone(),
+                    Arc::new(DefaultHostAllocator),
+                )
+                .unwrap(),
+            );
 
             // Read a slice
             let result = file_read
@@ -136,8 +143,14 @@ async fn test_file_read_with_real_file_tokio() {
     temp_file.flush().unwrap();
 
     let handle = TokioRuntime::current();
-    let file_read: Arc<dyn VortexReadAt> =
-        Arc::new(FileReadAt::open(temp_file.path(), handle.clone()).unwrap());
+    let file_read: Arc<dyn VortexReadAt> = Arc::new(
+        FileReadAt::open(
+            temp_file.path(),
+            handle.clone(),
+            Arc::new(DefaultHostAllocator),
+        )
+        .unwrap(),
+    );
 
     // Read a slice
     let result = file_read
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index 26d812f306b..9e5cd0a1a6d 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -18,7 +18,6 @@ use futures::FutureExt;
 use futures::future::BoxFuture;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::memory::HostAllocatorRef;
-use vortex_array::memory::PooledHostAllocator;
 use vortex_buffer::Alignment;
 use vortex_error::VortexResult;
 
@@ -71,12 +70,7 @@ pub struct FileReadAt {
 
 impl FileReadAt {
     /// Open a file for reading.
-    pub fn open(path: impl AsRef<Path>, handle: Handle) -> VortexResult<Self> {
-        Self::open_with_allocator(path, handle, Arc::new(PooledHostAllocator::default()))
-    }
-
-    /// Open a file for reading using a custom writable buffer allocator.
-    pub fn open_with_allocator(
+    pub fn open(
         path: impl AsRef<Path>,
         handle: Handle,
         allocator: HostAllocatorRef,

From 680997421ac5cb8d368a13c5ec4214188bc9e603 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 19:52:09 -0400
Subject: [PATCH 15/17] Buffer pools

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-array/src/memory/mod.rs  | 393 +++++++++++++++++++++++++
 vortex-array/src/memory/pool.rs | 500 ++++++++++++++++++++++++++++++++
 vortex-io/src/lib.rs:39:12      |   0
 3 files changed, 893 insertions(+)
 create mode 100644 vortex-array/src/memory/mod.rs
 create mode 100644 vortex-array/src/memory/pool.rs
 create mode 100644 vortex-io/src/lib.rs:39:12

diff --git a/vortex-array/src/memory/mod.rs b/vortex-array/src/memory/mod.rs
new file mode 100644
index 00000000000..2e766b36b50
--- /dev/null
+++ b/vortex-array/src/memory/mod.rs
@@ -0,0 +1,393 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Session-scoped memory allocation for host-side buffers.
+
+use std::fmt::Debug;
+use std::mem::size_of;
+use std::sync::Arc;
+
+use bytes::Bytes;
+use vortex_buffer::Alignment;
+use vortex_buffer::Buffer;
+use vortex_buffer::ByteBuffer;
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+use vortex_session::Ref;
+use vortex_session::RefMut;
+use vortex_session::SessionExt;
+
+mod pool;
+
+pub use pool::PooledHostAllocator;
+pub use pool::default_pooled_allocator_metrics_snapshot;
+
+/// Mutable host buffer contract used by [`WritableHostBuffer`].
+pub trait HostBufferMut: Send + 'static {
+    /// Returns the logical byte length of the buffer.
+    fn len(&self) -> usize;
+
+    /// Whether the buffer is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the alignment of the buffer.
+    fn alignment(&self) -> Alignment;
+
+    /// Returns mutable access to the writable byte range.
+    fn as_mut_slice(&mut self) -> &mut [u8];
+
+    /// Freeze the buffer into an immutable [`ByteBuffer`].
+    fn freeze(self: Box<Self>) -> ByteBuffer;
+}
+
+/// Exact-size writable host buffer returned by a [`HostAllocator`].
+pub struct WritableHostBuffer {
+    inner: Box<dyn HostBufferMut>,
+}
+
+impl WritableHostBuffer {
+    /// Create a writable host buffer from an implementation of [`HostBufferMut`].
+    pub fn new(inner: Box<dyn HostBufferMut>) -> Self {
+        Self { inner }
+    }
+
+    /// Returns the logical byte length of the buffer.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true when the buffer has zero bytes.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the alignment of the buffer.
+    pub fn alignment(&self) -> Alignment {
+        self.inner.alignment()
+    }
+
+    /// Returns mutable access to the writable byte range.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.inner.as_mut_slice()
+    }
+
+    /// Returns mutable access to the buffer as a typed slice.
+    pub fn as_mut_slice_typed<T>(&mut self) -> VortexResult<&mut [T]> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot create typed mutable slice for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            self.alignment().is_aligned_to(Alignment::of::<T>()),
+            InvalidArgument: "Buffer is not sufficiently aligned for type {}",
+            std::any::type_name::<T>()
+        );
+
+        let bytes = self.as_mut_slice();
+        let byte_len = bytes.len();
+        let ptr = bytes.as_mut_ptr();
+        let type_size = size_of::<T>();
+
+        vortex_ensure!(
+            byte_len.is_multiple_of(type_size),
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+
+        // SAFETY: We checked size divisibility and pointer alignment for `T`,
+        // and we have exclusive mutable access to the underlying bytes.
+        Ok(unsafe { std::slice::from_raw_parts_mut(ptr.cast::<T>(), byte_len / type_size) })
+    }
+
+    /// Freeze the writable buffer into an immutable [`ByteBuffer`].
+    pub fn freeze(self) -> ByteBuffer {
+        self.inner.freeze()
+    }
+
+    /// Freeze the writable buffer into a typed immutable [`Buffer<T>`].
+    pub fn freeze_typed<T>(self) -> VortexResult<Buffer<T>> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot freeze typed buffer for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+
+        let buffer = self.freeze();
+        let byte_len = buffer.len();
+        let type_size = size_of::<T>();
+        let type_align = Alignment::of::<T>();
+
+        vortex_ensure!(
+            byte_len.is_multiple_of(type_size),
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            buffer.is_aligned(type_align),
+            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
+            type_align,
+            std::any::type_name::<T>()
+        );
+
+        Ok(Buffer::from_byte_buffer(buffer))
+    }
+}
+
+impl Debug for WritableHostBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WritableHostBuffer")
+            .field("len", &self.len())
+            .field("alignment", &self.alignment())
+            .finish()
+    }
+}
+
+/// Allocator for exact-size writable host buffers.
+pub trait HostAllocator: Debug + Send + Sync + 'static {
+    /// Allocate a writable host buffer with the requested byte length and alignment.
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
+}
+
+/// Shared allocator reference used throughout session-scoped memory APIs.
+pub type HostAllocatorRef = Arc<dyn HostAllocator>;
+
+/// Extension methods for [`HostAllocator`]s.
+pub trait HostAllocatorExt: HostAllocator {
+    /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
+    fn allocate_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
+        let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
+            vortex_err!(
+                "Typed host allocation overflow for type {} and len {}",
+                std::any::type_name::<T>(),
+                len
+            )
+        })?;
+        self.allocate(bytes, Alignment::of::<T>())
+    }
+}
+
+impl<A: HostAllocator + ?Sized> HostAllocatorExt for A {}
+
+/// Session-scoped memory configuration for Vortex arrays.
+#[derive(Debug)]
+pub struct MemorySession {
+    allocator: HostAllocatorRef,
+}
+
+impl MemorySession {
+    /// Creates a new session memory configuration using the provided allocator.
+    pub fn new(allocator: HostAllocatorRef) -> Self {
+        Self { allocator }
+    }
+
+    /// Returns the configured allocator.
+    pub fn allocator(&self) -> HostAllocatorRef {
+        Arc::clone(&self.allocator)
+    }
+
+    /// Updates the configured allocator.
+    pub fn set_allocator(&mut self, allocator: HostAllocatorRef) {
+        self.allocator = allocator;
+    }
+}
+
+impl Default for MemorySession {
+    fn default() -> Self {
+        Self::new(Arc::new(PooledHostAllocator::default()))
+    }
+}
+
+/// Extension trait for accessing session-scoped memory configuration.
+pub trait MemorySessionExt: SessionExt {
+    /// Returns the memory session for this execution/session context.
+    fn memory(&self) -> Ref<'_, MemorySession> {
+        self.get::<MemorySession>()
+    }
+
+    /// Returns the configured host allocator for this execution/session context.
+    fn allocator(&self) -> HostAllocatorRef {
+        self.memory().allocator()
+    }
+
+    /// Returns mutable access to the memory session.
+    fn memory_mut(&self) -> RefMut<'_, MemorySession> {
+        self.get_mut::<MemorySession>()
+    }
+}
+
+impl<S: SessionExt> MemorySessionExt for S {}
+
+/// Default host allocator.
+#[derive(Debug, Default)]
+pub struct DefaultHostAllocator;
+
+impl HostAllocator for DefaultHostAllocator {
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+        allocate_unpooled(len, alignment)
+    }
+}
+
+pub(super) fn allocate_unpooled(
+    len: usize,
+    alignment: Alignment,
+) -> VortexResult<WritableHostBuffer> {
+    let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
+    // SAFETY: We fully initialize this slice before freezing it.
+    unsafe { buffer.set_len(len) };
+    Ok(WritableHostBuffer::new(Box::new(
+        DefaultWritableHostBuffer::new(buffer, alignment),
+    )))
+}
+
+#[derive(Debug)]
+struct DefaultWritableHostBuffer {
+    buffer: ByteBufferMut,
+    alignment: Alignment,
+}
+
+impl DefaultWritableHostBuffer {
+    fn new(buffer: ByteBufferMut, alignment: Alignment) -> Self {
+        Self { buffer, alignment }
+    }
+}
+
+#[derive(Debug)]
+struct HostBufferOwner {
+    buffer: ByteBufferMut,
+}
+
+impl AsRef<[u8]> for HostBufferOwner {
+    fn as_ref(&self) -> &[u8] {
+        self.buffer.as_slice()
+    }
+}
+
+impl HostBufferMut for DefaultWritableHostBuffer {
+    fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    fn alignment(&self) -> Alignment {
+        self.alignment
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer.as_mut_slice()
+    }
+
+    fn freeze(self: Box<Self>) -> ByteBuffer {
+        let Self { buffer, alignment } = *self;
+        let bytes = Bytes::from_owner(HostBufferOwner { buffer });
+        ByteBuffer::from_bytes_aligned(bytes, alignment)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
+
+    use super::*;
+
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl HostAllocator for CountingAllocator {
+        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultHostAllocator.allocate(len, alignment)
+        }
+    }
+
+    #[test]
+    fn writable_host_buffer_freeze_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
+        for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
+            *byte = u8::try_from(idx).unwrap();
+        }
+
+        let host = writable.freeze();
+        assert_eq!(host.len(), 16);
+        assert!(host.is_aligned(Alignment::new(8)));
+        assert_eq!(host.as_slice(), (0u8..16).collect::<Vec<_>>().as_slice());
+    }
+
+    #[test]
+    fn memory_session_replaces_allocator() {
+        let allocations = Arc::new(AtomicUsize::new(0));
+        let allocator = Arc::new(CountingAllocator {
+            allocations: Arc::clone(&allocations),
+        });
+        let mut session = MemorySession::default();
+        session.set_allocator(allocator);
+        drop(session.allocator().allocate(4, Alignment::none()).unwrap());
+        assert_eq!(allocations.load(Ordering::Relaxed), 1);
+    }
+
+    #[test]
+    fn typed_allocation_uses_type_alignment() {
+        let allocator = DefaultHostAllocator;
+        let writable = allocator.allocate_typed::<u64>(4).unwrap();
+        assert_eq!(writable.len(), 4 * size_of::<u64>());
+        assert_eq!(writable.alignment(), Alignment::of::<u64>());
+    }
+
+    #[test]
+    fn typed_mut_slice_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[10, 20, 30, 40]);
+
+        let frozen = writable.freeze();
+        let values = unsafe {
+            std::slice::from_raw_parts(
+                frozen.as_slice().as_ptr().cast::<u64>(),
+                frozen.len() / size_of::<u64>(),
+            )
+        };
+        assert_eq!(values, [10, 20, 30, 40]);
+    }
+
+    #[test]
+    fn typed_mut_slice_rejects_length_mismatch() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
+        assert!(writable.as_mut_slice_typed::<u32>().is_err());
+    }
+
+    #[test]
+    fn freeze_typed_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[1, 3, 5, 7]);
+
+        let frozen = writable.freeze_typed::<u64>().unwrap();
+        assert_eq!(frozen.as_slice(), [1, 3, 5, 7]);
+    }
+
+    #[test]
+    fn freeze_typed_rejects_length_mismatch() {
+        let allocator = DefaultHostAllocator;
+        let writable = allocator.allocate(7, Alignment::none()).unwrap();
+        let err = writable.freeze_typed::<u32>().unwrap_err();
+        let msg = format!("{err}");
+        assert!(msg.contains("not a multiple of"));
+    }
+}
diff --git a/vortex-array/src/memory/pool.rs b/vortex-array/src/memory/pool.rs
new file mode 100644
index 00000000000..72800e8bd07
--- /dev/null
+++ b/vortex-array/src/memory/pool.rs
@@ -0,0 +1,500 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::cell::RefCell;
+use std::sync::Arc;
+use std::sync::OnceLock;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+
+use bytes::Bytes;
+use vortex_buffer::Alignment;
+use vortex_buffer::ByteBuffer;
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_metrics::Counter;
+use vortex_metrics::DefaultMetricsRegistry;
+use vortex_metrics::Gauge;
+use vortex_metrics::Histogram;
+use vortex_metrics::Label;
+use vortex_metrics::Metric;
+use vortex_metrics::MetricBuilder;
+use vortex_metrics::MetricsRegistry;
+use vortex_utils::aliases::hash_map::HashMap;
+
+use super::HostAllocator;
+use super::HostBufferMut;
+use super::WritableHostBuffer;
+use super::allocate_unpooled;
+
+const DEFAULT_MAX_BYTES_PER_THREAD: usize = 64 * 1024 * 1024;
+const POOL_ALIGNMENT_BYTES: usize = 4 * 1024;
+
+// (bucket_size_bytes, max_entries_per_thread)
+const POOL_BUCKETS: &[(usize, usize)] = &[
+    (4 * 1024, 256),
+    (16 * 1024, 128),
+    (64 * 1024, 64),
+    (128 * 1024, 32),
+    (256 * 1024, 16),
+    (512 * 1024, 8),
+    (1024 * 1024, 8),
+    (2 * 1024 * 1024, 4),
+    (4 * 1024 * 1024, 2),
+];
+
+static NEXT_POOLED_ALLOCATOR_ID: AtomicU64 = AtomicU64::new(1);
+
+thread_local! {
+    static POOLED_HOST_ALLOCATOR_POOLS: RefCell<HashMap<u64, ThreadLocalAllocatorPool>> =
+        RefCell::new(HashMap::new());
+}
+
+fn default_pooled_metrics_registry() -> DefaultMetricsRegistry {
+    static REGISTRY: OnceLock<DefaultMetricsRegistry> = OnceLock::new();
+    REGISTRY
+        .get_or_init(DefaultMetricsRegistry::default)
+        .clone()
+}
+
+/// Returns a snapshot of metrics recorded by default-constructed pooled host allocators.
+pub fn default_pooled_allocator_metrics_snapshot() -> Vec<Metric> {
+    default_pooled_metrics_registry().snapshot()
+}
+
+/// A pooled host allocator with thread-local buckets and metric instrumentation.
+#[derive(Debug)]
+pub struct PooledHostAllocator {
+    id: u64,
+    max_bytes_per_thread: usize,
+    metrics: Arc<PooledAllocatorMetrics>,
+}
+
+impl PooledHostAllocator {
+    /// Create a pooled allocator.
+    ///
+    /// `max_bytes_per_thread` controls the maximum total capacity retained in the thread-local
+    /// pool for this allocator. Set it to `0` to disable pooling while still recording metrics.
+    pub fn new(max_bytes_per_thread: usize, metrics_registry: Arc<dyn MetricsRegistry>) -> Self {
+        let id = NEXT_POOLED_ALLOCATOR_ID.fetch_add(1, Ordering::Relaxed);
+        let labels = vec![
+            Label::new("allocator", "pooled_host"),
+            Label::new("allocator_id", id.to_string()),
+        ];
+
+        Self {
+            id,
+            max_bytes_per_thread,
+            metrics: Arc::new(PooledAllocatorMetrics::new(
+                metrics_registry.as_ref(),
+                labels,
+            )),
+        }
+    }
+
+    /// Maximum retained bytes per thread for this allocator.
+    pub fn max_bytes_per_thread(&self) -> usize {
+        self.max_bytes_per_thread
+    }
+}
+
+impl Default for PooledHostAllocator {
+    fn default() -> Self {
+        Self::new(
+            DEFAULT_MAX_BYTES_PER_THREAD,
+            Arc::new(default_pooled_metrics_registry()),
+        )
+    }
+}
+
+impl HostAllocator for PooledHostAllocator {
+    fn allocate(
+        &self,
+        len: usize,
+        requested_alignment: Alignment,
+    ) -> VortexResult<WritableHostBuffer> {
+        self.metrics.alloc_requests.add(1);
+        self.metrics.request_bytes.update(len as f64);
+
+        if self.max_bytes_per_thread == 0 {
+            self.metrics.bypass_disabled.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let pool_alignment = pooled_alignment();
+        if !pool_alignment.is_aligned_to(requested_alignment) {
+            self.metrics.bypass_alignment.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let Some(bucket_idx) = bucket_index_for_len(len) else {
+            self.metrics.bypass_size.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        };
+
+        let (bucket_size, _) = POOL_BUCKETS[bucket_idx];
+        if bucket_size > self.max_bytes_per_thread {
+            self.metrics.bypass_size.add(1);
+            return allocate_unpooled(len, requested_alignment);
+        }
+
+        let (pooled, retained_bytes, retained_buffers) = with_allocator_pool(self.id, |pool| {
+            let pooled = pool.take_buffer(bucket_idx);
+            (pooled, pool.retained_bytes, pool.buffer_count())
+        });
+
+        self.metrics.retained_bytes.set(retained_bytes as f64);
+        self.metrics.retained_buffers.set(retained_buffers as f64);
+        self.metrics.bucket_bytes.update(bucket_size as f64);
+
+        let mut buffer = if let Some(buffer) = pooled {
+            self.metrics.hits.add(1);
+            buffer
+        } else {
+            self.metrics.misses.add(1);
+            ByteBufferMut::with_capacity_aligned(bucket_size, pool_alignment)
+        };
+
+        // SAFETY: We fully initialize this slice before freezing it.
+        unsafe { buffer.set_len(len) };
+
+        Ok(WritableHostBuffer::new(Box::new(
+            PooledWritableHostBuffer::new(
+                buffer,
+                requested_alignment,
+                PooledReturn {
+                    allocator_id: self.id,
+                    bucket_idx,
+                    max_bytes_per_thread: self.max_bytes_per_thread,
+                    metrics: Arc::clone(&self.metrics),
+                },
+            ),
+        )))
+    }
+}
+
+#[derive(Debug)]
+struct PooledAllocatorMetrics {
+    alloc_requests: Counter,
+    hits: Counter,
+    misses: Counter,
+    puts: Counter,
+    drops: Counter,
+    bypass_alignment: Counter,
+    bypass_size: Counter,
+    bypass_disabled: Counter,
+    request_bytes: Histogram,
+    bucket_bytes: Histogram,
+    retained_bytes: Gauge,
+    retained_buffers: Gauge,
+}
+
+impl PooledAllocatorMetrics {
+    fn new(metrics_registry: &dyn MetricsRegistry, labels: Vec<Label>) -> Self {
+        Self {
+            alloc_requests: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.alloc_requests"),
+            hits: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.hits"),
+            misses: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.misses"),
+            puts: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.puts"),
+            drops: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.drops"),
+            bypass_alignment: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_alignment"),
+            bypass_size: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_size"),
+            bypass_disabled: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("memory.host_pool.bypass_disabled"),
+            request_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .histogram("memory.host_pool.request_bytes"),
+            bucket_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .histogram("memory.host_pool.bucket_bytes"),
+            retained_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .gauge("memory.host_pool.retained_bytes"),
+            retained_buffers: MetricBuilder::new(metrics_registry)
+                .add_labels(labels)
+                .gauge("memory.host_pool.retained_buffers"),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct PooledReturn {
+    allocator_id: u64,
+    bucket_idx: usize,
+    max_bytes_per_thread: usize,
+    metrics: Arc<PooledAllocatorMetrics>,
+}
+
+#[derive(Debug, Default)]
+struct ThreadLocalAllocatorPool {
+    retained_bytes: usize,
+    buckets: Vec<Vec<ByteBufferMut>>,
+}
+
+impl ThreadLocalAllocatorPool {
+    fn new() -> Self {
+        Self {
+            retained_bytes: 0,
+            buckets: (0..POOL_BUCKETS.len()).map(|_| Vec::new()).collect(),
+        }
+    }
+
+    fn take_buffer(&mut self, bucket_idx: usize) -> Option<ByteBufferMut> {
+        let buffer = self.buckets.get_mut(bucket_idx)?.pop()?;
+        self.retained_bytes = self.retained_bytes.saturating_sub(buffer.capacity());
+        Some(buffer)
+    }
+
+    fn try_put_buffer(
+        &mut self,
+        bucket_idx: usize,
+        mut buffer: ByteBufferMut,
+        max_bytes_per_thread: usize,
+    ) -> bool {
+        if bucket_idx >= self.buckets.len() {
+            return false;
+        }
+
+        let (_, max_entries) = POOL_BUCKETS[bucket_idx];
+        if self.buckets[bucket_idx].len() >= max_entries {
+            return false;
+        }
+
+        let capacity = buffer.capacity();
+        if self.retained_bytes.saturating_add(capacity) > max_bytes_per_thread {
+            return false;
+        }
+
+        buffer.clear();
+        self.retained_bytes = self.retained_bytes.saturating_add(capacity);
+        self.buckets[bucket_idx].push(buffer);
+        true
+    }
+
+    fn buffer_count(&self) -> usize {
+        self.buckets.iter().map(Vec::len).sum()
+    }
+
+    #[cfg(test)]
+    fn bucket_len(&self, bucket_idx: usize) -> usize {
+        self.buckets[bucket_idx].len()
+    }
+}
+
+fn with_allocator_pool<R>(
+    allocator_id: u64,
+    f: impl FnOnce(&mut ThreadLocalAllocatorPool) -> R,
+) -> R {
+    POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
+        let mut pools = pools.borrow_mut();
+        let pool = pools
+            .entry(allocator_id)
+            .or_insert_with(ThreadLocalAllocatorPool::new);
+        f(pool)
+    })
+}
+
+fn return_buffer_to_pool(buffer: ByteBufferMut, pooled: PooledReturn) {
+    let (stored, retained_bytes, retained_buffers) =
+        with_allocator_pool(pooled.allocator_id, |pool| {
+            let stored =
+                pool.try_put_buffer(pooled.bucket_idx, buffer, pooled.max_bytes_per_thread);
+            (stored, pool.retained_bytes, pool.buffer_count())
+        });
+
+    pooled.metrics.retained_bytes.set(retained_bytes as f64);
+    pooled.metrics.retained_buffers.set(retained_buffers as f64);
+
+    if stored {
+        pooled.metrics.puts.add(1);
+    } else {
+        pooled.metrics.drops.add(1);
+    }
+}
+
+fn bucket_index_for_len(len: usize) -> Option<usize> {
+    POOL_BUCKETS
+        .iter()
+        .position(|(bucket_size, _)| len <= *bucket_size)
+}
+
+fn pooled_alignment() -> Alignment {
+    static CACHED: OnceLock<Alignment> = OnceLock::new();
+    *CACHED.get_or_init(|| Alignment::new(POOL_ALIGNMENT_BYTES))
+}
+
+#[derive(Debug)]
+struct PooledWritableHostBuffer {
+    buffer: Option<ByteBufferMut>,
+    alignment: Alignment,
+    pooled: Option<PooledReturn>,
+}
+
+impl PooledWritableHostBuffer {
+    fn new(buffer: ByteBufferMut, alignment: Alignment, pooled: PooledReturn) -> Self {
+        Self {
+            buffer: Some(buffer),
+            alignment,
+            pooled: Some(pooled),
+        }
+    }
+
+    fn take_parts(&mut self) -> (ByteBufferMut, Option<PooledReturn>) {
+        (
+            self.buffer
+                .take()
+                .vortex_expect("buffer must exist until freeze/drop"),
+            self.pooled.take(),
+        )
+    }
+}
+
+impl Drop for PooledWritableHostBuffer {
+    fn drop(&mut self) {
+        let Some(pooled) = self.pooled.take() else {
+            return;
+        };
+
+        let Some(buffer) = self.buffer.take() else {
+            return;
+        };
+
+        return_buffer_to_pool(buffer, pooled);
+    }
+}
+
+#[derive(Debug)]
+struct PooledHostBufferOwner {
+    buffer: Option<ByteBufferMut>,
+    pooled: Option<PooledReturn>,
+}
+
+impl AsRef<[u8]> for PooledHostBufferOwner {
+    fn as_ref(&self) -> &[u8] {
+        self.buffer
+            .as_ref()
+            .vortex_expect("buffer must exist while bytes owner is alive")
+            .as_slice()
+    }
+}
+
+impl Drop for PooledHostBufferOwner {
+    fn drop(&mut self) {
+        let Some(pooled) = self.pooled.take() else {
+            return;
+        };
+
+        let Some(buffer) = self.buffer.take() else {
+            return;
+        };
+
+        return_buffer_to_pool(buffer, pooled);
+    }
+}
+
+impl HostBufferMut for PooledWritableHostBuffer {
+    fn len(&self) -> usize {
+        self.buffer
+            .as_ref()
+            .vortex_expect("buffer must exist until freeze/drop")
+            .len()
+    }
+
+    fn alignment(&self) -> Alignment {
+        self.alignment
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer
+            .as_mut()
+            .vortex_expect("buffer must exist until freeze/drop")
+            .as_mut_slice()
+    }
+
+    fn freeze(mut self: Box<Self>) -> ByteBuffer {
+        let alignment = self.alignment;
+        let (buffer, pooled) = self.take_parts();
+        let bytes = Bytes::from_owner(PooledHostBufferOwner {
+            buffer: Some(buffer),
+            pooled,
+        });
+        ByteBuffer::from_bytes_aligned(bytes, alignment)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use super::*;
+
+    fn clear_allocator_pool(allocator_id: u64) {
+        POOLED_HOST_ALLOCATOR_POOLS.with(|pools| {
+            pools.borrow_mut().remove(&allocator_id);
+        });
+    }
+
+    fn allocator_pool_bucket_len(allocator_id: u64, bucket_idx: usize) -> usize {
+        with_allocator_pool(allocator_id, |pool| pool.bucket_len(bucket_idx))
+    }
+
+    #[test]
+    fn pooled_allocator_reuses_bucket() {
+        let allocator =
+            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
+        clear_allocator_pool(allocator.id);
+
+        let bucket_idx = bucket_index_for_len(100).expect("bucket exists");
+        {
+            let writable = allocator
+                .allocate(100, Alignment::new(8))
+                .expect("pooled allocation");
+            drop(writable);
+        }
+
+        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
+
+        {
+            let writable = allocator
+                .allocate(100, Alignment::new(8))
+                .expect("pooled allocation");
+            // Reuse pops from pool.
+            assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 0);
+            drop(writable);
+        }
+
+        assert_eq!(allocator_pool_bucket_len(allocator.id, bucket_idx), 1);
+    }
+
+    #[test]
+    fn pooled_allocator_bypasses_large_requests() {
+        let allocator =
+            PooledHostAllocator::new(8 * 1024 * 1024, Arc::new(DefaultMetricsRegistry::default()));
+        clear_allocator_pool(allocator.id);
+
+        let too_large = POOL_BUCKETS.last().expect("pool bucket").0 + 1;
+        let writable = allocator
+            .allocate(too_large, Alignment::new(8))
+            .expect("unpooled allocation");
+        drop(writable);
+
+        let pooled_count = with_allocator_pool(allocator.id, |pool| pool.buffer_count());
+        assert_eq!(pooled_count, 0);
+    }
+}
diff --git a/vortex-io/src/lib.rs:39:12 b/vortex-io/src/lib.rs:39:12
new file mode 100644
index 00000000000..e69de29bb2d

From 8b7f57f26b9af6b52209c49b15745605b4688f17 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 20:34:50 -0400
Subject: [PATCH 16/17] Buffer pools

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 vortex-datafusion/src/persistent/format.rs | 4 ++--
 vortex-datafusion/src/persistent/reader.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/vortex-datafusion/src/persistent/format.rs b/vortex-datafusion/src/persistent/format.rs
index 2515b66289e..779698f9177 100644
--- a/vortex-datafusion/src/persistent/format.rs
+++ b/vortex-datafusion/src/persistent/format.rs
@@ -266,7 +266,7 @@ impl FileFormat for VortexFormat {
                     }
 
                     // Not entry or invalid - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
+                    let reader = Arc::new(ObjectStoreReadAt::new(
                         store,
                         object.location.clone(),
                         session.handle(),
@@ -339,7 +339,7 @@ impl FileFormat for VortexFormat {
                 Some(metadata) => metadata,
                 None => {
                     // Not entry - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
+                    let reader = Arc::new(ObjectStoreReadAt::new(
                         store,
                         object.location.clone(),
                         session.handle(),
diff --git a/vortex-datafusion/src/persistent/reader.rs b/vortex-datafusion/src/persistent/reader.rs
index 34ff646722c..89ada4657ac 100644
--- a/vortex-datafusion/src/persistent/reader.rs
+++ b/vortex-datafusion/src/persistent/reader.rs
@@ -46,7 +46,7 @@ impl VortexReaderFactory for DefaultVortexReaderFactory {
         file: &PartitionedFile,
         session: &VortexSession,
     ) -> DFResult<Arc<dyn VortexReadAt>> {
-        Ok(Arc::new(ObjectStoreReadAt::new_with_allocator(
+        Ok(Arc::new(ObjectStoreReadAt::new(
             Arc::clone(&self.object_store),
             file.path().as_ref().into(),
             session.handle(),

From 9500b0c608b87054b5b0b56535dfeb16570c3df1 Mon Sep 17 00:00:00 2001
From: Nicholas Gates <nick@nickgates.com>
Date: Wed, 8 Apr 2026 21:55:49 -0400
Subject: [PATCH 17/17] Use scalar functions as arrays

Signed-off-by: Nicholas Gates <nick@nickgates.com>
---
 AGENTS.md                                     |   5 +-
 bench-orchestrator/README.md                  |   5 +-
 bench-orchestrator/bench_orchestrator/cli.py  |  71 +++--
 .../bench_orchestrator/comparison/analyzer.py |  33 ++-
 .../bench_orchestrator/config.py              |   2 +
 .../bench_orchestrator/runner/executor.py     |  20 +-
 .../bench_orchestrator/storage/store.py       |   5 +-
 vortex-array/src/memory/mod.rs                |  11 +-
 vortex-array/src/memory/pool.rs               | 274 ++++++++++++++++--
 vortex-io/public-api.lock                     |  12 +-
 vortex-io/src/object_store/filesystem.rs      |   2 +-
 11 files changed, 375 insertions(+), 65 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index e6bf3b12c5d..30af7143968 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,6 +10,9 @@
   think you've finished work.
 * run `cargo xtask public-api` to re-generate the public API lock files. Please do this every time you reach a stopping
   point or think you've finished work.
+* exception: for trivial, isolated changes that cannot affect formatting or linting (for example constant-only edits
+  with no import/signature/control-flow changes), skip full-workspace `fmt`/`clippy`/`public-api` sweeps unless
+  explicitly requested; prefer targeted validation (for example crate-level `cargo check`/tests) only.
 * you can try running
   `cargo fix --lib --allow-dirty --allow-staged && cargo clippy --fix --lib --allow-dirty --allow-staged` to
   automatically many fix minor errors.
@@ -64,4 +67,4 @@
 
 ## Commits
 
-* All commits must be signed of by the committers in the form `Signed-off-by: "COMMITTER" <COMMITTER_EMAIL>`.
\ No newline at end of file
+* All commits must be signed of by the committers in the form `Signed-off-by: "COMMITTER" <COMMITTER_EMAIL>`.
diff --git a/bench-orchestrator/README.md b/bench-orchestrator/README.md
index 3d9d7ac99c6..f24d242e593 100644
--- a/bench-orchestrator/README.md
+++ b/bench-orchestrator/README.md
@@ -52,6 +52,7 @@ vx-bench run <benchmark> [options]
 - `--iterations, -i`: Iterations per query (default: 5)
 - `--label, -l`: Label for this run (useful for later reference)
 - `--track-memory`: Enable memory usage tracking
+- `--allocator`: Host allocator mode: `pooled`, `default`, or `ab` (run both in one run)
 - `--build/--no-build`: Build binaries before running (default: build)
 
 ### `compare` - Compare Results
@@ -71,9 +72,9 @@ vx-bench compare [options]
 - `--format`: Filter results to a specific format
 - `--threshold`: Significance threshold (default: 0.10 = 10%)
 
-**Within-run comparison** (`--run`): Compares different engine:format combinations within a single run. Output shows one row per query, with columns for each engine:format combo.
+**Within-run comparison** (`--run`): Compares different engine:format (or engine:format:allocator) combinations within a single run. Output shows one row per query, with columns for each combo.
 
-**Multi-run comparison** (`--runs`): Compares the same benchmarks across multiple runs. Output shows one row per (query, engine, format) combination, with columns for each run.
+**Multi-run comparison** (`--runs`): Compares the same benchmarks across multiple runs. Output shows one row per (query, engine, format[, allocator]) combination, with columns for each run.
 
 ### `list` - List Benchmark Runs
 
diff --git a/bench-orchestrator/bench_orchestrator/cli.py b/bench-orchestrator/bench_orchestrator/cli.py
index 5adf1a0a0de..5a5f3c3cd63 100644
--- a/bench-orchestrator/bench_orchestrator/cli.py
+++ b/bench-orchestrator/bench_orchestrator/cli.py
@@ -4,7 +4,7 @@
 """CLI for benchmark orchestration."""
 
 from datetime import datetime, timedelta
-from typing import Annotated
+from typing import Annotated, Literal
 
 import pandas as pd
 import typer
@@ -85,6 +85,13 @@ def run(
     build: Annotated[bool, typer.Option("--build/--no-build", help="Build binaries before running")] = True,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Log underlying commands")] = False,
     options: Annotated[list[str] | None, typer.Option("--opt", help="Engine or benchmark specific options")] = None,
+    allocator: Annotated[
+        str,
+        typer.Option(
+            "--allocator",
+            help="Host allocator mode: pooled, default, or ab (run both and compare)",
+        ),
+    ] = "pooled",
 ) -> None:
     """Run benchmarks with specified configuration."""
     engines = parse_engines(engine)
@@ -92,6 +99,25 @@ def run(
     query_list = parse_queries(queries)
     exclude_list = parse_queries(exclude_queries)
     bench_opts = {}
+    allocator_mode_value = allocator.strip().lower()
+    if allocator_mode_value not in {"pooled", "default", "ab"}:
+        console.print("[red]--allocator must be one of: pooled, default, ab[/red]")
+        raise typer.Exit(1)
+
+    allocator_mode: Literal["pooled", "default", "ab"]
+    if allocator_mode_value == "default":
+        allocator_mode = "default"
+    elif allocator_mode_value == "pooled":
+        allocator_mode = "pooled"
+    else:
+        allocator_mode = "ab"
+
+    allocator_variants: list[Literal["pooled", "default"]]
+    if allocator_mode == "ab":
+        allocator_variants = ["default", "pooled"]
+    else:
+        allocator_variants = [allocator_mode]
+
     # Build options dict
     if options:
         for opt in options:
@@ -111,6 +137,7 @@ def run(
         label=label,
         options=bench_opts,
         track_memory=track_memory,
+        allocator_mode=allocator_mode,
     )
 
     # Validate configuration
@@ -138,6 +165,7 @@ def run(
     console.print(f"  Engines: {', '.join(e.value for e in engines)}")
     console.print(f"  Formats: {', '.join(f.value for f in formats)}")
     console.print(f"  Iterations: {iterations}")
+    console.print(f"  Allocator: {allocator_mode}")
     if label:
         console.print(f"  Label: {label}")
     console.print()
@@ -156,21 +184,27 @@ def run(
             executor = BenchmarkExecutor(binary_paths[eng], eng, verbose=verbose)
 
             try:
-                results = executor.run(
-                    benchmark=benchmark,
-                    formats=engine_formats,
-                    queries=query_list,
-                    exclude_queries=exclude_list,
-                    iterations=iterations,
-                    options=bench_opts,
-                    track_memory=track_memory,
-                    show_session_metrics=show_session_metrics,
-                    samply=samply,
-                    sample_rate=sample_rate,
-                    tracing=tracing,
-                    on_result=ctx.write_raw_json,
-                )
-                console.print(f"[green]{eng.value}: {len(results)} results[/green]")
+                total_results = 0
+                for allocator_variant in allocator_variants:
+                    results = executor.run(
+                        benchmark=benchmark,
+                        formats=engine_formats,
+                        queries=query_list,
+                        exclude_queries=exclude_list,
+                        iterations=iterations,
+                        options=bench_opts,
+                        track_memory=track_memory,
+                        show_session_metrics=show_session_metrics,
+                        samply=samply,
+                        sample_rate=sample_rate,
+                        tracing=tracing,
+                        allocator_mode=allocator_variant,
+                        on_result=ctx.write_raw_json,
+                    )
+                    total_results += len(results)
+                    console.print(f"[green]{eng.value} ({allocator_variant}): {len(results)} results[/green]")
+                if allocator_mode == "ab":
+                    console.print(f"[green]{eng.value}: {total_results} total results[/green]")
             except RuntimeError as e:
                 console.print(f"[red]{eng.value} failed: {e}[/red]")
 
@@ -325,7 +359,10 @@ def compare(
             console.print(f"[red]{e}[/red]")
             raise typer.Exit(1)
 
-        table = pivot_comparison_table(pivot, threshold, row_keys=["query", "engine", "format"])
+        row_keys = ["query", "engine", "format"]
+        if "allocator" in pivot.df.columns:
+            row_keys.append("allocator")
+        table = pivot_comparison_table(pivot, threshold, row_keys=row_keys)
         console.print(table)
         return
 
diff --git a/bench-orchestrator/bench_orchestrator/comparison/analyzer.py b/bench-orchestrator/bench_orchestrator/comparison/analyzer.py
index 7ac62f188ff..7b43196c6c6 100644
--- a/bench-orchestrator/bench_orchestrator/comparison/analyzer.py
+++ b/bench-orchestrator/bench_orchestrator/comparison/analyzer.py
@@ -61,6 +61,7 @@ def extract_target_fields(df: pd.DataFrame) -> pd.DataFrame:
         if isinstance(first_target, dict):
             df["engine"] = df["target"].apply(lambda t: t.get("engine", "") if isinstance(t, dict) else "")
             df["format"] = df["target"].apply(lambda t: t.get("format", "") if isinstance(t, dict) else "")
+            df["allocator"] = df["target"].apply(lambda t: t.get("allocator", "") if isinstance(t, dict) else "")
 
     # Extract query number from name if present
     if "name" in df.columns:
@@ -196,9 +197,15 @@ def compare_within_run(
     if filter_format is not None and "format" in df.columns:
         df = df[df["format"] == filter_format]
 
-    # Find unique engine:format combinations
-    combos_df = df.groupby(["engine", "format"]).size().reset_index()[["engine", "format"]]
-    columns = [f"{row['engine']}:{row['format']}" for _, row in combos_df.iterrows()]
+    has_allocator = "allocator" in df.columns and df["allocator"].nunique(dropna=True) > 1
+
+    # Find unique engine:format[:allocator] combinations.
+    combo_keys = ["engine", "format"] + (["allocator"] if has_allocator else [])
+    combos_df = df.groupby(combo_keys).size().reset_index()[combo_keys]
+    if has_allocator:
+        columns = [f"{row['engine']}:{row['format']}:{row['allocator']}" for _, row in combos_df.iterrows()]
+    else:
+        columns = [f"{row['engine']}:{row['format']}" for _, row in combos_df.iterrows()]
 
     if len(columns) < 2:
         raise ValueError("Need at least 2 engine:format combinations to compare")
@@ -208,10 +215,17 @@ def compare_within_run(
         baseline_engine = combos_df.iloc[0]["engine"]
         baseline_format = combos_df.iloc[0]["format"]
 
-    baseline_key = f"{baseline_engine}:{baseline_format}"
+    if has_allocator:
+        baseline_allocator = combos_df.iloc[0]["allocator"]
+        baseline_key = f"{baseline_engine}:{baseline_format}:{baseline_allocator}"
+    else:
+        baseline_key = f"{baseline_engine}:{baseline_format}"
 
-    # Create engine:format column
-    df["combo"] = df["engine"] + ":" + df["format"]
+    # Create combo column.
+    if has_allocator:
+        df["combo"] = df["engine"] + ":" + df["format"] + ":" + df["allocator"]
+    else:
+        df["combo"] = df["engine"] + ":" + df["format"]
 
     # Pivot to get queries as rows, combos as columns
     pivot = df.pivot_table(index="query", columns="combo", values="value", aggfunc="mean")
@@ -268,8 +282,11 @@ def compare_runs(
     # Combine all runs
     combined: pd.DataFrame = pd.concat(processed, ignore_index=True)
 
-    # Pivot to get (query, engine, format) as rows, runs as columns
-    pivot = combined.pivot_table(index=["query", "engine", "format"], columns="run", values="value", aggfunc="mean")
+    # Pivot to get (query, engine, format[, allocator]) as rows, runs as columns.
+    index = ["query", "engine", "format"]
+    if "allocator" in combined.columns and combined["allocator"].nunique(dropna=True) > 1:
+        index.append("allocator")
+    pivot = combined.pivot_table(index=index, columns="run", values="value", aggfunc="mean")
 
     # Deduplicate labels while preserving order (two runs can share a label).
     unique_labels = list(dict.fromkeys(labels))
diff --git a/bench-orchestrator/bench_orchestrator/config.py b/bench-orchestrator/bench_orchestrator/config.py
index 5a99f7262e8..98918c61131 100644
--- a/bench-orchestrator/bench_orchestrator/config.py
+++ b/bench-orchestrator/bench_orchestrator/config.py
@@ -6,6 +6,7 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
+from typing import Literal
 
 
 class Engine(Enum):
@@ -78,6 +79,7 @@ class RunConfig:
     label: str | None = None
     options: dict[str, str] = field(default_factory=dict)
     track_memory: bool = False
+    allocator_mode: Literal["pooled", "default", "ab"] = "pooled"
 
     def validate(self) -> list[str]:
         """Validate the configuration and return any warnings."""
diff --git a/bench-orchestrator/bench_orchestrator/runner/executor.py b/bench-orchestrator/bench_orchestrator/runner/executor.py
index ba0af654d11..feafa520e1d 100644
--- a/bench-orchestrator/bench_orchestrator/runner/executor.py
+++ b/bench-orchestrator/bench_orchestrator/runner/executor.py
@@ -3,10 +3,12 @@
 
 """Benchmark binary execution."""
 
+import json
+import os
 import subprocess
 from collections.abc import Callable
 from pathlib import Path
-from typing import final
+from typing import Literal, final
 
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
@@ -38,6 +40,7 @@ def run(
         samply: bool = False,
         sample_rate: int | None = None,
         tracing: bool = False,
+        allocator_mode: Literal["pooled", "default"] = "pooled",
         on_result: Callable[[str], None] | None = None,
     ) -> list[str]:
         """
@@ -52,6 +55,7 @@ def run(
             options: Additional options (e.g., scale_factor)
             track_memory: Enable memory tracking
             show_session_metrics: Print session metrics at the end of the benchmark process
+            allocator_mode: Host allocator mode ("pooled" or "default")
             on_result: Callback for each result line (for streaming)
 
         Returns:
@@ -87,7 +91,7 @@ def run(
             cmd = ["--"] + cmd
             cmd_prefix = ["samply", "record"]
             if sample_rate:
-                cmd = cmd_prefix + ["--rate", sample_rate] + cmd
+                cmd = cmd_prefix + ["--rate", str(sample_rate)] + cmd
             else:
                 cmd = cmd_prefix + cmd
 
@@ -98,6 +102,9 @@ def run(
         if self.verbose:
             console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
 
+        env = os.environ.copy()
+        env["VORTEX_HOST_ALLOCATOR"] = allocator_mode
+
         results = []
 
         with Progress(
@@ -112,11 +119,20 @@ def run(
                 cmd,
                 stdout=subprocess.PIPE,
                 text=True,
+                env=env,
             )
 
             for line in iter(process.stdout.readline, ""):
                 line = line.strip()
                 if line:
+                    if line.startswith("{"):
+                        try:
+                            payload = json.loads(line)
+                            if isinstance(payload.get("target"), dict):
+                                payload["target"]["allocator"] = allocator_mode
+                            line = json.dumps(payload)
+                        except json.JSONDecodeError:
+                            pass
                     results.append(line)
                     if on_result:
                         on_result(line)
diff --git a/bench-orchestrator/bench_orchestrator/storage/store.py b/bench-orchestrator/bench_orchestrator/storage/store.py
index 1703af1ad6f..c1f544f527f 100644
--- a/bench-orchestrator/bench_orchestrator/storage/store.py
+++ b/bench-orchestrator/bench_orchestrator/storage/store.py
@@ -139,7 +139,10 @@ def create_run(self, config: RunConfig, build_config: BuildConfig) -> Iterator[R
             timestamp=datetime.now(),
             label=config.label,
             benchmark=config.benchmark.value,
-            dataset_config=config.options,
+            dataset_config={
+                **config.options,
+                "allocator_mode": config.allocator_mode,
+            },
             engines=[e.value for e in config.engines],
             formats=[f.value for f in config.formats],
             queries=config.queries or [],
diff --git a/vortex-array/src/memory/mod.rs b/vortex-array/src/memory/mod.rs
index 2e766b36b50..96548d29035 100644
--- a/vortex-array/src/memory/mod.rs
+++ b/vortex-array/src/memory/mod.rs
@@ -24,6 +24,8 @@ mod pool;
 pub use pool::PooledHostAllocator;
 pub use pool::default_pooled_allocator_metrics_snapshot;
 
+const VORTEX_HOST_ALLOCATOR_ENV: &str = "VORTEX_HOST_ALLOCATOR";
+
 /// Mutable host buffer contract used by [`WritableHostBuffer`].
 pub trait HostBufferMut: Send + 'static {
     /// Returns the logical byte length of the buffer.
@@ -200,7 +202,14 @@ impl MemorySession {
 
 impl Default for MemorySession {
     fn default() -> Self {
-        Self::new(Arc::new(PooledHostAllocator::default()))
+        Self::new(default_host_allocator())
+    }
+}
+
+fn default_host_allocator() -> HostAllocatorRef {
+    match std::env::var(VORTEX_HOST_ALLOCATOR_ENV).as_deref() {
+        Ok("default") => Arc::new(DefaultHostAllocator),
+        _ => Arc::new(PooledHostAllocator::default()),
     }
 }
 
diff --git a/vortex-array/src/memory/pool.rs b/vortex-array/src/memory/pool.rs
index 72800e8bd07..218e26d5a22 100644
--- a/vortex-array/src/memory/pool.rs
+++ b/vortex-array/src/memory/pool.rs
@@ -38,10 +38,12 @@ const POOL_BUCKETS: &[(usize, usize)] = &[
     (64 * 1024, 64),
     (128 * 1024, 32),
     (256 * 1024, 16),
-    (512 * 1024, 8),
-    (1024 * 1024, 8),
-    (2 * 1024 * 1024, 4),
-    (4 * 1024 * 1024, 2),
+    (512 * 1024, 12),
+    (1024 * 1024, 12),
+    (2 * 1024 * 1024, 6),
+    (4 * 1024 * 1024, 3),
+    (8 * 1024 * 1024, 1),
+    (16 * 1024 * 1024, 1),
 ];
 
 static NEXT_POOLED_ALLOCATOR_ID: AtomicU64 = AtomicU64::new(1);
@@ -130,29 +132,68 @@ impl HostAllocator for PooledHostAllocator {
 
         let Some(bucket_idx) = bucket_index_for_len(len) else {
             self.metrics.bypass_size.add(1);
+            self.metrics.request_unbucketed_bytes.update(len as f64);
             return allocate_unpooled(len, requested_alignment);
         };
 
+        if let Some(bucket_metrics) = self.metrics.bucket(bucket_idx) {
+            bucket_metrics.requests.add(1);
+        }
+
         let (bucket_size, _) = POOL_BUCKETS[bucket_idx];
         if bucket_size > self.max_bytes_per_thread {
             self.metrics.bypass_size.add(1);
             return allocate_unpooled(len, requested_alignment);
         }
 
-        let (pooled, retained_bytes, retained_buffers) = with_allocator_pool(self.id, |pool| {
+        let (
+            pooled,
+            retained_bytes,
+            retained_buffers,
+            bucket_retained_bytes,
+            bucket_retained_buffers,
+        ) = with_allocator_pool(self.id, |pool| {
             let pooled = pool.take_buffer(bucket_idx);
-            (pooled, pool.retained_bytes, pool.buffer_count())
+            (
+                pooled,
+                pool.retained_bytes,
+                pool.buffer_count(),
+                pool.bucket_retained_bytes(bucket_idx),
+                pool.bucket_len(bucket_idx),
+            )
         });
 
         self.metrics.retained_bytes.set(retained_bytes as f64);
         self.metrics.retained_buffers.set(retained_buffers as f64);
+        self.metrics.set_bucket_retained(
+            bucket_idx,
+            bucket_retained_bytes,
+            bucket_retained_buffers,
+        );
         self.metrics.bucket_bytes.update(bucket_size as f64);
 
         let mut buffer = if let Some(buffer) = pooled {
-            self.metrics.hits.add(1);
-            buffer
+            if buffer.capacity() >= len {
+                self.metrics.hits.add(1);
+                if let Some(bucket_metrics) = self.metrics.bucket(bucket_idx) {
+                    bucket_metrics.hits.add(1);
+                }
+                buffer
+            } else {
+                self.metrics.drops.add(1);
+                self.metrics
+                    .add_bucket_drop(bucket_idx, DropReason::InvalidCapacity);
+                self.metrics.misses.add(1);
+                if let Some(bucket_metrics) = self.metrics.bucket(bucket_idx) {
+                    bucket_metrics.misses.add(1);
+                }
+                ByteBufferMut::with_capacity_aligned(bucket_size, pool_alignment)
+            }
         } else {
             self.metrics.misses.add(1);
+            if let Some(bucket_metrics) = self.metrics.bucket(bucket_idx) {
+                bucket_metrics.misses.add(1);
+            }
             ByteBufferMut::with_capacity_aligned(bucket_size, pool_alignment)
         };
 
@@ -185,13 +226,23 @@ struct PooledAllocatorMetrics {
     bypass_size: Counter,
     bypass_disabled: Counter,
     request_bytes: Histogram,
+    request_unbucketed_bytes: Histogram,
     bucket_bytes: Histogram,
     retained_bytes: Gauge,
     retained_buffers: Gauge,
+    bucket_metrics: Vec<PooledBucketMetrics>,
 }
 
 impl PooledAllocatorMetrics {
     fn new(metrics_registry: &dyn MetricsRegistry, labels: Vec<Label>) -> Self {
+        let bucket_metrics = POOL_BUCKETS
+            .iter()
+            .enumerate()
+            .map(|(bucket_idx, (bucket_size, _))| {
+                PooledBucketMetrics::new(metrics_registry, &labels, bucket_idx, *bucket_size)
+            })
+            .collect();
+
         Self {
             alloc_requests: MetricBuilder::new(metrics_registry)
                 .add_labels(labels.clone())
@@ -220,6 +271,9 @@ impl PooledAllocatorMetrics {
             request_bytes: MetricBuilder::new(metrics_registry)
                 .add_labels(labels.clone())
                 .histogram("memory.host_pool.request_bytes"),
+            request_unbucketed_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .histogram("memory.host_pool.request_unbucketed_bytes"),
             bucket_bytes: MetricBuilder::new(metrics_registry)
                 .add_labels(labels.clone())
                 .histogram("memory.host_pool.bucket_bytes"),
@@ -229,6 +283,139 @@ impl PooledAllocatorMetrics {
             retained_buffers: MetricBuilder::new(metrics_registry)
                 .add_labels(labels)
                 .gauge("memory.host_pool.retained_buffers"),
+            bucket_metrics,
+        }
+    }
+
+    fn bucket(&self, bucket_idx: usize) -> Option<&PooledBucketMetrics> {
+        self.bucket_metrics.get(bucket_idx)
+    }
+
+    fn set_bucket_retained(
+        &self,
+        bucket_idx: usize,
+        retained_bytes: usize,
+        retained_buffers: usize,
+    ) {
+        let Some(bucket_metrics) = self.bucket(bucket_idx) else {
+            return;
+        };
+        bucket_metrics.retained_bytes.set(retained_bytes as f64);
+        bucket_metrics.retained_buffers.set(retained_buffers as f64);
+    }
+
+    fn add_bucket_drop(&self, bucket_idx: usize, reason: DropReason) {
+        let Some(bucket_metrics) = self.bucket(bucket_idx) else {
+            return;
+        };
+        bucket_metrics.drops.counter(reason).add(1);
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum DropReason {
+    InvalidBucket,
+    EntryLimit,
+    BytesLimit,
+    InvalidCapacity,
+}
+
+impl DropReason {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::InvalidBucket => "invalid_bucket",
+            Self::EntryLimit => "entry_limit",
+            Self::BytesLimit => "bytes_limit",
+            Self::InvalidCapacity => "invalid_capacity",
+        }
+    }
+}
+
+#[derive(Debug)]
+struct BucketDropMetrics {
+    invalid_bucket: Counter,
+    entry_limit: Counter,
+    bytes_limit: Counter,
+    invalid_capacity: Counter,
+}
+
+impl BucketDropMetrics {
+    fn new(metrics_registry: &dyn MetricsRegistry, bucket_labels: &[Label]) -> Self {
+        Self {
+            invalid_bucket: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .add_label("reason", DropReason::InvalidBucket.as_str())
+                .counter("memory.host_pool.bucket.drops"),
+            entry_limit: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .add_label("reason", DropReason::EntryLimit.as_str())
+                .counter("memory.host_pool.bucket.drops"),
+            bytes_limit: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .add_label("reason", DropReason::BytesLimit.as_str())
+                .counter("memory.host_pool.bucket.drops"),
+            invalid_capacity: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .add_label("reason", DropReason::InvalidCapacity.as_str())
+                .counter("memory.host_pool.bucket.drops"),
+        }
+    }
+
+    fn counter(&self, reason: DropReason) -> &Counter {
+        match reason {
+            DropReason::InvalidBucket => &self.invalid_bucket,
+            DropReason::EntryLimit => &self.entry_limit,
+            DropReason::BytesLimit => &self.bytes_limit,
+            DropReason::InvalidCapacity => &self.invalid_capacity,
+        }
+    }
+}
+
+#[derive(Debug)]
+struct PooledBucketMetrics {
+    requests: Counter,
+    hits: Counter,
+    misses: Counter,
+    puts: Counter,
+    drops: BucketDropMetrics,
+    retained_bytes: Gauge,
+    retained_buffers: Gauge,
+}
+
+impl PooledBucketMetrics {
+    fn new(
+        metrics_registry: &dyn MetricsRegistry,
+        base_labels: &[Label],
+        bucket_idx: usize,
+        bucket_size: usize,
+    ) -> Self {
+        let bucket_labels = {
+            let mut labels = base_labels.to_vec();
+            labels.push(Label::new("bucket", bucket_size.to_string()));
+            labels.push(Label::new("bucket_idx", bucket_idx.to_string()));
+            labels
+        };
+
+        Self {
+            requests: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .counter("memory.host_pool.bucket.requests"),
+            hits: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .counter("memory.host_pool.bucket.hits"),
+            misses: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .counter("memory.host_pool.bucket.misses"),
+            puts: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .counter("memory.host_pool.bucket.puts"),
+            drops: BucketDropMetrics::new(metrics_registry, &bucket_labels),
+            retained_bytes: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .gauge("memory.host_pool.bucket.retained_bytes"),
+            retained_buffers: MetricBuilder::new(metrics_registry)
+                .add_labels(bucket_labels.iter().cloned())
+                .gauge("memory.host_pool.bucket.retained_buffers"),
         }
     }
 }
@@ -245,6 +432,7 @@ struct PooledReturn {
 struct ThreadLocalAllocatorPool {
     retained_bytes: usize,
     buckets: Vec<Vec<ByteBufferMut>>,
+    bucket_retained_bytes: Vec<usize>,
 }
 
 impl ThreadLocalAllocatorPool {
@@ -252,12 +440,17 @@ impl ThreadLocalAllocatorPool {
         Self {
             retained_bytes: 0,
             buckets: (0..POOL_BUCKETS.len()).map(|_| Vec::new()).collect(),
+            bucket_retained_bytes: (0..POOL_BUCKETS.len()).map(|_| 0).collect(),
         }
     }
 
     fn take_buffer(&mut self, bucket_idx: usize) -> Option<ByteBufferMut> {
         let buffer = self.buckets.get_mut(bucket_idx)?.pop()?;
-        self.retained_bytes = self.retained_bytes.saturating_sub(buffer.capacity());
+        let capacity = buffer.capacity();
+        self.retained_bytes = self.retained_bytes.saturating_sub(capacity);
+        if let Some(bucket_bytes) = self.bucket_retained_bytes.get_mut(bucket_idx) {
+            *bucket_bytes = bucket_bytes.saturating_sub(capacity);
+        }
         Some(buffer)
     }
 
@@ -266,37 +459,52 @@ impl ThreadLocalAllocatorPool {
         bucket_idx: usize,
         mut buffer: ByteBufferMut,
         max_bytes_per_thread: usize,
-    ) -> bool {
+    ) -> PutBufferResult {
         if bucket_idx >= self.buckets.len() {
-            return false;
+            return PutBufferResult::Dropped(DropReason::InvalidBucket);
         }
 
         let (_, max_entries) = POOL_BUCKETS[bucket_idx];
         if self.buckets[bucket_idx].len() >= max_entries {
-            return false;
+            return PutBufferResult::Dropped(DropReason::EntryLimit);
         }
 
         let capacity = buffer.capacity();
         if self.retained_bytes.saturating_add(capacity) > max_bytes_per_thread {
-            return false;
+            return PutBufferResult::Dropped(DropReason::BytesLimit);
         }
 
         buffer.clear();
         self.retained_bytes = self.retained_bytes.saturating_add(capacity);
+        if let Some(bucket_bytes) = self.bucket_retained_bytes.get_mut(bucket_idx) {
+            *bucket_bytes = bucket_bytes.saturating_add(capacity);
+        }
         self.buckets[bucket_idx].push(buffer);
-        true
+        PutBufferResult::Stored
     }
 
     fn buffer_count(&self) -> usize {
         self.buckets.iter().map(Vec::len).sum()
     }
 
-    #[cfg(test)]
     fn bucket_len(&self, bucket_idx: usize) -> usize {
-        self.buckets[bucket_idx].len()
+        self.buckets.get(bucket_idx).map_or(0, Vec::len)
+    }
+
+    fn bucket_retained_bytes(&self, bucket_idx: usize) -> usize {
+        self.bucket_retained_bytes
+            .get(bucket_idx)
+            .copied()
+            .unwrap_or(0)
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+enum PutBufferResult {
+    Stored,
+    Dropped(DropReason),
+}
+
 fn with_allocator_pool<R>(
     allocator_id: u64,
     f: impl FnOnce(&mut ThreadLocalAllocatorPool) -> R,
@@ -311,20 +519,38 @@ fn with_allocator_pool<R>(
 }
 
 fn return_buffer_to_pool(buffer: ByteBufferMut, pooled: PooledReturn) {
-    let (stored, retained_bytes, retained_buffers) =
+    let (result, retained_bytes, retained_buffers, bucket_retained_bytes, bucket_retained_buffers) =
         with_allocator_pool(pooled.allocator_id, |pool| {
-            let stored =
+            let result =
                 pool.try_put_buffer(pooled.bucket_idx, buffer, pooled.max_bytes_per_thread);
-            (stored, pool.retained_bytes, pool.buffer_count())
+            (
+                result,
+                pool.retained_bytes,
+                pool.buffer_count(),
+                pool.bucket_retained_bytes(pooled.bucket_idx),
+                pool.bucket_len(pooled.bucket_idx),
+            )
         });
 
     pooled.metrics.retained_bytes.set(retained_bytes as f64);
     pooled.metrics.retained_buffers.set(retained_buffers as f64);
-
-    if stored {
-        pooled.metrics.puts.add(1);
-    } else {
-        pooled.metrics.drops.add(1);
+    pooled.metrics.set_bucket_retained(
+        pooled.bucket_idx,
+        bucket_retained_bytes,
+        bucket_retained_buffers,
+    );
+
+    match result {
+        PutBufferResult::Stored => {
+            pooled.metrics.puts.add(1);
+            if let Some(bucket_metrics) = pooled.metrics.bucket(pooled.bucket_idx) {
+                bucket_metrics.puts.add(1);
+            }
+        }
+        PutBufferResult::Dropped(reason) => {
+            pooled.metrics.drops.add(1);
+            pooled.metrics.add_bucket_drop(pooled.bucket_idx, reason);
+        }
     }
 }
 
diff --git a/vortex-io/public-api.lock b/vortex-io/public-api.lock
index 08d74ffc830..63586bce9b7 100644
--- a/vortex-io/public-api.lock
+++ b/vortex-io/public-api.lock
@@ -130,9 +130,9 @@ pub struct vortex_io::object_store::ObjectStoreFileSystem
 
 impl vortex_io::object_store::ObjectStoreFileSystem
 
-pub fn vortex_io::object_store::ObjectStoreFileSystem::local(handle: vortex_io::runtime::Handle) -> Self
+pub fn vortex_io::object_store::ObjectStoreFileSystem::local(handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
 
-pub fn vortex_io::object_store::ObjectStoreFileSystem::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, handle: vortex_io::runtime::Handle) -> Self
+pub fn vortex_io::object_store::ObjectStoreFileSystem::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
 
 impl core::fmt::Debug for vortex_io::object_store::ObjectStoreFileSystem
 
@@ -148,9 +148,7 @@ pub struct vortex_io::object_store::ObjectStoreReadAt
 
 impl vortex_io::object_store::ObjectStoreReadAt
 
-pub fn vortex_io::object_store::ObjectStoreReadAt::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle) -> Self
-
-pub fn vortex_io::object_store::ObjectStoreReadAt::new_with_allocator(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
+pub fn vortex_io::object_store::ObjectStoreReadAt::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_coalesce_config(self, config: vortex_io::CoalesceConfig) -> Self
 
@@ -466,9 +464,7 @@ pub struct vortex_io::std_file::FileReadAt
 
 impl vortex_io::std_file::FileReadAt
 
-pub fn vortex_io::std_file::FileReadAt::open(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle) -> vortex_error::VortexResult<Self>
-
-pub fn vortex_io::std_file::FileReadAt::open_with_allocator(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_io::std_file::FileReadAt::open(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> vortex_error::VortexResult<Self>
 
 impl vortex_io::VortexReadAt for vortex_io::std_file::FileReadAt
 
diff --git a/vortex-io/src/object_store/filesystem.rs b/vortex-io/src/object_store/filesystem.rs
index e6089776e66..e402e3ff747 100644
--- a/vortex-io/src/object_store/filesystem.rs
+++ b/vortex-io/src/object_store/filesystem.rs
@@ -86,7 +86,7 @@ impl FileSystem for ObjectStoreFileSystem {
             Arc::clone(&self.store),
             path.into(),
             self.handle.clone(),
-            self.allocator.clone(),
+            Arc::clone(&self.allocator),
         )))
     }
 }