[Storage] Fix UintIdentity hasher defeating hashbrown's SIMD filter (#3480)

Co-authored-by: Patrick O'Grady <me@patrickogrady.xyz>

Author: danlaine

storage/fuzz/Cargo.toml

@@ -152,13 +152,6 @@ test = false
 doc = false
 bench = false
 
-[[bin]]
-name = "translator_operations"
-path = "fuzz_targets/translator_operations.rs"
-test = false
-doc = false
-bench = false
-
 [[bin]]
 name = "mmr_journaled"
 path = "fuzz_targets/mmr_journaled.rs"

storage/fuzz/fuzz_targets/translator_operations.rs

@@ -1,13 +1,49 @@
+use commonware_cryptography::{Hasher, Sha256};
+use commonware_runtime::Metrics;
 use criterion::criterion_main;
+use prometheus_client::registry::Metric;
 
 mod hashmap_insert;
 mod hashmap_insert_fixed;
 mod hashmap_iteration;
 mod insert;
+mod lookup;
+mod lookup_miss;
+
+pub(crate) type Digest = <Sha256 as Hasher>::Digest;
+
+#[derive(Clone)]
+pub(crate) struct DummyMetrics;
+
+impl Metrics for DummyMetrics {
+    fn label(&self) -> String {
+        "".into()
+    }
+
+    fn with_label(&self, _: &str) -> Self {
+        Self
+    }
+
+    fn encode(&self) -> String {
+        "".into()
+    }
+
+    fn register<N: Into<String>, H: Into<String>>(&self, _: N, _: H, _: impl Metric) {}
+
+    fn with_attribute(&self, _: &str, _: impl std::fmt::Display) -> Self {
+        Self
+    }
+
+    fn with_scope(&self) -> Self {
+        Self
+    }
+}
 
 criterion_main!(
     hashmap_iteration::benches,
     hashmap_insert_fixed::benches,
     hashmap_insert::benches,
     insert::benches,
+    lookup::benches,
+    lookup_miss::benches,
 );

storage/src/index/benches/bench.rs

@@ -1,11 +1,10 @@
+use super::DummyMetrics;
 use commonware_cryptography::{Hasher, Sha256};
-use commonware_runtime::Metrics;
 use commonware_storage::{
     index::{ordered, partitioned, unordered, Unordered},
     translator::{Cap, FourCap, Hashed, TwoCap},
 };
 use criterion::{criterion_group, Criterion};
-use prometheus_client::registry::Metric;
 use rand::{rngs::StdRng, seq::SliceRandom, SeedableRng};
 use std::time::{Duration, Instant};
 
@@ -55,33 +54,6 @@ const VARIANTS: [Variant; 9] = [
     Variant::HashedPartitionedUnordered2,
 ];
 
-#[derive(Clone)]
-struct DummyMetrics;
-
-impl Metrics for DummyMetrics {
-    fn label(&self) -> String {
-        "".into()
-    }
-
-    fn with_label(&self, _: &str) -> Self {
-        Self
-    }
-
-    fn encode(&self) -> String {
-        "".into()
-    }
-
-    fn register<N: Into<String>, H: Into<String>>(&self, _: N, _: H, _: impl Metric) {}
-
-    fn with_attribute(&self, _: &str, _: impl std::fmt::Display) -> Self {
-        Self
-    }
-
-    fn with_scope(&self) -> Self {
-        Self
-    }
-}
-
 fn bench_insert(c: &mut Criterion) {
     for items in N_ITEMS {
         // Setup items

storage/src/index/benches/insert.rs

@@ -0,0 +1,71 @@
+use super::{Digest, DummyMetrics};
+use commonware_cryptography::{Hasher, Sha256};
+use commonware_storage::{
+    index::{unordered, Unordered},
+    translator::{EightCap, FourCap, OneCap, Translator, TwoCap},
+};
+use criterion::{criterion_group, Criterion};
+use rand::{rngs::StdRng, seq::SliceRandom, SeedableRng};
+use std::{
+    hint::black_box,
+    time::{Duration, Instant},
+};
+
+#[cfg(not(full_bench))]
+const N_ITEMS: [usize; 2] = [10_000, 50_000];
+#[cfg(full_bench)]
+const N_ITEMS: [usize; 5] = [10_000, 50_000, 100_000, 500_000, 1_000_000];
+
+fn run_lookup<T: Translator>(
+    c: &mut Criterion,
+    translator: T,
+    name: &str,
+    items: usize,
+    keys: &[Digest],
+) {
+    // Populate the index
+    let mut index = unordered::Index::new(DummyMetrics, translator);
+    for (i, key) in keys.iter().enumerate().take(items) {
+        index.insert(key, i as u64);
+    }
+
+    // Shuffle lookup order
+    let mut rng = StdRng::seed_from_u64(1);
+    let mut lookup_keys: Vec<_> = keys.iter().take(items).cloned().collect();
+    lookup_keys.shuffle(&mut rng);
+
+    let label = format!("{}/translator={name} items={items}", module_path!());
+    c.bench_function(&label, |b| {
+        b.iter_custom(|iters| {
+            let mut total = Duration::ZERO;
+            for _ in 0..iters {
+                let start = Instant::now();
+                for key in &lookup_keys {
+                    black_box(index.get(key).next().is_some());
+                }
+                total += start.elapsed();
+            }
+            total
+        });
+    });
+}
+
+fn bench_lookup(c: &mut Criterion) {
+    let max_items = *N_ITEMS.last().unwrap();
+    let keys: Vec<_> = (0..max_items)
+        .map(|i| Sha256::hash(&i.to_be_bytes()))
+        .collect();
+
+    for items in N_ITEMS {
+        run_lookup(c, OneCap, "one_cap", items, &keys);
+        run_lookup(c, TwoCap, "two_cap", items, &keys);
+        run_lookup(c, FourCap, "four_cap", items, &keys);
+        run_lookup(c, EightCap, "eight_cap", items, &keys);
+    }
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(10);
+    targets = bench_lookup,
+}