add benchmark

Author: aneubeck

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "crates/*",
     "crates/bpe/benchmarks",
     "crates/bpe/tests",
+    "crates/consistent-hashing/benchmarks",
 ]
 resolver = "2"
 

crates/consistent-hashing/benchmarks/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "consistent-hashing-benchmarks"
+edition = "2021"
+
+[[bench]]
+name = "performance"
+path = "performance.rs"
+harness = false
+test = false
+
+[dependencies]
+consistent-hashing = { path = "../" }
+
+criterion = { version = "0.7", features = ["csv_output"] }
+rand = "0.9"

crates/consistent-hashing/benchmarks/criterion.toml

@@ -0,0 +1,18 @@
+# save report in this directory, even if a custom target directory is set
+criterion_home = "./target/criterion"
+
+# The colors table allows users to configure the colors used by the charts 
+# cargo-criterion generates.
+[colors]
+# Color-blind friendly color scheme from https://personal.sron.nl/~pault/.
+comparison_colors = [
+  {r =  51, g =  34, b = 136 }, # indigo
+  {r = 136, g = 204, b = 238 }, # cyan
+  {r =  68, g = 170, b = 153 }, # teal
+  {r =  17, g = 119, b =  51 }, # green
+  {r = 153, g = 153, b =  51 }, # olive
+  {r = 221, g = 204, b = 119 }, # sand
+  {r = 204, g = 102, b = 119 }, # rose
+  {r = 136, g =  34, b =  85 }, # wine
+  {r = 170, g =  68, b = 153 }, # purple
+]

crates/consistent-hashing/benchmarks/performance.rs

@@ -0,0 +1,63 @@
+use std::{
+    hash::{DefaultHasher, Hash},
+    hint::black_box,
+    time::Duration,
+};
+
+use consistent_hashing::{ConsistentChooseKHasher, ConsistentHasher};
+use criterion::{
+    criterion_group, criterion_main, AxisScale, Bencher, BenchmarkId, Criterion, PlotConfiguration,
+    Throughput,
+};
+use rand::{rng, Rng};
+
+fn throughput_benchmark(c: &mut Criterion) {
+    let keys: Vec<u64> = rng().random_iter().take(1000).collect();
+
+    let mut group = c.benchmark_group(format!("choose"));
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
+    for n in [1usize, 10, 100, 1000, 10000] {
+        group.throughput(Throughput::Elements(keys.len() as u64));
+        group.bench_with_input(BenchmarkId::new(format!("1"), n), &n, |b, n| {
+            b.iter_batched(
+                || &keys,
+                |keys| {
+                    for key in keys {
+                        let mut h = DefaultHasher::new();
+                        key.hash(&mut h);
+                        black_box(ConsistentHasher::new(h).prev(*n + 1));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            )
+        });
+        for k in [1, 2, 3, 10, 100] {
+            group.bench_with_input(BenchmarkId::new(format!("k_{k}"), n), &n, |b, n| {
+                b.iter_batched(
+                    || &keys,
+                    |keys| {
+                        let mut res = Vec::with_capacity(k);
+                        for key in keys {
+                            let mut h = DefaultHasher::new();
+                            key.hash(&mut h);
+                            black_box(ConsistentChooseKHasher::new(h, k).prev(*n + k, &mut res));
+                        }
+                    },
+                    criterion::BatchSize::SmallInput,
+                )
+            });
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default()
+                .warm_up_time(Duration::from_millis(500))
+                .measurement_time(Duration::from_millis(4000))
+                .nresamples(1000);
+
+    targets = throughput_benchmark,
+);
+criterion_main!(benches);

crates/consistent-hashing/src/lib.rs

@@ -232,11 +232,11 @@ impl<H: ManySeqBuilder> ConsistentChooseKHasher<H> {
     }
 
     // TODO: Implement this as an iterator!
-    pub fn prev(&self, mut n: usize) -> Vec<usize> {
-        let mut samples = Vec::with_capacity(self.k);
+    pub fn prev(&self, mut n: usize, samples: &mut Vec<usize>)  {
         let mut samplers: Vec<_> = (0..self.k)
             .map(|i| ConsistentHashRevIterator::new(n - i, self.builder.seq_builder(i)).peekable())
             .collect();
+        samples.clear();
         for i in (0..self.k).rev() {
             let mut max = 0;
             for k in 0..=i {
@@ -248,8 +248,6 @@ impl<H: ManySeqBuilder> ConsistentChooseKHasher<H> {
             samples.push(max);
             n = max;
         }
-        samples.sort();
-        samples
     }
 }