Add: FoldHasher comparison

Author: ashvardanian

Cargo.lock

@@ -37,6 +37,7 @@ bench_hash = [
     "crc32fast",   # CRC32
     "murmur3",     # MurmurHash3
     "cityhash",    # CityHash
+    "foldhash",    # FoldHash
     "bit-set",     # for collision counting
 ]
 bench_sequence = [
@@ -128,6 +129,10 @@ optional = true
 version = "0.1"
 optional = true
 
+[dependencies.foldhash]
+version = "0.2"
+optional = true
+
 [dependencies.gxhash]
 version = "3.4.1"
 optional = true

Cargo.toml

@@ -47,6 +47,7 @@ On Intel Sapphire Rapids CPU, on `xlsum.csv` dataset, the following numbers can
 | `crc32fast::hash`     |  32   |    ✅    |     0.49 GiB/s |      8.45 GiB/s |
 | `xxh3::xxh3_64`       |  64   |    ✅    |     1.08 GiB/s |      9.48 GiB/s |
 | `aHash::hash_one`     |  64   |    ❌    |     1.23 GiB/s |      8.61 GiB/s |
+| `foldhash::hash_one`  |  64   |    ❌    |     1.02 GiB/s |      8.24 GiB/s |
 | `gxhash::gxhash64`    |  64   |    ❌    | __2.68 GiB/s__ |      9.19 GiB/s |
 | `stringzilla::hash`   |  64   |    ✅    |     1.84 GiB/s | __11.23 GiB/s__ |
 |                       |       |         |                |                 |
@@ -70,6 +71,7 @@ This is especially important in distributed systems, where the data is too large
 | Rust 🦀                     |       |         |                |                |
 | `std::hash::DefaultHasher` |  64   |    ❌    |     0.51 GiB/s |     3.92 GiB/s |
 | `aHash::AHasher`           |  64   |    ❌    | __1.30 GiB/s__ | __8.56 GiB/s__ |
+| `foldhash::FoldHasher`     |  64   |    ❌    |     1.27 GiB/s |     8.18 GiB/s |
 | `crc32fast::Hasher`        |  32   |    ✅    |     0.37 GiB/s |     8.39 GiB/s |
 | `stringzilla::Hasher`      |  64   |    ✅    |     0.89 GiB/s |     6.39 GiB/s |
 |                            |       |         |                |                |

README.md

@@ -13,6 +13,7 @@ The benchmarks compare the performance of different hash functions including:
 - aHash (both incremental and single-entry variants)
 - xxHash (xxh3) through the third-party `xxhash-rust` crate
 - gxhash (gxhash64)
+- FoldHash (a fast hash with good quality)
 - CRC32 (IEEE) via `crc32fast`
 - Blake3 (the only cryptographic hash in the comparison, for reference)
 
@@ -52,6 +53,7 @@ use ahash::RandomState as AHashState;
 use blake3;
 use cityhash;
 use crc32fast;
+use foldhash;
 use gxhash;
 use murmur3;
 use stringzilla::sz;
@@ -247,6 +249,20 @@ fn bench_stateless(
         print_collision_rate(&unique_tokens, |t| gxhash::gxhash64(t, 42));
     }
 
+    // Benchmark: FoldHash
+    if should_run("stateless/foldhash::hash_one") {
+        let foldhash_builder = foldhash::fast::RandomState::default();
+        group.bench_function("foldhash::hash_one", |b| {
+            b.iter(|| {
+                for token in tokens {
+                    let t = black_box(*token);
+                    let _ = black_box(foldhash_builder.hash_one(t));
+                }
+            })
+        });
+        print_collision_rate(&unique_tokens, |t| foldhash_builder.hash_one(t));
+    }
+
     // Benchmark: CRC32
     if should_run("stateless/crc32fast::hash") {
         group.bench_function("crc32fast::hash", |b| {
@@ -362,6 +378,20 @@ fn bench_stateful(
         });
     }
 
+    // Benchmark: FoldHash
+    if should_run("stateful/foldhash::FoldHasher") {
+        group.bench_function("foldhash::FoldHasher", |b| {
+            let state = foldhash::fast::RandomState::default();
+            b.iter(|| {
+                let mut aggregate = state.build_hasher();
+                for token in tokens {
+                    aggregate.write(token);
+                }
+                black_box(aggregate.finish());
+            })
+        });
+    }
+
     // Benchmark: CRC32
     if should_run("stateful/crc32fast::Hasher") {
         group.bench_function("crc32fast::Hasher", |b| {