chore: trim micro-bench input sizes (#6890)

Signed-off-by: Alexander Droste <alexander.droste@protonmail.com>

Author: 0ax1

encodings/fastlanes/benches/bitpacking_take.rs

@@ -28,10 +28,10 @@ fn main() {
 
 #[divan::bench]
 fn take_10_stratified(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 10_000));
+    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_553));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
@@ -46,7 +46,7 @@ fn take_10_stratified(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10_contiguous(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
     let indices = buffer![0..10].into_array();
@@ -64,7 +64,7 @@ fn take_10_contiguous(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10k_random(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let range = Uniform::new(0, values.len()).unwrap();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
@@ -85,7 +85,7 @@ fn take_10k_random(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10k_contiguous(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
     let indices = PrimitiveArray::from_iter(0..10_000);
@@ -102,11 +102,11 @@ fn take_10k_contiguous(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn take_200k_dispersed(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+fn take_10k_dispersed(bencher: Bencher) {
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| (i * 42) % values.len() as u64));
+    let indices = PrimitiveArray::from_iter((0..10_000).map(|i| (i * 42) % values.len() as u64));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
@@ -120,11 +120,11 @@ fn take_200k_dispersed(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn take_200k_first_chunk_only(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+fn take_10k_first_chunk_only(bencher: Bencher) {
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| ((i * 42) % 1024) as u64));
+    let indices = PrimitiveArray::from_iter((0..10_000).map(|i| ((i * 42) % 1024) as u64));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
@@ -154,8 +154,8 @@ fn fixture(len: usize, bits: usize) -> Buffer<u32> {
 // I've iterated on both thresholds (1) and (2) using this collection of benchmarks, and those
 // were roughly the best values that I found.
 
-const BIG_BASE2: u32 = 1048576;
-const NUM_EXCEPTIONS: u32 = 10000;
+const BIG_BASE2: u32 = 65536;
+const NUM_EXCEPTIONS: u32 = 1024;
 
 #[divan::bench]
 fn patched_take_10_stratified(bencher: Bencher) {
@@ -169,7 +169,7 @@ fn patched_take_10_stratified(bencher: Bencher) {
         NUM_EXCEPTIONS as usize
     );
 
-    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 10_000));
+    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_653));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
@@ -273,11 +273,11 @@ fn patched_take_10k_contiguous_patches(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn patched_take_200k_dispersed(bencher: Bencher) {
+fn patched_take_10k_dispersed(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| (i * 42) % values.len() as u64));
+    let indices = PrimitiveArray::from_iter((0..10_000).map(|i| (i * 42) % values.len() as u64));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
@@ -291,11 +291,11 @@ fn patched_take_200k_dispersed(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn patched_take_200k_first_chunk_only(bencher: Bencher) {
+fn patched_take_10k_first_chunk_only(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| ((i * 42) % 1024) as u64));
+    let indices = PrimitiveArray::from_iter((0..10_000).map(|i| ((i * 42) % 1024) as u64));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))

encodings/runend/benches/run_end_compress.rs

@@ -36,12 +36,6 @@ const BENCH_ARGS: &[(usize, usize)] = &[
     (100_000, 256),
     (100_000, 1024),
     (100_000, 4096),
-    (1_000_000, 4),
-    (1_000_000, 16),
-    (1_000_000, 256),
-    (1_000_000, 1024),
-    (1_000_000, 4096),
-    (1_000_000, 8192),
 ];
 
 #[divan::bench(args = BENCH_ARGS)]

vortex-array/benches/compare.rs

@@ -21,7 +21,7 @@ fn main() {
     divan::main();
 }
 
-const ARRAY_SIZE: usize = 10_000_000;
+const ARRAY_SIZE: usize = 65_536;
 
 #[divan::bench]
 fn compare_bool(bencher: Bencher) {

vortex-array/benches/search_sorted.rs

@@ -33,8 +33,8 @@ fn binary_search_vortex(bencher: Bencher) {
 
 fn fixture() -> (Vec<i32>, i32) {
     let mut rng = StdRng::seed_from_u64(0);
-    let range = Uniform::new(0, 1_000_000).unwrap();
-    let mut data: Vec<i32> = (0..1_000_000).map(|_| rng.sample(range)).collect();
+    let range = Uniform::new(0, 65_536).unwrap();
+    let mut data: Vec<i32> = (0..65_536).map(|_| rng.sample(range)).collect();
     data.sort();
 
     (data, rng.sample(range))

vortex-array/benches/take_fsl.rs

@@ -28,7 +28,7 @@ fn main() {
 }
 
 /// Number of lists in the source array.
-const NUM_LISTS: usize = 10_000;
+const NUM_LISTS: usize = 500;
 
 /// Number of indices to take.
 const NUM_INDICES: &[usize] = &[100, 1_000];

vortex-btrblocks/benches/compress.rs

@@ -21,11 +21,11 @@ mod benchmarks {
 
     fn make_clickbench_window_name() -> ArrayRef {
         // A test that's meant to mirror the WindowName column from ClickBench.
-        let mut values = buffer_mut![-1i32; 1_000_000];
+        let mut values = buffer_mut![-1i32; 65_536];
         let mut visited = HashSet::new();
         let mut rng = StdRng::seed_from_u64(1u64);
         while visited.len() < 223 {
-            let random = (rng.next_u32() as usize) % 1_000_000;
+            let random = (rng.next_u32() as usize) % 65_536;
             if visited.contains(&random) {
                 continue;
             }

vortex/benches/common_encoding_tree_throughput.rs

@@ -44,7 +44,7 @@ fn main() {
     divan::main();
 }
 
-const NUM_VALUES: u64 = 1_000_000;
+const NUM_VALUES: u64 = 100_000;
 
 // Helper function to conditionally add counter based on codspeed cfg
 fn with_byte_counter<'a, 'b>(bencher: Bencher<'a, 'b>, bytes: u64) -> Bencher<'a, 'b> {

vortex/benches/single_encoding_throughput.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::cast_possible_truncation)]
 #![allow(unexpected_cfgs)]
 
 use divan::Bencher;
@@ -41,7 +42,7 @@ fn main() {
     divan::main();
 }
 
-const NUM_VALUES: u64 = 1_000_000;
+const NUM_VALUES: u64 = 100_000;
 
 // Helper function to conditionally add counter based on codspeed cfg
 fn with_byte_counter<'a, 'b>(bencher: Bencher<'a, 'b>, bytes: u64) -> Bencher<'a, 'b> {
@@ -326,7 +327,8 @@ fn bench_zstd_decompress_u32(bencher: Bencher) {
 // String compression benchmarks
 #[divan::bench(name = "dict_compress_string")]
 fn bench_dict_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let nbytes = varbinview_arr.nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
@@ -336,7 +338,8 @@ fn bench_dict_compress_string(bencher: Bencher) {
 
 #[divan::bench(name = "dict_decompress_string")]
 fn bench_dict_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let dict = dict_encode(&varbinview_arr.clone().into_array()).unwrap();
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
 
@@ -347,7 +350,8 @@ fn bench_dict_decompress_string(bencher: Bencher) {
 
 #[divan::bench(name = "fsst_compress_string")]
 fn bench_fsst_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let fsst_compressor = fsst_train_compressor(&varbinview_arr);
     let nbytes = varbinview_arr.nbytes() as u64;
 
@@ -358,7 +362,8 @@ fn bench_fsst_compress_string(bencher: Bencher) {
 
 #[divan::bench(name = "fsst_decompress_string")]
 fn bench_fsst_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let fsst_compressor = fsst_train_compressor(&varbinview_arr);
     let fsst_array = fsst_compress(&varbinview_arr, &fsst_compressor);
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
@@ -371,7 +376,8 @@ fn bench_fsst_decompress_string(bencher: Bencher) {
 #[cfg(feature = "zstd")]
 #[divan::bench(name = "zstd_compress_string")]
 fn bench_zstd_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let nbytes = varbinview_arr.nbytes() as u64;
     let array = varbinview_arr.into_array();
 
@@ -383,7 +389,8 @@ fn bench_zstd_compress_string(bencher: Bencher) {
 #[cfg(feature = "zstd")]
 #[divan::bench(name = "zstd_decompress_string")]
 fn bench_zstd_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let compressed = ZstdArray::from_array(varbinview_arr.clone().into_array(), 3, 8192).unwrap();
     let nbytes = varbinview_arr.into_array().nbytes() as u64;