forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf(header): improve on MemSlice usage in headers

Browse Source
This commit is contained in:
Sean McArthur
2017-01-26 23:49:44 -08:00
parent 1b556389c0
commit 61364d245b
14 changed files with 190 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
src/http/buf.rs
View File

@@ -1,14 +1,14 @@
use std::borrow::Cow;
use std::cell::UnsafeCell;
use std::cell::{Cell, UnsafeCell};
use std::fmt;
use std::io::{self, Read};
use std::ops::{Deref, Range, RangeFrom, RangeTo, RangeFull};
use std::ops::{Index, Range, RangeFrom, RangeTo, RangeFull};
use std::ptr;
use std::sync::Arc;
pub struct MemBuf {
buf: Arc<UnsafeCell<Vec<u8>>>,
start: usize,
start: Cell<usize>,
end: usize,
}
@@ -20,13 +20,13 @@ impl MemBuf {
pub fn with_capacity(cap: usize) -> MemBuf {
MemBuf {
buf: Arc::new(UnsafeCell::new(vec![0; cap])),
start: 0,
start: Cell::new(0),
end: 0,
}
}
pub fn bytes(&self) -> &[u8] {
&self.buf()[self.start..self.end]
&self.buf()[self.start.get()..self.end]
}
pub fn is_empty(&self) -> bool {
@@ -34,7 +34,7 @@ impl MemBuf {
}
pub fn len(&self) -> usize {
self.end - self.start
self.end - self.start.get()
}
pub fn capacity(&self) -> usize {
@@ -42,20 +42,21 @@ impl MemBuf {
}
pub fn read_from<R: Read>(&mut self, io: &mut R) -> io::Result<usize> {
let start = self.end - self.start;
let start = self.end - self.start.get();
let n = try!(io.read(&mut self.buf_mut()[start..]));
self.end += n;
Ok(n)
}
pub fn slice(&mut self, len: usize) -> MemSlice {
assert!(self.end - self.start >= len);
let start = self.start;
self.start += len;
pub fn slice(&self, len: usize) -> MemSlice {
assert!(self.end - self.start.get() >= len);
let start = self.start.get();
let end = start + len;
self.start.set(end);
MemSlice {
buf: self.buf.clone(),
start: start,
end: self.start,
end: end,
}
}
@@ -68,18 +69,18 @@ impl MemBuf {
}
let is_unique = Arc::get_mut(&mut self.buf).is_some();
trace!("MemBuf::reserve {} access", if is_unique { "unique" } else { "shared" });
if is_unique && remaining + self.start >= needed {
if is_unique && remaining + self.start.get() >= needed {
// we have unique access, we can mutate this vector
trace!("MemBuf::reserve unique access, shifting");
unsafe {
let mut buf = &mut *self.buf.get();
let len = self.len();
ptr::copy(
buf.as_ptr().offset(self.start as isize),
buf.as_ptr().offset(self.start.get() as isize),
buf.as_mut_ptr(),
len
);
self.start = 0;
self.start.set(0);
self.end = len;
}
} else if is_unique {
@@ -110,7 +111,7 @@ impl MemBuf {
match Arc::get_mut(&mut self.buf) {
Some(_) => {
trace!("MemBuf::reset was unique, re-using");
self.start = 0;
self.start.set(0);
self.end = 0;
},
None => {
@@ -120,13 +121,19 @@ impl MemBuf {
}
}
#[cfg(all(feature = "nightly", test))]
pub fn restart(&mut self) {
Arc::get_mut(&mut self.buf).unwrap();
self.start.set(0);
}
fn buf_mut(&mut self) -> &mut [u8] {
// The contract here is that we NEVER have a MemSlice that exists
// with slice.end > self.start.
// In other words, we should *ALWAYS* be the only instance that can
// look at the bytes on the right side of self.start.
unsafe {
&mut (*self.buf.get())[self.start..]
&mut (*self.buf.get())[self.start.get()..]
}
}
@@ -170,9 +177,9 @@ fn test_grow_zerofill() {
impl fmt::Debug for MemBuf {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("MemBuf")
.field("start", &self.start)
.field("start", &self.start.get())
.field("end", &self.end)
.field("buf", &&self.buf()[self.start..self.end])
.field("buf", &&self.buf()[self.start.get()..self.end])
.finish()
}
}
@@ -183,7 +190,7 @@ impl From<Vec<u8>> for MemBuf {
vec.shrink_to_fit();
MemBuf {
buf: Arc::new(UnsafeCell::new(vec)),
start: 0,
start: Cell::new(0),
end: end,
}
}
@@ -196,11 +203,6 @@ pub struct MemSlice {
}
impl MemSlice {
#[doc(hidden)]
pub fn get(&self) -> &[u8] {
unsafe { &(*self.buf.get())[self.start..self.end] }
}
pub fn empty() -> MemSlice {
MemSlice {
buf: Arc::new(UnsafeCell::new(Vec::new())),
@@ -209,9 +211,21 @@ impl MemSlice {
}
}
pub fn len(&self) -> usize {
self.get().len()
}
pub fn is_empty(&self) -> bool {
self.get().is_empty()
}
pub fn slice<S: Slice>(&self, range: S) -> MemSlice {
range.slice(self)
}
fn get(&self) -> &[u8] {
unsafe { &(*self.buf.get())[self.start..self.end] }
}
}
impl AsRef<[u8]> for MemSlice {
@@ -222,15 +236,14 @@ impl AsRef<[u8]> for MemSlice {
impl fmt::Debug for MemSlice {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
fmt::Debug::fmt(&self.get(), f)
}
}
impl Deref for MemSlice {
type Target = [u8];
fn deref(&self) -> &[u8] {
self.get()
impl Index<usize> for MemSlice {
type Output = u8;
fn index(&self, i: usize) -> &u8 {
&self.get()[i]
}
}
@@ -386,18 +399,18 @@ mod tests {
#[test]
fn test_mem_slice_slice() {
let mut buf = MemBuf::from(b"Hello World".to_vec());
let buf = MemBuf::from(b"Hello World".to_vec());
let len = buf.len();
let full = buf.slice(len);
assert_eq!(&*full, b"Hello World");
assert_eq!(&*full.slice(6..), b"World");
assert_eq!(&*full.slice(..5), b"Hello");
assert_eq!(&*full.slice(..), b"Hello World");
assert_eq!(full.as_ref(), b"Hello World");
assert_eq!(full.slice(6..).as_ref(), b"World");
assert_eq!(full.slice(..5).as_ref(), b"Hello");
assert_eq!(full.slice(..).as_ref(), b"Hello World");
for a in 0..len {
for b in a..len {
assert_eq!(&*full.slice(a..b), &b"Hello World"[a..b], "{}..{}", a, b);
assert_eq!(full.slice(a..b).as_ref(), &b"Hello World"[a..b], "{}..{}", a, b);
}
}
}

2
src/http/chunk.rs
View File

@@ -69,7 +69,7 @@ impl AsRef<[u8]> for Chunk {
match self.0 {
Inner::Owned(ref vec) => vec,
Inner::Referenced(ref vec) => vec,
Inner::Mem(ref slice) => slice,
Inner::Mem(ref slice) => slice.as_ref(),
Inner::Static(slice) => slice,
}
}

15
src/http/conn.rs
View File

@@ -595,6 +595,21 @@ mod tests {
}
}
#[test]
fn test_conn_parse_partial() {
let good_message = b"GET / HTTP/1.1\r\nHost: foo.bar\r\n\r\n".to_vec();
let io = AsyncIo::new_buf(good_message, 10);
let mut conn = Conn::<_, ServerTransaction>::new(io, Default::default());
assert!(conn.poll().unwrap().is_not_ready());
conn.io.io_mut().block_in(50);
let async = conn.poll().unwrap();
assert!(async.is_ready());
match async {
Async::Ready(Some(Frame::Message { .. })) => (),
f => panic!("frame is not Message: {:?}", f),
}
}
#[test]
fn test_conn_closed_read() {
let io = AsyncIo::new_buf(vec![], 0);

8
src/http/h1/decode.rs
View File

@@ -88,7 +88,7 @@ impl Decoder {
} else {
let to_read = *remaining as usize;
let buf = try!(body.read_mem(to_read));
let num = buf.len() as u64;
let num = buf.as_ref().len() as u64;
trace!("Length read: {}", num);
if num > *remaining {
*remaining = 0;
@@ -399,7 +399,7 @@ mod tests {
let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n"[..];
let buf = Decoder::chunked().decode(&mut mock_buf).expect("decode");
assert_eq!(16, buf.len());
let result = String::from_utf8(buf.to_vec()).expect("decode String");
let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
assert_eq!("1234567890abcdef", &result);
}
@@ -411,7 +411,7 @@ mod tests {
// normal read
let buf = decoder.decode(&mut mock_buf).expect("decode");
assert_eq!(16, buf.len());
let result = String::from_utf8(buf.to_vec()).expect("decode String");
let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
assert_eq!("1234567890abcdef", &result);
// eof read
@@ -438,7 +438,7 @@ mod tests {
if buf.is_empty() {
break; // eof
}
outs.write(&buf).expect("write buffer");
outs.write(buf.as_ref()).expect("write buffer");
}
Err(e) => match e.kind() {
io::ErrorKind::WouldBlock => {

65
src/http/h1/parse.rs
View File

@@ -6,7 +6,7 @@ use httparse;
use header::{self, Headers, ContentLength, TransferEncoding};
use http::{MessageHead, RawStatus, Http1Transaction, ParseResult, ServerTransaction, ClientTransaction, RequestLine};
use http::h1::{Encoder, Decoder};
use http::buf::MemSlice;
use http::buf::{MemBuf, MemSlice};
use method::Method;
use status::StatusCode;
use version::HttpVersion::{Http10, Http11};
@@ -14,7 +14,7 @@ use version::HttpVersion::{Http10, Http11};
const MAX_HEADERS: usize = 100;
const AVERAGE_HEADER_SIZE: usize = 30; // totally scientific
pub fn parse<T: Http1Transaction<Incoming=I>, I>(buf: MemSlice) -> ParseResult<I> {
pub fn parse<T: Http1Transaction<Incoming=I>, I>(buf: &MemBuf) -> ParseResult<I> {
if buf.len() == 0 {
return Ok(None);
}
@@ -26,20 +26,26 @@ impl Http1Transaction for ServerTransaction {
type Incoming = RequestLine;
type Outgoing = StatusCode;
fn parse(buf: MemSlice) -> ParseResult<RequestLine> {
fn parse(buf: &MemBuf) -> ParseResult<RequestLine> {
let mut headers = [httparse::EMPTY_HEADER; MAX_HEADERS];
trace!("Request.parse([Header; {}], [u8; {}])", headers.len(), buf.len());
let mut req = httparse::Request::new(&mut headers);
Ok(match try!(req.parse(buf.clone().get())) {
Ok(match try!(req.parse(buf.bytes())) {
httparse::Status::Complete(len) => {
trace!("Request.parse Complete({})", len);
let mut headers = Headers::with_capacity(req.headers.len());
let slice = buf.slice(len);
headers.extend(HeadersAsMemSliceIter {
headers: req.headers.iter(),
slice: slice,
});
Some((MessageHead {
version: if req.version.unwrap() == 1 { Http11 } else { Http10 },
subject: RequestLine(
try!(req.method.unwrap().parse()),
try!(req.path.unwrap().parse())
),
headers: try!(Headers::from_raw(req.headers, buf))
headers: headers,
}, len))
}
httparse::Status::Partial => None,
@@ -113,11 +119,11 @@ impl Http1Transaction for ClientTransaction {
type Incoming = RawStatus;
type Outgoing = RequestLine;
fn parse(buf: MemSlice) -> ParseResult<RawStatus> {
fn parse(buf: &MemBuf) -> ParseResult<RawStatus> {
let mut headers = [httparse::EMPTY_HEADER; MAX_HEADERS];
trace!("Response.parse([Header; {}], [u8; {}])", headers.len(), buf.len());
let mut res = httparse::Response::new(&mut headers);
Ok(match try!(res.parse(buf.clone().get())) {
Ok(match try!(res.parse(buf.bytes())) {
httparse::Status::Complete(len) => {
trace!("Response.try_parse Complete({})", len);
let code = res.code.unwrap();
@@ -125,10 +131,16 @@ impl Http1Transaction for ClientTransaction {
Some(reason) if reason == res.reason.unwrap() => Cow::Borrowed(reason),
_ => Cow::Owned(res.reason.unwrap().to_owned())
};
let mut headers = Headers::with_capacity(res.headers.len());
let slice = buf.slice(len);
headers.extend(HeadersAsMemSliceIter {
headers: res.headers.iter(),
slice: slice,
});
Some((MessageHead {
version: if res.version.unwrap() == 1 { Http11 } else { Http10 },
subject: RawStatus(code, reason),
headers: try!(Headers::from_raw(res.headers, buf))
headers: headers,
}, len))
},
httparse::Status::Partial => None
@@ -217,6 +229,22 @@ impl Http1Transaction for ClientTransaction {
}
}
struct HeadersAsMemSliceIter<'a> {
headers: ::std::slice::Iter<'a, httparse::Header<'a>>,
slice: MemSlice,
}
impl<'a> Iterator for HeadersAsMemSliceIter<'a> {
type Item = (&'a str, MemSlice);
fn next(&mut self) -> Option<Self::Item> {
self.headers.next().map(|header| {
let value_start = header.value.as_ptr() as usize - self.slice.as_ref().as_ptr() as usize;
let value_end = value_start + header.value.len();
(header.name, self.slice.slice(value_start..value_end))
})
}
}
struct FastWrite<'a>(&'a mut Vec<u8>);
impl<'a> fmt::Write for FastWrite<'a> {
@@ -245,23 +273,23 @@ fn extend(dst: &mut Vec<u8>, data: &[u8]) {
#[cfg(test)]
mod tests {
use http;
use http::buf::MemSlice;
use http::buf::MemBuf;
use super::{parse};
#[test]
fn test_parse_request() {
let raw = MemSlice::from(b"GET /echo HTTP/1.1\r\nHost: hyper.rs\r\n\r\n" as &[u8]);
parse::<http::ServerTransaction, _>(raw).unwrap();
let raw = MemBuf::from(b"GET /echo HTTP/1.1\r\nHost: hyper.rs\r\n\r\n".to_vec());
parse::<http::ServerTransaction, _>(&raw).unwrap();
}
#[test]
fn test_parse_raw_status() {
let raw = MemSlice::from(b"HTTP/1.1 200 OK\r\n\r\n" as &[u8]);
let (res, _) = parse::<http::ClientTransaction, _>(raw).unwrap().unwrap();
let raw = MemBuf::from(b"HTTP/1.1 200 OK\r\n\r\n".to_vec());
let (res, _) = parse::<http::ClientTransaction, _>(&raw).unwrap().unwrap();
assert_eq!(res.subject.1, "OK");
let raw = MemSlice::from(b"HTTP/1.1 200 Howdy\r\n\r\n" as &[u8]);
let (res, _) = parse::<http::ClientTransaction, _>(raw).unwrap().unwrap();
let raw = MemBuf::from(b"HTTP/1.1 200 Howdy\r\n\r\n".to_vec());
let (res, _) = parse::<http::ClientTransaction, _>(&raw).unwrap().unwrap();
assert_eq!(res.subject.1, "Howdy");
}
@@ -271,7 +299,7 @@ mod tests {
#[cfg(feature = "nightly")]
#[bench]
fn bench_parse_incoming(b: &mut Bencher) {
let raw = MemSlice::from(b"GET /super_long_uri/and_whatever?what_should_we_talk_about/\
let mut raw = MemBuf::from(b"GET /super_long_uri/and_whatever?what_should_we_talk_about/\
I_wonder/Hard_to_write_in_an_uri_after_all/you_have_to_make\
_up_the_punctuation_yourself/how_fun_is_that?test=foo&test1=\
foo1&test2=foo2&test3=foo3&test4=foo4 HTTP/1.1\r\nHost: \
@@ -287,9 +315,10 @@ mod tests {
X-Content-Duration: None\r\nX-Content-Security-Policy: None\
\r\nX-DNSPrefetch-Control: None\r\nX-Frame-Options: \
Something important obviously\r\nX-Requested-With: Nothing\
\r\n\r\n" as &[u8]);
\r\n\r\n".to_vec());
b.iter(|| {
parse::<http::ServerTransaction, _>(raw.clone()).unwrap()
parse::<http::ServerTransaction, _>(&raw).unwrap();
raw.restart();
});
}

12
src/http/io.rs
View File

@@ -70,11 +70,11 @@ impl<T: Io> Buffered<T> {
_ => return Err(e.into())
}
}
match try!(parse::<S, _>(MemSlice::from(self.read_buf.bytes()))) {
Some((head, len)) => {
trace!("parsed {} bytes out of {}", len, self.read_buf.len());
self.read_buf.slice(len);
Ok(Some(head))
match try!(parse::<S, _>(&self.read_buf)) {
Some(head) => {
//trace!("parsed {} bytes out of {}", len, self.read_buf.len());
//self.read_buf.slice(len);
Ok(Some(head.0))
},
None => {
if self.read_buf.capacity() >= MAX_BUFFER_SIZE {
@@ -140,7 +140,7 @@ impl<T: Write> Write for Buffered<T> {
}
}
fn parse<T: Http1Transaction<Incoming=I>, I>(rdr: MemSlice) -> ParseResult<I> {
fn parse<T: Http1Transaction<Incoming=I>, I>(rdr: &MemBuf) -> ParseResult<I> {
h1::parse::<T, I>(rdr)
}

4
src/http/mod.rs
View File

@@ -13,7 +13,7 @@ use version::HttpVersion::{Http10, Http11};
pub use self::conn::{Conn, KeepAlive, KA};
pub use self::body::{Body, TokioBody};
pub use self::chunk::Chunk;
use self::buf::MemSlice;
use self::buf::MemBuf;
mod body;
#[doc(hidden)]
@@ -125,7 +125,7 @@ pub trait Http1Transaction {
type Incoming;
type Outgoing: Default;
//type KeepAlive: KeepAlive;
fn parse(bytes: MemSlice) -> ParseResult<Self::Incoming>;
fn parse(bytes: &MemBuf) -> ParseResult<Self::Incoming>;
fn decoder(head: &MessageHead<Self::Incoming>) -> ::Result<h1::Decoder>;
fn encode(head: &mut MessageHead<Self::Outgoing>, dst: &mut Vec<u8>) -> h1::Encoder;
fn should_set_length(head: &MessageHead<Self::Outgoing>) -> bool;