more benches

Author: aneubeck

crates/hash-sorted-map/benchmarks/Cargo.toml

@@ -21,3 +21,4 @@ ahash = "0.8"
 hashbrown = "0.15"
 foldhash = "0.1"
 fnv = "1"
+itertools = "0.14"

crates/hash-sorted-map/benchmarks/performance.rs

@@ -2,7 +2,8 @@ use std::hash::BuildHasher;
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use hash_sorted_map::HashSortedMap;
-use hash_sorted_map_benchmarks::{random_trigram_hashes, IdentityBuildHasher};
+use hash_sorted_map_benchmarks::{folded_multiply, random_trigram_hashes, IdentityBuildHasher};
+use rand::RngExt;
 
 fn trigrams() -> Vec<u32> {
     random_trigram_hashes(1000)
@@ -428,13 +429,162 @@ fn bench_sort(c: &mut Criterion) {
     group.finish();
 }
 
+fn bench_merge_sort(c: &mut Criterion) {
+    const NUM_MAPS: usize = 100;
+    const KEYS_PER_MAP: usize = 100_000;
+
+    // Pre-generate 100 key vectors with random u32 values scrambled via folded_multiply.
+    let maps_data: Vec<Vec<u32>> = (0..NUM_MAPS)
+        .map(|_| {
+            let mut rng = rand::rng();
+            (0..KEYS_PER_MAP)
+                .map(|_| folded_multiply(rng.random_range(0..1_000_000u32) as u64, 0x243f6a8885a308d3) as u32)
+                .collect()
+        })
+        .collect();
+
+    let hasher = IdentityBuildHasher::default();
+    let mut group = c.benchmark_group("merge_100_maps_sorted");
+    group.sample_size(10);
+
+    // ── 1. HashSortedMap: merge all, then sort_by_hash ──────────────
+    group.bench_function("HashSortedMap merge + sort_by_hash", |b| {
+        b.iter(|| {
+            let mut map: HashSortedMap<u32, u32, _> =
+                HashSortedMap::with_hasher(IdentityBuildHasher::default());
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1u32;
+                }
+            }
+            map.sort_by_hash()
+        });
+    });
+
+    // ── 2. K-way merge over pre-sorted vectors ──────────────────────
+    group.bench_function("k-way merge sorted vecs", |b| {
+        use itertools::Itertools;
+
+        b.iter(|| {
+            // Phase 1: build per-map sorted (hash, key, count) vectors.
+            let sorted_vecs: Vec<Vec<(u64, u32, u32)>> = maps_data
+                .iter()
+                .map(|keys| {
+                    let mut counts = std::collections::HashMap::<u32, u32, IdentityBuildHasher>::with_hasher(IdentityBuildHasher::default());
+                    for &key in keys {
+                        *counts.entry(key).or_default() += 1;
+                    }
+                    let mut vec: Vec<(u64, u32, u32)> = counts
+                        .into_iter()
+                        .map(|(k, v)| (hasher.hash_one(k), k, v))
+                        .collect();
+                    vec.sort_unstable_by_key(|&(h, _, _)| h);
+                    vec
+                })
+                .collect();
+
+            // Phase 2: k-merge + group_by to aggregate counts.
+            let result: Vec<(u32, u32)> = sorted_vecs
+                .into_iter()
+                .map(|v| v.into_iter())
+                .kmerge_by(|a, b| a.0 <= b.0)
+                .chunk_by(|&(_, key, _)| key)
+                .into_iter()
+                .map(|(key, group)| (key, group.map(|(_, _, c)| c).sum()))
+                .collect();
+            result
+        });
+    });
+
+    // ── 3. hashbrown HashMap merge, then sort into Vec ──────────────
+    group.bench_function("hashbrown merge + Vec sort", |b| {
+        b.iter(|| {
+            let mut map =
+                hashbrown::HashMap::<u32, u32, IdentityBuildHasher>::with_hasher(IdentityBuildHasher::default());
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1;
+                }
+            }
+            let mut vec: Vec<(u32, u32)> = map.into_iter().collect();
+            vec.sort_unstable_by_key(|&(key, _)| hasher.hash_one(key));
+            vec
+        });
+    });
+
+    // ── 4. hashbrown HashMap merge only (no sort) ───────────────────
+    group.bench_function("hashbrown merge", |b| {
+        b.iter(|| {
+            let mut map =
+                hashbrown::HashMap::<u32, u32, IdentityBuildHasher>::with_hasher(IdentityBuildHasher::default());
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1;
+                }
+            }
+            map
+        });
+    });
+
+    // ── 5. HashSortedMap merge only (no sort) ───────────────────────
+    group.bench_function("HashSortedMap merge", |b| {
+        b.iter(|| {
+            let mut map: HashSortedMap<u32, u32, _> =
+                HashSortedMap::with_hasher(IdentityBuildHasher::default());
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1u32;
+                }
+            }
+            map
+        });
+    });
+
+    // ── 6. hashbrown presized merge only ────────────────────────────
+    group.bench_function("hashbrown merge presized", |b| {
+        b.iter(|| {
+            let mut map =
+                hashbrown::HashMap::<u32, u32, IdentityBuildHasher>::with_capacity_and_hasher(
+                    1_000_000,
+                    IdentityBuildHasher::default(),
+                );
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1;
+                }
+            }
+            map
+        });
+    });
+
+    // ── 7. HashSortedMap presized merge only ─────────────────────────
+    group.bench_function("HashSortedMap merge presized", |b| {
+        b.iter(|| {
+            let mut map: HashSortedMap<u32, u32, _> =
+                HashSortedMap::with_capacity_and_hasher(
+                    1_000_000,
+                    IdentityBuildHasher::default(),
+                );
+            for keys in &maps_data {
+                for &key in keys {
+                    *map.entry(key).or_default() += 1u32;
+                }
+            }
+            map
+        });
+    });
+
+    group.finish();
+}
+
 criterion_group!(
     benches,
     bench_insert,
     bench_reinsert,
     bench_grow,
     bench_count,
     bench_iter,
-    bench_sort
+    bench_sort,
+    bench_merge_sort
 );
 criterion_main!(benches);

crates/hash-sorted-map/src/hash_sorted_map.rs

@@ -660,12 +660,9 @@ impl<'a, K: Hash + Eq, V, S: BuildHasher> VacantEntry<'a, K, V, S> {
 /// Cold path: the chain was full, the table is at capacity, and we need to
 /// grow before inserting. Re-walks via the slow path after grow.
 ///
-/// After `grow()` doubles `num_primary` (`n_bits += 1`), our key's new
-/// primary group can have at most ~half the old chain's keys, so hitting
-/// `NeedsOverflow` again would require `GROUP_SIZE` keys to all collide on
-/// one extra bit of hash — essentially impossible for any reasonable hash.
-/// (`insert_for_grow` relies on the same assumption to skip its own
-/// capacity check.)
+/// With clustered hash functions (e.g. identity hashing), the new primary
+/// group may still be full after grow, so we handle `NeedsOverflow` by
+/// allocating an overflow group.
 #[cold]
 #[inline(never)]
 fn insert_after_grow<K: Hash + Eq, V, S: BuildHasher>(
@@ -675,9 +672,9 @@ fn insert_after_grow<K: Hash + Eq, V, S: BuildHasher>(
     value: V,
 ) -> &mut V {
     map.grow();
+    let tag = tag(hash);
     match map.find_or_insertion_slot(hash, &key) {
         FindResult::Vacant(Insertion::Empty { group, slot }) => {
-            let tag = tag(hash);
             // SAFETY: `group` points into `map.container.groups` and is valid for `'a`.
             unsafe {
                 let g = &mut *group;
@@ -688,10 +685,28 @@ fn insert_after_grow<K: Hash + Eq, V, S: BuildHasher>(
                 g.values[slot].assume_init_mut()
             }
         }
-        // After grow, the new primary group for `key` cannot be full (see
-        // function docs), and the key wasn't in the table before grow.
-        FindResult::Vacant(Insertion::NeedsOverflow { .. }) | FindResult::Found(_) => {
-            unreachable!("post-grow walk must hit an empty slot")
+        FindResult::Vacant(Insertion::NeedsOverflow { tail }) => {
+            // Primary group chain is full even after grow (possible with
+            // clustered identity hashes). Allocate an overflow group.
+            debug_assert!(
+                (map.container.num_groups as usize) < map.container.groups.len(),
+                "overflow pool exhausted right after grow"
+            );
+            let new_gi = map.container.num_groups as usize;
+            map.container.num_groups += 1;
+            unsafe {
+                (*tail).overflow = new_gi as u32;
+            }
+            let slot = slot_hint(hash);
+            let group = &mut map.container.groups[new_gi];
+            group.ctrl[slot] = tag;
+            group.keys[slot] = MaybeUninit::new(key);
+            group.values[slot] = MaybeUninit::new(value);
+            map.container.len += 1;
+            unsafe { group.values[slot].assume_init_mut() }
+        }
+        FindResult::Found(_) => {
+            unreachable!("key was not in the table before grow")
         }
     }
 }