std: use siphash-1-3 for HashMap
This commit is contained in:
Sean McArthur
parent
59152a45af
commit
db1b1919ba
6 changed files with 339 additions and 80 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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<Sip13Rounds>,
|
||||
}
|
||||
|
||||
/// 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<Sip24Rounds>,
|
||||
}
|
||||
|
||||
/// 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<S: Sip> {
|
||||
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<S>,
|
||||
}
|
||||
|
||||
#[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<S: Sip> Hasher<S> {
|
||||
#[inline]
|
||||
fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {
|
||||
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<S: Sip> super::Hasher for Hasher<S> {
|
||||
#[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<S: Sip> Clone for Hasher<S> {
|
||||
#[inline]
|
||||
fn clone(&self) -> SipHasher {
|
||||
SipHasher {
|
||||
fn clone(&self) -> Hasher<S> {
|
||||
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<S: Sip> Default for Hasher<S> {
|
||||
#[inline]
|
||||
fn default() -> Hasher<S> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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_with<H: Hasher, T: Hash>(mut st: H, x: &T) -> u64 {
|
||||
x.hash(&mut st);
|
||||
st.finish()
|
||||
}
|
||||
|
||||
fn hash<T: Hash>(x: &T) -> u64 {
|
||||
let mut st = SipHasher::new();
|
||||
x.hash(&mut st);
|
||||
st.finish()
|
||||
hash_with(SipHasher::new(), x)
|
||||
}
|
||||
|
||||
fn hash_with_keys<T: Hash>(k1: u64, k2: u64, x: &T) -> u64 {
|
||||
let mut st = SipHasher::new_with_keys(k1, k2);
|
||||
x.hash(&mut st);
|
||||
st.finish()
|
||||
}
|
||||
|
||||
fn hash_bytes(x: &[u8]) -> u64 {
|
||||
let mut s = SipHasher::default();
|
||||
fn hash_bytes<H: Hasher>(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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@
|
|||
#![feature(nonzero)]
|
||||
#![feature(rand)]
|
||||
#![feature(raw)]
|
||||
#![feature(sip_hash_13)]
|
||||
#![feature(slice_patterns)]
|
||||
#![feature(step_by)]
|
||||
#![feature(test)]
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue