Remove internal buffering in CodedOutputStream

This commit removes the internal buffering in CodedOutputStream. The protobuf
library should rely on the application to provide a buffered Write
implementation, if it so desires. By buffering internally, the protobuf library
forces double buffering in situations where the application is already buffering.
Additionally, it forces awkward resource lifetime issues as discussed in stepancheg#147.
Removing the internal buffering simplifies the internals of CodedOutputStream
and improves performance on the rust-protobuf-perftest write tests.

Before:

test1: write: 86 ns per iter
test_repeated_bool: write: 91 ns per iter
test_repeated_packed_int32: write: 127 ns per iter
test_repeated_messages: write: 224 ns per iter
test_optional_messages: write: 202 ns per iter
test_strings: write: 136 ns per iter
test_small_bytearrays: write: 1098 ns per iter
test_large_bytearrays: write: 119221 ns per iter

After:

test1: write: 55 ns per iter
test_repeated_bool: write: 66 ns per iter
test_repeated_packed_int32: write: 122 ns per iter
test_repeated_messages: write: 248 ns per iter
test_optional_messages: write: 207 ns per iter
test_strings: write: 118 ns per iter
test_small_bytearrays: write: 1064 ns per iter
test_large_bytearrays: write: 109567 ns per iter

Author: danburkert

src/lib/stream.rs

@@ -702,71 +702,27 @@ impl<'a> WithCodedInputStream for &'a [u8] {
     }
 }
 
-
 pub struct CodedOutputStream<'a> {
-    buffer: Box<[u8]>,
-    // within buffer
-    position: u32,
-    writer: Option<&'a mut (Write + 'a)>,
+    writer: &'a mut Write,
 }
 
 impl<'a> CodedOutputStream<'a> {
     pub fn new(writer: &'a mut Write) -> CodedOutputStream<'a> {
-        let buffer_len = 4096;
-        let mut buffer = Vec::with_capacity(buffer_len);
-        unsafe { buffer.set_len(buffer_len); }
         CodedOutputStream {
-            buffer: buffer.into_boxed_slice(),
-            position: 0,
-            writer: Some(writer),
+            writer: writer,
         }
     }
 
-    fn refresh_buffer(&mut self) -> ProtobufResult<()> {
-        match self.writer {
-            Some(ref mut writer) => {
-                try!(writer.write_all(&self.buffer[0..self.position as usize])
-                    .map_err(|e| ProtobufError::IoError(e)));
-            },
-            None => panic!()
-        };
-        self.position = 0;
-        Ok(())
-    }
-
     pub fn flush(&mut self) -> ProtobufResult<()> {
-        if self.writer.is_some() {
-            try!(self.refresh_buffer());
-        }
-        Ok(())
+        self.writer.flush().map_err(ProtobufError::IoError)
     }
 
     pub fn write_raw_byte(&mut self, byte: u8) -> ProtobufResult<()> {
-        if self.position as usize == self.buffer.len() {
-            try!(self.refresh_buffer());
-        }
-        self.buffer[self.position as usize] = byte;
-        self.position += 1;
-        Ok(())
+        self.writer.write_all(&[byte]).map_err(ProtobufError::IoError)
     }
 
     pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> ProtobufResult<()> {
-        if bytes.len() <= self.buffer.len() - self.position as usize {
-            // TODO: use `copy_from_slice` as soon as rust 1.9 released
-            unsafe {
-                let dest = &mut self.buffer[self.position as usize..];
-                ptr::copy_nonoverlapping(bytes.as_ptr(), dest.as_mut_ptr(), bytes.len());
-                self.position += bytes.len() as u32;
-                return Ok(());
-            }
-        }
-
-        try!(self.refresh_buffer());
-        match self.writer {
-            Some(ref mut writer) => try!(writer.write_all(bytes).map_err(|e| ProtobufError::IoError(e))),
-            None => panic!()
-        };
-        Ok(())
+        self.writer.write_all(bytes).map_err(ProtobufError::IoError)
     }
 
     pub fn write_tag(&mut self, field_number: u32, wire_type: wire_format::WireType) -> ProtobufResult<()> {