Skip materializing splitless chunk children during split collection

Split collection previously built a full Layout + LayoutReader for every
chunk of every column just so flat chunks could re-register the chunk-end
boundary the parent already knows from its chunk offsets.

- VTable::registers_interior_splits() (default true; flat returns false)
  lets a layout declare that its readers only ever push the end of the
  requested range, forwarded through LayoutVTablePlugin and DynLayout.
- LayoutChildren::child_has_no_interior_splits(idx) answers that without
  materializing the child: owned children ask the vtable, viewed children
  resolve only the flatbuffer encoding tag against the registry, with a
  single-slot memo since siblings almost always share one encoding.
- ChunkedReader caches a lazy per-chunk classification; when no chunk has
  interior splits it bulk-extends boundaries straight from chunk_offsets.
- RowSplits drops consecutive identical ascending runs (columns with
  aligned chunk boundaries) and skips the final sort when a single run
  survives. StructReader pushes its end boundary after the field walk so
  the common case stays one ascending run.
- LazyReaderChildren::new_uniform avoids a DType and name clone per chunk
  at reader construction.

Split-collection bench medians (64 columns x 256 chunks): cold 916us ->
181us, warm 247us -> 13us; with fully misaligned columns cold 1223us ->
321us, warm 387us -> 146us.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

vortex-layout/src/children.rs

@@ -4,6 +4,8 @@
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::sync::Arc;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
 
 use flatbuffers::Follow;
 use itertools::Itertools;
@@ -35,6 +37,16 @@ pub trait LayoutChildren: 'static + Send + Sync {
     fn child_row_count(&self, idx: usize) -> u64;
 
     fn nchildren(&self) -> usize;
+
+    /// Returns `true` if the child at `idx` is known — without materializing it — to register no
+    /// split boundaries strictly inside its row range (see
+    /// [`VTable::registers_interior_splits`](crate::VTable::registers_interior_splits)).
+    ///
+    /// Implementations may conservatively return `false` when the answer would require
+    /// materializing the child.
+    fn child_has_no_interior_splits(&self, _idx: usize) -> bool {
+        false
+    }
 }
 
 impl Debug for dyn LayoutChildren {
@@ -61,6 +73,10 @@ impl LayoutChildren for Arc<dyn LayoutChildren> {
     fn nchildren(&self) -> usize {
         self.as_ref().nchildren()
     }
+
+    fn child_has_no_interior_splits(&self, idx: usize) -> bool {
+        self.as_ref().child_has_no_interior_splits(idx)
+    }
 }
 
 /// An implementation of [`LayoutChildren`] for in-memory owned children.
@@ -102,6 +118,10 @@ impl LayoutChildren for OwnedLayoutChildren {
     fn nchildren(&self) -> usize {
         self.0.len()
     }
+
+    fn child_has_no_interior_splits(&self, idx: usize) -> bool {
+        !self.0[idx].dyn_registers_interior_splits()
+    }
 }
 
 #[derive(Clone)]
@@ -114,6 +134,10 @@ pub(crate) struct ViewedLayoutChildren {
     allow_unknown: bool,
     session: VortexSession,
     cache: Arc<[OnceCell<LayoutRef>]>,
+    /// Single-slot memo for [`LayoutChildren::child_has_no_interior_splits`]: children of one
+    /// layout node almost always share an encoding, so remember the last resolved flatbuffer
+    /// encoding tag and its answer. Packed as `tag | (answer << 16) | (valid << 17)`.
+    no_interior_splits_memo: Arc<AtomicU32>,
 }
 
 impl ViewedLayoutChildren {
@@ -146,6 +170,7 @@ impl ViewedLayoutChildren {
             allow_unknown,
             session,
             cache,
+            no_interior_splits_memo: Arc::new(AtomicU32::new(0)),
         }
     }
 
@@ -270,4 +295,38 @@ impl LayoutChildren for ViewedLayoutChildren {
     fn nchildren(&self) -> usize {
         self.cache.len()
     }
+
+    fn child_has_no_interior_splits(&self, idx: usize) -> bool {
+        if idx >= self.nchildren() {
+            return false;
+        }
+        // Resolve the child's layout encoding from the flatbuffer tag alone, without
+        // deserializing the child layout. Unknown encodings conservatively report interior
+        // splits so callers fall back to materializing the child.
+        let encoding = self
+            .flatbuffer()
+            .children()
+            .unwrap_or_default()
+            .get(idx)
+            .encoding();
+
+        const MEMO_VALID: u32 = 1 << 17;
+        const MEMO_ANSWER: u32 = 1 << 16;
+        const MEMO_TAG: u32 = 0xFFFF;
+        let memo = self.no_interior_splits_memo.load(Ordering::Relaxed);
+        if memo & MEMO_VALID != 0 && memo & MEMO_TAG == u32::from(encoding) {
+            return memo & MEMO_ANSWER != 0;
+        }
+
+        let answer = self
+            .layout_read_ctx
+            .resolve(encoding)
+            .and_then(|encoding_id| self.layouts.get(&encoding_id))
+            .is_some_and(|encoding| !encoding.registers_interior_splits());
+        self.no_interior_splits_memo.store(
+            u32::from(encoding) | MEMO_VALID | if answer { MEMO_ANSWER } else { 0 },
+            Ordering::Relaxed,
+        );
+        answer
+    }
 }

vortex-layout/src/encoding.rs

@@ -67,6 +67,12 @@ pub trait LayoutVTablePlugin: 'static + Send + Sync + Debug {
         children: &dyn LayoutChildren,
         build_ctx: &LayoutBuildContext<'_>,
     ) -> VortexResult<LayoutRef>;
+
+    /// Returns `true` if readers of this layout may register natural split boundaries strictly
+    /// inside their row range (see [`VTable::registers_interior_splits`]).
+    fn registers_interior_splits(&self) -> bool {
+        true
+    }
 }
 
 /// Backwards-compatible name for the object-safe layout-vtable plugin.
@@ -102,6 +108,10 @@ impl<V: VTable> LayoutVTablePlugin for V {
         )?
         .into_layout())
     }
+
+    fn registers_interior_splits(&self) -> bool {
+        VTable::registers_interior_splits(self)
+    }
 }
 
 impl Display for dyn LayoutVTablePlugin + '_ {

vortex-layout/src/layout.rs

@@ -267,6 +267,12 @@ pub trait DynLayout: 'static + Send + Sync + Debug {
         session: &VortexSession,
         ctx: &LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef>;
+
+    /// Returns `true` if readers of this layout may register natural split boundaries strictly
+    /// inside their row range (see [`crate::VTable::registers_interior_splits`]).
+    fn dyn_registers_interior_splits(&self) -> bool {
+        true
+    }
 }
 
 impl<V: VTable> DynLayout for Layout<V> {
@@ -323,6 +329,10 @@ impl<V: VTable> DynLayout for Layout<V> {
     ) -> VortexResult<LayoutReaderRef> {
         Layout::new_reader(self, name, segment_source, session, ctx)
     }
+
+    fn dyn_registers_interior_splits(&self) -> bool {
+        self.vtable().registers_interior_splits()
+    }
 }
 
 /// Identifies how a layout child relates to its parent.

vortex-layout/src/layouts/chunked/reader.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::future;
+use std::iter::once;
 use std::ops::Range;
 use std::sync::Arc;
 use std::sync::LazyLock;
@@ -10,6 +11,7 @@ use futures::FutureExt;
 use futures::TryStreamExt;
 use futures::future::BoxFuture;
 use futures::stream::FuturesOrdered;
+use once_cell::sync::OnceCell;
 use tracing::trace;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
@@ -40,6 +42,20 @@ pub struct ChunkedReader {
     layout: ChunkedLayout,
     name: Arc<str>,
     lazy_children: LazyReaderChildren,
+    /// Lazily computed classification of which chunks register no interior splits, letting
+    /// [`ChunkedReader::register_splits`] avoid materializing those chunks' readers.
+    chunk_skips: OnceCell<ChunkSkips>,
+}
+
+/// Which chunks of a chunked layout are known to register no interior splits.
+enum ChunkSkips {
+    /// Every chunk end is a split boundary and no chunk has interior splits (e.g. all-flat
+    /// chunks): splits come straight from the chunk offsets.
+    All,
+    /// No chunk can be skipped.
+    None,
+    /// Per-chunk answers.
+    Mixed(Box<[bool]>),
 }
 
 static UNKNOWN: LazyLock<Arc<str>> = LazyLock::new(|| Arc::from("chunked-child"));
@@ -52,32 +68,38 @@ impl ChunkedReader {
         session: &VortexSession,
         ctx: LayoutReaderContext,
     ) -> Self {
-        let nchildren = layout.nchildren();
-        let dtypes = vec![layout.dtype().clone(); nchildren];
-
-        // format!() has non-marginal overhead for short queries like random
-        // access benchmarks
-        let names = if cfg!(debug_assertions) {
-            (0..nchildren)
+        let lazy_children = if cfg!(debug_assertions) {
+            // format!() has non-marginal overhead for short queries like random
+            // access benchmarks
+            let nchildren = layout.nchildren();
+            let dtypes = vec![layout.dtype().clone(); nchildren];
+            let names = (0..nchildren)
                 .map(|idx| Arc::from(format!("{name}.[{idx}]")))
-                .collect()
+                .collect();
+            LazyReaderChildren::new(
+                Arc::clone(layout.children()),
+                dtypes,
+                names,
+                segment_source,
+                session.clone(),
+                ctx,
+            )
         } else {
-            vec![Arc::clone(&*UNKNOWN); nchildren]
+            LazyReaderChildren::new_uniform(
+                Arc::clone(layout.children()),
+                layout.dtype().clone(),
+                Arc::clone(&*UNKNOWN),
+                segment_source,
+                session.clone(),
+                ctx,
+            )
         };
 
-        let lazy_children = LazyReaderChildren::new(
-            Arc::clone(layout.children()),
-            dtypes,
-            names,
-            segment_source,
-            session.clone(),
-            ctx,
-        );
-
         Self {
             layout,
             name,
             lazy_children,
+            chunk_skips: OnceCell::new(),
         }
     }
 
@@ -86,6 +108,28 @@ impl ChunkedReader {
         self.lazy_children.get(idx)
     }
 
+    /// Classify which chunks are known to register no interior splits, without materializing
+    /// any chunk layouts or readers.
+    fn chunk_skips(&self) -> &ChunkSkips {
+        self.chunk_skips.get_or_init(|| {
+            let children = self.layout.children();
+            let nchildren = self.layout.nchildren();
+            if nchildren == 0 {
+                return ChunkSkips::None;
+            }
+            let skips = (0..nchildren)
+                .map(|idx| children.child_has_no_interior_splits(idx))
+                .collect::<Box<[bool]>>();
+            if skips.iter().all(|&skip| skip) {
+                ChunkSkips::All
+            } else if skips.iter().all(|&skip| !skip) {
+                ChunkSkips::None
+            } else {
+                ChunkSkips::Mixed(skips)
+            }
+        })
+    }
+
     fn chunk_offset(&self, idx: usize) -> u64 {
         if idx >= self.layout.chunk_offsets.len() {
             vortex_panic!(
@@ -185,24 +229,59 @@ impl LayoutReader for ChunkedReader {
             return Ok(());
         }
 
-        let iter = self.ranges(split_range.row_range());
-        splits.reserve(iter.size_hint().0);
+        let row_range = split_range.row_range();
+        let row_offset = split_range.row_offset();
 
-        for (chunk_idx, chunk_start, child_range, _) in iter {
-            let child = self.chunk_reader(chunk_idx)?;
-            let child_row_offset = split_range
-                .row_offset()
-                .checked_add(chunk_start)
+        // Fast path: no chunk has interior splits (e.g. all-flat chunks), so the splits are
+        // exactly the chunk-end boundaries — no chunk layouts or readers needed.
+        if matches!(self.chunk_skips(), ChunkSkips::All) {
+            let chunk_range = self.chunk_range(row_range);
+            if chunk_range.is_empty() {
+                return Ok(());
+            }
+            let offsets = &self.layout.chunk_offsets;
+            // The boundaries below are all bounded by the last one, so a single overflow check
+            // covers the whole batch.
+            let last = row_offset
+                .checked_add(offsets[chunk_range.end].min(row_range.end))
                 .vortex_expect("Chunked layout split offset overflow");
-            let child_split_range = SplitRange::try_new(child_row_offset, child_range)?;
+            splits.reserve(chunk_range.len());
+            splits.extend_ascending(
+                offsets[chunk_range.start + 1..chunk_range.end]
+                    .iter()
+                    .map(|&offset| row_offset + offset)
+                    .chain(once(last)),
+            );
+            return Ok(());
+        }
+
+        let iter = self.ranges(row_range);
+        splits.reserve(iter.size_hint().0);
 
-            child.register_splits(field_mask, &child_split_range, splits)?;
+        for (chunk_idx, chunk_start, child_range, _) in iter {
+            let child_end = child_range.end;
+
+            // Children without interior splits (e.g. flat) would only re-register this chunk's
+            // end boundary, so skip materializing a layout and reader for them.
+            let skip_child = match self.chunk_skips() {
+                ChunkSkips::All => true,
+                ChunkSkips::None => false,
+                ChunkSkips::Mixed(skips) => skips[chunk_idx],
+            };
+            if !skip_child {
+                let child = self.chunk_reader(chunk_idx)?;
+                let child_row_offset = row_offset
+                    .checked_add(chunk_start)
+                    .vortex_expect("Chunked layout split offset overflow");
+                let child_split_range = SplitRange::try_new(child_row_offset, child_range)?;
+
+                child.register_splits(field_mask, &child_split_range, splits)?;
+            }
 
             // Register the split indicating the end of this chunk
             splits.push(
-                split_range
-                    .row_offset()
-                    .checked_add(chunk_start + child_split_range.row_range().end)
+                row_offset
+                    .checked_add(chunk_start + child_end)
                     .vortex_expect("Chunked layout split offset overflow"),
             );
         }

vortex-layout/src/layouts/flat/mod.rs

@@ -65,6 +65,12 @@ impl VTable for Flat {
         *ID
     }
 
+    /// Flat readers only ever register the end of the requested range, so split collection can
+    /// skip materializing flat children.
+    fn registers_interior_splits(&self) -> bool {
+        false
+    }
+
     fn metadata(layout: &Layout<Self>) -> Self::Metadata {
         ProstMetadata(FlatLayoutMetadata {
             array_encoding_tree: layout.array_tree.as_ref().map(|bytes| bytes.to_vec()),

vortex-layout/src/layouts/struct_/reader.rs

@@ -371,9 +371,6 @@ impl LayoutReader for StructReader {
         split_range: &SplitRange,
         splits: &mut RowSplits,
     ) -> VortexResult<()> {
-        // In the case of an empty struct, we need to register the end split.
-        splits.push(split_range.root_row_range().end);
-
         // Register splits for the validity child, if there is one
         if let Some(validity_ref) = self.validity()? {
             validity_ref.register_splits(field_mask, split_range, splits)?;
@@ -382,7 +379,13 @@ impl LayoutReader for StructReader {
         self.layout.matching_fields(field_mask, |mask, idx| {
             self.field_reader_by_index(idx)?
                 .register_splits(&[mask], split_range, splits)
-        })
+        })?;
+
+        // In the case of an empty struct, we need to register the end split. Pushed last so it
+        // extends the final field's ascending run rather than starting a run of its own.
+        splits.push(split_range.root_row_range().end);
+
+        Ok(())
     }
 
     fn pruning_evaluation(