Add xxhash xxh3 mention in benchmarks

.github/workflows/bench.yml

@@ -36,7 +36,7 @@ jobs:
       run: rustup default nightly
 
     - name: Benchmark
-      run: cargo bench --bench throughput --features bench-plot hybrid
+      run: cargo bench --bench throughput --features bench-plot,hybrid
 
     - uses: actions/upload-artifact@v3
       with:

benches/hashset.rs

@@ -22,13 +22,18 @@ fn benchmark<T>(c: &mut Criterion, name: &str, value: T)
 {
     let mut group = c.benchmark_group(format!("HashSet/{}", name));
 
+    let mut set: HashSet::<T, GxBuildHasher> = gxhash::HashSet::<T>::default();
+    group.bench_function("GxHash", |b| {
+        iterate(b, &value, &mut set);
+    });
+
     let mut set = HashSet::<T>::new();
     group.bench_function("Default Hasher", |b| {
         iterate(b, &value, &mut set);
     });
 
-    let mut set: HashSet::<T, GxBuildHasher> = gxhash::HashSet::<T>::default();
-    group.bench_function("GxHash", |b| {
+    let mut set = HashSet::<T, BuildHasherDefault<xxh3::Hash64>>::default();
+    group.bench_function("XxHash (XXH3)", |b| {
         iterate(b, &value, &mut set);
     });
 
@@ -37,8 +42,8 @@ fn benchmark<T>(c: &mut Criterion, name: &str, value: T)
         iterate(b, &value, &mut set);
     });
 
-    let mut set = HashSet::<T, BuildHasherDefault<xxh3::Hash64>>::default();
-    group.bench_function("XxHash", |b| {
+    let mut set = t1ha::T1haHashSet::<T>::default();
+    group.bench_function("T1ha", |b| {
         iterate(b, &value, &mut set);
     });
 
@@ -47,11 +52,6 @@ fn benchmark<T>(c: &mut Criterion, name: &str, value: T)
         iterate(b, &value, &mut set);
     });
 
-    let mut set = t1ha::T1haHashSet::<T>::default();
-    group.bench_function("T1ha", |b| {
-        iterate(b, &value, &mut set);
-    });
-
     let mut set = HashSet::<T, highway::HighwayBuildHasher>::default();
     group.bench_function("HighwayHash", |b| {
         iterate(b, &value, &mut set);

benches/quality/main.rs

@@ -4,10 +4,10 @@ use criterion::black_box;
 
 fn main() {
     bench_hasher_quality::<gxhash::GxBuildHasher>("GxHash");
+    bench_hasher_quality::<std::collections::hash_map::RandomState>("Default");
+    bench_hasher_quality::<twox_hash::xxh3::RandomHashBuilder64>("XxHash (XXH3)");
     bench_hasher_quality::<ahash::RandomState>("AHash");
     bench_hasher_quality::<t1ha::T1haBuildHasher>("T1ha");
-    bench_hasher_quality::<twox_hash::xxh3::RandomHashBuilder64>("XxHash3");
-    bench_hasher_quality::<std::collections::hash_map::RandomState>("Default");
     bench_hasher_quality::<fnv::FnvBuildHasher>("FNV-1a");
 }
 

benches/throughput/main.rs

@@ -38,52 +38,52 @@ fn main() {
     };
 
     // GxHash
-    let gxhash_name = if cfg!(hybrid) { "gxhash-hybrid" } else { "gxhash" };
+    let gxhash_name = if cfg!(feature = "hybrid") { "GxHash-Hybrid" } else { "GxHash" };
     benchmark(processor.as_mut(), slice, gxhash_name, |data: &[u8], seed: i64| -> u64 {
         gxhash64(data, seed)
     });
 
     // XxHash (twox-hash)
-    benchmark(processor.as_mut(), slice, "xxhash", |data: &[u8], seed: u64| -> u64 {
+    benchmark(processor.as_mut(), slice, "XxHash (XXH3)", |data: &[u8], seed: u64| -> u64 {
         twox_hash::xxh3::hash64_with_seed(data, seed)
     });
 
     // AHash
     let ahash_hasher = ahash::RandomState::with_seeds(0, 0, 0, 0);
-    benchmark(processor.as_mut(), slice, "ahash", |data: &[u8], _: i32| -> u64 {
+    benchmark(processor.as_mut(), slice, "AHash", |data: &[u8], _: i32| -> u64 {
         ahash_hasher.hash_one(data)
     });
 
     // T1ha0
-    benchmark(processor.as_mut(), slice, "t1ha0", |data: &[u8], seed: u64| -> u64 {
+    benchmark(processor.as_mut(), slice, "T1ha0", |data: &[u8], seed: u64| -> u64 {
         t1ha::t1ha0(data, seed)
     });
 
+    // FNV-1a
+    benchmark(processor.as_mut(), slice, "FNV-1a", |data: &[u8], seed: u64| -> u64 {
+        let mut fnv_hasher = fnv::FnvHasher::with_key(seed);
+        fnv_hasher.write(data);
+        fnv_hasher.finish()
+    });
+
+    // HighwayHash
+    benchmark(processor.as_mut(), slice, "HighwayHash", |data: &[u8], _: i32| -> u64 {
+        use highway::{HighwayHasher, HighwayHash};
+        HighwayHasher::default().hash64(data)
+    });
+
     // SeaHash
-    benchmark(processor.as_mut(), slice, "seahash", |data: &[u8], seed: u64| -> u64 {
+    benchmark(processor.as_mut(), slice, "SeaHash", |data: &[u8], seed: u64| -> u64 {
         seahash::hash_seeded(data, seed, 0, 0, 0)
     });
 
     // MetroHash
-    benchmark(processor.as_mut(), slice, "metrohash", |data: &[u8], seed: i32| -> u64 {
+    benchmark(processor.as_mut(), slice, "Metrohash", |data: &[u8], seed: i32| -> u64 {
         let mut metrohash_hasher = metrohash::MetroHash64::with_seed(seed as u64);
         metrohash_hasher.write(data);
         metrohash_hasher.finish()
     });
 
-    // HighwayHash
-    benchmark(processor.as_mut(), slice, "highwayhash", |data: &[u8], _: i32| -> u64 {
-        use highway::{HighwayHasher, HighwayHash};
-        HighwayHasher::default().hash64(data)
-    });
-
-    // FNV-1a
-    benchmark(processor.as_mut(), slice, "fnv-1a", |data: &[u8], seed: u64| -> u64 {
-        let mut fnv_hasher = fnv::FnvHasher::with_key(seed);
-        fnv_hasher.write(data);
-        fnv_hasher.finish()
-    });
-
     processor.finish();
 
     // Free benchmark data

benches/throughput/result_processor.rs

@@ -120,7 +120,8 @@ impl ResultProcessor for OutputPlot {
 
     fn finish(&self) {
         let mut arch = std::env::consts::ARCH.to_string();
-        if cfg!(hybrid) {
+        if cfg!(feature = "hybrid") {
+            println!("Hybrid feature enabled");
             arch += "-hybrid";
         }
         let file_name = format!("benches/throughput/{}.svg", arch);