diff --git a/vortex-layout/src/scan/execution/filter.rs b/vortex-layout/src/scan/execution/filter/mod.rs similarity index 88% rename from vortex-layout/src/scan/execution/filter.rs rename to vortex-layout/src/scan/execution/filter/mod.rs index 88462ea713f..bc3169ecdda 100644 --- a/vortex-layout/src/scan/execution/filter.rs +++ b/vortex-layout/src/scan/execution/filter/mod.rs @@ -6,9 +6,15 @@ use std::sync::Arc; use bit_vec::BitVec; use rustc_hash::FxHashSet; +use vortex_array::ArrayRef; +use vortex_array::ArrayView; use vortex_array::VortexSessionExecute; +use vortex_array::arrays::Bool; +use vortex_array::arrays::Constant; use vortex_array::builtins::ArrayBuiltins; use vortex_array::expr::BoundExpression; +use vortex_array::validity::Validity; +use vortex_buffer::BitBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure_eq; @@ -237,10 +243,55 @@ pub(super) fn hint( /// Executes a scan's boolean piece to a mask, nulls as false. pub(super) fn piece_mask(session: &VortexSession, piece: Piece) -> VortexResult { + if let Some(mask) = try_ready_piece_mask(&piece.array)? { + return Ok(mask); + } let mut ctx = session.create_execution_ctx(); piece.array.fill_null(false)?.execute::(&mut ctx) } +/// Avoid expression execution for already computed host Boolean pieces. Encoded values and +/// validity, and device buffers, retain the ordinary execution path. +fn try_ready_piece_mask(array: &ArrayRef) -> VortexResult> { + if !array.dtype().is_boolean() { + return Ok(None); + } + let len = array.len(); + if let Some(constant) = array.as_opt::() { + return Ok(Some(Mask::new( + len, + constant.scalar().as_bool().value().unwrap_or(false), + ))); + } + let Some(boolean) = array.as_opt::() else { + return Ok(None); + }; + let Some(bits) = host_bool_bits(boolean) else { + return Ok(None); + }; + let mask = match boolean.validity()? { + Validity::NonNullable | Validity::AllValid => Mask::from_buffer(bits), + Validity::AllInvalid => Mask::new_false(len), + Validity::Array(validity) => { + if validity.dtype().is_nullable() { + return Ok(None); + } + let Some(validity_bits) = validity.as_opt::().and_then(host_bool_bits) else { + return Ok(None); + }; + Mask::from_buffer(bits & validity_bits) + } + }; + Ok(Some(mask)) +} + +fn host_bool_bits(array: ArrayView<'_, Bool>) -> Option { + let parts = array.data().clone().into_parts(array.len()); + parts.bits.is_on_host().then(|| { + BitBuffer::new_with_offset(parts.bits.unwrap_host(), array.len(), parts.meta.offset()) + }) +} + impl IoConsumer for FilterPlanner { fn set_io_result(&mut self, request: IoRequestId, result: IoResult) { if let Some((_, _, adaptor)) = &mut self.active { @@ -390,3 +441,6 @@ impl Planner for FilterPlanner { )) } } + +#[cfg(test)] +mod tests; diff --git a/vortex-layout/src/scan/execution/filter/tests.rs b/vortex-layout/src/scan/execution/filter/tests.rs new file mode 100644 index 00000000000..5392f8aacb3 --- /dev/null +++ b/vortex-layout/src/scan/execution/filter/tests.rs @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: Copyright the Vortex contributors + +use std::any::Any; + +use futures::future::BoxFuture; +use rstest::rstest; +use vortex_array::IntoArray; +use vortex_array::arrays::BoolArray; +use vortex_array::arrays::ConstantArray; +use vortex_array::arrays::DictArray; +use vortex_array::arrays::Slice; +use vortex_array::buffer::BufferHandle; +use vortex_array::buffer::DeviceBuffer; +use vortex_array::dtype::DType; +use vortex_array::dtype::Nullability; +use vortex_array::scalar::Scalar; +use vortex_buffer::Alignment; +use vortex_buffer::ByteBuffer; +use vortex_buffer::buffer; +use vortex_error::vortex_bail; + +use super::*; +use crate::test::SESSION; + +fn assert_piece_result(array: ArrayRef, expected: Mask) -> VortexResult<()> { + let reference = array + .fill_null(false)? + .execute::(&mut SESSION.create_execution_ctx())?; + assert_eq!(reference, expected); + let len = array.len(); + // Piece rows number outputs; they are not the array's logical row range. + let actual = piece_mask( + &SESSION, + Piece { + rows: 41..42, + array, + }, + )?; + assert_eq!(actual.len(), len); + assert_eq!(actual, expected); + Ok(()) +} + +#[rstest] +#[case(Scalar::from(true), true)] +#[case(Scalar::from(false), false)] +#[case(Scalar::from(Some(true)), true)] +#[case(Scalar::from(Some(false)), false)] +#[case(Scalar::null(DType::Bool(Nullability::Nullable)), false)] +fn test_ready_constant_mask( + #[case] scalar: Scalar, + #[case] value: bool, + #[values(0, 1, 9)] len: usize, +) -> VortexResult<()> { + let array = ConstantArray::new(scalar, len).into_array(); + assert_eq!(try_ready_piece_mask(&array)?, Some(Mask::new(len, value))); + assert_piece_result(array, Mask::new(len, value)) +} + +#[rstest] +#[case(Validity::NonNullable)] +#[case(Validity::AllValid)] +#[case(Validity::AllInvalid)] +fn test_ready_bool_validity(#[case] validity: Validity) -> VortexResult<()> { + let expected = if matches!(validity, Validity::AllInvalid) { + Mask::new_false(3) + } else { + Mask::from_iter([true, false, true]) + }; + let array = BoolArray::new(BitBuffer::from_iter([true, false, true]), validity).into_array(); + assert_eq!(try_ready_piece_mask(&array)?, Some(expected.clone())); + assert_piece_result(array, expected) +} + +#[rstest] +fn test_ready_bool_preserves_offsets_and_padding( + #[values(0, 1, 7, 8, 9, 65)] len: usize, +) -> VortexResult<()> { + // Set padding and invalid value bits, and slice values and validity at different offsets. + let values = BitBuffer::from_iter( + (0..len + 8).map(|index| index < 3 || index >= len + 3 || !(index - 3).is_multiple_of(3)), + ) + .slice(3..len + 3); + let validity = BitBuffer::from_iter( + (0..len + 8).map(|index| index < 5 || index >= len + 5 || (index - 5).is_multiple_of(2)), + ) + .slice(5..len + 5); + let array = BoolArray::new( + values, + Validity::Array(BoolArray::new(validity, Validity::NonNullable).into_array()), + ) + .into_array(); + let expected = + Mask::from_iter((0..len).map(|index| !index.is_multiple_of(3) && index.is_multiple_of(2))); + assert_eq!(try_ready_piece_mask(&array)?, Some(expected.clone())); + assert_piece_result(array, expected) +} + +#[test] +fn test_encoded_piece_and_validity_keep_fallback() -> VortexResult<()> { + let codes = buffer![0_u8, 1, 0].into_array(); + let encoded = DictArray::try_new( + codes.clone(), + BoolArray::from_iter([Some(true), None]).into_array(), + )? + .into_array(); + assert!(try_ready_piece_mask(&encoded)?.is_none()); + assert_piece_result(encoded, Mask::from_iter([true, false, true]))?; + + let validity = + DictArray::try_new(codes, BoolArray::from_iter([true, false]).into_array())?.into_array(); + let array = BoolArray::new(BitBuffer::new_set(3), Validity::Array(validity)).into_array(); + assert!(try_ready_piece_mask(&array)?.is_none()); + assert_piece_result(array, Mask::from_iter([true, false, true]))?; + + let non_boolean = ConstantArray::new(1_i32, 3).into_array(); + assert!(try_ready_piece_mask(&non_boolean)?.is_none()); + Ok(()) +} + +#[test] +fn test_lazy_boolean_piece_keeps_fallback() -> VortexResult<()> { + let array = BoolArray::from_iter([Some(false), Some(true), None, Some(false), Some(true)]) + .into_array() + .slice(1..4)?; + assert!(array.is::()); + assert!(try_ready_piece_mask(&array)?.is_none()); + assert_piece_result(array, Mask::from_iter([true, false, false])) +} + +#[test] +fn test_lazy_validity_keeps_fallback() -> VortexResult<()> { + let validity = BoolArray::from_iter([false, true, false, true, false]) + .into_array() + .slice(1..4)?; + assert!(validity.is::()); + let array = BoolArray::new( + BitBuffer::from_iter([true, true, false]), + Validity::Array(validity), + ) + .into_array(); + assert!(try_ready_piece_mask(&array)?.is_none()); + assert_piece_result(array, Mask::from_iter([true, false, false])) +} + +#[test] +fn test_non_boolean_piece_preserves_fallback_error() -> VortexResult<()> { + let array = ConstantArray::new("not a predicate", 3).into_array(); + assert!(try_ready_piece_mask(&array)?.is_none()); + let reference = array + .fill_null(false) + .and_then(|array| array.execute::(&mut SESSION.create_execution_ctx())); + assert!(reference.is_err()); + assert!( + piece_mask( + &SESSION, + Piece { + rows: 41..42, + array + } + ) + .is_err() + ); + Ok(()) +} + +// A fast-path eligibility check must not access device memory or copy it to the host. +#[derive(Debug, PartialEq, Eq, Hash)] +struct MetadataOnlyDeviceBuffer(usize); + +impl DeviceBuffer for MetadataOnlyDeviceBuffer { + fn as_any(&self) -> &dyn Any { + self + } + + fn len(&self) -> usize { + self.0 + } + + fn alignment(&self) -> Alignment { + Alignment::of::() + } + + fn copy_to_host_sync(&self, _alignment: Alignment) -> VortexResult { + panic!("mask eligibility must not read device values"); + } + + fn copy_to_host( + &self, + _alignment: Alignment, + ) -> VortexResult>> { + panic!("mask eligibility must not read device values"); + } + + fn slice(&self, _range: Range) -> Arc { + panic!("mask eligibility must not slice device values"); + } + + fn aligned(self: Arc, alignment: Alignment) -> VortexResult> { + if alignment != self.alignment() { + vortex_bail!("mask eligibility must not realign device values"); + } + Ok(self) + } +} + +#[test] +fn test_device_piece_and_validity_decline_without_reading() -> VortexResult<()> { + let device = BufferHandle::new_device(Arc::new(MetadataOnlyDeviceBuffer(1))); + for validity in [Validity::NonNullable, Validity::AllInvalid] { + let array = BoolArray::try_new_from_handle(device.clone(), 3, 5, validity)?.into_array(); + assert!(try_ready_piece_mask(&array)?.is_none()); + } + let validity = BoolArray::try_new_from_handle(device, 2, 5, Validity::NonNullable)?; + let array = BoolArray::new( + BitBuffer::new_set(5), + Validity::Array(validity.into_array()), + ) + .into_array(); + assert!(try_ready_piece_mask(&array)?.is_none()); + Ok(()) +}