perf(http): introduce MemBuf, a shared read buffer

benches/end_to_end.rs

@@ -1,21 +1,24 @@
 #![feature(test)]
+#![deny(warnings)]
 
 extern crate futures;
 extern crate hyper;
 extern crate tokio_core;
+extern crate pretty_env_logger;
 
 extern crate test;
 
 use futures::{Future, Stream};
 use tokio_core::reactor::Core;
 
+use hyper::client;
 use hyper::header::{ContentLength, ContentType};
-use hyper::server::{Service, Request, Response};
+use hyper::Method;
+use hyper::server::{self, Service};
 
 
 #[bench]
-fn one_request_at_a_time(b: &mut test::Bencher) {
-    extern crate pretty_env_logger;
+fn get_one_at_a_time(b: &mut test::Bencher) {
     let _ = pretty_env_logger::init();
     let mut core = Core::new().unwrap();
     let handle = core.handle();
@@ -23,11 +26,11 @@ fn one_request_at_a_time(b: &mut test::Bencher) {
     let addr = hyper::Server::http(&"127.0.0.1:0".parse().unwrap(), &handle).unwrap()
         .handle(|| Ok(Hello), &handle).unwrap();
 
-    let mut client = hyper::Client::new(&handle);
+    let client = hyper::Client::new(&handle);
 
     let url: hyper::Url = format!("http://{}/get", addr).parse().unwrap();
 
-    b.bytes = 160;
+    b.bytes = 160 * 2 + PHRASE.len() as u64;
     b.iter(move || {
         let work = client.get(url.clone()).and_then(|res| {
             res.body().for_each(|_chunk| {
@@ -39,19 +42,49 @@ fn one_request_at_a_time(b: &mut test::Bencher) {
     });
 }
 
-static PHRASE: &'static [u8] = b"Hello, World!";
+#[bench]
+fn post_one_at_a_time(b: &mut test::Bencher) {
+    let _ = pretty_env_logger::init();
+    let mut core = Core::new().unwrap();
+    let handle = core.handle();
+
+    let addr = hyper::Server::http(&"127.0.0.1:0".parse().unwrap(), &handle).unwrap()
+        .handle(|| Ok(Hello), &handle).unwrap();
+
+    let client = hyper::Client::new(&handle);
+
+    let url: hyper::Url = format!("http://{}/get", addr).parse().unwrap();
+
+    let post = "foo bar baz quux";
+    b.bytes = 180 * 2 + post.len() as u64 + PHRASE.len() as u64;
+    b.iter(move || {
+        let mut req = client::Request::new(Method::Post, url.clone());
+        req.headers_mut().set(ContentLength(post.len() as u64));
+        req.set_body(post);
+
+        let work = client.get(url.clone()).and_then(|res| {
+            res.body().for_each(|_chunk| {
+                Ok(())
+            })
+        });
+
+        core.run(work).unwrap();
+    });
+}
+
+static PHRASE: &'static [u8] = include_bytes!("../CHANGELOG.md"); //b"Hello, World!";
 
 #[derive(Clone, Copy)]
 struct Hello;
 
 impl Service for Hello {
-    type Request = Request;
-    type Response = Response;
+    type Request = server::Request;
+    type Response = server::Response;
     type Error = hyper::Error;
-    type Future = ::futures::Finished<Response, hyper::Error>;
-    fn call(&mut self, _req: Request) -> Self::Future {
+    type Future = ::futures::Finished<Self::Response, hyper::Error>;
+    fn call(&self, _req: Self::Request) -> Self::Future {
         ::futures::finished(
-            Response::new()
+            server::Response::new()
                 .with_header(ContentLength(PHRASE.len() as u64))
                 .with_header(ContentType::plaintext())
                 .with_body(PHRASE)