Expose the precomputed hash using a trait so that I can use it from rust-selectors.

This allows us to get rid of the extra hashing overhead every time we check the
bloom filter.

Author: emilio

Cargo.toml

@@ -28,6 +28,7 @@ log-events = ["rustc-serialize"]
 unstable = []
 
 [dependencies]
+precomputed-hash = "0.1"
 lazy_static = "0.2"
 serde = "0.9"
 phf_shared = "0.7.4"

src/atom.rs

@@ -177,6 +177,7 @@ pub struct PhfStrSet {
     pub key: u64,
     pub disps: &'static [(u32, u32)],
     pub atoms: &'static [&'static str],
+    pub hashes: &'static [u32],
 }
 
 pub struct EmptyStaticAtomSet;
@@ -189,6 +190,8 @@ impl StaticAtomSet for EmptyStaticAtomSet {
             key: 0,
             disps: &[(0, 0)],
             atoms: &[""],
+            // "" SipHash'd, and xored with u64_hash_to_u32.
+            hashes: &[0x3ddddef3],
         };
         &SET
     }
@@ -219,14 +222,37 @@ impl<Static: StaticAtomSet> HeapSizeOf for Atom<Static> {
     }
 }
 
+impl<Static: StaticAtomSet> ::precomputed_hash::PrecomputedHash for Atom<Static> {
+    fn precomputed_hash(&self) -> u32 {
+        self.get_hash()
+    }
+}
+
+fn u64_hash_as_u32(h: u64) -> u32 {
+    // This may or may not be great...
+    ((h >> 32) ^ h) as u32
+}
+
 impl<Static: StaticAtomSet> Atom<Static> {
     #[inline(always)]
     unsafe fn unpack(&self) -> UnpackedAtom {
         UnpackedAtom::from_packed(self.unsafe_data)
     }
 
     pub fn get_hash(&self) -> u32 {
-        ((self.unsafe_data >> 32) ^ self.unsafe_data) as u32
+        match unsafe { self.unpack() } {
+            Static(index) => {
+                let static_set = Static::get();
+                static_set.hashes[index as usize]
+            }
+            Dynamic(entry) => {
+                let entry = entry as *mut StringCacheEntry;
+                u64_hash_as_u32(unsafe { (*entry).hash })
+            }
+            Inline(..) => {
+                u64_hash_as_u32(self.unsafe_data)
+            }
+        }
     }
 }
 

src/lib.rs

@@ -19,8 +19,9 @@
 #[cfg(test)] extern crate rand;
 #[macro_use] extern crate lazy_static;
 #[macro_use] extern crate debug_unreachable;
-extern crate serde;
 extern crate phf_shared;
+extern crate precomputed_hash;
+extern crate serde;
 extern crate string_cache_shared as shared;
 
 pub use atom::{Atom, StaticAtomSet, PhfStrSet, EmptyStaticAtomSet, DefaultAtom};

string-cache-codegen/Cargo.toml

@@ -15,4 +15,5 @@ path = "lib.rs"
 [dependencies]
 string_cache_shared = {path = "../shared", version = "0.3"}
 phf_generator = "0.7.15"
+phf_shared = "0.7.4"
 quote = "0.3.9"

string-cache-codegen/lib.rs

@@ -7,7 +7,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![recursion_limit = "128"]
+
 extern crate phf_generator;
+extern crate phf_shared;
 extern crate string_cache_shared as shared;
 #[macro_use] extern crate quote;
 
@@ -93,6 +96,12 @@ impl AtomType {
         let empty_string_index = atoms.iter().position(|s| s.is_empty()).unwrap() as u32;
         let data = (0..atoms.len()).map(|i| quote::Hex(shared::pack_static(i as u32)));
 
+        let hashes: Vec<u32> =
+            atoms.iter().map(|string| {
+                let hash = phf_shared::hash(string, key);
+                ((hash >> 32) ^ hash) as u32
+            }).collect();
+
         let type_name = if let Some(position) = self.path.rfind("::") {
             &self.path[position + "::".len() ..]
         } else {
@@ -112,6 +121,7 @@ impl AtomType {
                         key: #key,
                         disps: &#disps,
                         atoms: &#atoms,
+                        hashes: &#hashes
                     };
                     &SET
                 }