Use new string_cache_codegen crate for static atoms

Author: aidanhs

Cargo.toml

@@ -30,6 +30,7 @@ heap_size = ["heapsize", "heapsize_plugin"]
 [dependencies]
 lazy_static = "0.1.10"
 serde = ">=0.6, <0.8"
+phf = "0.7.4"
 phf_shared = "0.7.4"
 debug_unreachable = "0.0.6"
 
@@ -48,6 +49,5 @@ optional = true
 version = "0.1.4"
 optional = true
 
-[build-dependencies]
-phf_generator = "0.7.4"
-phf_shared = "0.7.4"
+[build-dependencies.string_cache_codegen]
+version = "0.2.11"

build.rs

@@ -1,73 +1,19 @@
-extern crate phf_shared;
-extern crate phf_generator;
+extern crate string_cache_codegen;
 
-#[path = "src/shared.rs"] #[allow(dead_code)] mod shared;
 #[path = "src/static_atom_list.rs"] mod static_atom_list;
 
 use std::env;
 use std::fs::File;
-use std::io::{BufWriter, Write};
-use std::mem;
+use std::io::BufWriter;
 use std::path::Path;
-use std::slice;
 
 fn main() {
-    let hash_state = generate();
-    write_static_atom_set(&hash_state);
-    write_atom_macro(&hash_state);
-}
-
-fn generate() -> phf_generator::HashState {
-    let mut set = std::collections::HashSet::new();
-    for atom in static_atom_list::ATOMS {
-        if !set.insert(atom) {
-            panic!("duplicate static atom `{:?}`", atom);
-        }
-    }
-    phf_generator::generate_hash(static_atom_list::ATOMS)
-}
-
-fn write_static_atom_set(hash_state: &phf_generator::HashState) {
-    let path = Path::new(&std::env::var("OUT_DIR").unwrap()).join("static_atom_set.rs");
+    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("static_atoms.rs");
     let mut file = BufWriter::new(File::create(&path).unwrap());
-    macro_rules! w {
-        ($($arg: expr),+) => { (writeln!(&mut file, $($arg),+).unwrap()) }
-    }
-    w!("pub static STATIC_ATOM_SET: StaticAtomSet = StaticAtomSet {{");
-    w!("    key: {},", hash_state.key);
-    w!("    disps: &[");
-    for &(d1, d2) in &hash_state.disps {
-        w!("        ({}, {}),", d1, d2);
-    }
-    w!("    ],");
-    w!("    atoms: &[");
-    for &idx in &hash_state.map {
-        w!("        {:?},", static_atom_list::ATOMS[idx]);
-    }
-    w!("    ],");
-    w!("}};");
-}
 
-fn write_atom_macro(hash_state: &phf_generator::HashState) {
-    let set = shared::StaticAtomSet {
-        key: hash_state.key,
-        disps: leak(hash_state.disps.clone()),
-        atoms: leak(hash_state.map.iter().map(|&idx| static_atom_list::ATOMS[idx]).collect()),
-    };
-
-    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("atom_macro.rs");
-    let mut file = BufWriter::new(File::create(&path).unwrap());
-    writeln!(file, r"#[macro_export]").unwrap();
-    writeln!(file, r"macro_rules! atom {{").unwrap();
-    for &s in set.iter() {
-        let data = shared::pack_static(set.get_index_or_hash(s).unwrap() as u32);
-        writeln!(file, r"({:?}) => {{ $crate::Atom {{ data: 0x{:x} }} }};", s, data).unwrap();
+    let mut builder = string_cache_codegen::AtomSetBuilder::new();
+    for atom in static_atom_list::ATOMS {
+        builder.atom(atom);
     }
-    writeln!(file, r"}}").unwrap();
-}
-
-fn leak<T>(v: Vec<T>) -> &'static [T] {
-    let slice = unsafe { slice::from_raw_parts(v.as_ptr(), v.len()) };
-    mem::forget(v);
-    slice
+    builder.build(&mut file, "ServoAtom", "STATIC_ATOM_SET", "atom");
 }

src/atom/mod.rs

@@ -23,19 +23,19 @@ use std::ops;
 use std::ptr;
 use std::slice;
 use std::str;
+use std::hash::Hash;
+use std::marker::PhantomData;
 use std::sync::Mutex;
 use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::Ordering::SeqCst;
 
 use shared::{STATIC_TAG, INLINE_TAG, DYNAMIC_TAG, TAG_MASK, MAX_INLINE_LEN, STATIC_SHIFT_BITS,
-             ENTRY_ALIGNMENT, pack_static, StaticAtomSet};
+             ENTRY_ALIGNMENT, pack_static, dynamic_hash};
 use self::UnpackedAtom::{Dynamic, Inline, Static};
 
 #[cfg(feature = "log-events")]
 use event::Event;
 
-include!(concat!(env!("OUT_DIR"), "/static_atom_set.rs"));
-
 #[cfg(not(feature = "log-events"))]
 macro_rules! log (($e:expr) => (()));
 
@@ -160,29 +160,58 @@ impl StringCache {
     }
 }
 
+pub trait Kind: Eq + Hash + Ord + PartialEq + PartialOrd {
+    #[inline]
+    fn get_index_or_hash(s: &str) -> Result<u32, u64>;
+
+    #[inline]
+    fn index(i: u32) -> Option<&'static str>;
+}
+
+// Although DefaultKind isn't used right now, it will be when ServoAtomKind is
+// removed. Note it will only be used for dynamic atoms.
+#[derive(Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum DefaultKind {}
+impl Kind for DefaultKind {
+    // There are no static atoms for DefaultKind so there's never an index
+    #[inline]
+    fn get_index_or_hash(s: &str) -> Result<u32, u64> {
+        Err(dynamic_hash(s))
+    }
+
+    #[inline]
+    fn index(_: u32) -> Option<&'static str> {
+        None
+    }
+}
+
+pub type Atom = BaseAtom<super::ServoAtomKind>;
+
 // NOTE: Deriving Eq here implies that a given string must always
-// be interned the same way.
+// be interned the same way for the same kind.
 #[cfg_attr(feature = "unstable", unsafe_no_drop_flag)]  // See tests::atom_drop_is_idempotent
 #[cfg_attr(feature = "heap_size", derive(HeapSizeOf))]
 #[derive(Eq, Hash, PartialEq)]
-pub struct Atom {
+// After RFC 213, rename `BaseAtom` to `Atom` and use `K=super::ServoAtomKind`.
+pub struct BaseAtom<K> where K: Kind {
     /// This field is public so that the `atom!()` macro can use it.
     /// You should not otherwise access this field.
     pub data: u64,
+    pub kind: PhantomData<K>,
 }
 
-impl Atom {
+impl<K> BaseAtom<K> where K: Kind {
     #[inline(always)]
     unsafe fn unpack(&self) -> UnpackedAtom {
         UnpackedAtom::from_packed(self.data)
     }
 }
 
-impl<'a> From<Cow<'a, str>> for Atom {
+impl<'a, K> From<Cow<'a, str>> for BaseAtom<K> where K: Kind {
     #[inline]
-    fn from(string_to_add: Cow<'a, str>) -> Atom {
-        let unpacked = match STATIC_ATOM_SET.get_index_or_hash(&*string_to_add) {
-            Ok(id) => Static(id as u32),
+    fn from(string_to_add: Cow<'a, str>) -> BaseAtom<K> {
+        let unpacked = match K::get_index_or_hash(&*string_to_add) {
+            Ok(id) => Static(id),
             Err(hash) => {
                 let len = string_to_add.len();
                 if len <= MAX_INLINE_LEN {
@@ -197,27 +226,27 @@ impl<'a> From<Cow<'a, str>> for Atom {
 
         let data = unsafe { unpacked.pack() };
         log!(Event::Intern(data));
-        Atom { data: data }
+        BaseAtom { data: data, kind: PhantomData }
     }
 }
 
-impl<'a> From<&'a str> for Atom {
+impl<'a, K> From<&'a str> for BaseAtom<K> where K: Kind {
     #[inline]
-    fn from(string_to_add: &str) -> Atom {
-        Atom::from(Cow::Borrowed(string_to_add))
+    fn from(string_to_add: &str) -> BaseAtom<K> {
+        BaseAtom::from(Cow::Borrowed(string_to_add))
     }
 }
 
-impl From<String> for Atom {
+impl<K> From<String> for BaseAtom<K> where K: Kind {
     #[inline]
-    fn from(string_to_add: String) -> Atom {
-        Atom::from(Cow::Owned(string_to_add))
+    fn from(string_to_add: String) -> BaseAtom<K> {
+        BaseAtom::from(Cow::Owned(string_to_add))
     }
 }
 
-impl Clone for Atom {
+impl<K> Clone for BaseAtom<K> where K: Kind {
     #[inline(always)]
-    fn clone(&self) -> Atom {
+    fn clone(&self) -> BaseAtom<K> {
         unsafe {
             match from_packed_dynamic(self.data) {
                 Some(entry) => {
@@ -227,17 +256,18 @@ impl Clone for Atom {
                 None => (),
             }
         }
-        Atom {
-            data: self.data
+        BaseAtom {
+            data: self.data,
+            kind: PhantomData,
         }
     }
 }
 
-impl Drop for Atom {
+impl<K> Drop for BaseAtom<K> where K: Kind {
     #[inline]
     fn drop(&mut self) {
         // Out of line to guide inlining.
-        fn drop_slow(this: &mut Atom) {
+        fn drop_slow<K>(this: &mut BaseAtom<K>) where K: Kind {
             STRING_CACHE.lock().unwrap().remove(this.data);
         }
 
@@ -256,7 +286,7 @@ impl Drop for Atom {
 }
 
 
-impl ops::Deref for Atom {
+impl<K> ops::Deref for BaseAtom<K> where K: Kind {
     type Target = str;
 
     #[inline]
@@ -267,7 +297,7 @@ impl ops::Deref for Atom {
                     let buf = inline_orig_bytes(&self.data);
                     str::from_utf8(buf).unwrap()
                 },
-                Static(idx) => STATIC_ATOM_SET.index(idx).expect("bad static atom"),
+                Static(idx) => K::index(idx).expect("bad static atom"),
                 Dynamic(entry) => {
                     let entry = entry as *mut StringCacheEntry;
                     &(*entry).string
@@ -277,14 +307,14 @@ impl ops::Deref for Atom {
     }
 }
 
-impl fmt::Display for Atom {
+impl<K> fmt::Display for BaseAtom<K> where K: Kind {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         <str as fmt::Display>::fmt(self, f)
     }
 }
 
-impl fmt::Debug for Atom {
+impl<K> fmt::Debug for BaseAtom<K> where K: Kind {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let ty_str = unsafe {
@@ -299,63 +329,63 @@ impl fmt::Debug for Atom {
     }
 }
 
-impl PartialOrd for Atom {
+impl<K> PartialOrd for BaseAtom<K> where K: Kind {
     #[inline]
-    fn partial_cmp(&self, other: &Atom) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &BaseAtom<K>) -> Option<Ordering> {
         if self.data == other.data {
             return Some(Equal);
         }
         self.as_ref().partial_cmp(other.as_ref())
     }
 }
 
-impl Ord for Atom {
+impl<K> Ord for BaseAtom<K> where K: Kind {
     #[inline]
-    fn cmp(&self, other: &Atom) -> Ordering {
+    fn cmp(&self, other: &BaseAtom<K>) -> Ordering {
         if self.data == other.data {
             return Equal;
         }
         self.as_ref().cmp(other.as_ref())
     }
 }
 
-impl AsRef<str> for Atom {
+impl<K> AsRef<str> for BaseAtom<K> where K: Kind {
     fn as_ref(&self) -> &str {
         &self
     }
 }
 
-impl Serialize for Atom {
+impl<K> Serialize for BaseAtom<K> where K: Kind {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer {
         let string: &str = self.as_ref();
         string.serialize(serializer)
     }
 }
 
-impl Deserialize for Atom {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Atom,D::Error> where D: Deserializer {
+impl<K> Deserialize for BaseAtom<K> where K: Kind {
+    fn deserialize<D>(deserializer: &mut D) -> Result<BaseAtom<K>,D::Error> where D: Deserializer {
         let string: String = try!(Deserialize::deserialize(deserializer));
-        Ok(Atom::from(&*string))
+        Ok(BaseAtom::from(&*string))
     }
 }
 
 // AsciiExt requires mutating methods, so we just implement the non-mutating ones.
 // We don't need to implement is_ascii because there's no performance improvement
 // over the one from &str.
-impl Atom {
-    pub fn to_ascii_uppercase(&self) -> Atom {
+impl<K> BaseAtom<K> where K: Kind {
+    pub fn to_ascii_uppercase(&self) -> BaseAtom<K> {
         if self.chars().all(char::is_uppercase) {
             self.clone()
         } else {
-            Atom::from(&*((&**self).to_ascii_uppercase()))
+            BaseAtom::from(&*((&**self).to_ascii_uppercase()))
         }
     }
 
-    pub fn to_ascii_lowercase(&self) -> Atom {
+    pub fn to_ascii_lowercase(&self) -> BaseAtom<K> {
         if self.chars().all(char::is_lowercase) {
             self.clone()
         } else {
-            Atom::from(&*((&**self).to_ascii_lowercase()))
+            BaseAtom::from(&*((&**self).to_ascii_lowercase()))
         }
     }
 
@@ -486,7 +516,8 @@ mod bench;
 mod tests {
     use std::mem;
     use std::thread;
-    use super::{Atom, StringCacheEntry, STATIC_ATOM_SET};
+    use super::{Atom, StringCacheEntry};
+    use super::super::STATIC_ATOM_SET;
     use super::UnpackedAtom::{Dynamic, Inline, Static};
     use shared::ENTRY_ALIGNMENT;
 

src/lib.rs

@@ -23,6 +23,7 @@
 #[macro_use] extern crate lazy_static;
 #[macro_use] extern crate debug_unreachable;
 extern crate serde;
+extern crate phf;
 extern crate phf_shared;
 
 pub use atom::Atom;
@@ -55,7 +56,7 @@ macro_rules! ns {
     (mathml) => { $crate::Namespace(atom!("http://www.w3.org/1998/Math/MathML")) };
 }
 
-include!(concat!(env!("OUT_DIR"), "/atom_macro.rs"));
+include!(concat!(env!("OUT_DIR"), "/static_atoms.rs"));
 
 #[cfg(feature = "log-events")]
 #[macro_use]
@@ -73,4 +74,5 @@ pub mod shared;
 mod string_cache {
     pub use atom;
     pub use namespace;
+    pub use shared;
 }