From 24a8ef63ff786dd702d428f73fd64aac2a828f19 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Fri, 12 Dec 2014 18:43:07 -0800 Subject: [PATCH] Move hash module from collections to core --- src/liballoc/boxed.rs | 9 + src/liballoc/lib.rs | 2 +- src/liballoc/rc.rs | 9 + src/libcollections/lib.rs | 3 +- src/libcollections/str.rs | 2 +- src/libcollections/string.rs | 2 +- src/libcollections/vec.rs | 8 + src/libcollections/vec_map.rs | 4 +- src/{libcollections => libcore}/hash/mod.rs | 164 +----------- src/{libcollections => libcore}/hash/sip.rs | 5 +- src/libcore/lib.rs | 2 + src/libcore/option.rs | 2 +- src/libcore/result.rs | 2 +- src/libcoretest/hash/mod.rs | 101 +++++++ src/libcoretest/hash/sip.rs | 283 ++++++++++++++++++++ src/libcoretest/lib.rs | 3 +- src/librustrt/c_str.rs | 2 +- src/libstd/hash.rs | 2 +- 18 files changed, 433 insertions(+), 172 deletions(-) rename src/{libcollections => libcore}/hash/mod.rs (60%) rename src/{libcollections => libcore}/hash/sip.rs (99%) create mode 100644 src/libcoretest/hash/mod.rs create mode 100644 src/libcoretest/hash/sip.rs diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index b0ba20b0133..c6afeb063fb 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -15,6 +15,7 @@ use core::clone::Clone; use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; +use core::hash::{mod, Hash}; use core::kinds::Sized; use core::mem; use core::option::Option; @@ -93,6 +94,14 @@ impl Ord for Box { } impl Eq for Box {} +impl> Hash for Box { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } +} + + /// Extension methods for an owning `Any` trait object. #[unstable = "post-DST and coherence changes, this will not be a trait but \ rather a direct `impl` on `Box`"] diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 0b27fbd4404..61b5d43d1cb 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -64,7 +64,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/")] #![no_std] -#![feature(lang_items, phase, unsafe_destructor)] +#![feature(lang_items, phase, unsafe_destructor, default_type_params)] #[phase(plugin, link)] extern crate core; diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 217c898e661..7af816f2e09 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -147,6 +147,7 @@ use core::clone::Clone; use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; +use core::hash::{mod, Hash}; use core::kinds::marker; use core::mem::{transmute, min_align_of, size_of, forget}; use core::ops::{Deref, Drop}; @@ -594,6 +595,14 @@ impl Ord for Rc { fn cmp(&self, other: &Rc) -> Ordering { (**self).cmp(&**other) } } +// FIXME (#18248) Make `T` `Sized?` +impl> Hash for Rc { + #[inline] + fn hash(&self, state: &mut S) { + (**self).hash(state); + } +} + #[experimental = "Show is experimental."] impl fmt::Show for Rc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 274fa13d074..1d60d7612a0 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -67,7 +67,6 @@ pub mod slice; pub mod str; pub mod string; pub mod vec; -pub mod hash; pub mod vec_map; pub mod bitv { @@ -116,5 +115,5 @@ mod std { pub use core::clone; // deriving(Clone) pub use core::cmp; // deriving(Eq, Ord, etc.) pub use core::kinds; // deriving(Copy) - pub use hash; // deriving(Hash) + pub use core::hash; // deriving(Hash) } diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 3c3a1291ba0..d14552afebe 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -60,10 +60,10 @@ use self::DecompositionType::*; use core::borrow::{BorrowFrom, Cow, ToOwned}; use core::default::Default; use core::fmt; +use core::hash; use core::cmp; use core::iter::AdditiveIterator; -use hash; use ring_buf::RingBuf; use string::String; use unicode; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 7f78f547298..bc179cb37fb 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -17,13 +17,13 @@ use core::prelude::*; use core::borrow::{Cow, IntoCow}; use core::default::Default; use core::fmt; +use core::hash; use core::mem; use core::ptr; use core::ops; // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait use core::raw::Slice as RawSlice; -use hash; use slice::CloneSliceExt; use str; use str::{CharRange, CowString, FromStr, StrAllocating, Owned}; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 932366d77ad..fa4cfc99753 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -20,6 +20,7 @@ use core::borrow::{Cow, IntoCow}; use core::cmp::max; use core::default::Default; use core::fmt; +use core::hash::{mod, Hash}; use core::kinds::marker::{ContravariantLifetime, InvariantType}; use core::kinds::Sized; use core::mem; @@ -619,6 +620,13 @@ impl Ord for Vec { } } +impl> Hash for Vec { + #[inline] + fn hash(&self, state: &mut S) { + self.as_slice().hash(state); + } +} + // FIXME: #13996: need a way to mark the return value as `noalias` #[inline(never)] unsafe fn alloc_or_realloc(ptr: *mut T, old_size: uint, size: uint) -> *mut T { diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index cc2fd0a6646..5762acb8e71 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -17,12 +17,12 @@ use core::prelude::*; use core::default::Default; use core::fmt; +use core::hash::{Hash, Writer}; use core::iter; use core::iter::{Enumerate, FilterMap}; use core::mem::replace; use core::ops::FnOnce; -use hash::{Hash, Writer}; use {vec, slice}; use vec::Vec; @@ -642,7 +642,7 @@ pub type MoveItems = FilterMap< mod test_map { use std::prelude::*; use vec::Vec; - use hash::hash; + use core::hash::hash; use super::VecMap; diff --git a/src/libcollections/hash/mod.rs b/src/libcore/hash/mod.rs similarity index 60% rename from src/libcollections/hash/mod.rs rename to src/libcore/hash/mod.rs index 446ebbbdbe9..671ab825829 100644 --- a/src/libcollections/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -61,16 +61,12 @@ #![allow(unused_must_use)] -use core::prelude::*; +use prelude::*; -use alloc::boxed::Box; -use alloc::rc::Rc; -use core::borrow::{Cow, ToOwned}; -use core::intrinsics::TypeId; -use core::mem; -use core::num::Int; - -use vec::Vec; +use borrow::{Cow, ToOwned}; +use intrinsics::TypeId; +use mem; +use num::Int; /// Reexport the `sip::hash` function as our default hasher. pub use self::sip::hash as hash; @@ -92,6 +88,7 @@ pub trait Hasher { fn hash>(&self, value: &T) -> u64; } +#[allow(missing_docs)] pub trait Writer { fn write(&mut self, bytes: &[u8]); } @@ -103,7 +100,7 @@ macro_rules! impl_hash { impl Hash for $ty { #[inline] fn hash(&self, state: &mut S) { - let a: [u8, ..::core::$ty::BYTES] = unsafe { + let a: [u8, ..::$ty::BYTES] = unsafe { mem::transmute((*self as $uty).to_le() as $ty) }; state.write(a.as_slice()) @@ -197,13 +194,6 @@ impl> Hash for [T] { } -impl> Hash for Vec { - #[inline] - fn hash(&self, state: &mut S) { - self.as_slice().hash(state); - } -} - impl<'a, S: Writer, Sized? T: Hash> Hash for &'a T { #[inline] fn hash(&self, state: &mut S) { @@ -218,36 +208,6 @@ impl<'a, S: Writer, Sized? T: Hash> Hash for &'a mut T { } } -impl> Hash for Box { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } -} - -// FIXME (#18248) Make `T` `Sized?` -impl> Hash for Rc { - #[inline] - fn hash(&self, state: &mut S) { - (**self).hash(state); - } -} - -impl> Hash for Option { - #[inline] - fn hash(&self, state: &mut S) { - match *self { - Some(ref x) => { - 0u8.hash(state); - x.hash(state); - } - None => { - 1u8.hash(state); - } - } - } -} - impl Hash for *const T { #[inline] fn hash(&self, state: &mut S) { @@ -273,119 +233,9 @@ impl Hash for TypeId { } } -impl, U: Hash> Hash for Result { - #[inline] - fn hash(&self, state: &mut S) { - match *self { - Ok(ref t) => { 1u.hash(state); t.hash(state); } - Err(ref t) => { 2u.hash(state); t.hash(state); } - } - } -} - impl<'a, T, Sized? B, S> Hash for Cow<'a, T, B> where B: Hash + ToOwned { #[inline] fn hash(&self, state: &mut S) { Hash::hash(&**self, state) } } - -////////////////////////////////////////////////////////////////////////////// - -#[cfg(test)] -mod tests { - use core::kinds::Sized; - use std::mem; - - use slice::SliceExt; - use super::{Hash, Hasher, Writer}; - - struct MyWriterHasher; - - impl Hasher for MyWriterHasher { - fn hash>(&self, value: &T) -> u64 { - let mut state = MyWriter { hash: 0 }; - value.hash(&mut state); - state.hash - } - } - - struct MyWriter { - hash: u64, - } - - impl Writer for MyWriter { - // Most things we'll just add up the bytes. - fn write(&mut self, buf: &[u8]) { - for byte in buf.iter() { - self.hash += *byte as u64; - } - } - } - - #[test] - fn test_writer_hasher() { - use alloc::boxed::Box; - - let hasher = MyWriterHasher; - - assert_eq!(hasher.hash(&()), 0); - - assert_eq!(hasher.hash(&5u8), 5); - assert_eq!(hasher.hash(&5u16), 5); - assert_eq!(hasher.hash(&5u32), 5); - assert_eq!(hasher.hash(&5u64), 5); - assert_eq!(hasher.hash(&5u), 5); - - assert_eq!(hasher.hash(&5i8), 5); - assert_eq!(hasher.hash(&5i16), 5); - assert_eq!(hasher.hash(&5i32), 5); - assert_eq!(hasher.hash(&5i64), 5); - assert_eq!(hasher.hash(&5i), 5); - - assert_eq!(hasher.hash(&false), 0); - assert_eq!(hasher.hash(&true), 1); - - assert_eq!(hasher.hash(&'a'), 97); - - let s: &str = "a"; - assert_eq!(hasher.hash(& s), 97 + 0xFF); - // FIXME (#18283) Enable test - //let s: Box = box "a"; - //assert_eq!(hasher.hash(& s), 97 + 0xFF); - let cs: &[u8] = &[1u8, 2u8, 3u8]; - assert_eq!(hasher.hash(& cs), 9); - let cs: Box<[u8]> = box [1u8, 2u8, 3u8]; - assert_eq!(hasher.hash(& cs), 9); - - // FIXME (#18248) Add tests for hashing Rc and Rc<[T]> - - unsafe { - let ptr: *const int = mem::transmute(5i); - assert_eq!(hasher.hash(&ptr), 5); - } - - unsafe { - let ptr: *mut int = mem::transmute(5i); - assert_eq!(hasher.hash(&ptr), 5); - } - } - - struct Custom { - hash: u64 - } - - impl Hash for Custom { - fn hash(&self, state: &mut u64) { - *state = self.hash; - } - } - - #[test] - fn test_custom_state() { - let custom = Custom { hash: 5 }; - let mut state = 0; - custom.hash(&mut state); - assert_eq!(state, 5); - } -} diff --git a/src/libcollections/hash/sip.rs b/src/libcore/hash/sip.rs similarity index 99% rename from src/libcollections/hash/sip.rs rename to src/libcore/hash/sip.rs index 575e407fc2a..62752072e2f 100644 --- a/src/libcollections/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -24,9 +24,8 @@ //! As such, all cryptographic uses of this implementation are strongly //! discouraged. -use core::prelude::*; - -use core::default::Default; +use prelude::*; +use default::Default; use super::{Hash, Hasher, Writer}; diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 84d84cbd5e1..729cb69193e 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -121,6 +121,7 @@ pub mod simd; pub mod slice; pub mod str; pub mod tuple; +pub mod hash; // FIXME #15320: primitive documentation needs top-level modules, this // should be `core::tuple::unit`. #[path = "tuple/unit.rs"] @@ -142,4 +143,5 @@ mod std { pub use kinds; pub use option; pub use fmt; + pub use hash; } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 7be47f73e9e..020e907a423 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -164,7 +164,7 @@ use ops::{Deref, FnOnce}; // which basically means it must be `Option`. /// The `Option` type. -#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)] +#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show, Hash)] #[stable] pub enum Option { /// No value diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 88d33a59b38..6dd23abf11f 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -244,7 +244,7 @@ use ops::{FnMut, FnOnce}; /// `Result` is a type that represents either success (`Ok`) or failure (`Err`). /// /// See the [`std::result`](index.html) module documentation for details. -#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)] +#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show, Hash)] #[must_use] #[stable] pub enum Result { diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs new file mode 100644 index 00000000000..23f9be124da --- /dev/null +++ b/src/libcoretest/hash/mod.rs @@ -0,0 +1,101 @@ +// Copyright 2014 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. +use core::kinds::Sized; +use std::mem; + +use core::slice::SliceExt; +use core::hash::{Hash, Hasher, Writer}; + +struct MyWriterHasher; + +impl Hasher for MyWriterHasher { + fn hash>(&self, value: &T) -> u64 { + let mut state = MyWriter { hash: 0 }; + value.hash(&mut state); + state.hash + } +} + +struct MyWriter { + hash: u64, +} + +impl Writer for MyWriter { + // Most things we'll just add up the bytes. + fn write(&mut self, buf: &[u8]) { + for byte in buf.iter() { + self.hash += *byte as u64; + } + } +} + +#[test] +fn test_writer_hasher() { + let hasher = MyWriterHasher; + + assert_eq!(hasher.hash(&()), 0); + + assert_eq!(hasher.hash(&5u8), 5); + assert_eq!(hasher.hash(&5u16), 5); + assert_eq!(hasher.hash(&5u32), 5); + assert_eq!(hasher.hash(&5u64), 5); + assert_eq!(hasher.hash(&5u), 5); + + assert_eq!(hasher.hash(&5i8), 5); + assert_eq!(hasher.hash(&5i16), 5); + assert_eq!(hasher.hash(&5i32), 5); + assert_eq!(hasher.hash(&5i64), 5); + assert_eq!(hasher.hash(&5i), 5); + + assert_eq!(hasher.hash(&false), 0); + assert_eq!(hasher.hash(&true), 1); + + assert_eq!(hasher.hash(&'a'), 97); + + let s: &str = "a"; + assert_eq!(hasher.hash(& s), 97 + 0xFF); + // FIXME (#18283) Enable test + //let s: Box = box "a"; + //assert_eq!(hasher.hash(& s), 97 + 0xFF); + let cs: &[u8] = &[1u8, 2u8, 3u8]; + assert_eq!(hasher.hash(& cs), 9); + let cs: Box<[u8]> = box [1u8, 2u8, 3u8]; + assert_eq!(hasher.hash(& cs), 9); + + // FIXME (#18248) Add tests for hashing Rc and Rc<[T]> + + unsafe { + let ptr: *const int = mem::transmute(5i); + assert_eq!(hasher.hash(&ptr), 5); + } + + unsafe { + let ptr: *mut int = mem::transmute(5i); + assert_eq!(hasher.hash(&ptr), 5); + } +} + +struct Custom { + hash: u64 +} + +impl Hash for Custom { + fn hash(&self, state: &mut u64) { + *state = self.hash; + } +} + +#[test] +fn test_custom_state() { + let custom = Custom { hash: 5 }; + let mut state = 0; + custom.hash(&mut state); + assert_eq!(state, 5); +} diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs new file mode 100644 index 00000000000..8801c2975c8 --- /dev/null +++ b/src/libcoretest/hash/sip.rs @@ -0,0 +1,283 @@ +// Copyright 2014 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. +use test::Bencher; +use std::prelude::*; +use std::fmt; + +use str::Str; +use string::String; +use slice::{AsSlice, SlicePrelude}; +use vec::Vec; + +use core::hash::{Hash, Writer}; +use core::hash::sip::{SipState, hash, hash_with_keys}; + +// Hash just the bytes of the slice, without length prefix +struct Bytes<'a>(&'a [u8]); + +impl<'a, S: Writer> Hash for Bytes<'a> { + #[allow(unused_must_use)] + fn hash(&self, state: &mut S) { + let Bytes(v) = *self; + state.write(v); + } +} + +#[test] +#[allow(unused_must_use)] +fn test_siphash() { + let vecs : [[u8, ..8], ..64] = [ + [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ], + [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ], + [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ], + [ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, ], + [ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, ], + [ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, ], + [ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, ], + [ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, ], + [ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, ], + [ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, ], + [ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, ], + [ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, ], + [ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, ], + [ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, ], + [ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, ], + [ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, ], + [ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, ], + [ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, ], + [ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, ], + [ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, ], + [ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, ], + [ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, ], + [ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, ], + [ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, ], + [ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, ], + [ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, ], + [ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, ], + [ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, ], + [ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, ], + [ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, ], + [ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, ], + [ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, ], + [ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, ], + [ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, ], + [ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, ], + [ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, ], + [ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, ], + [ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, ], + [ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, ], + [ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, ], + [ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, ], + [ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, ], + [ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, ], + [ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, ], + [ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, ], + [ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, ], + [ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, ], + [ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, ], + [ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, ], + [ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, ], + [ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, ], + [ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, ], + [ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, ], + [ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, ], + [ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, ], + [ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, ], + [ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, ], + [ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, ], + [ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, ], + [ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, ], + [ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, ], + [ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, ], + [ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, ], + [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ] + ]; + + let k0 = 0x_07_06_05_04_03_02_01_00_u64; + let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64; + let mut buf = Vec::new(); + let mut t = 0; + let mut state_inc = SipState::new_with_keys(k0, k1); + let mut state_full = SipState::new_with_keys(k0, k1); + + fn to_hex_str(r: &[u8, ..8]) -> String { + let mut s = String::new(); + for b in r.iter() { + s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); + } + s + } + + fn result_bytes(h: u64) -> Vec { + vec![(h >> 0) as u8, + (h >> 8) as u8, + (h >> 16) as u8, + (h >> 24) as u8, + (h >> 32) as u8, + (h >> 40) as u8, + (h >> 48) as u8, + (h >> 56) as u8, + ] + } + + fn result_str(h: u64) -> String { + let r = result_bytes(h); + let mut s = String::new(); + for b in r.iter() { + s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); + } + s + } + + while t < 64 { + debug!("siphash test {}: {}", t, buf); + let vec = u8to64_le!(vecs[t], 0); + let out = hash_with_keys(k0, k1, &Bytes(buf.as_slice())); + debug!("got {}, expected {}", out, vec); + assert_eq!(vec, out); + + state_full.reset(); + state_full.write(buf.as_slice()); + let f = result_str(state_full.result()); + let i = result_str(state_inc.result()); + let v = to_hex_str(&vecs[t]); + debug!("{}: ({}) => inc={} full={}", t, v, i, f); + + assert_eq!(f, i); + assert_eq!(f, v); + + buf.push(t as u8); + state_inc.write(&[t as u8]); + + t += 1; + } +} + +#[test] #[cfg(target_arch = "arm")] +fn test_hash_uint() { + let val = 0xdeadbeef_deadbeef_u64; + assert!(hash(&(val as u64)) != hash(&(val as uint))); + assert_eq!(hash(&(val as u32)), hash(&(val as uint))); +} +#[test] #[cfg(target_arch = "x86_64")] +fn test_hash_uint() { + let val = 0xdeadbeef_deadbeef_u64; + assert_eq!(hash(&(val as u64)), hash(&(val as uint))); + assert!(hash(&(val as u32)) != hash(&(val as uint))); +} +#[test] #[cfg(target_arch = "x86")] +fn test_hash_uint() { + let val = 0xdeadbeef_deadbeef_u64; + assert!(hash(&(val as u64)) != hash(&(val as uint))); + assert_eq!(hash(&(val as u32)), hash(&(val as uint))); +} + +#[test] +fn test_hash_idempotent() { + let val64 = 0xdeadbeef_deadbeef_u64; + assert_eq!(hash(&val64), hash(&val64)); + let val32 = 0xdeadbeef_u32; + assert_eq!(hash(&val32), hash(&val32)); +} + +#[test] +fn test_hash_no_bytes_dropped_64() { + let val = 0xdeadbeef_deadbeef_u64; + + assert!(hash(&val) != hash(&zero_byte(val, 0))); + assert!(hash(&val) != hash(&zero_byte(val, 1))); + assert!(hash(&val) != hash(&zero_byte(val, 2))); + assert!(hash(&val) != hash(&zero_byte(val, 3))); + assert!(hash(&val) != hash(&zero_byte(val, 4))); + assert!(hash(&val) != hash(&zero_byte(val, 5))); + assert!(hash(&val) != hash(&zero_byte(val, 6))); + assert!(hash(&val) != hash(&zero_byte(val, 7))); + + fn zero_byte(val: u64, byte: uint) -> u64 { + assert!(byte < 8); + val & !(0xff << (byte * 8)) + } +} + +#[test] +fn test_hash_no_bytes_dropped_32() { + let val = 0xdeadbeef_u32; + + assert!(hash(&val) != hash(&zero_byte(val, 0))); + assert!(hash(&val) != hash(&zero_byte(val, 1))); + assert!(hash(&val) != hash(&zero_byte(val, 2))); + assert!(hash(&val) != hash(&zero_byte(val, 3))); + + fn zero_byte(val: u32, byte: uint) -> u32 { + assert!(byte < 4); + val & !(0xff << (byte * 8)) + } +} + +#[test] +fn test_hash_no_concat_alias() { + let s = ("aa", "bb"); + let t = ("aabb", ""); + let u = ("a", "abb"); + + assert!(s != t && t != u); + assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u)); + + let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]); + let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]); + + assert!(v != w); + assert!(hash(&v) != hash(&w)); +} + +#[bench] +fn bench_str_under_8_bytes(b: &mut Bencher) { + let s = "foo"; + b.iter(|| { + assert_eq!(hash(&s), 16262950014981195938); + }) +} + +#[bench] +fn bench_str_of_8_bytes(b: &mut Bencher) { + let s = "foobar78"; + b.iter(|| { + assert_eq!(hash(&s), 4898293253460910787); + }) +} + +#[bench] +fn bench_str_over_8_bytes(b: &mut Bencher) { + let s = "foobarbaz0"; + b.iter(|| { + assert_eq!(hash(&s), 10581415515220175264); + }) +} + +#[bench] +fn bench_long_str(b: &mut Bencher) { + let s = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \ +incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \ +exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute \ +irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \ +pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \ +officia deserunt mollit anim id est laborum."; + b.iter(|| { + assert_eq!(hash(&s), 17717065544121360093); + }) +} + +#[bench] +fn bench_u64(b: &mut Bencher) { + let u = 16262950014981195938u64; + b.iter(|| { + assert_eq!(hash(&u), 5254097107239593357); + }) +} diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 089a2cc880e..05d862d7bc7 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -7,7 +7,7 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(globs, unsafe_destructor, macro_rules, slicing_syntax)] +#![feature(globs, unsafe_destructor, macro_rules, slicing_syntax, default_type_params)] #![feature(unboxed_closures)] extern crate core; @@ -21,6 +21,7 @@ mod char; mod cmp; mod finally; mod fmt; +mod hash; mod iter; mod mem; mod num; diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs index b0bcc55985f..6649b93e4b0 100644 --- a/src/librustrt/c_str.rs +++ b/src/librustrt/c_str.rs @@ -70,7 +70,7 @@ use core::prelude::*; use collections::string::String; -use collections::hash; +use core::hash; use core::fmt; use core::kinds::{Sized, marker}; use core::mem; diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs index ac68e1ef121..a63abec96d5 100644 --- a/src/libstd/hash.rs +++ b/src/libstd/hash.rs @@ -61,7 +61,7 @@ #![experimental] -pub use core_collections::hash::{Hash, Hasher, Writer, hash, sip}; +pub use core::hash::{Hash, Hasher, Writer, hash, sip}; use core::kinds::Sized; use default::Default;