Alright, let's do the dumb thing of caching Date

Author: alexcrichton

http/src/date.rs

@@ -0,0 +1,78 @@
+use std::cell::RefCell;
+use std::fmt::{self, Write};
+use std::str;
+
+use time::{self, Duration};
+
+pub struct Now(());
+
+/// Returns a struct, which when formatted, renders an appropriate `Date` header
+/// value.
+pub fn now() -> Now {
+    Now(())
+}
+
+// Gee Alex, doesn't this seem like premature optimization. Well you see there
+// Billy, you're absolutely correct! If your server is *bottlenecked* on
+// rendering the `Date` header, well then boy do I have news for you, you don't
+// need this optimization.
+//
+// In all seriousness, though, a simple "hello world" benchmark which just sends
+// back literally "hello world" with standard headers actually is bottlenecked
+// on rendering a date into a byte buffer. Since it was at the top of a profile,
+// and this was done for some competitive benchmarks, this module was written.
+//
+// Just to be clear, though, I was not intending on doing this because it really
+// does seem kinda absurd, but it was done by someone else [1], so I blame them!
+// :)
+//
+// [1]: https://github.com/rapidoid/rapidoid/blob/f1c55c0555007e986b5d069fe1086e6d09933f7b/rapidoid-commons/src/main/java/org/rapidoid/commons/Dates.java#L48-L66
+
+struct LastRenderedNow {
+    bytes: [u8; 128],
+    amt: usize,
+    next_update: time::Timespec,
+}
+
+thread_local!(static LAST: RefCell<LastRenderedNow> = RefCell::new(LastRenderedNow {
+    bytes: [0; 128],
+    amt: 0,
+    next_update: time::Timespec::new(0, 0),
+}));
+
+impl fmt::Display for Now {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        LAST.with(|cache| {
+            let mut cache = cache.borrow_mut();
+            let now = time::get_time();
+            if now > cache.next_update {
+                cache.update(now);
+            }
+            f.write_str(cache.buffer())
+        })
+    }
+}
+
+impl LastRenderedNow {
+    fn buffer(&self) -> &str {
+        str::from_utf8(&self.bytes[..self.amt]).unwrap()
+    }
+
+    fn update(&mut self, now: time::Timespec) {
+        self.amt = 0;
+        write!(LocalBuffer(self), "{}", time::at(now).rfc822()).unwrap();
+        self.next_update = now + Duration::seconds(1);
+    }
+}
+
+struct LocalBuffer<'a>(&'a mut LastRenderedNow);
+
+impl<'a> fmt::Write for LocalBuffer<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let start = self.0.amt;
+        let end = start + s.len();
+        self.0.bytes[start..end].copy_from_slice(s.as_bytes());
+        self.0.amt += s.len();
+        Ok(())
+    }
+}

http/src/lib.rs

@@ -25,6 +25,8 @@ mod io2;
 pub use io2::{Parse, Serialize};
 use io2::{ParseStream, StreamWriter};
 
+mod date;
+
 pub trait Service<Req, Resp>: Send + Sync + 'static
     where Req: Send + 'static,
           Resp: Send + 'static

http/src/response.rs

@@ -1,7 +1,5 @@
 use std::fmt::{self, Write};
 
-use time;
-
 use io2::Serialize;
 
 pub struct Response {
@@ -35,7 +33,7 @@ impl Serialize for Response {
             Server: Example\r\n\
             Content-Length: {}\r\n\
             Date: {}\r\n\
-        ", self.response.len(), time::now().rfc822()).unwrap();
+        ", self.response.len(), ::date::now()).unwrap();
         for &(ref k, ref v) in &self.headers {
             extend(buf, k.as_bytes());
             extend(buf, b": ");
@@ -59,6 +57,10 @@ impl<'a> fmt::Write for FastWrite<'a> {
         extend(self.0, s.as_bytes());
         Ok(())
     }
+
+    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self, args)
+    }
 }
 
 // TODO: why doesn't extend_from_slice optimize to this?