Add optional event logging

We can use this with Servo to generate traces from real websites for
optimization purposes.

Author: kmcallister

Cargo.toml

@@ -4,6 +4,9 @@ name = "string_cache"
 version = "0.0.0"
 authors = [ "The Servo Project Developers" ]
 
+[features]
+log-events = []
+
 [dependencies.string_cache_macros]
 path = "macros"
 

src/atom/mod.rs

@@ -28,6 +28,12 @@ use sync::Mutex;
 
 use self::repr::{UnpackedAtom, Static, Inline, Dynamic};
 
+#[cfg(feature = "log-events")]
+use event;
+
+#[cfg(not(feature = "log-events"))]
+macro_rules! log (($e:expr) => (()))
+
 #[path="../../shared/repr.rs"]
 pub mod repr;
 
@@ -110,6 +116,7 @@ impl StringCache {
                             StringCacheEntry::new(self.buckets[bucket_index], hash, string_to_add));
             }
             self.buckets[bucket_index] = ptr;
+            log!(event::Insert(ptr as u64, String::from_str(string_to_add)));
         }
 
         debug_assert!(ptr != ptr::null_mut());
@@ -146,6 +153,8 @@ impl StringCache {
             heap::deallocate(ptr as *mut u8,
                 mem::size_of::<StringCacheEntry>(), ENTRY_ALIGNMENT);
         }
+
+        log!(event::Remove(key));
     }
 }
 
@@ -180,9 +189,9 @@ impl Atom {
             }
         };
 
-        Atom {
-            data: unsafe { unpacked.pack() },
-        }
+        let data = unsafe { unpacked.pack() };
+        log!(event::Intern(data))
+        Atom { data: data }
     }
 
     pub fn as_slice<'t>(&'t self) -> &'t str {

src/event.rs

@@ -0,0 +1,36 @@
+// Copyright 2014 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![macro_escape]
+
+use core::prelude::*;
+
+use alloc::boxed::Box;
+use collections::MutableSeq;
+use collections::vec::Vec;
+use collections::string::String;
+use sync::Mutex;
+
+#[deriving(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Show, Encodable)]
+pub enum Event {
+    Intern(u64),
+    Insert(u64, String),
+    Remove(u64),
+}
+
+lazy_static! {
+    pub static ref LOG: Mutex<Vec<Event>>
+        = Mutex::new(Vec::with_capacity(50_000));
+}
+
+pub fn log(e: Event) {
+    LOG.lock().push(e);
+}
+
+macro_rules! log (($e:expr) => (::event::log($e)))

src/lib.rs

@@ -41,9 +41,15 @@ extern crate xxhash;
 #[phase(plugin)]
 extern crate string_cache_macros;
 
+#[cfg(feature = "log-events")]
+extern crate serialize;
+
 pub use atom::Atom;
 pub use namespace::{Namespace, QualName};
 
+#[cfg(feature = "log-events")]
+pub mod event;
+
 pub mod atom;
 pub mod namespace;
 
@@ -60,7 +66,7 @@ mod string_cache {
 // For macros and deriving.
 #[cfg(not(test))]
 mod std {
-    pub use core::{cmp, fmt, clone, option, mem};
+    pub use core::{cmp, fmt, clone, option, mem, result};
     pub use collections::hash;
 
     pub mod sync {