highway 0.1.4

Native Rust port of Google's HighwayHash, which makes use of SIMD instructions for a fast and strong hash function
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

#[macro_use]
extern crate criterion;
extern crate blake2;
extern crate blake2b_simd;
extern crate farmhash;
extern crate fnv;
extern crate highway;
extern crate sha2;

use blake2::Blake2s;
use blake2b_simd::Params;
use criterion::{Criterion, ParameterizedBenchmark, Throughput};
use highway::{HighwayBuilder, HighwayHash, Key, PortableHash};

#[cfg(target_arch = "x86_64")]
use highway::{AvxHash, SseHash};
use sha2::{Digest, Sha256};
use std::collections::hash_map::DefaultHasher;
use std::hash::Hasher;

fn builder(c: &mut Criterion) {
    let parameters = vec![1, 4, 16, 64, 256, 1024, 4096, 16384, 65536];

    c.bench(
        "highway-builder",
        ParameterizedBenchmark::new(
            "64bit",
            |b, param| {
                let data = vec![0u8; *param];
                let key = Key([0, 0, 0, 0]);
                b.iter(|| HighwayBuilder::new(&key).hash64(&data))
            },
            parameters,
        ).throughput(|s| Throughput::Bytes(*s as u32)),
    );
}

fn hashing(c: &mut Criterion) {
    let parameters = vec![1, 4, 16, 64, 256, 1024, 4096, 16384, 65536];
    let key = Key([0, 0, 0, 0]);

    let mut bit64 = ParameterizedBenchmark::new(
        "portable",
        |b, param| {
            let data = vec![0u8; *param];
            let key = Key([0, 0, 0, 0]);
            b.iter(|| PortableHash::new(&key).hash64(&data))
        },
        parameters.clone(),
    ).with_function("hashmap default", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| {
            let mut hasher = DefaultHasher::new();
            hasher.write(&data);
            hasher.finish()
        })
    }).with_function("fnv", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| {
            let mut hasher = fnv::FnvHasher::with_key(0);
            hasher.write(&data);
            hasher.finish()
        })
    }).with_function("farmhash", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| farmhash::hash64(&data))
    }).throughput(|s| Throughput::Bytes(*s as u32));

    #[cfg(target_arch = "x86_64")]
    {
        if AvxHash::new(&key).is_some() {
            bit64 = bit64.with_function("avx", |b, param| {
                let data = vec![0u8; *param];
                let key = Key([0, 0, 0, 0]);
                b.iter(|| unsafe { AvxHash::force_new(&key) }.hash64(&data))
            });
        }

        if SseHash::new(&key).is_some() {
            bit64 = bit64.with_function("sse", |b, param| {
                let data = vec![0u8; *param];
                let key = Key([0, 0, 0, 0]);
                b.iter(|| unsafe { SseHash::force_new(&key) }.hash64(&data))
            });
        }
    }

    c.bench("64bit", bit64);

    let mut bit256 = ParameterizedBenchmark::new(
        "portable",
        |b, param| {
            let data = vec![0u8; *param];
            let key = Key([0, 0, 0, 0]);
            b.iter(|| PortableHash::new(&key).hash256(&data))
        },
        parameters.clone(),
    ).with_function("sha2", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| Sha256::digest(&data))
    }).with_function("blake2s", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| {
            let mut blake = Blake2s::default();
            blake.input(&data);
            blake.result()
        })
    }).with_function("blake2b_simd", |b, param| {
        let data = vec![0u8; *param];
        b.iter(|| {
            Params::new()
                .hash_length(32)
                .key(&[1, 2, 3, 4])
                .to_state()
                .update(&data)
                .finalize()
        });
    }).throughput(|s| Throughput::Bytes(*s as u32));

    #[cfg(target_arch = "x86_64")]
    {
        if AvxHash::new(&key).is_some() {
            bit256 = bit256.with_function("avx", |b, param| {
                let data = vec![0u8; *param];
                let key = Key([0, 0, 0, 0]);
                b.iter(|| unsafe { AvxHash::force_new(&key) }.hash256(&data))
            });
        }

        if SseHash::new(&key).is_some() {
            bit256 = bit256.with_function("sse", |b, param| {
                let data = vec![0u8; *param];
                let key = Key([0, 0, 0, 0]);
                b.iter(|| unsafe { SseHash::force_new(&key) }.hash256(&data))
            });
        }
    }

    c.bench("256bit", bit256);
}

criterion_group!(benches, builder, hashing);
criterion_main!(benches);