minor cleanup

Sebastian Thiel committed 8 years ago

Commit 4b7e9ee1 parent 5ef64852 files · +15 −42Browse files

Unified · Split

2 files

lib/git-odb/src/deflate.rs +6 −25
lib/git-odb/src/loose.rs +9 −17

 use failure::Error;
 use miniz_oxide::inflate::core::DecompressorOxide;
-use std::io::Cursor;
+use std::io::{self, Cursor};
 use miniz_oxide::inflate::{TINFLStatus,
                            core::{decompress,
                                   inflate_flags::{TINFL_FLAG_HAS_MORE_INPUT,
+                                                  TINFL_FLAG_PARSE_ZLIB_HEADER,
                                                   TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF}}};
-use std::io;
 pub struct State {
     inner: DecompressorOxide,
         &mut self,
         input: &[u8],
         mut out: impl io::Write,
-        flags: u32,
     ) -> Result<(usize, usize), Error> {
-        let mut buf = [0; 1024];
+        let mut buf = [0; 8192]; // as per git itself
         let mut in_pos = 0;
         let mut out_pos = 0;
         loop {
-            //            let (status, in_consumed, out_consumed) = {
-            //                let mut c = Cursor::new(&mut buf[..]);
-            //                decompress(
-            //                    &mut self.inner,
-            //                    &input[in_pos..],
-            //                    &mut c,
-            //                    flags | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF
-            //
-            //                )
-            //            };
             let (status, in_consumed, out_consumed) = {
                 let mut c = Cursor::new(&mut buf[..]);
-                self.once(&input[in_pos..], &mut c, flags)?
+                self.once(&input[in_pos..], &mut c)?
             };
-            println!(
-                "in {} + {} of {}\nout {} + {}",
-                in_pos,
-                in_consumed,
-                input.len(),
-                out_pos,
-                out_consumed
-            );
             out.write_all(&buf[..out_consumed])?;
             in_pos += in_consumed;
             out_pos += out_consumed;
         &mut self,
         input: &[u8],
         out: &mut Cursor<&mut [u8]>,
-        flags: u32,
     ) -> Result<(TINFLStatus, usize, usize), Error> {
         let (status, in_consumed, out_consumed) = decompress(
             &mut self.inner,
             input,
             out,
-            flags | TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF,
+            TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_HAS_MORE_INPUT
+                | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF,
         );
         use miniz_oxide::inflate::TINFLStatus::*;

lib/git-odb/src/loose.rs+9−17

 use std::os::unix::fs::MetadataExt;
 use deflate;
 use object::parsed;
-use miniz_oxide::inflate::core::inflate_flags::TINFL_FLAG_PARSE_ZLIB_HEADER;
 const HEADER_READ_COMPRESSED_BYTES: usize = 256;
 const HEADER_READ_UNCOMPRESSED_BYTES: usize = 256;
                     let total_size = self.header_size + self.size;
                     let cap = self.decompressed_data.capacity();
                     if cap < total_size {
-                        self.decompressed_data
+                        self.decompressed_data.reserve_exact(total_size - cap);
-                            .reserve_exact(total_size - cap);
                     }
                     unsafe {
                         debug_assert!(self.decompressed_data.capacity() >= total_size);
                         self.decompressed_data.set_len(total_size);
                     }
-                    println!("out capacity: {}", self.decompressed_data.len());
                     let mut cursor = Cursor::new(&mut self.decompressed_data[..]);
+                    // TODO Performance opportunity
+                    // here we do a lot of additional work, which could be saved if we
+                    // could re-use the previous state. This doesn't work for some reason.
                     self.deflate = Default::default();
-                    let (consumed_in, consumed_out) = self.deflate.to_end(
+                    let (consumed_in, consumed_out) =
-                        &self.compressed_data[..],
+                        self.deflate.to_end(&self.compressed_data[..], &mut cursor)?;
-                        &mut cursor,
-                        TINFL_FLAG_PARSE_ZLIB_HEADER,
-                    )?;
                     debug_assert!(self.deflate.is_done);
                     self.end_of_decompressed_bytes = consumed_out;
                     self.end_of_consumed_compressed_bytes = consumed_in;
                     debug_assert!(self.end_of_decompressed_bytes == total_size);
                 }
-                let bytes = &self.decompressed_data[..self.end_of_decompressed_bytes];
+                let bytes = &self.decompressed_data[self.header_size..];
                 match self.kind {
                     Kind::Tag => parsed::Object::Tag(parsed::Tag::from_bytes(bytes)?),
                     _ => unimplemented!(),
             (
                 deflate
-                    .once(
+                    .once(&compressed[..bytes_read], &mut out)
-                        &compressed[..bytes_read],
-                        &mut out,
-                        TINFL_FLAG_PARSE_ZLIB_HEADER,
-                    )
                     .with_context(|_| {
                         format!("ZIP inflating failed while reading '{}'", path.display())
                     })?,
                 istream,
             )
         };
-        println!("{:?} = stauts", _status);
         let (kind, size, header_size) =
             parse::header(&decompressed[..consumed_out]).with_context(|_| {
             (Some(kind), Some(size)) => Ok((
                 object::Kind::from_bytes(kind)?,
                 str::from_utf8(size)?.parse()?,
-                header_end + 1 // account for 0 byte
+                header_end + 1, // account for 0 byte
             )),
             _ => bail!("expected '<type> <size>'"),
         }