Only keep decompressed bytes of base objects…

…because • decompressed deltas are really not useful nor do they speed up anything. Oposedly, it costs more to allocate. * base objects at least are fully resolved so that might one day be useful.

Sebastian Thiel committed 6 years ago

Commit b39ad891 parent 8812e914 files · +29 −14Browse files

Unified · Split

4 files

git-odb/src/pack/data/iter.rs +12 −4
git-odb/src/pack/index/write/mod.rs +4 −3
git-odb/tests/pack/index.rs +10 −3
git-odb/tests/pack/iter.rs +3 −4

git-odb/src/pack/data/iter.rs+12−4

     /// These do not contain the header, which makes it possible to easily replace a RefDelta with offset deltas
     /// when resolving thin packs.
     pub compressed: Vec<u8>,
-    /// The decompressed data.
+    /// The decompressed data of a base object, which are the only ones who are fully resolved.
-    pub decompressed: Vec<u8>,
+    pub decompressed: Option<Vec<u8>>,
+    /// The amount of decompressed bytes
+    pub decompressed_size: u64,
     /// Set for the last object in the iteration, providing the hash over all bytes of the iteration
     /// for use as trailer in a pack
     pub trailer: Option<owned::Id>,
             decompressor,
         };
-        let mut decompressed = Vec::with_capacity(entry.decompressed_size as usize);
+        let (bytes_copied, decompressed) = if entry.header.is_delta() {
-        let bytes_copied = io::copy(&mut reader, &mut decompressed)?;
+            let mut decompressed = Vec::with_capacity(entry.decompressed_size as usize);
+            let bytes_copied = io::copy(&mut reader, &mut decompressed)?;
+            (bytes_copied, Some(decompressed))
+        } else {
+            (io::copy(&mut reader, &mut io::sink())?, None)
+        };
         debug_assert_eq!(
             bytes_copied, entry.decompressed_size,
             "We should have decompressed {} bytes, but got {} instead",
             compressed,
             pack_offset,
             decompressed,
+            decompressed_size: bytes_copied,
             trailer,
         })
     }

git-odb/src/pack/index/write/mod.rs+4−3

                 pack_offset,
                 header_size,
                 compressed,
-                decompressed,
+                decompressed: _,
+                decompressed_size,
                 trailer,
             } = entry?;
             let compressed_len = compressed.len();
-            bytes_to_process += decompressed.len() as u64;
+            bytes_to_process += decompressed_size;
             let entry_len = header_size as usize + compressed_len;
             let crc32 = {
-                let header_len = header.to_write(decompressed.len() as u64, header_buf.as_mut())?;
+                let header_len = header.to_write(decompressed_size, header_buf.as_mut())?;
                 let state = hash::crc32_update(0, &header_buf[..header_len]);
                 hash::crc32_update(state, &compressed)
             };

git-odb/tests/pack/index.rs+10−3

             );
             let mut buf = Vec::new();
-            buf.resize(entry.decompressed.len(), 0);
+            buf.resize(entry.decompressed_size as usize, 0);
             let pack_entry = pack.entry(offset_from_index);
             pack.decompress_entry(&pack_entry, &mut buf)?;
             assert_eq!(
-                buf, entry.decompressed,
+                buf.len() as u64,
-                "the decompressed bytes are the same no matter what who decompressed them"
+                entry.decompressed_size,
+                "the decompressed length are the same no matter what decompressed them"
             );
+            if let Some(decompressed) = entry.decompressed {
+                assert_eq!(
+                    buf, decompressed,
+                    "the decompressed bytes are the same no matter what decompressed them"
+                );
+            }
             let next_offset_index = sorted_offsets
                 .binary_search(&entry.pack_offset)

git-odb/tests/pack/iter.rs+3−4

 fn size_of_entry() {
     assert_eq!(
         std::mem::size_of::<pack::data::iter::Entry>(),
-        104,
+        112,
         "let's keep the size in check as we have many of them"
     );
 }
                 let entry = entry?;
                 let mut buf = Vec::<u8>::new();
-                entry.header.to_write(entry.decompressed.len() as u64, &mut buf)?;
+                entry.header.to_write(entry.decompressed_size, &mut buf)?;
                 let new_entry = pack::data::Entry::from_bytes(&buf, entry.pack_offset);
                 assert_eq!(
                     "it should consume all provided bytes"
                 );
                 assert_eq!(
-                    new_entry.decompressed_size,
+                    new_entry.decompressed_size, entry.decompressed_size as u64,
-                    entry.decompressed.len() as u64,
                     "decoded size must match"
                 );
                 assert_eq!(new_entry.header, entry.header, "headers match after roundtrip");

Only keep decompressed bytes of base objects…

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code