Struct FastHasher 

pub struct FastHasher { /* private fields */ }

Faster non-cryptographic hasher for small integer keys.

Intended to replace and outperform the default SipHash hasher for small keys used in puzzles. It should not be used in cryptographic or sensitive contexts and is vulnerable to HashDoS attacks.

Integer writes smaller than 64 bits are packed into a pending u64, so a key such as (u32, u16, u16) hashes like the manually packed value (a << 32) | (b << 16) | c.

The mixing step is inspired by wyhash. It uses XOR to mix the current state and value, then does a 128bit multiplication with a large constant, before XOR-ing the high and low 64bit halves.

The branches should be optimized out for fixed-sized types in release builds. Example x86 assembly for u64:

movabsq $SEED,%rax
xorq    %rdi,%rax
movabsq $MUL,%rcx
mulq    %rcx
xorq    %rdx,%rax
retq

Example x86 assembly for (u32, u16, u16), showing bit packing followed by the same fold:

shlq    $32,%rdi
shll    $16,%esi
leaq    (%rsi,%rdi),%rax
movzwl  %dx,%ecx
orq     %rax,%rcx
movabsq $SEED,%rax
xorq    %rcx,%rax
movabsq $MUL,%rcx
mulq    %rcx
xorq    %rdx,%rax
retq

Trait Implementations

impl Clone for FastHasher

fn clone(&self) -> FastHasher

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FastHasher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FastHasher

fn default() -> Self

Returns the “default value” for a type.

impl Hasher for FastHasher

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, bytes: &[u8])

Writes some data into this Hasher.

fn write_u8(&mut self, n: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, n: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, n: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, n: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, n: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, n: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a single str into this hasher.