Benchmarks and experiments using rapidhash instead of FNV

Signed-off-by: Liam Gray <[email protected]>

Author: hoxxep

Cargo.toml

@@ -32,6 +32,7 @@ protobuf = { version = "^3.7.2", optional = true }
 memchr = "^2.3"
 reqwest = { version = "^0.12", features = ["blocking"], optional = true }
 thiserror = "^2.0"
+rapidhash = { version = "1.4.0" }  # path = "../rapidhash"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 procfs = { version = "^0.17", optional = true, default-features = false }

benches/counter.rs

@@ -17,6 +17,7 @@ use prometheus::{Counter, CounterVec, IntCounter, Opts};
 use std::collections::HashMap;
 use std::sync::{atomic, Arc};
 use std::thread;
+use rapidhash::RapidBuildHasher;
 
 fn bench_counter_with_label_values(c: &mut Criterion) {
     let counter = CounterVec::new(
@@ -69,6 +70,132 @@ fn bench_counter_with_mapped_labels_fnv(c: &mut Criterion) {
     });
 }
 
+fn bench_counter_with_mapped_labels_rapidhash(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["one", "two", "three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_labels_rapidhash", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity_and_hasher(3, RapidBuildHasher::default());
+            labels.insert("two", "zwei");
+            labels.insert("one", "eins");
+            labels.insert("three", "drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_mid_labels(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["midsize_one", "midsize_two", "midsize_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_mid_labels", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity(3);
+            labels.insert("midsize_two", "midsize_zwei");
+            labels.insert("midsize_one", "midsize_eins");
+            labels.insert("midsize_three", "midsize_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_mid_labels_fnv(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["midsize_one", "midsize_two", "midsize_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_mid_labels_fnv", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity_and_hasher(3, FnvBuildHasher::default());
+            labels.insert("midsize_two", "midsize_zwei");
+            labels.insert("midsize_one", "midsize_eins");
+            labels.insert("midsize_three", "midsize_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_mid_labels_rapidhash(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["midsize_one", "midsize_two", "midsize_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_mid_labels_rapidhash", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity_and_hasher(3, RapidBuildHasher::default());
+            labels.insert("midsize_two", "midsize_zwei");
+            labels.insert("midsize_one", "midsize_eins");
+            labels.insert("midsize_three", "midsize_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_long_labels(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["longer_field_number_one", "longer_field_number_two", "longer_field_number_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_longer_labels", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity(3);
+            labels.insert("longer_field_number_two", "longer_field_number_zwei");
+            labels.insert("longer_field_number_one", "longer_field_number_eins");
+            labels.insert("longer_field_number_three", "longer_field_number_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_long_labels_fnv(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["longer_field_number_one", "longer_field_number_two", "longer_field_number_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_longer_labels_fnv", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity_and_hasher(3, FnvBuildHasher::default());
+            labels.insert("longer_field_number_two", "longer_field_number_zwei");
+            labels.insert("longer_field_number_one", "longer_field_number_eins");
+            labels.insert("longer_field_number_three", "longer_field_number_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
+fn bench_counter_with_mapped_long_labels_rapidhash(c: &mut Criterion) {
+    let counter = CounterVec::new(
+        Opts::new("benchmark_counter", "A counter to benchmark it."),
+        &["longer_field_number_one", "longer_field_number_two", "longer_field_number_three"],
+    )
+        .unwrap();
+
+    c.bench_function("counter_with_mapped_longer_labels_rapidhash", |b| {
+        b.iter(|| {
+            let mut labels = HashMap::with_capacity_and_hasher(3, RapidBuildHasher::default());
+            labels.insert("longer_field_number_two", "longer_field_number_zwei");
+            labels.insert("longer_field_number_one", "longer_field_number_eins");
+            labels.insert("longer_field_number_three", "longer_field_number_drei");
+            counter.with(&black_box(labels)).inc();
+        })
+    });
+}
+
 fn bench_counter_with_prepared_mapped_labels(c: &mut Criterion) {
     let counter = CounterVec::new(
         Opts::new("benchmark_counter", "A counter to benchmark it."),
@@ -216,6 +343,13 @@ criterion_group!(
     bench_counter_with_label_values_concurrent_write,
     bench_counter_with_mapped_labels,
     bench_counter_with_mapped_labels_fnv,
+    bench_counter_with_mapped_labels_rapidhash,
+    bench_counter_with_mapped_mid_labels,
+    bench_counter_with_mapped_mid_labels_fnv,
+    bench_counter_with_mapped_mid_labels_rapidhash,
+    bench_counter_with_mapped_long_labels,
+    bench_counter_with_mapped_long_labels_fnv,
+    bench_counter_with_mapped_long_labels_rapidhash,
     bench_counter_with_prepared_mapped_labels,
     bench_int_counter_no_labels,
     bench_int_counter_no_labels_concurrent_write,

src/vec.rs

@@ -5,7 +5,9 @@ use std::collections::HashMap;
 use std::hash::{BuildHasher, Hasher};
 use std::sync::Arc;
 
-use fnv::FnvHasher;
+// TODO: experimenting, alternating while benchmarking
+// use fnv::FnvHasher;
+use rapidhash::RapidHasher as FnvHasher;
 use parking_lot::RwLock;
 
 use crate::desc::{Desc, Describer};