From bdd2e1a3adccfed54e2e9353c914b5fbaaf7b513 Mon Sep 17 00:00:00 2001
From: Sean McArthur <sean.monstar@gmail.com>
Date: Fri, 26 May 2017 12:29:26 -0700
Subject: [PATCH] perf(server): cache renderings of the Date header

This is actually one of the biggest impacts to benchmark performances at
this point. Caching the rendering of the Date header improves "hello
world" benchmarks by around 10%.
---
 src/http/h1/date.rs  | 59 ++++++++++++++++++++++++++++++++++++++++++++
 src/http/h1/mod.rs   |  1 +
 src/http/h1/parse.rs | 31 +++++++++++------------
 3 files changed, 74 insertions(+), 17 deletions(-)
 create mode 100644 src/http/h1/date.rs

diff --git a/src/http/h1/date.rs b/src/http/h1/date.rs
new file mode 100644
index 0000000000..6a2a6c56c7
--- /dev/null
+++ b/src/http/h1/date.rs
@@ -0,0 +1,59 @@
+use std::cell::RefCell;
+use std::fmt::{self, Write};
+use std::str;
+
+use time::{self, Duration};
+
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+pub const DATE_VALUE_LENGTH: usize = 29;
+
+pub fn extend(dst: &mut Vec<u8>) {
+    CACHED.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        let now = time::get_time();
+        if now > cache.next_update {
+            cache.update(now);
+        }
+        dst.extend_from_slice(cache.buffer());
+    })
+}
+
+struct CachedDate {
+    bytes: [u8; DATE_VALUE_LENGTH],
+    pos: usize,
+    next_update: time::Timespec,
+}
+
+thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
+    bytes: [0; DATE_VALUE_LENGTH],
+    pos: 0,
+    next_update: time::Timespec::new(0, 0),
+}));
+
+impl CachedDate {
+    fn buffer(&self) -> &[u8] {
+        &self.bytes[..]
+    }
+
+    fn update(&mut self, now: time::Timespec) {
+        self.pos = 0;
+        write!(self, "{}", time::at_utc(now).rfc822()).unwrap();
+        assert!(self.pos == DATE_VALUE_LENGTH);
+        self.next_update = now + Duration::seconds(1);
+        self.next_update.nsec = 0;
+    }
+}
+
+impl fmt::Write for CachedDate {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let len = s.len();
+        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
+        self.pos += len;
+        Ok(())
+    }
+}
+
+#[test]
+fn test_date_len() {
+    assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
+}
\ No newline at end of file
diff --git a/src/http/h1/mod.rs b/src/http/h1/mod.rs
index 9bf4762985..3853d4e096 100644
--- a/src/http/h1/mod.rs
+++ b/src/http/h1/mod.rs
@@ -1,6 +1,7 @@
 pub use self::decode::Decoder;
 pub use self::encode::Encoder;
 
+mod date;
 mod decode;
 mod encode;
 pub mod parse;
diff --git a/src/http/h1/parse.rs b/src/http/h1/parse.rs
index 4adc7b923c..c1ead352e3 100644
--- a/src/http/h1/parse.rs
+++ b/src/http/h1/parse.rs
@@ -1,13 +1,12 @@
 use std::borrow::Cow;
 use std::fmt::{self, Write};
-use std::time::SystemTime;
 
 use httparse;
 use bytes::{BytesMut, Bytes};
 
 use header::{self, Headers, ContentLength, TransferEncoding};
 use http::{ByteStr, MessageHead, RawStatus, Http1Transaction, ParseResult, ServerTransaction, ClientTransaction, RequestLine};
-use http::h1::{Encoder, Decoder};
+use http::h1::{Encoder, Decoder, date};
 use method::Method;
 use status::StatusCode;
 use version::HttpVersion::{Http10, Http11};
@@ -90,10 +89,6 @@ impl Http1Transaction for ServerTransaction {
         use ::header;
         trace!("writing head: {:?}", head);
 
-        if !head.headers.has::<header::Date>() {
-            head.headers.set(header::Date(SystemTime::now().into()));
-        }
-
         let len = head.headers.get::<header::ContentLength>().map(|n| **n);
 
         let body = if let Some(len) = len {
@@ -121,10 +116,19 @@ impl Http1Transaction for ServerTransaction {
         debug!("writing headers = {:?}", head.headers);
         if head.version == ::HttpVersion::Http11 && head.subject == ::StatusCode::Ok {
             extend(dst, b"HTTP/1.1 200 OK\r\n");
-            let _ = write!(FastWrite(dst), "{}\r\n", head.headers);
+            let _ = write!(FastWrite(dst), "{}", head.headers);
         } else {
-            let _ = write!(FastWrite(dst), "{} {}\r\n{}\r\n", head.version, head.subject, head.headers);
+            let _ = write!(FastWrite(dst), "{} {}\r\n{}", head.version, head.subject, head.headers);
         }
+        // using http::h1::date is quite a lot faster than generating a unique Date header each time
+        // like req/s goes up about 10%
+        if !head.headers.has::<header::Date>() {
+            dst.reserve(date::DATE_VALUE_LENGTH + 8);
+            extend(dst, b"Date: ");
+            date::extend(dst);
+            extend(dst, b"\r\n");
+        }
+        extend(dst, b"\r\n");
         body
     }
 
@@ -316,16 +320,9 @@ impl<'a> fmt::Write for FastWrite<'a> {
     }
 }
 
+#[inline]
 fn extend(dst: &mut Vec<u8>, data: &[u8]) {
-    use std::ptr;
-    dst.reserve(data.len());
-    let prev = dst.len();
-    unsafe {
-        ptr::copy_nonoverlapping(data.as_ptr(),
-                                 dst.as_mut_ptr().offset(prev as isize),
-                                 data.len());
-        dst.set_len(prev + data.len());
-    }
+    dst.extend_from_slice(data);
 }
 
 #[cfg(test)]