fxhash-0.2.1/.gitignore01006440001750000175000000000462131242501520013201 0ustar0000000000000000# Generated by Cargo # will have compiled files and executables /target/ # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries # More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock Cargo.lock # These are backup files generated by rustfmt **/*.rs.bkfxhash-0.2.1/Cargo.toml.orig01006440001750000175000000001064131371555050014111 0ustar0000000000000000[package] name = "fxhash" version = "0.2.1" description = "A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc." documentation = "https://docs.rs/fxhash" repository = "https://github.com/cbreeden/fxhash" readme = "README.md" keywords = [ "hash" ] categories = [ "algorithms" ] license = "Apache-2.0/MIT" authors = ["cbreeden "] [lib] name = "fxhash" path = "lib.rs" [[bench]] name = "fxhash" path = "bench.rs" [dependencies] byteorder = "1.0.0" [dev-dependencies] seahash = "3.0.5" fnv = "1.0.5"fxhash-0.2.1/Cargo.toml0000644000000021470007336 0ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g. crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "fxhash" version = "0.2.1" authors = ["cbreeden "] description = "A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc." documentation = "https://docs.rs/fxhash" readme = "README.md" keywords = ["hash"] categories = ["algorithms"] license = "Apache-2.0/MIT" repository = "https://github.com/cbreeden/fxhash" [lib] name = "fxhash" path = "lib.rs" [[bench]] name = "fxhash" path = "bench.rs" [dependencies.byteorder] version = "1.0.0" [dev-dependencies.fnv] version = "1.0.5" [dev-dependencies.seahash] version = "3.0.5" fxhash-0.2.1/Cargo.toml.orig0000644000000021470010275 0ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g. crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "fxhash" version = "0.2.1" authors = ["cbreeden "] description = "A fast, non-secure, hashing algorithm derived from an internal hasher used in FireFox and Rustc." documentation = "https://docs.rs/fxhash" readme = "README.md" keywords = ["hash"] categories = ["algorithms"] license = "Apache-2.0/MIT" repository = "https://github.com/cbreeden/fxhash" [lib] name = "fxhash" path = "lib.rs" [[bench]] name = "fxhash" path = "bench.rs" [dependencies.byteorder] version = "1.0.0" [dev-dependencies.seahash] version = "3.0.5" [dev-dependencies.fnv] version = "1.0.5" fxhash-0.2.1/README.md01006440001750000175000000005333131242562710012502 0ustar0000000000000000# Fx Hash This hashing algorithm was extracted from the Rustc compiler. This is the same hashing algoirthm used for some internal operations in FireFox. The strength of this algorithm is in hashing 8 bytes at a time on 64-bit platforms, where the FNV algorithm works on one byte at a time. ## Disclaimer It is **not a cryptographically secure** hash, so it is strongly recommended that you do not use this hash for cryptographic purproses. Furthermore, this hashing algorithm was not designed to prevent any attacks for determining collisions which could be used to potentially cause quadratic behavior in `HashMap`s. So it is not recommended to expose this hash in places where collissions or DDOS attacks may be a concern. ## Examples Building an Fx backed hashmap. ```rust extern crate fxhash; use fxhash::FxHashMap; let mut hashmap = FxHashMap::new(); hashmap.insert("black", 0); hashmap.insert("white", 255); ``` Building an Fx backed hashset. ```rust extern crate fxhash; use fxhash::FxHashSet; let mut hashmap = FxHashSet::new(); hashmap.insert("black"); hashmap.insert("white"); ``` ## Benchmarks Generally `fxhash` is than `fnv` on `u32`, `u64`, or any byte sequence with length >= 5. However, keep in mind that hashing speed is not the only characteristic worth considering. That being said, Rustc had an observable increase in speed when switching from `fnv` backed hashmaps to `fx` based hashmaps. bench_fnv_003 ... bench: 3 ns/iter (+/- 0) bench_fnv_004 ... bench: 2 ns/iter (+/- 0) bench_fnv_011 ... bench: 6 ns/iter (+/- 1) bench_fnv_012 ... bench: 5 ns/iter (+/- 1) bench_fnv_023 ... bench: 14 ns/iter (+/- 3) bench_fnv_024 ... bench: 14 ns/iter (+/- 4) bench_fnv_068 ... bench: 57 ns/iter (+/- 11) bench_fnv_132 ... bench: 145 ns/iter (+/- 30) bench_fx_003 ... bench: 4 ns/iter (+/- 0) bench_fx_004 ... bench: 3 ns/iter (+/- 1) bench_fx_011 ... bench: 5 ns/iter (+/- 2) bench_fx_012 ... bench: 4 ns/iter (+/- 1) bench_fx_023 ... bench: 7 ns/iter (+/- 3) bench_fx_024 ... bench: 4 ns/iter (+/- 1) bench_fx_068 ... bench: 10 ns/iter (+/- 3) bench_fx_132 ... bench: 19 ns/iter (+/- 5) bench_seahash_003 ... bench: 30 ns/iter (+/- 12) bench_seahash_004 ... bench: 32 ns/iter (+/- 22) bench_seahash_011 ... bench: 30 ns/iter (+/- 4) bench_seahash_012 ... bench: 31 ns/iter (+/- 1) bench_seahash_023 ... bench: 32 ns/iter (+/- 6) bench_seahash_024 ... bench: 31 ns/iter (+/- 5) bench_seahash_068 ... bench: 40 ns/iter (+/- 9) bench_seahash_132 ... bench: 50 ns/iter (+/- 12)fxhash-0.2.1/bench.rs01006440001750000175000000005012131371340360012640 0ustar0000000000000000#![feature(test)] extern crate test; extern crate fnv; extern crate fxhash; extern crate seahash; use std::hash::{Hash, Hasher}; use test::{Bencher, black_box}; fn fnvhash(b: H) -> u64 { let mut hasher = fnv::FnvHasher::default(); b.hash(&mut hasher); hasher.finish() } fn seahash(b: H) -> u64 { let mut hasher = seahash::SeaHasher::default(); b.hash(&mut hasher); hasher.finish() } macro_rules! generate_benches { ($($fx:ident, $fx32:ident, $fx64:ident, $fnv:ident, $sea:ident, $s:expr),* $(,)*) => ( $( #[bench] fn $fx(b: &mut Bencher) { let s = black_box($s); b.iter(|| { fxhash::hash(&s) }) } #[bench] fn $fx32(b: &mut Bencher) { let s = black_box($s); b.iter(|| { fxhash::hash32(&s) }) } #[bench] fn $fx64(b: &mut Bencher) { let s = black_box($s); b.iter(|| { fxhash::hash64(&s) }) } #[bench] fn $fnv(b: &mut Bencher) { let s = black_box($s); b.iter(|| { fnvhash(&s) }) } #[bench] fn $sea(b: &mut Bencher) { let s = black_box($s); b.iter(|| { seahash(&s) }) } )* ) } generate_benches!( bench_fx_003, bench_fx32_003, bench_fx64_003, bench_fnv_003, bench_seahash_003, "123", bench_fx_004, bench_fx32_004, bench_fx64_004, bench_fnv_004, bench_seahash_004, "1234", bench_fx_011, bench_fx32_011, bench_fx64_011, bench_fnv_011, bench_seahash_011, "12345678901", bench_fx_012, bench_fx32_012, bench_fx64_012, bench_fnv_012, bench_seahash_012, "123456789012", bench_fx_023, bench_fx32_023, bench_fx64_023, bench_fnv_023, bench_seahash_023, "12345678901234567890123", bench_fx_024, bench_fx32_024, bench_fx64_024, bench_fnv_024, bench_seahash_024, "123456789012345678901234", bench_fx_068, bench_fx32_068, bench_fx64_068, bench_fnv_068, bench_seahash_068, "11234567890123456789012345678901234567890123456789012345678901234567", bench_fx_132, bench_fx32_132, bench_fx64_132, bench_fnv_132, bench_seahash_132, "112345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", );fxhash-0.2.1/lib.rs01006440001750000175000000020422131371554040012333 0ustar0000000000000000// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![deny(missing_docs)] //! # Fx Hash //! //! This hashing algorithm was extracted from the Rustc compiler. This is the same hashing //! algoirthm used for some internal operations in FireFox. The strength of this algorithm //! is in hashing 8 bytes at a time on 64-bit platforms, where the FNV algorithm works on one //! byte at a time. //! //! ## Disclaimer //! //! It is **not a cryptographically secure** hash, so it is strongly recommended that you do //! not use this hash for cryptographic purproses. Furthermore, this hashing algorithm was //! not designed to prevent any attacks for determining collisions which could be used to //! potentially cause quadratic behavior in `HashMap`s. So it is not recommended to expose //! this hash in places where collissions or DDOS attacks may be a concern. use std::collections::{HashMap, HashSet}; use std::default::Default; use std::hash::{Hasher, Hash, BuildHasherDefault}; use std::ops::BitXor; extern crate byteorder; use byteorder::{ByteOrder, NativeEndian}; /// A builder for default Fx hashers. pub type FxBuildHasher = BuildHasherDefault; /// A `HashMap` using a default Fx hasher. pub type FxHashMap = HashMap; /// A `HashSet` using a default Fx hasher. pub type FxHashSet = HashSet; const ROTATE: u32 = 5; const SEED64: u64 = 0x517cc1b727220a95; const SEED32: u32 = (SEED64 & 0xFFFF_FFFF) as u32; #[cfg(target_pointer_width = "32")] const SEED: usize = SEED32 as usize; #[cfg(target_pointer_width = "64")] const SEED: usize = SEED64 as usize; trait HashWord { fn hash_word(&mut self, Self); } macro_rules! impl_hash_word { ($($ty:ty = $key:ident),* $(,)*) => ( $( impl HashWord for $ty { #[inline] fn hash_word(&mut self, word: Self) { *self = self.rotate_left(ROTATE).bitxor(word).wrapping_mul($key); } } )* ) } impl_hash_word!(usize = SEED, u32 = SEED32, u64 = SEED64); #[inline] fn write32(mut hash: u32, mut bytes: &[u8]) -> u32 { while bytes.len() >= 4 { let n = NativeEndian::read_u32(bytes); hash.hash_word(n); bytes = bytes.split_at(4).1; } for byte in bytes { hash.hash_word(*byte as u32); } hash } #[inline] fn write64(mut hash: u64, mut bytes: &[u8]) -> u64 { while bytes.len() >= 8 { let n = NativeEndian::read_u64(bytes); hash.hash_word(n); bytes = bytes.split_at(8).1; } if bytes.len() >= 4 { let n = NativeEndian::read_u32(bytes); hash.hash_word(n as u64); bytes = bytes.split_at(4).1; } for byte in bytes { hash.hash_word(*byte as u64); } hash } #[inline] #[cfg(target_pointer_width = "32")] fn write(hash: usize, bytes: &[u8]) -> usize { write32(hash as u32, bytes) as usize } #[inline] #[cfg(target_pointer_width = "64")] fn write(hash: usize, bytes: &[u8]) -> usize { write64(hash as u64, bytes) as usize } /// This hashing algorithm was extracted from the Rustc compiler. /// This is the same hashing algoirthm used for some internal operations in FireFox. /// The strength of this algorithm is in hashing 8 bytes at a time on 64-bit platforms, /// where the FNV algorithm works on one byte at a time. /// /// This hashing algorithm should not be used for cryptographic, or in scenarios where /// DOS attacks are a concern. #[derive(Debug, Clone)] pub struct FxHasher { hash: usize, } impl Default for FxHasher { #[inline] fn default() -> FxHasher { FxHasher { hash: 0 } } } impl Hasher for FxHasher { #[inline] fn write(&mut self, bytes: &[u8]) { self.hash = write(self.hash, bytes); } #[inline] fn write_u8(&mut self, i: u8) { self.hash.hash_word(i as usize); } #[inline] fn write_u16(&mut self, i: u16) { self.hash.hash_word(i as usize); } #[inline] fn write_u32(&mut self, i: u32) { self.hash.hash_word(i as usize); } #[inline] #[cfg(target_pointer_width = "32")] fn write_u64(&mut self, i: u64) { self.hash.hash_word(i as usize); self.hash.hash_word((i >> 32) as usize); } #[inline] #[cfg(target_pointer_width = "64")] fn write_u64(&mut self, i: u64) { self.hash.hash_word(i as usize); } #[inline] fn write_usize(&mut self, i: usize) { self.hash.hash_word(i); } #[inline] fn finish(&self) -> u64 { self.hash as u64 } } /// This hashing algorithm was extracted from the Rustc compiler. /// This is the same hashing algoirthm used for some internal operations in FireFox. /// The strength of this algorithm is in hashing 8 bytes at a time on any platform, /// where the FNV algorithm works on one byte at a time. /// /// This hashing algorithm should not be used for cryptographic, or in scenarios where /// DOS attacks are a concern. #[derive(Debug, Clone)] pub struct FxHasher64 { hash: u64, } impl Default for FxHasher64 { #[inline] fn default() -> FxHasher64 { FxHasher64 { hash: 0 } } } impl Hasher for FxHasher64 { #[inline] fn write(&mut self, bytes: &[u8]) { self.hash = write64(self.hash, bytes); } #[inline] fn write_u8(&mut self, i: u8) { self.hash.hash_word(i as u64); } #[inline] fn write_u16(&mut self, i: u16) { self.hash.hash_word(i as u64); } #[inline] fn write_u32(&mut self, i: u32) { self.hash.hash_word(i as u64); } fn write_u64(&mut self, i: u64) { self.hash.hash_word(i); } #[inline] fn write_usize(&mut self, i: usize) { self.hash.hash_word(i as u64); } #[inline] fn finish(&self) -> u64 { self.hash } } /// This hashing algorithm was extracted from the Rustc compiler. /// This is the same hashing algoirthm used for some internal operations in FireFox. /// The strength of this algorithm is in hashing 4 bytes at a time on any platform, /// where the FNV algorithm works on one byte at a time. /// /// This hashing algorithm should not be used for cryptographic, or in scenarios where /// DOS attacks are a concern. #[derive(Debug, Clone)] pub struct FxHasher32 { hash: u32, } impl Default for FxHasher32 { #[inline] fn default() -> FxHasher32 { FxHasher32 { hash: 0 } } } impl Hasher for FxHasher32 { #[inline] fn write(&mut self, bytes: &[u8]) { self.hash = write32(self.hash, bytes); } #[inline] fn write_u8(&mut self, i: u8) { self.hash.hash_word(i as u32); } #[inline] fn write_u16(&mut self, i: u16) { self.hash.hash_word(i as u32); } #[inline] fn write_u32(&mut self, i: u32) { self.hash.hash_word(i); } #[inline] fn write_u64(&mut self, i: u64) { self.hash.hash_word(i as u32); self.hash.hash_word((i >> 32) as u32); } #[inline] #[cfg(target_pointer_width = "32")] fn write_usize(&mut self, i: usize) { self.write_u32(i as u32); } #[inline] #[cfg(target_pointer_width = "64")] fn write_usize(&mut self, i: usize) { self.write_u64(i as u64); } #[inline] fn finish(&self) -> u64 { self.hash as u64 } } /// A convenience function for when you need a quick 64-bit hash. #[inline] pub fn hash64(v: &T) -> u64 { let mut state = FxHasher64::default(); v.hash(&mut state); state.finish() } /// A convenience function for when you need a quick 32-bit hash. #[inline] pub fn hash32(v: &T) -> u32 { let mut state = FxHasher32::default(); v.hash(&mut state); state.finish() as u32 } /// A convenience function for when you need a quick usize hash. #[inline] pub fn hash(v: &T) -> usize { let mut state = FxHasher::default(); v.hash(&mut state); state.finish() as usize }