Use getrandom for obtaining random state if std is enabled.

(This requires an API change.)

Author: tkaitchuck

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ahash"
-version = "0.4.5"
+version = "0.5.0"
 authors = ["Tom Kaitchuck <[email protected]>"]
 license = "MIT OR Apache-2.0"
 description = "A non-cryptographic hash function using AES-NI for high performance"
@@ -19,18 +19,15 @@ bench = true
 doc = true
 
 [features]
-default = ["compile-time-rng", "std"]
+default = ["std"]
 
 # Enabling this will enable `AHashMap` and `AHashSet`
-std = []
+std = ["getrandom", "lazy_static"]
+compile-time-rng = ["const-random"]
 
-# Enables specilization (reuqires nightly)
+# Enables specilization (requires nightly)
 specialize = []
 
-# Disabling this feature will make the `ABuildHasher::new` use a preset seed
-# and disable the `Default` impl for `AHasher`
-compile-time-rng = ["const-random"]
-
 [[bench]]
 name = "ahash"
 path = "tests/bench.rs"
@@ -60,16 +57,18 @@ debug-assertions = false
 codegen-units = 1
 
 [dependencies]
+lazy_static = { version = "1.4.0", optional = true }
+getrandom = { version = "0.2.0", optional = true }
 const-random = { version = "0.1.6", optional = true }
 
 [dev-dependencies]
 no-panic = "0.1.10"
 criterion = {version =  "0.3.2"}
-seahash = "3.0.5"
+seahash = "4.0"
 fnv = "1.0.5"
 fxhash = "0.2.1"
-hex = "0.3.2"
-rand = "0.6.5"
+hex = "0.4.2"
+rand = "0.7.3"
 
 [package.metadata.docs.rs]
 rustc-args = ["-C", "target-feature=+aes"]

src/aes_hash.rs

@@ -3,6 +3,7 @@ use crate::operations::*;
 #[cfg(feature = "specialize")]
 use crate::HasherExt;
 use core::hash::Hasher;
+use crate::RandomState;
 
 /// A `Hasher` for hashing an arbitrary stream of bytes.
 ///
@@ -56,14 +57,14 @@ impl AHasher {
         }
     }
 
-    #[cfg(test)]
-    pub(crate) fn test_with_keys(key1: u64, key2: u64) -> AHasher {
-        use crate::random_state::scramble_keys;
-        let (k1, k2, k3, k4) = scramble_keys(key1, key2);
-        AHasher {
-            enc: [k1, k2].convert(),
-            sum: [k3, k4].convert(),
-            key: add_by_64s([k1, k2], [k3, k4]).convert(),
+    #[inline]
+    pub(crate) fn from_random_state(rand_state: &RandomState) -> Self {
+        let key1 = [rand_state.k0, rand_state.k1].convert();
+        let key2 = [rand_state.k2, rand_state.k3].convert();
+        Self {
+            enc: key1,
+            sum: key2,
+            key: key1 ^ key2,
         }
     }
 
@@ -108,7 +109,9 @@ impl HasherExt for AHasher {
     }
 }
 
-/// Provides methods to hash all of the primitive types.
+/// Provides [Hasher] methods to hash all of the primitive types.
+///
+/// [Hasher]: core::hash::Hasher
 impl Hasher for AHasher {
     #[inline]
     fn write_u8(&mut self, i: u8) {
@@ -228,7 +231,7 @@ mod tests {
     use std::hash::{BuildHasher, Hasher};
     #[test]
     fn test_sanity() {
-        let mut hasher = RandomState::with_seeds(192837465, 1234567890).build_hasher();
+        let mut hasher = RandomState::with_seeds(1, 2, 3,4).build_hasher();
         hasher.write_u64(0);
         let h1 = hasher.finish();
         hasher.write(&[1, 0, 0, 0, 0, 0, 0, 0]);

src/convert.rs

@@ -47,6 +47,12 @@ convert!(u128, [u64; 2]);
 convert!(u128, [u32; 4]);
 convert!(u128, [u16; 8]);
 convert!(u128, [u8; 16]);
+convert!([u64; 8], [u32; 16]);
+convert!([u64; 8], [u16; 32]);
+convert!([u64; 8], [u8; 64]);
+convert!([u64; 4], [u32; 8]);
+convert!([u64; 4], [u16; 16]);
+convert!([u64; 4], [u8; 32]);
 convert!([u64; 2], [u32; 4]);
 convert!([u64; 2], [u16; 8]);
 convert!([u64; 2], [u8; 16]);

src/fallback_hash.rs

@@ -3,9 +3,11 @@ use crate::operations::folded_multiply;
 #[cfg(feature = "specialize")]
 use crate::HasherExt;
 use core::hash::Hasher;
+use crate::RandomState;
+use crate::random_state::PI;
 
 ///This constant come from Kunth's prng (Empirically it works better than those from splitmix32).
-const MULTIPLE: u64 = crate::random_state::MULTIPLE;
+const MULTIPLE: u64 = 6364136223846793005;
 const ROT: u32 = 23; //17
 
 /// A `Hasher` for hashing an arbitrary stream of bytes.
@@ -31,22 +33,23 @@ impl AHasher {
     #[inline]
     #[allow(dead_code)] // Is not called if non-fallback hash is used.
     pub fn new_with_keys(key1: u128, key2: u128) -> AHasher {
+        let pi: [u128; 2] = PI.convert();
+        let key1: [u64; 2] = (key1 ^ pi[0]).convert();
+        let key2: [u64; 2] = (key2 ^ pi[1]).convert();
         AHasher {
-            buffer: key1 as u64,
-            pad: key2 as u64,
-            extra_keys: (key1 ^ key2).convert(),
+            buffer: key1[0],
+            pad: key1[1],
+            extra_keys: key2,
         }
     }
-
-    #[cfg(test)]
+ 
+    #[inline]
     #[allow(dead_code)] // Is not called if non-fallback hash is used.
-    pub(crate) fn test_with_keys(key1: u64, key2: u64) -> AHasher {
-        use crate::random_state::scramble_keys;
-        let (k1, k2, k3, k4) = scramble_keys(key1, key2);
+    pub(crate) fn from_random_state(rand_state: &RandomState) -> AHasher  {
         AHasher {
-            buffer: k1,
-            pad: k2,
-            extra_keys: [k3, k4],
+            buffer: rand_state.k0,
+            pad: rand_state.k1,
+            extra_keys: [rand_state.k2, rand_state.k3],
         }
     }
 
@@ -117,7 +120,9 @@ impl HasherExt for AHasher {
     }
 }
 
-/// Provides methods to hash all of the primitive types.
+/// Provides [Hasher] methods to hash all of the primitive types.
+///
+/// [Hasher]: core::hash::Hasher
 impl Hasher for AHasher {
     #[inline]
     fn write_u8(&mut self, i: u8) {
@@ -141,9 +146,7 @@ impl Hasher for AHasher {
 
     #[inline]
     fn write_u128(&mut self, i: u128) {
-        let data: [u64; 2] = i.convert();
-        self.update(data[0]);
-        self.update(data[1]);
+        self.large_update(i);
     }
 
     #[inline]

src/hash_quality_test.rs

@@ -93,7 +93,7 @@ fn test_no_full_collisions<T: Hasher>(gen_hash: impl Fn() -> T) {
     assert_eq!(2396744, map.len());
 }
 
-fn test_keys_change_output<T: HasherExt>(constructor: impl Fn(u64, u64) -> T) {
+fn test_keys_change_output<T: HasherExt>(constructor: impl Fn(u128, u128) -> T) {
     let mut a = constructor(1, 1);
     let mut b = constructor(1, 2);
     let mut c = constructor(2, 1);
@@ -110,7 +110,7 @@ fn test_keys_change_output<T: HasherExt>(constructor: impl Fn(u64, u64) -> T) {
     assert_sufficiently_different(c.finish(), d.finish(), 1);
 }
 
-fn test_input_affect_every_byte<T: HasherExt>(constructor: impl Fn(u64, u64) -> T) {
+fn test_input_affect_every_byte<T: HasherExt>(constructor: impl Fn(u128, u128) -> T) {
     let base = 0.get_hash(constructor(0, 0));
     for shift in 0..16 {
         let mut alternitives = vec![];
@@ -124,13 +124,13 @@ fn test_input_affect_every_byte<T: HasherExt>(constructor: impl Fn(u64, u64) ->
 }
 
 ///Ensures that for every bit in the output there is some value for each byte in the key that flips it.
-fn test_keys_affect_every_byte<H: Hash, T: HasherExt>(item: H, constructor: impl Fn(u64, u64) -> T) {
+fn test_keys_affect_every_byte<H: Hash, T: HasherExt>(item: H, constructor: impl Fn(u128, u128) -> T) {
     let base = item.get_hash(constructor(0, 0));
-    for shift in 0..8 {
+    for shift in 0..16 {
         let mut alternitives1 = vec![];
         let mut alternitives2 = vec![];
         for v in 0..256 {
-            let input = (v as u64) << (shift * 8);
+            let input = (v as u128) << (shift * 8);
             let hasher1 = constructor(input, 0);
             let hasher2 = constructor(0, input);
             let h1 = item.get_hash(hasher1);
@@ -151,16 +151,16 @@ fn assert_each_byte_differs(base: u64, alternitives: Vec<u64>) {
     assert_eq!(core::u64::MAX, changed_bits, "Bits changed: {:x}", changed_bits);
 }
 
-fn test_finish_is_consistent<T: Hasher>(constructor: impl Fn(u64, u64) -> T) {
+fn test_finish_is_consistent<T: Hasher>(constructor: impl Fn(u128, u128) -> T) {
     let mut hasher = constructor(1, 2);
     "Foo".hash(&mut hasher);
     let a = hasher.finish();
     let b = hasher.finish();
     assert_eq!(a, b);
 }
 
-fn test_single_key_bit_flip<T: Hasher>(constructor: impl Fn(u64, u64) -> T) {
-    for bit in 0..64 {
+fn test_single_key_bit_flip<T: Hasher>(constructor: impl Fn(u128, u128) -> T) {
+    for bit in 0..128 {
         let mut a = constructor(0, 0);
         let mut b = constructor(0, 1 << bit);
         let mut c = constructor(1 << bit, 0);
@@ -320,57 +320,58 @@ mod fallback_tests {
 
     #[test]
     fn fallback_single_bit_flip() {
-        test_single_bit_flip(|| AHasher::test_with_keys(0, 0))
+        test_single_bit_flip(|| AHasher::new_with_keys(0, 0))
     }
 
     #[test]
     fn fallback_single_key_bit_flip() {
-        test_single_key_bit_flip(AHasher::test_with_keys)
+        test_single_key_bit_flip(AHasher::new_with_keys)
     }
 
     #[test]
     fn fallback_all_bytes_matter() {
-        test_all_bytes_matter(|| AHasher::test_with_keys(0, 0));
+        test_all_bytes_matter(|| AHasher::new_with_keys(0, 0));
     }
 
     #[test]
     fn fallback_test_no_pair_collisions() {
-        test_no_pair_collisions(|| AHasher::test_with_keys(0, 0));
+        test_no_pair_collisions(|| AHasher::new_with_keys(0, 0));
     }
 
     #[test]
     fn fallback_test_no_full_collisions() {
-        test_no_full_collisions(|| AHasher::test_with_keys(12345, 67890));
+        test_no_full_collisions(|| AHasher::new_with_keys(12345, 67890));
     }
 
     #[test]
     fn fallback_keys_change_output() {
-        test_keys_change_output(AHasher::test_with_keys);
+        test_keys_change_output(AHasher::new_with_keys);
     }
 
     #[test]
     fn fallback_input_affect_every_byte() {
-        test_input_affect_every_byte(AHasher::test_with_keys);
+        test_input_affect_every_byte(AHasher::new_with_keys);
     }
 
     #[test]
     fn fallback_keys_affect_every_byte() {
-        test_keys_affect_every_byte(0, AHasher::test_with_keys);
-        test_keys_affect_every_byte("", AHasher::test_with_keys);
-        test_keys_affect_every_byte((0, 0), AHasher::test_with_keys);
+        //For fallback second key is not used in every hash.
+        test_keys_affect_every_byte(0, |a, b| AHasher::new_with_keys(a ^ b, a));
+        test_keys_affect_every_byte("", |a, b| AHasher::new_with_keys(a ^ b, a));
+        test_keys_affect_every_byte((0, 0), |a, b| AHasher::new_with_keys(a ^ b, a));
     }
 
     #[test]
     fn fallback_finish_is_consistant() {
-        test_finish_is_consistent(AHasher::test_with_keys)
+        test_finish_is_consistent(AHasher::new_with_keys)
     }
 
     #[test]
     fn fallback_padding_doesnot_collide() {
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(0, 0));
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(0, 1));
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(1, 0));
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(1, 1));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(0, 0));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(0, 1));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(1, 0));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(1, 1));
     }
 }
 
@@ -382,8 +383,8 @@ mod aes_tests {
     use crate::hash_quality_test::*;
     use std::hash::{Hash, Hasher};
 
-    const BAD_KEY: u64 = 0x5252_5252_5252_5252; //This encrypts to 0.
-    const BAD_KEY2: u64 = 0x6363_6363_6363_6363; //This decrypts to 0.
+    const BAD_KEY: u128 = 0x5252_5252_5252_5252_5252_5252_5252_5252; //This encrypts to 0.
+    const BAD_KEY2: u128 = 0x6363_6363_6363_6363_6363_6363_6363_6363; //This decrypts to 0.
 
     #[test]
     fn test_single_bit_in_byte() {
@@ -396,56 +397,56 @@ mod aes_tests {
 
     #[test]
     fn aes_single_bit_flip() {
-        test_single_bit_flip(|| AHasher::test_with_keys(BAD_KEY, BAD_KEY));
-        test_single_bit_flip(|| AHasher::test_with_keys(BAD_KEY2, BAD_KEY2));
+        test_single_bit_flip(|| AHasher::new_with_keys(BAD_KEY, BAD_KEY));
+        test_single_bit_flip(|| AHasher::new_with_keys(BAD_KEY2, BAD_KEY2));
     }
 
     #[test]
     fn aes_single_key_bit_flip() {
-        test_single_key_bit_flip(|k1, k2| AHasher::test_with_keys(k1, k2))
+        test_single_key_bit_flip(AHasher::new_with_keys)
     }
 
     #[test]
     fn aes_all_bytes_matter() {
-        test_all_bytes_matter(|| AHasher::test_with_keys(BAD_KEY, BAD_KEY));
-        test_all_bytes_matter(|| AHasher::test_with_keys(BAD_KEY2, BAD_KEY2));
+        test_all_bytes_matter(|| AHasher::new_with_keys(BAD_KEY, BAD_KEY));
+        test_all_bytes_matter(|| AHasher::new_with_keys(BAD_KEY2, BAD_KEY2));
     }
 
     #[test]
     fn aes_test_no_pair_collisions() {
-        test_no_pair_collisions(|| AHasher::test_with_keys(BAD_KEY, BAD_KEY));
-        test_no_pair_collisions(|| AHasher::test_with_keys(BAD_KEY2, BAD_KEY2));
+        test_no_pair_collisions(|| AHasher::new_with_keys(BAD_KEY, BAD_KEY));
+        test_no_pair_collisions(|| AHasher::new_with_keys(BAD_KEY2, BAD_KEY2));
     }
 
     #[test]
     fn ase_test_no_full_collisions() {
-        test_no_full_collisions(|| AHasher::test_with_keys(12345, 67890));
+        test_no_full_collisions(|| AHasher::new_with_keys(12345, 67890));
     }
 
     #[test]
     fn aes_keys_change_output() {
-        test_keys_change_output(AHasher::test_with_keys);
+        test_keys_change_output(AHasher::new_with_keys);
     }
 
     #[test]
     fn aes_input_affect_every_byte() {
-        test_input_affect_every_byte(AHasher::test_with_keys);
+        test_input_affect_every_byte(AHasher::new_with_keys);
     }
 
     #[test]
     fn aes_keys_affect_every_byte() {
-        test_keys_affect_every_byte(0, AHasher::test_with_keys);
-        test_keys_affect_every_byte("", AHasher::test_with_keys);
-        test_keys_affect_every_byte((0, 0), AHasher::test_with_keys);
+        test_keys_affect_every_byte(0, AHasher::new_with_keys);
+        test_keys_affect_every_byte("", AHasher::new_with_keys);
+        test_keys_affect_every_byte((0, 0), AHasher::new_with_keys);
     }
     #[test]
     fn aes_finish_is_consistant() {
-        test_finish_is_consistent(AHasher::test_with_keys)
+        test_finish_is_consistent(AHasher::new_with_keys)
     }
 
     #[test]
     fn aes_padding_doesnot_collide() {
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(BAD_KEY, BAD_KEY));
-        test_padding_doesnot_collide(|| AHasher::test_with_keys(BAD_KEY2, BAD_KEY2));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(BAD_KEY, BAD_KEY));
+        test_padding_doesnot_collide(|| AHasher::new_with_keys(BAD_KEY2, BAD_KEY2));
     }
 }