Execute primitive comparisons with RowFn

[connortsui20]

Rationale for this change

Moves primitive comparisons to RowFn where native measurements support it. The faster fused x86 path remains for selected 64-bit comparisons.

• Progress towards: Epic: Row-oriented scalar functions #9128
• API tracking: Tracking Issue: Define the RowFn API #9129
• Progress towards: Tracking Issue: Execute RowFn over Vortex arrays #9130

What changes are included in this PR?

The columnar path handles equality for i64, u64, and f64, all i64 and f64 operators, and mixed-constant u64 operators. Tests force both paths over identical values, validity, NaN, signed zero, and constant positions. Their encoding difference is intentional: columnar execution materializes a BoolArray, while row execution keeps a lazy mask chain.

With Rust 1.97.1 and LLVM 22.1.6, optimized IR and assembly confirm that mixed-constant primitive comparisons vectorize under the 16-CGU, no-LTO benchmark profile. The earlier 8.3–8.5x mixed-constant regressions were measured before the output-iterator fix in #9353 and no longer describe this branch. The fused comparison and bit-packing path remains about 38% faster for compare_u64_constant.

What APIs are changed? Are there any user-facing changes?

There are no public API changes. The path selector and forced-path controls remain internal.

[codspeed-hq]

Merging this PR will degrade performance by 13.54%

⚠️ Unknown Walltime execution environment detected

Using the Walltime instrument on standard Hosted Runners will lead to inconsistent data.

For the most accurate results, we recommend using CodSpeed Macro Runners: bare-metal machines fine-tuned for performance measurement consistency.

⚡ 6 improved benchmarks
❌ 43 regressed benchmarks
✅ 1976 untouched benchmarks
🆕 11 new benchmarks
⏩ 89 skipped benchmarks¹

Warning

Please fix the performance issues or acknowledge them on CodSpeed.

Performance Changes

	Mode	Benchmark	BASE	HEAD	Efficiency
❌	Simulation	case_when_nary_10_conditions[1000]	402.8 µs	607.6 µs	-33.71%
❌	Simulation	case_when_nary_equality_lookup[1000]	306.5 µs	422.3 µs	-27.42%
❌	Simulation	baseline_lt[4, 1024]	96.9 µs	130.1 µs	-25.5%
❌	Simulation	case_when_nary_early_dominant[1000]	222.8 µs	296.2 µs	-24.77%
❌	Simulation	case_when_nary_10_conditions[10000]	742.1 µs	984.9 µs	-24.65%
❌	Simulation	baseline_eq[4, 1024]	96.3 µs	126.3 µs	-23.75%
❌	Simulation	case_when_nary_3_conditions[1000]	225.8 µs	295.5 µs	-23.58%
❌	Simulation	baseline_eq[16, 1024]	98 µs	127.8 µs	-23.32%
❌	Simulation	baseline_lt[16, 1024]	98.1 µs	127.3 µs	-22.93%
❌	Simulation	decompress[u64, (10000, 4)]	309 µs	400 µs	-22.74%
❌	Simulation	case_when_all_false[1000]	120 µs	151.6 µs	-20.85%
❌	Simulation	case_when_nary_equality_lookup[10000]	513.7 µs	647.8 µs	-20.7%
❌	Simulation	case_when_all_true[1000]	124 µs	156.4 µs	-20.69%
❌	Simulation	bench_compare_sliced_dict_primitive[(1000, 10000)]	127.7 µs	159.5 µs	-19.97%
❌	Simulation	bench_compare_sliced_dict_primitive[(2000, 10000)]	141.4 µs	174.8 µs	-19.15%
❌	Simulation	bench_compare_sliced_dict_primitive[(2500, 10000)]	148 µs	182.9 µs	-19.09%
❌	Simulation	bench_compare_sliced_dict_primitive[(3333, 10000)]	161.9 µs	196.6 µs	-17.65%
❌	Simulation	case_when_nary_early_dominant[10000]	382.2 µs	463.2 µs	-17.48%
❌	Simulation	case_when_nary_3_conditions[10000]	384.1 µs	465.2 µs	-17.44%
❌	Simulation	case_when_without_else[1000]	161.1 µs	194.6 µs	-17.21%
...	...	...	...	...	...

ℹ️ Only the first 20 benchmarks are displayed. Go to the app to view all benchmarks.

Tip

Investigate this regression by commenting @codspeedbot fix this regression on this PR, or directly use the CodSpeed MCP with your agent.

---

_{Comparing ct/row-fn-primitive-comparisons (a7ac7b1) with ct/row-fn-numeric-operators (d0f1b2d)}

Footnotes

1. 89 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[connortsui20]

Here are the local primitive-comparison benchmark results from the final Rust 1.97.1 run.

The comparison used a develop baseline with benchmark-only backfills (1edd0fca) and the full RowFn stack (8ca9fc73). Later stack layers do not change primitive comparison source, but unrelated code-placement effects can still affect these binaries.

The machine was an AMD Ryzen 9 7950X running Linux. The build used rustc 1.97.1, LLVM 22.1.6, one CGU, fat LTO, and -C target-cpu=native. Each target used two warm runs and seven alternating measured pairs. Each process used 100 samples with a 0.25–0.5 second measurement window on CPU 4.

Negative changes are faster. The values are medians across the seven paired runs.

The per-row u8 and f32 cases improve by 23.52% and 15.85%. The per-row i32, f32 equality, and u64 cases regress by 21.92–25.88%. LLVM 22 emits scalar loops for the mixed-constant i32 and u8 RowFn paths, which makes those cases 8.32–8.53x slower.

All primitive-comparison results: 25 cases

Benchmark	Baseline	RowFn stack	Change
compare_u8_constant	3.689 µs	31.480 µs	+752.81%
compare_i32_constant	3.779 µs	31.460 µs	+731.88%
compare_f32_eq	4.559 µs	5.729 µs	+25.88%
compare_i32	4.549 µs	5.709 µs	+25.34%
compare_u64	9.509 µs	11.680 µs	+21.92%
compare_struct_eq	179.400 µs	193.800 µs	+8.06%
compare_string_eq	31.750 µs	32.260 µs	+1.64%
compare_int_eq	9.329 µs	9.449 µs	+1.39%
compare_u64_constant	4.919 µs	4.919 µs	+1.38%
compare_float_eq	9.459 µs	9.539 µs	+1.28%
compare_int_constant	4.949 µs	4.939 µs	+1.07%
compare_string_constant	31.460 µs	31.660 µs	+0.79%
compare_int_nullable	9.779 µs	9.799 µs	+0.72%
compare_u64_eq	9.459 µs	9.529 µs	+0.42%
compare_struct_lt	179.200 µs	179.500 µs	+0.11%
compare_int	9.649 µs	9.599 µs	+0.11%
compare_decimal	41.610 µs	41.590 µs	-0.10%
compare_float	11.510 µs	11.370 µs	-0.26%
compare_string_lt	33.550 µs	33.410 µs	-0.42%
compare_bool_nullable	1.619 µs	1.599 µs	-0.62%
compare_bool_constant	719.7 ns	709.7 ns	-1.39%
compare_bool	1.429 µs	1.419 µs	-1.39%
compare_int_constant_lhs	5.059 µs	4.879 µs	-2.49%
compare_f32	6.949 µs	5.849 µs	-15.85%
compare_u8	3.859 µs	2.949 µs	-23.52%