From db1b1919baba8be48d997d9f70a6a5df7e31612a Mon Sep 17 00:00:00 2001 From: Sean McArthur Date: Tue, 21 Jun 2016 14:27:15 -0700 Subject: [PATCH] std: use siphash-1-3 for HashMap --- src/libcore/hash/mod.rs | 3 + src/libcore/hash/sip.rs | 249 +++++++++++++++++++++++------ src/libcoretest/hash/sip.rs | 131 ++++++++++++--- src/libcoretest/lib.rs | 1 + src/libstd/collections/hash/map.rs | 28 +++- src/libstd/lib.rs | 1 + 6 files changed, 336 insertions(+), 77 deletions(-) diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 051eb974895ce..9e3f7a4a84a81 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -80,6 +80,9 @@ use mem; #[stable(feature = "rust1", since = "1.0.0")] pub use self::sip::SipHasher; +#[unstable(feature = "sip_hash_13", issue = "29754")] +pub use self::sip::{SipHasher13, SipHasher24}; + mod sip; /// A hashable type. diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index fd1dab7a1f043..c52c0b0730be7 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -8,12 +8,30 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! An implementation of SipHash 2-4. +//! An implementation of SipHash. use prelude::v1::*; +use marker::PhantomData; use ptr; -use super::Hasher; + +/// An implementation of SipHash 1-3. +/// +/// See: https://131002.net/siphash/ +#[unstable(feature = "sip_hash_13", issue = "29754")] +#[derive(Debug, Clone, Default)] +pub struct SipHasher13 { + hasher: Hasher, +} + +/// An implementation of SipHash 2-4. +/// +/// See: https://131002.net/siphash/ +#[unstable(feature = "sip_hash_13", issue = "29754")] +#[derive(Debug, Clone, Default)] +pub struct SipHasher24 { + hasher: Hasher, +} /// An implementation of SipHash 2-4. /// @@ -30,22 +48,31 @@ use super::Hasher; /// Although the SipHash algorithm is considered to be generally strong, /// it is not intended for cryptographic purposes. As such, all /// cryptographic uses of this implementation are _strongly discouraged_. -#[derive(Debug)] #[stable(feature = "rust1", since = "1.0.0")] -pub struct SipHasher { +#[derive(Debug, Clone, Default)] +pub struct SipHasher(SipHasher24); + +#[derive(Debug)] +struct Hasher { k0: u64, k1: u64, length: usize, // how many bytes we've processed + state: State, // hash State + tail: u64, // unprocessed bytes le + ntail: usize, // how many bytes in tail are valid + _marker: PhantomData, +} + +#[derive(Debug, Clone, Copy)] +struct State { // v0, v2 and v1, v3 show up in pairs in the algorithm, // and simd implementations of SipHash will use vectors // of v02 and v13. By placing them in this order in the struct, // the compiler can pick up on just a few simd optimizations by itself. - v0: u64, // hash state + v0: u64, v2: u64, v1: u64, v3: u64, - tail: u64, // unprocessed bytes le - ntail: usize, // how many bytes in tail are valid } // sadly, these macro definitions can't appear later, @@ -93,6 +120,9 @@ macro_rules! rotl { } macro_rules! compress { + ($state:expr) => ({ + compress!($state.v0, $state.v1, $state.v2, $state.v3) + }); ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => ({ $v0 = $v0.wrapping_add($v1); $v1 = rotl!($v1, 13); $v1 ^= $v0; @@ -101,7 +131,7 @@ macro_rules! compress { $v0 = $v0.wrapping_add($v3); $v3 = rotl!($v3, 21); $v3 ^= $v0; $v2 = $v2.wrapping_add($v1); $v1 = rotl!($v1, 17); $v1 ^= $v2; $v2 = rotl!($v2, 32); - }) + }); } impl SipHasher { @@ -116,16 +146,63 @@ impl SipHasher { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher { - let mut state = SipHasher { + SipHasher(SipHasher24::new_with_keys(key0, key1)) + } +} + + +impl SipHasher13 { + /// Creates a new `SipHasher13` with the two initial keys set to 0. + #[inline] + #[unstable(feature = "sip_hash_13", issue = "29754")] + pub fn new() -> SipHasher13 { + SipHasher13::new_with_keys(0, 0) + } + + /// Creates a `SipHasher13` that is keyed off the provided keys. + #[inline] + #[unstable(feature = "sip_hash_13", issue = "29754")] + pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 { + SipHasher13 { + hasher: Hasher::new_with_keys(key0, key1) + } + } +} + +impl SipHasher24 { + /// Creates a new `SipHasher24` with the two initial keys set to 0. + #[inline] + #[unstable(feature = "sip_hash_13", issue = "29754")] + pub fn new() -> SipHasher24 { + SipHasher24::new_with_keys(0, 0) + } + + /// Creates a `SipHasher24` that is keyed off the provided keys. + #[inline] + #[unstable(feature = "sip_hash_13", issue = "29754")] + pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher24 { + SipHasher24 { + hasher: Hasher::new_with_keys(key0, key1) + } + } +} + +impl Hasher { + #[inline] + fn new_with_keys(key0: u64, key1: u64) -> Hasher { + let mut state = Hasher { k0: key0, k1: key1, length: 0, - v0: 0, - v1: 0, - v2: 0, - v3: 0, + state: State { + v0: 0, + v1: 0, + v2: 0, + v3: 0, + }, tail: 0, ntail: 0, + _marker: PhantomData, }; state.reset(); state @@ -134,16 +211,54 @@ impl SipHasher { #[inline] fn reset(&mut self) { self.length = 0; - self.v0 = self.k0 ^ 0x736f6d6570736575; - self.v1 = self.k1 ^ 0x646f72616e646f6d; - self.v2 = self.k0 ^ 0x6c7967656e657261; - self.v3 = self.k1 ^ 0x7465646279746573; + self.state.v0 = self.k0 ^ 0x736f6d6570736575; + self.state.v1 = self.k1 ^ 0x646f72616e646f6d; + self.state.v2 = self.k0 ^ 0x6c7967656e657261; + self.state.v3 = self.k1 ^ 0x7465646279746573; self.ntail = 0; } } #[stable(feature = "rust1", since = "1.0.0")] -impl Hasher for SipHasher { +impl super::Hasher for SipHasher { + #[inline] + fn write(&mut self, msg: &[u8]) { + self.0.write(msg) + } + + #[inline] + fn finish(&self) -> u64 { + self.0.finish() + } +} + +#[unstable(feature = "sip_hash_13", issue = "29754")] +impl super::Hasher for SipHasher13 { + #[inline] + fn write(&mut self, msg: &[u8]) { + self.hasher.write(msg) + } + + #[inline] + fn finish(&self) -> u64 { + self.hasher.finish() + } +} + +#[unstable(feature = "sip_hash_13", issue = "29754")] +impl super::Hasher for SipHasher24 { + #[inline] + fn write(&mut self, msg: &[u8]) { + self.hasher.write(msg) + } + + #[inline] + fn finish(&self) -> u64 { + self.hasher.finish() + } +} + +impl super::Hasher for Hasher { #[inline] fn write(&mut self, msg: &[u8]) { let length = msg.len(); @@ -161,10 +276,9 @@ impl Hasher for SipHasher { let m = self.tail | u8to64_le!(msg, 0, needed) << 8 * self.ntail; - self.v3 ^= m; - compress!(self.v0, self.v1, self.v2, self.v3); - compress!(self.v0, self.v1, self.v2, self.v3); - self.v0 ^= m; + self.state.v3 ^= m; + S::c_rounds(&mut self.state); + self.state.v0 ^= m; self.ntail = 0; } @@ -177,10 +291,9 @@ impl Hasher for SipHasher { while i < len - left { let mi = unsafe { load_u64_le(msg, i) }; - self.v3 ^= mi; - compress!(self.v0, self.v1, self.v2, self.v3); - compress!(self.v0, self.v1, self.v2, self.v3); - self.v0 ^= mi; + self.state.v3 ^= mi; + S::c_rounds(&mut self.state); + self.state.v0 ^= mi; i += 8; } @@ -191,49 +304,81 @@ impl Hasher for SipHasher { #[inline] fn finish(&self) -> u64 { - let mut v0 = self.v0; - let mut v1 = self.v1; - let mut v2 = self.v2; - let mut v3 = self.v3; + let mut state = self.state; let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail; - v3 ^= b; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - v0 ^= b; + state.v3 ^= b; + S::c_rounds(&mut state); + state.v0 ^= b; - v2 ^= 0xff; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); + state.v2 ^= 0xff; + S::d_rounds(&mut state); - v0 ^ v1 ^ v2 ^ v3 + state.v0 ^ state.v1 ^ state.v2 ^ state.v3 } } -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for SipHasher { +impl Clone for Hasher { #[inline] - fn clone(&self) -> SipHasher { - SipHasher { + fn clone(&self) -> Hasher { + Hasher { k0: self.k0, k1: self.k1, length: self.length, - v0: self.v0, - v1: self.v1, - v2: self.v2, - v3: self.v3, + state: self.state, tail: self.tail, ntail: self.ntail, + _marker: self._marker, } } } -#[stable(feature = "rust1", since = "1.0.0")] -impl Default for SipHasher { - fn default() -> SipHasher { - SipHasher::new() +impl Default for Hasher { + #[inline] + fn default() -> Hasher { + Hasher::new_with_keys(0, 0) + } +} + +#[doc(hidden)] +trait Sip { + fn c_rounds(&mut State); + fn d_rounds(&mut State); +} + +#[derive(Debug, Clone, Default)] +struct Sip13Rounds; + +impl Sip for Sip13Rounds { + #[inline] + fn c_rounds(state: &mut State) { + compress!(state); + } + + #[inline] + fn d_rounds(state: &mut State) { + compress!(state); + compress!(state); + compress!(state); + } +} + +#[derive(Debug, Clone, Default)] +struct Sip24Rounds; + +impl Sip for Sip24Rounds { + #[inline] + fn c_rounds(state: &mut State) { + compress!(state); + compress!(state); + } + + #[inline] + fn d_rounds(state: &mut State) { + compress!(state); + compress!(state); + compress!(state); + compress!(state); } } diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs index 9b6cedd25b741..a5e6005545bd7 100644 --- a/src/libcoretest/hash/sip.rs +++ b/src/libcoretest/hash/sip.rs @@ -10,7 +10,7 @@ use test::{Bencher, black_box}; use core::hash::{Hash, Hasher}; -use core::hash::SipHasher; +use core::hash::{SipHasher, SipHasher13, SipHasher24}; // Hash just the bytes of the slice, without length prefix struct Bytes<'a>(&'a [u8]); @@ -45,27 +45,117 @@ macro_rules! u8to64_le { }); } -fn hash(x: &T) -> u64 { - let mut st = SipHasher::new(); +fn hash_with(mut st: H, x: &T) -> u64 { x.hash(&mut st); st.finish() } -fn hash_with_keys(k1: u64, k2: u64, x: &T) -> u64 { - let mut st = SipHasher::new_with_keys(k1, k2); - x.hash(&mut st); - st.finish() +fn hash(x: &T) -> u64 { + hash_with(SipHasher::new(), x) } -fn hash_bytes(x: &[u8]) -> u64 { - let mut s = SipHasher::default(); +fn hash_bytes(mut s: H, x: &[u8]) -> u64 { Hasher::write(&mut s, x); s.finish() } #[test] #[allow(unused_must_use)] -fn test_siphash() { +fn test_siphash_1_3() { + let vecs : [[u8; 8]; 64] = [ + [ 0xdc, 0xc4, 0x0f, 0x05, 0x58, 0x01, 0xac, 0xab ], + [ 0x93, 0xca, 0x57, 0x7d, 0xf3, 0x9b, 0xf4, 0xc9 ], + [ 0x4d, 0xd4, 0xc7, 0x4d, 0x02, 0x9b, 0xcb, 0x82 ], + [ 0xfb, 0xf7, 0xdd, 0xe7, 0xb8, 0x0a, 0xf8, 0x8b ], + [ 0x28, 0x83, 0xd3, 0x88, 0x60, 0x57, 0x75, 0xcf ], + [ 0x67, 0x3b, 0x53, 0x49, 0x2f, 0xd5, 0xf9, 0xde ], + [ 0xa7, 0x22, 0x9f, 0xc5, 0x50, 0x2b, 0x0d, 0xc5 ], + [ 0x40, 0x11, 0xb1, 0x9b, 0x98, 0x7d, 0x92, 0xd3 ], + [ 0x8e, 0x9a, 0x29, 0x8d, 0x11, 0x95, 0x90, 0x36 ], + [ 0xe4, 0x3d, 0x06, 0x6c, 0xb3, 0x8e, 0xa4, 0x25 ], + [ 0x7f, 0x09, 0xff, 0x92, 0xee, 0x85, 0xde, 0x79 ], + [ 0x52, 0xc3, 0x4d, 0xf9, 0xc1, 0x18, 0xc1, 0x70 ], + [ 0xa2, 0xd9, 0xb4, 0x57, 0xb1, 0x84, 0xa3, 0x78 ], + [ 0xa7, 0xff, 0x29, 0x12, 0x0c, 0x76, 0x6f, 0x30 ], + [ 0x34, 0x5d, 0xf9, 0xc0, 0x11, 0xa1, 0x5a, 0x60 ], + [ 0x56, 0x99, 0x51, 0x2a, 0x6d, 0xd8, 0x20, 0xd3 ], + [ 0x66, 0x8b, 0x90, 0x7d, 0x1a, 0xdd, 0x4f, 0xcc ], + [ 0x0c, 0xd8, 0xdb, 0x63, 0x90, 0x68, 0xf2, 0x9c ], + [ 0x3e, 0xe6, 0x73, 0xb4, 0x9c, 0x38, 0xfc, 0x8f ], + [ 0x1c, 0x7d, 0x29, 0x8d, 0xe5, 0x9d, 0x1f, 0xf2 ], + [ 0x40, 0xe0, 0xcc, 0xa6, 0x46, 0x2f, 0xdc, 0xc0 ], + [ 0x44, 0xf8, 0x45, 0x2b, 0xfe, 0xab, 0x92, 0xb9 ], + [ 0x2e, 0x87, 0x20, 0xa3, 0x9b, 0x7b, 0xfe, 0x7f ], + [ 0x23, 0xc1, 0xe6, 0xda, 0x7f, 0x0e, 0x5a, 0x52 ], + [ 0x8c, 0x9c, 0x34, 0x67, 0xb2, 0xae, 0x64, 0xf4 ], + [ 0x79, 0x09, 0x5b, 0x70, 0x28, 0x59, 0xcd, 0x45 ], + [ 0xa5, 0x13, 0x99, 0xca, 0xe3, 0x35, 0x3e, 0x3a ], + [ 0x35, 0x3b, 0xde, 0x4a, 0x4e, 0xc7, 0x1d, 0xa9 ], + [ 0x0d, 0xd0, 0x6c, 0xef, 0x02, 0xed, 0x0b, 0xfb ], + [ 0xf4, 0xe1, 0xb1, 0x4a, 0xb4, 0x3c, 0xd9, 0x88 ], + [ 0x63, 0xe6, 0xc5, 0x43, 0xd6, 0x11, 0x0f, 0x54 ], + [ 0xbc, 0xd1, 0x21, 0x8c, 0x1f, 0xdd, 0x70, 0x23 ], + [ 0x0d, 0xb6, 0xa7, 0x16, 0x6c, 0x7b, 0x15, 0x81 ], + [ 0xbf, 0xf9, 0x8f, 0x7a, 0xe5, 0xb9, 0x54, 0x4d ], + [ 0x3e, 0x75, 0x2a, 0x1f, 0x78, 0x12, 0x9f, 0x75 ], + [ 0x91, 0x6b, 0x18, 0xbf, 0xbe, 0xa3, 0xa1, 0xce ], + [ 0x06, 0x62, 0xa2, 0xad, 0xd3, 0x08, 0xf5, 0x2c ], + [ 0x57, 0x30, 0xc3, 0xa3, 0x2d, 0x1c, 0x10, 0xb6 ], + [ 0xa1, 0x36, 0x3a, 0xae, 0x96, 0x74, 0xf4, 0xb3 ], + [ 0x92, 0x83, 0x10, 0x7b, 0x54, 0x57, 0x6b, 0x62 ], + [ 0x31, 0x15, 0xe4, 0x99, 0x32, 0x36, 0xd2, 0xc1 ], + [ 0x44, 0xd9, 0x1a, 0x3f, 0x92, 0xc1, 0x7c, 0x66 ], + [ 0x25, 0x88, 0x13, 0xc8, 0xfe, 0x4f, 0x70, 0x65 ], + [ 0xa6, 0x49, 0x89, 0xc2, 0xd1, 0x80, 0xf2, 0x24 ], + [ 0x6b, 0x87, 0xf8, 0xfa, 0xed, 0x1c, 0xca, 0xc2 ], + [ 0x96, 0x21, 0x04, 0x9f, 0xfc, 0x4b, 0x16, 0xc2 ], + [ 0x23, 0xd6, 0xb1, 0x68, 0x93, 0x9c, 0x6e, 0xa1 ], + [ 0xfd, 0x14, 0x51, 0x8b, 0x9c, 0x16, 0xfb, 0x49 ], + [ 0x46, 0x4c, 0x07, 0xdf, 0xf8, 0x43, 0x31, 0x9f ], + [ 0xb3, 0x86, 0xcc, 0x12, 0x24, 0xaf, 0xfd, 0xc6 ], + [ 0x8f, 0x09, 0x52, 0x0a, 0xd1, 0x49, 0xaf, 0x7e ], + [ 0x9a, 0x2f, 0x29, 0x9d, 0x55, 0x13, 0xf3, 0x1c ], + [ 0x12, 0x1f, 0xf4, 0xa2, 0xdd, 0x30, 0x4a, 0xc4 ], + [ 0xd0, 0x1e, 0xa7, 0x43, 0x89, 0xe9, 0xfa, 0x36 ], + [ 0xe6, 0xbc, 0xf0, 0x73, 0x4c, 0xb3, 0x8f, 0x31 ], + [ 0x80, 0xe9, 0xa7, 0x70, 0x36, 0xbf, 0x7a, 0xa2 ], + [ 0x75, 0x6d, 0x3c, 0x24, 0xdb, 0xc0, 0xbc, 0xb4 ], + [ 0x13, 0x15, 0xb7, 0xfd, 0x52, 0xd8, 0xf8, 0x23 ], + [ 0x08, 0x8a, 0x7d, 0xa6, 0x4d, 0x5f, 0x03, 0x8f ], + [ 0x48, 0xf1, 0xe8, 0xb7, 0xe5, 0xd0, 0x9c, 0xd8 ], + [ 0xee, 0x44, 0xa6, 0xf7, 0xbc, 0xe6, 0xf4, 0xf6 ], + [ 0xf2, 0x37, 0x18, 0x0f, 0xd8, 0x9a, 0xc5, 0xae ], + [ 0xe0, 0x94, 0x66, 0x4b, 0x15, 0xf6, 0xb2, 0xc3 ], + [ 0xa8, 0xb3, 0xbb, 0xb7, 0x62, 0x90, 0x19, 0x9d ] + ]; + + let k0 = 0x_07_06_05_04_03_02_01_00; + let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08; + let mut buf = Vec::new(); + let mut t = 0; + let mut state_inc = SipHasher13::new_with_keys(k0, k1); + + while t < 64 { + let vec = u8to64_le!(vecs[t], 0); + let out = hash_with(SipHasher13::new_with_keys(k0, k1), &Bytes(&buf)); + assert_eq!(vec, out); + + let full = hash_with(SipHasher13::new_with_keys(k0, k1), &Bytes(&buf)); + let i = state_inc.finish(); + + assert_eq!(full, i); + assert_eq!(full, vec); + + buf.push(t as u8); + Hasher::write(&mut state_inc, &[t as u8]); + + t += 1; + } +} + +#[test] +#[allow(unused_must_use)] +fn test_siphash_2_4() { let vecs : [[u8; 8]; 64] = [ [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ], [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ], @@ -137,14 +227,14 @@ fn test_siphash() { let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08; let mut buf = Vec::new(); let mut t = 0; - let mut state_inc = SipHasher::new_with_keys(k0, k1); + let mut state_inc = SipHasher24::new_with_keys(k0, k1); while t < 64 { let vec = u8to64_le!(vecs[t], 0); - let out = hash_with_keys(k0, k1, &Bytes(&buf)); + let out = hash_with(SipHasher24::new_with_keys(k0, k1), &Bytes(&buf)); assert_eq!(vec, out); - let full = hash_with_keys(k0, k1, &Bytes(&buf)); + let full = hash_with(SipHasher24::new_with_keys(k0, k1), &Bytes(&buf)); let i = state_inc.finish(); assert_eq!(full, i); @@ -156,7 +246,6 @@ fn test_siphash() { t += 1; } } - #[test] #[cfg(target_arch = "arm")] fn test_hash_usize() { let val = 0xdeadbeef_deadbeef_u64; @@ -289,7 +378,7 @@ fn bench_u32_keyed(b: &mut Bencher) { let k1 = black_box(0x1); let k2 = black_box(0x2); b.iter(|| { - hash_with_keys(k1, k2, &u) + hash_with(SipHasher::new_with_keys(k1, k2), &u) }); b.bytes = 8; } @@ -308,7 +397,7 @@ fn bench_u64(b: &mut Bencher) { fn bench_bytes_4(b: &mut Bencher) { let data = black_box([b' '; 4]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 4; } @@ -317,7 +406,7 @@ fn bench_bytes_4(b: &mut Bencher) { fn bench_bytes_7(b: &mut Bencher) { let data = black_box([b' '; 7]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 7; } @@ -326,7 +415,7 @@ fn bench_bytes_7(b: &mut Bencher) { fn bench_bytes_8(b: &mut Bencher) { let data = black_box([b' '; 8]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 8; } @@ -335,7 +424,7 @@ fn bench_bytes_8(b: &mut Bencher) { fn bench_bytes_a_16(b: &mut Bencher) { let data = black_box([b' '; 16]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 16; } @@ -344,7 +433,7 @@ fn bench_bytes_a_16(b: &mut Bencher) { fn bench_bytes_b_32(b: &mut Bencher) { let data = black_box([b' '; 32]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 32; } @@ -353,7 +442,7 @@ fn bench_bytes_b_32(b: &mut Bencher) { fn bench_bytes_c_128(b: &mut Bencher) { let data = black_box([b' '; 128]); b.iter(|| { - hash_bytes(&data) + hash_bytes(SipHasher::default(), &data) }); b.bytes = 128; } diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 88d73df937f7e..0c4385725edfc 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -26,6 +26,7 @@ #![feature(nonzero)] #![feature(rand)] #![feature(raw)] +#![feature(sip_hash_13)] #![feature(slice_patterns)] #![feature(step_by)] #![feature(test)] diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 536f168e40108..60d7e01d98814 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -14,7 +14,7 @@ use self::VacantEntryState::*; use borrow::Borrow; use cmp::max; use fmt::{self, Debug}; -use hash::{Hash, SipHasher, BuildHasher}; +use hash::{Hash, Hasher, BuildHasher, SipHasher13}; use iter::FromIterator; use mem::{self, replace}; use ops::{Deref, Index}; @@ -1711,10 +1711,30 @@ impl RandomState { #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] impl BuildHasher for RandomState { - type Hasher = SipHasher; + type Hasher = DefaultHasher; #[inline] - fn build_hasher(&self) -> SipHasher { - SipHasher::new_with_keys(self.k0, self.k1) + fn build_hasher(&self) -> DefaultHasher { + DefaultHasher(SipHasher13::new_with_keys(self.k0, self.k1)) + } +} + +/// The default `Hasher` used by `RandomState`. +/// +/// The internal algorithm is not specified, and so it and its hashes should +/// not be relied upon over releases. +#[unstable(feature = "hashmap_default_hasher", issue = "0")] +pub struct DefaultHasher(SipHasher13); + +#[unstable(feature = "hashmap_default_hasher", issue = "0")] +impl Hasher for DefaultHasher { + #[inline] + fn write(&mut self, msg: &[u8]) { + self.0.write(msg) + } + + #[inline] + fn finish(&self) -> u64 { + self.0.finish() } } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 135ea8a5e7cb4..a396c7be09ad1 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -255,6 +255,7 @@ #![feature(reflect_marker)] #![feature(rustc_attrs)] #![feature(shared)] +#![feature(sip_hash_13)] #![feature(slice_bytes)] #![feature(slice_concat_ext)] #![feature(slice_patterns)]