Remove more scalar_at from sparse arrays (#7439)

| Benchmark case | Before (mean) | After (mean) | Speedup |
|---|---:|---:|---:|
| `extend_from_array_non_zctl_overlapping (1000, 8)` | `1.413 ms` |
`80.71 us` | `17.5x` |
| `extend_from_array_non_zctl_overlapping (1000, 32)` | `2.586 ms` |
`83.67 us` | `30.9x` |
| `extend_from_array_non_zctl_overlapping (10000, 8)` | `9.708 ms` |
`560.3 us` | `17.3x` |
| `extend_from_array_zctl (1000, 8)` | `1.116 ms` | `14.31 us` | `78.0x`
|
| `extend_from_array_zctl (1000, 64)` | `5.511 ms` | `38.68 us` |
`142.5x` |
| `extend_from_array_zctl (10000, 8)` | `11.01 ms` | `108.4 us` |
`101.6x` |

Before = commit `d72bf9b93` (pre-fix), After = commit `c4ad4e2ad` (the
ListViewBuilder scalar-at removal fix).

---------

Signed-off-by: Nicholas Gates <nick@nickgates.com>
Signed-off-by: Robert Kruszewski <github@robertk.io>
Co-authored-by: Robert Kruszewski <github@robertk.io>

Author: gatesn

Cargo.lock

@@ -27,6 +27,11 @@ vortex-mask = { workspace = true }
 vortex-session = { workspace = true }
 
 [dev-dependencies]
+divan = { workspace = true }
 itertools = { workspace = true }
 rstest = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
+
+[[bench]]
+name = "sparse_canonical"
+harness = false

encodings/sparse/Cargo.toml

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::cast_possible_truncation)]
+
+use std::sync::Arc;
+
+use divan::Bencher;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::dtype::Nullability::NonNullable;
+use vortex_array::dtype::PType::I32;
+use vortex_array::scalar::Scalar;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_sparse::Sparse;
+
+fn main() {
+    divan::main();
+}
+
+const LIST_ARGS: &[(usize, usize, usize)] = &[
+    // len, patch_stride, list_size
+    (512, 7, 4),
+    (1_024, 17, 8),
+];
+
+const FIXED_SIZE_LIST_ARGS: &[(usize, usize, u32)] = &[
+    // len, patch_stride, list_size
+    (512, 7, 4),
+    (1_024, 17, 8),
+];
+
+fn make_sparse_list(len: usize, patch_stride: usize, list_size: usize) -> ArrayRef {
+    let patch_indices: Buffer<u32> = (0..len).step_by(patch_stride).map(|i| i as u32).collect();
+    let n_patches = patch_indices.len();
+
+    let patch_elements = PrimitiveArray::from_iter(0..(n_patches * list_size) as i32).into_array();
+    let patch_offsets: Buffer<u32> = (0..n_patches).map(|i| (i * list_size) as u32).collect();
+    let patch_sizes: Buffer<u32> = std::iter::repeat_n(list_size as u32, n_patches).collect();
+    let patch_values = ListViewArray::new(
+        patch_elements,
+        patch_offsets.into_array(),
+        patch_sizes.into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+
+    let fill_value = Scalar::list(
+        Arc::new(I32.into()),
+        (0..list_size as i32).map(Scalar::from).collect(),
+        NonNullable,
+    );
+
+    Sparse::try_new(patch_indices.into_array(), patch_values, len, fill_value)
+        .vortex_expect("sparse list input should be valid")
+        .into_array()
+}
+
+fn make_sparse_fixed_size_list(len: usize, patch_stride: usize, list_size: u32) -> ArrayRef {
+    let patch_indices: Buffer<u32> = (0..len).step_by(patch_stride).map(|i| i as u32).collect();
+    let n_patches = patch_indices.len();
+
+    let patch_elements =
+        PrimitiveArray::from_iter(0..(n_patches * list_size as usize) as i32).into_array();
+    let patch_values =
+        FixedSizeListArray::new(patch_elements, list_size, Validity::NonNullable, n_patches)
+            .into_array();
+
+    let fill_value = Scalar::fixed_size_list(
+        Arc::new(I32.into()),
+        (0..list_size as i32).map(Scalar::from).collect(),
+        NonNullable,
+    );
+
+    Sparse::try_new(patch_indices.into_array(), patch_values, len, fill_value)
+        .vortex_expect("sparse fixed-size-list input should be valid")
+        .into_array()
+}
+
+#[divan::bench(args = LIST_ARGS)]
+fn canonicalize_sparse_list(
+    bencher: Bencher,
+    (len, patch_stride, list_size): (usize, usize, usize),
+) {
+    let sparse = make_sparse_list(len, patch_stride, list_size);
+
+    bencher
+        .with_inputs(|| (sparse.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .bench_values(|(array, mut ctx)| {
+            divan::black_box(
+                array
+                    .execute::<Canonical>(&mut ctx)
+                    .vortex_expect("sparse list canonicalization"),
+            )
+        });
+}
+
+#[divan::bench(args = FIXED_SIZE_LIST_ARGS)]
+fn canonicalize_sparse_fixed_size_list(
+    bencher: Bencher,
+    (len, patch_stride, list_size): (usize, usize, u32),
+) {
+    let sparse = make_sparse_fixed_size_list(len, patch_stride, list_size);
+
+    bencher
+        .with_inputs(|| (sparse.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .bench_values(|(array, mut ctx)| {
+            divan::black_box(
+                array
+                    .execute::<Canonical>(&mut ctx)
+                    .vortex_expect("sparse fixed-size-list canonicalization"),
+            )
+        });
+}