Repository navigation
Compare primitive values through the shared RowFn executor - #10676
Draft
connortsui20 wants to merge 2 commits into
Draft
connortsui20 wants to merge 2 commits into
connortsui20 wants to merge 2 commits into
Conversation
Merging this PR will degrade performance by 3.85%4 warnings
Warning Please fix the performance issues or acknowledge them on CodSpeed. Performance Changes
Tip Investigate this regression by commenting Comparing 
Footnotes
|
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 22, 2026 14:09
dee1a57 to
3a38935
Compare
connortsui20
changed the base branch from
ct/row-fn-cleanup/fused-execution
to
ct/row-fn-cleanup/batch-inputs
October 22, 2026 14:10
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 22, 2026 14:49
3a38935 to
33ccf9b
Compare
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 22, 2026 15:13
33ccf9b to
b837021
Compare
connortsui20
changed the base branch from
ct/row-fn-cleanup/batch-inputs
to
ct/row-fn-cleanup/fused-execution
October 22, 2026 15:13
Member
Author
|
Edit: reopened as a draft. The controlled measurements showed substantial AVX2 gains as well as ARM and AVX-512 regressions. Those results justify holding the PR for further work, but do not establish that the migration has no benefit. The earlier closure treated those two conclusions as equivalent. #10741 isolates a useful float32 packing policy, and #10742 explores a smaller validity change. Neither replaces every benefit observed in the migration. Both remain independent drafts with their own measurement limits. #10675 and this PR are being rebased while preserving their dependency. The saved measurements are historical evidence, not validation of the rebased heads. |
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 23, 2026 17:53
b837021 to
3583fc2
Compare
robert3005
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 26, 2026 00:51
3583fc2 to
237dfc0
Compare
connortsui20
added a commit
that referenced
this pull request
Oct 26, 2026
## Summary - Tracking Issue: #9128 - Independent validity candidate: #10742 Routes float32 comparisons through the existing word-packing collectors. This recovers the measured float32 gains from the RowFn comparison investigation with two private dispatch changes. It is independent of the comparison migration and fusion work in #10676 and #10675. ## Changes Adds `F32` to the existing collector selections for array pairs and array/constant comparisons. Integer collector policies remain unchanged. The floating-point documentation now accounts for NaN signs and payloads. **Draft pending fresh isolated benchmarks on this head.** Saved measurements show a consistent float32 gain, but also some unrelated ARM regressions. The later combined packing/validity candidate had an AVX2 regression that has not been attributed to either change individually. <details> <summary>Saved benchmark evidence and validation</summary> The isolated packing snapshot `4c98df49e379853f8e990d9764791b5330511771` was compared with frozen `develop` at `a1693389301e446eec41373cb274d98a303d3ca0`. Measurements used Rust 1.99.1 / LLVM 23.1.1, 16 CGUs, no LTO, CPU 2, and 21 balanced paired blocks on Graviton3 C7g and Sapphire Rapids C7i. This was native wall time, not CodSpeed simulation. Across 48 float32 cases at 8,192 and 65,536 rows, covering array pairs, both constant orientations, equality/ordering, and four validity shapes, the median block ratios of equally weighted geometric means were: | Target | Candidate / baseline time | 95% paired bootstrap interval | | --- | ---: | ---: | | NEON | 0.611 | 0.610–0.611 | | AVX2 | 0.632 | 0.630–0.633 | | AVX-512 | 0.679 | 0.678–0.681 | Among all 375 probe cases, the isolated snapshot had no flagged regressions on AVX2 or AVX-512. ARM had four, including roughly 4.7% slower u64 multiply and 4.6% slower large f64 equality. Those paths do not use the changed float32 collector, so their movement is not evidence of extra float32 work, but it still counts against a no-regression claim. A separate combined packing/validity candidate at `8d8ef8151454bbc73e1cd0b236567542a1401cbe`, based on `d834a11faa79370b4d2e0bbcc73195f451a8a212`, retained the float32 gain but regressed large nullable u64 add by about 18% on AVX2. Profiling found a byte-identical retry hot loop with essentially unchanged instructions per operation and more cycles. The precise placement-sensitive mechanism remains unresolved. That combined result does not isolate this PR. The combined candidate passed 225 RowFn tests and 232 binary-function tests on that newer base. Separate native probes checked scalar-reference results and float/encoding/tail edge cases. The changed file passed the pinned formatter. These are saved checks, not fresh validation of this individual PR. This PR is rebased onto `c750fbd80882f78efd6a2703bc0f3e17f1aca9f9`. The patch is unchanged by the rebase. Tests and benchmarks were not rerun after it. </details> Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
2 times, most recently
from
October 26, 2026 20:53
1af8625 to
e843b51
Compare
connortsui20
added
the
action/bench-sql
github-actions
Bot
removed
the
action/bench-sql
Contributor
Polar Signals Profiling ResultsLatest Run
Powered by Polar Signals Cloud |
Contributor
Benchmarks: PolarSignals Profiling 📖Commits: PR datafusion / vortex-file-compressed / ns (1.001x ➖, 0↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: FineWeb NVMe 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (0.987x ➖, 1↑ 1↓)
datafusion / parquet / ns (1.005x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.035x ➖, 0↑ 1↓)
duckdb / parquet / ns (1.001x ➖, 0↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: TPC-H SF=1 on NVME 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (1.002x ➖, 0↑ 0↓)
datafusion / parquet / ns (1.000x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.004x ➖, 0↑ 0↓)
duckdb / parquet / ns (1.000x ➖, 0↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: TPC-H SF=10 on NVME 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (0.991x ➖, 0↑ 0↓)
datafusion / parquet / ns (0.999x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.005x ➖, 0↑ 0↓)
duckdb / parquet / ns (1.004x ➖, 0↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: TPC-DS SF=1 on NVME 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (0.997x ➖, 0↑ 0↓)
datafusion / parquet / ns (1.001x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.005x ➖, 0↑ 0↓)
duckdb / parquet / ns (1.004x ➖, 1↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: Clickbench on NVME 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (0.995x ➖, 0↑ 0↓)
datafusion / parquet / ns (0.994x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.001x ➖, 0↑ 1↓)
duckdb / parquet / ns (0.993x ➖, 1↑ 0↓)
No file size changes detected. |
Contributor
Benchmarks: TPC-H SF=1 on S3 📖Commits: PR How to read Verdict and Engines
datafusion / vortex-file-compressed / ns (1.006x ➖, 1↑ 2↓)
datafusion / parquet / ns (0.977x ➖, 0↑ 0↓)
duckdb / vortex-file-compressed / ns (1.025x ➖, 0↑ 2↓)
duckdb / parquet / ns (1.110x ➖, 0↑ 3↓)
|
connortsui20
added a commit
that referenced
this pull request
Oct 27, 2026
Related to #10676. This PR is independent of the RowFn stack. Uses the existing fill-and-pack collector for `i64`, `u64`, and `f64` array-pair comparisons on AArch64 with NEON. The dispatch and the unchecked slice reads stay inside the private primitive kernel, where equal lengths and the collector's index range establish the bounds proof. Constant comparisons, other primitive types, and validity handling retain their existing paths. Extends bitmap-boundary tests to wide types with differently sliced inputs, and checks floating-point total ordering through full words and a tail. Validation: 236 comparison tests and all-target, all-feature Clippy with warnings denied pass on macOS ARM. Native ARM and AVX2 builds pass the 455-case probe (452 reference-array checks plus three unchanged Boolean controls) and 3,456 comparison edge checks plus four arithmetic error checks. On Graviton3, the two counterbalanced full-suite sessions show the following elapsed-time reductions in the long array-pair cohorts: | Type | First session | Confirmation | Confirmation ratio and paired 95% interval | | --- | --- | --- | --- | | `i64` | 15.6% | 15.4% | `0.846 [0.843, 0.856]` | | `u64` | 14.1% | 14.0% | `0.860 [0.858, 0.864]` | | `f64` | 11.8% | 11.8% | `0.882 [0.880, 0.886]` | Each cohort contains 32 cases. Ratios are candidate/baseline, with a geometric mean across cases within a paired block and the median across 21 blocks. Intervals bootstrap those paired block ratios. Neither ARM session has a case crossing the 3% regression threshold with its interval above 1. The AVX2 baseline and candidate `.text` sections are byte-for-byte identical. Control timings still vary, so no x86 speedup is attributed to this change. These are public-path microbenchmarks, not query results. Release-profile and AVX-512 timing were not repeated for this ARM-only variant. <details> <summary>Measurement protocol and reproduction</summary> Baseline: `a59294e35e7109fac894a7a38a68f42db0c3c967`. Candidate: `f018aaeef739145e1bc50079a441c5d9fd53404a`. Uses rustc 1.99.1 (LLVM 23.1.1), the repository's bench profile (16 codegen units, no LTO), MiMalloc, and CPU 2. Graviton3 uses `-C target-feature=+neon -C force-frame-pointers=yes`. The AVX2 control uses `-C target-feature=+avx2 -C force-frame-pointers=yes` on AMD EPYC 7R13. Optimized LLVM IR and assembly were emitted during both builds, and the resulting executables were timed without instrumentation. Both labels run the same full 455-case suite in the same order. Each case has exactly 1,000 single-iteration samples. Each session has 21 baseline/baseline calibration blocks and 21 paired baseline/candidate blocks with alternating executable order. Separate arithmetic control binaries bracket the blocks. The two hosts are measured serially, and a second session confirms the result. The confirmation session reverses the starting order, so the combined sessions contain equal AB and BA counts. Preliminary fixed-order source comparisons were excluded, while valid identical-binary calibration was retained. The long-array cohorts each contain 32 cases, including partially valid inputs and lengths around the 16K boundary. To reproduce, save the harness below as `vortex-array/benches/interaction_probe.rs` on each revision and add this target to `vortex-array/Cargo.toml`: ```toml [[bench]] name = "interaction_probe" harness = false ``` Set `RUSTFLAGS` to the host flags above. Build both revisions with those same flags, retain separate immutable executables, and alternate the commands below. Unset `VORTEX_PERF_CHECK` for timing. ```sh cargo +1.99.1 build --locked -p vortex-array --bench interaction_probe --profile bench VORTEX_PERF_CHECK=1 "$binary" --test --color never taskset -c 2 "$binary" --bench --color never --timer os --sample-count 1000 --sample-size 1 --skip-ext-time true ``` </details> <details> <summary>Exact benchmark harness</summary> The measured harness SHA-256 is `0a7de7999381d237ad0471716107f7e1972a7c6b11c0936a7d3b7d8c15b6c37d`. ```rust // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors //! Common public-path inputs for the RowFn interaction experiments. #![expect(clippy::unwrap_used)] #![expect(clippy::cast_possible_truncation)] #![expect(clippy::cast_precision_loss)] use std::fmt; use divan::Bencher; use mimalloc::MiMalloc; use vortex_array::{ArrayRef, Canonical, IntoArray, VortexSessionExecute}; use vortex_array::arrays::{BoolArray, ConstantArray, PrimitiveArray}; use vortex_array::builtins::ArrayBuiltins; use vortex_array::dtype::NativePType; use vortex_array::scalar::Scalar; use vortex_array::scalar_fn::fns::operators::Operator; use vortex_array::validity::Validity; use vortex_buffer::Buffer; #[global_allocator] static GLOBAL: MiMalloc = MiMalloc; fn main() { if check_enabled() { eprintln!("detected SIMD level: {:?}", fearless_simd::Level::new()); } divan::main(); } #[derive(Clone, Copy, Debug)] enum Shape { Arrays, LeftConstant, RightConstant } #[derive(Clone, Copy, Debug)] enum InputValidity { Dense, AllValid, Nullable, Sparse } #[derive(Clone, Copy, Debug)] enum Comparison { Eq, Gte } #[derive(Clone, Copy)] struct Case { rows: usize, shape: Shape, validity: InputValidity, op: Comparison } impl fmt::Display for Case { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "rows={},shape={:?},validity={:?},op={:?}", self.rows, self.shape, self.validity, self.op) } } const CASES: &[Case] = &[ Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 64, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 64, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 64, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 8192, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::LeftConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Dense, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::AllValid, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 65536, shape: Shape::RightConstant, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 16383, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 16383, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 16383, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 16383, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 16384, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 16384, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 16384, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 16384, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 16385, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 16385, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 16385, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 16385, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, Case { rows: 32768, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Eq }, Case { rows: 32768, shape: Shape::Arrays, validity: InputValidity::Nullable, op: Comparison::Gte }, Case { rows: 32768, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Eq }, Case { rows: 32768, shape: Shape::Arrays, validity: InputValidity::Sparse, op: Comparison::Gte }, ]; trait Input: NativePType + Into<Scalar> { fn value(index: usize, offset: usize) -> Self; } macro_rules! input { ($($ty:ty),*) => {$( impl Input for $ty { fn value(index: usize, offset: usize) -> Self { ((index * 17 + offset * 31) % 251) as Self } } )*}; } input!(u8, i64, u64, f32, f64); fn validity(kind: InputValidity, rows: usize, offset: usize) -> Validity { match kind { InputValidity::Dense => Validity::NonNullable, InputValidity::AllValid => Validity::AllValid, InputValidity::Nullable => Validity::from_iter((0..rows).map(|i| (i + offset) % 10 != 0)), InputValidity::Sparse => Validity::from_iter((0..rows).map(|i| i % 10 == 0)), } } fn array<T: Input>(case: Case, offset: usize) -> ArrayRef { PrimitiveArray::new((0..case.rows).map(|i| T::value(i,offset)).collect::<Buffer<_>>(), validity(case.validity,case.rows,offset)).into_array() } fn operands<T: Input>(case: Case) -> (ArrayRef, ArrayRef) { let lhs=match case.shape { Shape::LeftConstant => ConstantArray::new(T::value(13,0),case.rows).into_array(), _ => array::<T>(case,0) }; let rhs=match case.shape { Shape::RightConstant => ConstantArray::new(T::value(13,0),case.rows).into_array(), _ => array::<T>(case,1) }; (lhs,rhs) } fn scalar_inputs<T: Input>(case: Case, index: usize) -> (T,T) { let lhs=match case.shape { Shape::LeftConstant => T::value(13,0), _ => T::value(index,0) }; let rhs=match case.shape { Shape::RightConstant => T::value(13,0), _ => T::value(index,1) }; (lhs,rhs) } fn check_enabled() -> bool { std::env::var_os("VORTEX_PERF_CHECK").is_some() } fn measure(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef, op: Operator) { let session=vortex_session::VortexSession::empty(); bencher.with_inputs(|| (&lhs,&rhs,session.create_execution_ctx())).bench_refs(|(lhs,rhs,ctx)| { lhs.clone().binary(rhs.clone(),op).unwrap().execute::<Canonical>(ctx).unwrap() }); } #[divan::bench(args=CASES, types=[u8,i64,u64,f32,f64])] fn compare<T: Input>(bencher: Bencher, case: &Case) { let case=*case; let (lhs,rhs)=operands::<T>(case); let op=match case.op { Comparison::Eq => Operator::Eq, Comparison::Gte => Operator::Gte }; if check_enabled() { let session=vortex_session::VortexSession::empty(); let mut ctx=session.create_execution_ctx(); let actual=lhs.clone().binary(rhs.clone(),op).unwrap().execute::<Canonical>(&mut ctx).unwrap().into_array(); let expected_values=(0..case.rows).map(|i| { let(a,b)=scalar_inputs::<T>(case,i); match case.op {Comparison::Eq=>a.is_eq(b),Comparison::Gte=>a.is_ge(b)} }).collect(); let expected=BoolArray::new(expected_values,lhs.validity().unwrap().and(rhs.validity().unwrap()).unwrap()).into_array(); vortex_array::assert_arrays_eq!(&actual,&expected,&mut ctx); } measure(bencher,lhs,rhs,op); } trait Arithmetic: Input { fn multiply(self, other: Self) -> Self; fn add(self, other: Self) -> Self; } impl Arithmetic for i64 { fn multiply(self, other: Self)->Self{self*other} fn add(self,other:Self)->Self{self+other} } impl Arithmetic for u64 { fn multiply(self, other: Self)->Self{self*other} fn add(self,other:Self)->Self{self+other} } #[divan::bench(args=[64,8192,32768], types=[i64,u64])] fn multiply<T: Arithmetic>(bencher: Bencher, rows: usize) { let case=Case{rows,shape:Shape::Arrays,validity:InputValidity::Dense,op:Comparison::Eq}; let(lhs,rhs)=operands::<T>(case); if check_enabled(){ let session=vortex_session::VortexSession::empty();let mut ctx=session.create_execution_ctx(); let actual=lhs.clone().binary(rhs.clone(),Operator::Mul).unwrap().execute::<Canonical>(&mut ctx).unwrap().into_array(); let expected=PrimitiveArray::new((0..rows).map(|i|{let(a,b)=scalar_inputs::<T>(case,i);a.multiply(b)}).collect::<Buffer<_>>(),Validity::NonNullable).into_array(); vortex_array::assert_arrays_eq!(&actual,&expected,&mut ctx); } measure(bencher,lhs,rhs,Operator::Mul); } #[divan::bench(args=[64,8192,32768], types=[i64,u64])] fn add_nullable<T: Arithmetic>(bencher: Bencher, rows: usize) { let case=Case{rows,shape:Shape::RightConstant,validity:InputValidity::Nullable,op:Comparison::Eq}; let(lhs,rhs)=operands::<T>(case); if check_enabled(){ let session=vortex_session::VortexSession::empty();let mut ctx=session.create_execution_ctx(); let actual=lhs.clone().binary(rhs.clone(),Operator::Add).unwrap().execute::<Canonical>(&mut ctx).unwrap().into_array(); let expected=PrimitiveArray::new((0..rows).map(|i|{let(a,b)=scalar_inputs::<T>(case,i);Arithmetic::add(a,b)}).collect::<Buffer<_>>(),lhs.validity().unwrap()).into_array(); vortex_array::assert_arrays_eq!(&actual,&expected,&mut ctx); } measure(bencher,lhs,rhs,Operator::Add); } #[divan::bench(args=[64,8192,65536])] fn bool_control(bencher: Bencher, rows: usize) { let lhs=BoolArray::from_iter((0..rows).map(|i|i%3==0)).into_array(); let rhs=BoolArray::from_iter((0..rows).map(|i|i%5==0)).into_array(); measure(bencher,lhs,rhs,Operator::Eq); } ``` </details> Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
2 times, most recently
from
October 27, 2026 15:05
45aacd1 to
8579ee2
Compare
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
2 times, most recently
from
October 27, 2026 18:56
4277040 to
3fc76fb
Compare
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 27, 2026 19:40
3fc76fb to
369e825
Compare
Keep the comparison type and operator dispatch, constant orientation, borrowed operand dtypes, and comparison coverage in this layer. Shared decoding, validity planning, and packed output belong to the framework below. The required input classification runs before decoding, and this layer adds no one-pass decoder hook or eager validity conjunction. Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
total_cmp sorts a NaN with the sign bit set below -inf, so NaN is not always the largest value. Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
connortsui20
force-pushed
the
ct/row-fn-cleanup/primitive-compare
branch
from
October 27, 2026 21:19
369e825 to
0bd1d53
Compare
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Tracking Issue: #9128
Summary
Moves primitive comparisons onto the shared RowFn executor from #10675, so comparison code only selects the predicate while the framework handles decoding, constants, validity, and Boolean output.
Changes
Preserves the public
Binaryidentity and floating-point total ordering. Uses borrowed operands and dtypes, and moves a constant left operand to the right with the swapped operator. Adds coverage for all six swapped operators across a bitmap boundary and keeps the existing comparison benchmarks.Based on #10675, rebased onto
developata5f574e69bbf9010029f0e62ca59d56cd0c4aa6e. Keeps the wide-type, sliced-input, bitmap-boundary, NaN, and signed-zero tests added upstream in #10843.Performance
Still draft. Earlier EC2 runs showed gains on some configurations and regressions on others. They measured an earlier accumulated stack, not this layer in isolation or the current head.
The baseline now includes #10843's private NEON packing optimization. This migration replaces that private kernel with RowFn execution, so its performance must be compared with the improved baseline. The old packing gains cannot be credited to this PR.
Historical EC2 accumulated-stack measurements
Ratios are the median of 21 paired candidate/baseline elapsed-time ratios. Below 1 is faster. This compares the earlier complete migration, M0
ddf8a16df6b7d7c20cfd860e5f23438d97ca4238, with D0291778db36809f77ce0219bf9850506d3cba3b6. That baseline predates #10843. The array-pair cases use all-valid nullable inputs. The addition case is an arithmetic control whose algorithm was unchanged.f32array-pair Gte, 8,192 rowsi64array-pair Gte, 8,192 rowsi64add, 32,768 rowsFor example, the old stack took about 10% less time for the ARM
i64comparison, but about 14% more for the same case on AVX2-only C6a. C6a nullablei64addition took about 12% more time. These whole-executable measurements do not establish that the comparison algorithm caused movement in arithmetic controls.In the four-label matrix, D ran before M0 in 11 blocks and after it in ten. The experimental one-pass decoder variants are excluded from this table.
EC2 C7g (Neoverse V1), C6a (EPYC 7R13), and C7i (Xeon Platinum 8488C). Rust 1.99.1 / LLVM 23.1.1, bench profile with 16 CGUs and no LTO, MiMalloc, CPU 2 pinned. The same 455-case public-path microbenchmark suite ran serially across hosts, with 21 paired blocks, 10 ms per case, A/A calibration, and a separate control executable. These are microbenchmarks, not query results. C7i can dispatch to AVX-512 at runtime even in its AVX2 build.
Saved evidence is in the local investigation archive
row-fn-evaluation-20261026:manifest.json,*-matrix-*-medians.csv,*-matrix-*-summary.json, andresults/<host>/results/matrix-*.json.Confirmed independent packing gains, now in develop via #10843
The ARM-only private-kernel change reduced long array-pair cohort time on Graviton3 as follows. Each cohort contains 32 cases, including partially valid inputs and lengths around 16K.
i64u64f64Baseline
a59294e35e7109fac894a7a38a68f42db0c3c967, candidatef018aaeef739145e1bc50079a441c5d9fd53404a. The cohort uses a geometric mean of case ratios within each block, then the median across blocks. Two 21-block sessions used complementary AB/BA orders, the same full 455-case suite, and 1,000 single-iteration samples per case. The initial fixed-order source comparisons were discarded. The AVX2 builds had identical.textbytes, so no x86 speedup was attributed to this change. See #10843 for the harness and full methodology.These gains required neither this PR nor #10675.
Prior validation at
e843b51408: 963 accumulated scalar-function tests and all-target, all-feature Clippy with warnings denied passed. This rebase was reviewed from source, including the kernel conflict and upstream test coverage. Tests, builds, and benchmarks have not been rerun on the rebased head.