simplehash 0.1.3

A simple, fast Rust library implementing common non-cryptographic hash functions: FNV, MurmurHash3, CityHash, and Rendezvous hashing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
use simplehash::{fnv1_32, fnv1_64, fnv1a_32, fnv1a_64, murmurhash3_32, murmurhash3_128};

fn bench_all_hash_functions(c: &mut Criterion) {
    // Create a benchmark group
    let mut group = c.benchmark_group("Hash Functions Comparison");

    // Test different input sizes
    let sizes = [16, 64, 256, 1024, 4096];

    for size in sizes {
        // Create test data of specified size
        let data = vec![0xAA; size];

        // Set throughput to measure performance in bytes per second
        group.throughput(criterion::Throughput::Bytes(size as u64));

        // Benchmark all hash functions
        group.bench_function(BenchmarkId::new("FNV1-32", size), |b| {
            b.iter(|| fnv1_32(black_box(&data)));
        });

        group.bench_function(BenchmarkId::new("FNV1a-32", size), |b| {
            b.iter(|| fnv1a_32(black_box(&data)));
        });

        group.bench_function(BenchmarkId::new("FNV1-64", size), |b| {
            b.iter(|| fnv1_64(black_box(&data)));
        });

        group.bench_function(BenchmarkId::new("FNV1a-64", size), |b| {
            b.iter(|| fnv1a_64(black_box(&data)));
        });

        group.bench_function(BenchmarkId::new("MurmurHash3-32", size), |b| {
            b.iter(|| murmurhash3_32(black_box(&data), 0));
        });

        group.bench_function(BenchmarkId::new("MurmurHash3-128", size), |b| {
            b.iter(|| murmurhash3_128(black_box(&data), 0));
        });
    }

    group.finish();
}

// Benchmark with different input patterns
fn bench_input_patterns(c: &mut Criterion) {
    let mut group = c.benchmark_group("Hash Function Input Patterns");

    // Create different input patterns of the same size
    let size = 1024;

    // Pattern 1: All zeros
    let zeros = vec![0x00; size];

    // Pattern 2: All ones
    let ones = vec![0xFF; size];

    // Pattern 3: Alternating
    let mut alternating = Vec::with_capacity(size);
    for i in 0..size {
        alternating.push(if i % 2 == 0 { 0x55 } else { 0xAA });
    }

    // Pattern 4: Incremental
    let mut incremental = Vec::with_capacity(size);
    for i in 0..size {
        incremental.push((i % 256) as u8);
    }

    // Test different patterns for each hash function
    for (name, data) in [
        ("zeros", &zeros),
        ("ones", &ones),
        ("alternating", &alternating),
        ("incremental", &incremental),
    ] {
        group.bench_function(BenchmarkId::new("FNV1a-32", name), |b| {
            b.iter(|| fnv1a_32(black_box(data)));
        });

        group.bench_function(BenchmarkId::new("FNV1a-64", name), |b| {
            b.iter(|| fnv1a_64(black_box(data)));
        });

        group.bench_function(BenchmarkId::new("MurmurHash3-32", name), |b| {
            b.iter(|| murmurhash3_32(black_box(data), 0));
        });

        group.bench_function(BenchmarkId::new("MurmurHash3-128", name), |b| {
            b.iter(|| murmurhash3_128(black_box(data), 0));
        });
    }

    group.finish();
}

// Benchmark with realistic data types
fn bench_realistic_data(c: &mut Criterion) {
    let mut group = c.benchmark_group("Realistic Data");

    // Sample real-world inputs
    let inputs = [
        // Short string
        "hello world",
        // URL
        "https://example.com/path/to/resource?param1=value1&param2=value2",
        // JSON
        r#"{"id":123,"name":"John Doe","email":"john@example.com","active":true}"#,
        // UUID
        "550e8400-e29b-41d4-a716-446655440000",
    ];

    for input in inputs {
        let data = input.as_bytes();
        let input_name = if input.len() > 15 {
            format!("{}...({}B)", &input[0..15], input.len())
        } else {
            input.to_string()
        };

        // Set throughput
        group.throughput(criterion::Throughput::Bytes(data.len() as u64));

        // Test fastest hash functions for realistic data
        group.bench_function(BenchmarkId::new("FNV1a-32", &input_name), |b| {
            b.iter(|| fnv1a_32(black_box(data)));
        });

        group.bench_function(BenchmarkId::new("FNV1a-64", &input_name), |b| {
            b.iter(|| fnv1a_64(black_box(data)));
        });

        group.bench_function(BenchmarkId::new("MurmurHash3-32", &input_name), |b| {
            b.iter(|| murmurhash3_32(black_box(data), 0));
        });
    }

    group.finish();
}

criterion_group!(
    benches,
    bench_all_hash_functions,
    bench_input_patterns,
    bench_realistic_data
);
criterion_main!(benches);