Add SIMD primitive comparison kernels

Moves the explicit AVX2 and AVX-512 primitive comparison kernels from #9547 into
the handwritten comparison path, leaving the RowFn work in #9547 and #9548
untouched. Non-x86 targets and x86-64 CPUs without AVX2 keep the portable
lane-kernel fallback.

Full-word kernels cover every primitive type, comparison operator, and
array/constant orientation, with scalar tail handling, split by lane width so
each width reads on its own. Boundary and nullable coverage comes with them.

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-array/src/scalar_fn/fns/binary/compare/mod.rs

@@ -4,9 +4,9 @@
 //! Native comparison kernels.
 //!
 //! [`execute_compare`] dispatches on the logical [`DType`] of its operands and evaluates every
-//! comparison directly over Vortex canonical arrays — bit buffers for booleans, lane kernels from
-//! `vortex-compute` for primitives and decimals, binary views for strings/bytes, and a row-wise
-//! comparator for nested types. There is no Arrow fallback.
+//! comparison directly over Vortex canonical arrays: bit buffers for booleans, explicit x86 SIMD
+//! or portable lane kernels for primitives, lane kernels for decimals, binary views for
+//! strings/bytes, and a row-wise comparator for nested types. There is no Arrow fallback.
 //!
 //! Floating point values compare with Vortex's total ordering (`NaN` is the largest value,
 //! `-0.0 < +0.0`, and equality is bitwise), matching [`Scalar`] comparison semantics.
@@ -282,8 +282,14 @@ pub(super) fn ordering_predicate(op: CompareOperator) -> fn(Ordering) -> bool {
 }
 
 /// Freeze `len` bits packed into `words` (LSB-first, 64 lanes per word) into a [`BitBuffer`].
-pub(super) fn bit_buffer_from_words(words: BufferMut<u64>, len: usize) -> BitBuffer {
+pub(super) fn bit_buffer_from_words(mut words: BufferMut<u64>, len: usize) -> BitBuffer {
     debug_assert!(words.len() * 64 >= len);
+
+    // Byte reinterpretation must preserve LSB-first lane order on big-endian hosts.
+    for word in words.iter_mut() {
+        *word = word.to_le();
+    }
+
     let mut bytes = words.into_byte_buffer();
     bytes.truncate(len.div_ceil(8));
     BitBuffer::new(bytes.freeze(), len)

…calar_fn/fns/binary/compare/primitive.rs …r_fn/fns/binary/compare/primitive/mod.rsvortex-array/src/scalar_fn/fns/binary/compare/primitive.rs renamed to vortex-array/src/scalar_fn/fns/binary/compare/primitive/mod.rs vortex-array/src/scalar_fn/fns/binary/compare/primitive.rs renamed to vortex-array/src/scalar_fn/fns/binary/compare/primitive/mod.rs

@@ -1,7 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Native comparison of primitive arrays via bit-packing lane kernels.
+//! Native comparison of primitive arrays with Vortex's scalar ordering semantics.
+//!
+//! The outer comparison path owns decoding, validity, and the portable bit-packing fallback.
+//! On x86-64, [`simd`] can replace the value loop with explicit AVX2 or AVX-512 kernels.
+
+mod simd;
 
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexResult;
@@ -41,7 +46,7 @@ pub(super) fn compare_primitive(
     })
 }
 
-fn compare_primitive_typed<T: NativePType>(
+fn compare_primitive_typed<T: NativePType + simd::SimdCompare>(
     lhs: &ArrayRef,
     rhs: &ArrayRef,
     op: CompareOperator,
@@ -105,7 +110,15 @@ fn apply_op<T: NativePType>(lhs: T, rhs: T, op: CompareOperator) -> bool {
     }
 }
 
-fn compare_slices<T: NativePType>(lhs: &[T], rhs: &[T], op: CompareOperator) -> BitBuffer {
+fn compare_slices<T: NativePType + simd::SimdCompare>(
+    lhs: &[T],
+    rhs: &[T],
+    op: CompareOperator,
+) -> BitBuffer {
+    if let Some(bits) = simd::try_compare_slices(lhs, rhs, op) {
+        return bits;
+    }
+
     // Dispatch the operator outside the lane loop so each instantiation vectorizes a single
     // branch-free predicate.
     match op {
@@ -118,7 +131,15 @@ fn compare_slices<T: NativePType>(lhs: &[T], rhs: &[T], op: CompareOperator) ->
     }
 }
 
-fn compare_slice_constant<T: NativePType>(lhs: &[T], rhs: T, op: CompareOperator) -> BitBuffer {
+fn compare_slice_constant<T: NativePType + simd::SimdCompare>(
+    lhs: &[T],
+    rhs: T,
+    op: CompareOperator,
+) -> BitBuffer {
+    if let Some(bits) = simd::try_compare_slice_constant(lhs, rhs, op) {
+        return bits;
+    }
+
     match op {
         CompareOperator::Eq => collect_bits(lhs, |a: T| a.is_eq(rhs)),
         CompareOperator::NotEq => collect_bits(lhs, |a: T| !a.is_eq(rhs)),
@@ -128,3 +149,6 @@ fn compare_slice_constant<T: NativePType>(lhs: &[T], rhs: T, op: CompareOperator
         CompareOperator::Lte => collect_bits(lhs, |a: T| a.is_le(rhs)),
     }
 }
+
+#[cfg(test)]
+mod tests;