feat!: Make usage of decompression context explicit.

That way, the context can be reused which is more efficient than recreating
it from scratch for every little delta to decompress.

This leads to a performance gain of 1.3%.

Author: Byron

gix-pack/src/bundle/find.rs

@@ -1,25 +1,30 @@
+use gix_features::zlib;
+
 impl crate::Bundle {
-    /// Find an object with the given [`ObjectId`][gix_hash::ObjectId] and place its data into `out`.
+    /// Find an object with the given [`ObjectId`](gix_hash::ObjectId) and place its data into `out`.
+    /// `inflate` is used to decompress objects, and will be reset before first use, but not after the last use.
     ///
-    /// [`cache`][crate::cache::DecodeEntry] is used to accelerate the lookup.
+    /// [`cache`](crate::cache::DecodeEntry) is used to accelerate the lookup.
     ///
     /// **Note** that ref deltas are automatically resolved within this pack only, which makes this implementation unusable
     /// for thin packs, which by now are expected to be resolved already.
     pub fn find<'a>(
         &self,
         id: impl AsRef<gix_hash::oid>,
         out: &'a mut Vec<u8>,
+        inflate: &mut zlib::Inflate,
         cache: &mut impl crate::cache::DecodeEntry,
     ) -> Result<Option<(gix_object::Data<'a>, crate::data::entry::Location)>, crate::data::decode::Error> {
         let idx = match self.index.lookup(id) {
             Some(idx) => idx,
             None => return Ok(None),
         };
-        self.get_object_by_index(idx, out, cache).map(Some)
+        self.get_object_by_index(idx, out, inflate, cache).map(Some)
     }
 
     /// Special-use function to get an object given an index previously returned from
-    /// `internal_find_pack_index`.
+    /// [index::File::](crate::index::File::lookup()).
+    /// `inflate` is used to decompress objects, and will be reset before first use, but not after the last use.
     ///
     /// # Panics
     ///
@@ -28,6 +33,7 @@ impl crate::Bundle {
         &self,
         idx: u32,
         out: &'a mut Vec<u8>,
+        inflate: &mut zlib::Inflate,
         cache: &mut impl crate::cache::DecodeEntry,
     ) -> Result<(gix_object::Data<'a>, crate::data::entry::Location), crate::data::decode::Error> {
         let ofs = self.index.pack_offset_at_index(idx);
@@ -37,6 +43,7 @@ impl crate::Bundle {
             .decode_entry(
                 pack_entry,
                 out,
+                inflate,
                 |id, _out| {
                     self.index.lookup(id).map(|idx| {
                         crate::data::decode::entry::ResolvedBase::InPack(

gix-pack/src/data/file/decode/entry.rs

@@ -75,22 +75,28 @@ impl Outcome {
 /// Decompression of objects
 impl File {
     /// Decompress the given `entry` into `out` and return the amount of bytes read from the pack data.
+    /// Note that `inflate` is not reset after usage, but will be reset before using it.
     ///
     /// _Note_ that this method does not resolve deltified objects, but merely decompresses their content
     /// `out` is expected to be large enough to hold `entry.size` bytes.
     ///
     /// # Panics
     ///
     /// If `out` isn't large enough to hold the decompressed `entry`
-    pub fn decompress_entry(&self, entry: &data::Entry, out: &mut [u8]) -> Result<usize, Error> {
+    pub fn decompress_entry(
+        &self,
+        entry: &data::Entry,
+        inflate: &mut zlib::Inflate,
+        out: &mut [u8],
+    ) -> Result<usize, Error> {
         assert!(
             out.len() as u64 >= entry.decompressed_size,
             "output buffer isn't large enough to hold decompressed result, want {}, have {}",
             entry.decompressed_size,
             out.len()
         );
 
-        self.decompress_entry_from_data_offset(entry.data_offset, out)
+        self.decompress_entry_from_data_offset(entry.data_offset, inflate, out)
             .map_err(Into::into)
     }
 
@@ -121,12 +127,14 @@ impl File {
     pub(crate) fn decompress_entry_from_data_offset(
         &self,
         data_offset: data::Offset,
+        inflate: &mut zlib::Inflate,
         out: &mut [u8],
     ) -> Result<usize, zlib::inflate::Error> {
         let offset: usize = data_offset.try_into().expect("offset representable by machine");
         assert!(offset < self.data.len(), "entry offset out of bounds");
 
-        zlib::Inflate::default()
+        inflate.reset();
+        inflate
             .once(&self.data[offset..], out)
             .map(|(_status, consumed_in, _consumed_out)| consumed_in)
     }
@@ -135,12 +143,14 @@ impl File {
     pub(crate) fn decompress_entry_from_data_offset_2(
         &self,
         data_offset: data::Offset,
+        inflate: &mut zlib::Inflate,
         out: &mut [u8],
     ) -> Result<(usize, usize), zlib::inflate::Error> {
         let offset: usize = data_offset.try_into().expect("offset representable by machine");
         assert!(offset < self.data.len(), "entry offset out of bounds");
 
-        zlib::Inflate::default()
+        inflate.reset();
+        inflate
             .once(&self.data[offset..], out)
             .map(|(_status, consumed_in, consumed_out)| (consumed_in, consumed_out))
     }
@@ -149,6 +159,7 @@ impl File {
     /// space to hold the result object.
     ///
     /// The `entry` determines which object to decode, and is commonly obtained with the help of a pack index file or through pack iteration.
+    /// `inflate` will be used for decompressing entries, and will not be reset after usage, but before first using it.
     ///
     /// `resolve` is a function to lookup objects with the given [`ObjectId`][gix_hash::ObjectId], in case the full object id is used to refer to
     /// a base object, instead of an in-pack offset.
@@ -159,6 +170,7 @@ impl File {
         &self,
         entry: data::Entry,
         out: &mut Vec<u8>,
+        inflate: &mut zlib::Inflate,
         resolve: impl Fn(&gix_hash::oid, &mut Vec<u8>) -> Option<ResolvedBase>,
         delta_cache: &mut impl cache::DecodeEntry,
     ) -> Result<Outcome, Error> {
@@ -172,15 +184,16 @@ impl File {
                         .expect("size representable by machine"),
                     0,
                 );
-                self.decompress_entry(&entry, out.as_mut_slice()).map(|consumed_input| {
-                    Outcome::from_object_entry(
-                        entry.header.as_kind().expect("a non-delta entry"),
-                        &entry,
-                        consumed_input,
-                    )
-                })
+                self.decompress_entry(&entry, inflate, out.as_mut_slice())
+                    .map(|consumed_input| {
+                        Outcome::from_object_entry(
+                            entry.header.as_kind().expect("a non-delta entry"),
+                            &entry,
+                            consumed_input,
+                        )
+                    })
             }
-            OfsDelta { .. } | RefDelta { .. } => self.resolve_deltas(entry, resolve, out, delta_cache),
+            OfsDelta { .. } | RefDelta { .. } => self.resolve_deltas(entry, resolve, inflate, out, delta_cache),
         }
     }
 
@@ -191,6 +204,7 @@ impl File {
         &self,
         last: data::Entry,
         resolve: impl Fn(&gix_hash::oid, &mut Vec<u8>) -> Option<ResolvedBase>,
+        inflate: &mut zlib::Inflate,
         out: &mut Vec<u8>,
         cache: &mut impl cache::DecodeEntry,
     ) -> Result<Outcome, Error> {
@@ -278,6 +292,7 @@ impl File {
             for (delta_idx, delta) in chain.iter_mut().rev().enumerate() {
                 let consumed_from_data_offset = self.decompress_entry_from_data_offset(
                     delta.data_offset,
+                    inflate,
                     &mut instructions[..delta.decompressed_size],
                 )?;
                 let is_last_delta_to_be_applied = delta_idx + 1 == chain_len;
@@ -338,7 +353,7 @@ impl File {
                 let base_entry = cursor;
                 debug_assert!(!base_entry.header.is_delta());
                 object_kind = base_entry.header.as_kind();
-                self.decompress_entry_from_data_offset(base_entry.data_offset, out)?;
+                self.decompress_entry_from_data_offset(base_entry.data_offset, inflate, out)?;
             }
 
             (first_buffer_size, second_buffer_end)

gix-pack/src/data/file/decode/header.rs

@@ -2,6 +2,7 @@ use crate::{
     data,
     data::{delta, file::decode::Error, File},
 };
+use gix_features::zlib;
 
 /// A return value of a resolve function, which given an [`ObjectId`][gix_hash::ObjectId] determines where an object can be found.
 #[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd, Clone)]
@@ -37,12 +38,14 @@ impl File {
     /// Resolve the object header information starting at `entry`, following the chain of entries as needed.
     ///
     /// The `entry` determines which object to decode, and is commonly obtained with the help of a pack index file or through pack iteration.
+    /// `inflate` will be used for (partially) decompressing entries, and will be reset before first use, but not after the last use.
     ///
     /// `resolve` is a function to lookup objects with the given [`ObjectId`][gix_hash::ObjectId], in case the full object id
     /// is used to refer to a base object, instead of an in-pack offset.
     pub fn decode_header(
         &self,
         mut entry: data::Entry,
+        inflate: &mut zlib::Inflate,
         resolve: impl Fn(&gix_hash::oid) -> Option<ResolvedBase>,
     ) -> Result<Outcome, Error> {
         use crate::data::entry::Header::*;
@@ -60,14 +63,14 @@ impl File {
                 OfsDelta { base_distance } => {
                     num_deltas += 1;
                     if first_delta_decompressed_size.is_none() {
-                        first_delta_decompressed_size = Some(self.decode_delta_object_size(&entry)?);
+                        first_delta_decompressed_size = Some(self.decode_delta_object_size(inflate, &entry)?);
                     }
                     entry = self.entry(entry.base_pack_offset(base_distance))
                 }
                 RefDelta { base_id } => {
                     num_deltas += 1;
                     if first_delta_decompressed_size.is_none() {
-                        first_delta_decompressed_size = Some(self.decode_delta_object_size(&entry)?);
+                        first_delta_decompressed_size = Some(self.decode_delta_object_size(inflate, &entry)?);
                     }
                     match resolve(base_id.as_ref()) {
                         Some(ResolvedBase::InPack(base_entry)) => entry = base_entry,
@@ -89,9 +92,11 @@ impl File {
     }
 
     #[inline]
-    fn decode_delta_object_size(&self, entry: &data::Entry) -> Result<u64, Error> {
+    fn decode_delta_object_size(&self, inflate: &mut zlib::Inflate, entry: &data::Entry) -> Result<u64, Error> {
         let mut buf = [0_u8; 32];
-        let used = self.decompress_entry_from_data_offset_2(entry.data_offset, &mut buf)?.1;
+        let used = self
+            .decompress_entry_from_data_offset_2(entry.data_offset, inflate, &mut buf)?
+            .1;
         let buf = &buf[..used];
         let (_base_size, offset) = delta::decode_header_size(buf);
         let (result_size, _offset) = delta::decode_header_size(&buf[offset..]);

gix-pack/src/index/traverse/mod.rs

@@ -3,6 +3,7 @@ use std::sync::atomic::AtomicBool;
 use gix_features::{
     parallel,
     progress::{Progress, RawProgress},
+    zlib,
 };
 
 use crate::index;
@@ -155,6 +156,7 @@ impl index::File {
         pack: &crate::data::File,
         cache: &mut C,
         buf: &mut Vec<u8>,
+        inflate: &mut zlib::Inflate,
         progress: &mut dyn RawProgress,
         index_entry: &index::Entry,
         processor: &mut impl FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn RawProgress) -> Result<(), E>,
@@ -169,6 +171,7 @@ impl index::File {
             .decode_entry(
                 pack_entry,
                 buf,
+                inflate,
                 |id, _| {
                     self.lookup(id).map(|index| {
                         crate::data::decode::entry::ResolvedBase::InPack(pack.entry(self.pack_offset_at_index(index)))

gix-pack/src/index/traverse/with_lookup.rs

@@ -4,6 +4,7 @@ use gix_features::{
     parallel::{self, in_parallel_if},
     progress::{self, Progress},
     threading::{lock, Mutable, OwnShared},
+    zlib,
 };
 
 use super::{Error, Reducer};
@@ -131,6 +132,7 @@ impl index::File {
                         (
                             make_pack_lookup_cache(),
                             Vec::with_capacity(2048), // decode buffer
+                            zlib::Inflate::default(),
                             lock(&reduce_progress)
                                 .add_child_with_id(format!("thread {index}"), gix_features::progress::UNKNOWN), // per thread progress
                         )
@@ -143,7 +145,7 @@ impl index::File {
                     thread_limit,
                     state_per_thread,
                     move |entries: &[index::Entry],
-                          (cache, buf, progress)|
+                          (cache, buf, inflate, progress)|
                           -> Result<Vec<data::decode::entry::Outcome>, Error<_>> {
                         progress.init(
                             Some(entries.len()),
@@ -157,6 +159,7 @@ impl index::File {
                                 pack,
                                 cache,
                                 buf,
+                                inflate,
                                 progress,
                                 index_entry,
                                 &mut processor,

gix-pack/tests/pack/bundle.rs

@@ -1,5 +1,6 @@
 mod locate {
     use bstr::ByteSlice;
+    use gix_features::zlib;
     use gix_object::Kind;
     use gix_odb::pack;
 
@@ -8,13 +9,19 @@ mod locate {
     fn locate<'a>(hex_id: &str, out: &'a mut Vec<u8>) -> gix_object::Data<'a> {
         let bundle = pack::Bundle::at(fixture_path(SMALL_PACK_INDEX), gix_hash::Kind::Sha1).expect("pack and idx");
         bundle
-            .find(hex_to_id(hex_id), out, &mut pack::cache::Never)
+            .find(
+                hex_to_id(hex_id),
+                out,
+                &mut zlib::Inflate::default(),
+                &mut pack::cache::Never,
+            )
             .expect("read success")
             .expect("id present")
             .0
     }
 
     mod locate_and_verify {
+        use gix_features::zlib;
         use gix_odb::pack;
 
         use crate::{fixture_path, pack::PACKS_AND_INDICES};
@@ -29,7 +36,12 @@ mod locate {
                 let mut buf = Vec::new();
                 for entry in bundle.index.iter() {
                     let (obj, _location) = bundle
-                        .find(entry.oid, &mut buf, &mut pack::cache::Never)?
+                        .find(
+                            entry.oid,
+                            &mut buf,
+                            &mut zlib::Inflate::default(),
+                            &mut pack::cache::Never,
+                        )?
                         .expect("id present");
                     obj.verify_checksum(entry.oid)?;
                 }

gix-pack/tests/pack/data/file.rs

@@ -105,8 +105,14 @@ mod decode_entry {
         let p = pack_at(SMALL_PACK);
         let entry = p.entry(offset);
         let mut buf = Vec::new();
-        p.decode_entry(entry, &mut buf, resolve_with_panic, &mut cache::Never)
-            .expect("valid offset provides valid entry");
+        p.decode_entry(
+            entry,
+            &mut buf,
+            &mut Default::default(),
+            resolve_with_panic,
+            &mut cache::Never,
+        )
+        .expect("valid offset provides valid entry");
         buf
     }
 }
@@ -154,7 +160,7 @@ mod resolve_header {
 
         let p = pack_at(SMALL_PACK);
         let entry = p.entry(offset);
-        p.decode_header(entry, resolve_with_panic)
+        p.decode_header(entry, &mut Default::default(), resolve_with_panic)
             .expect("valid offset provides valid entry")
     }
 }
@@ -206,7 +212,8 @@ mod decompress_entry {
 
         let size = entry.decompressed_size as usize;
         let mut buf = vec![0; size];
-        p.decompress_entry(&entry, &mut buf).expect("valid offset");
+        p.decompress_entry(&entry, &mut Default::default(), &mut buf)
+            .expect("valid offset");
 
         buf.resize(entry.decompressed_size as usize, 0);
         buf

gix-pack/tests/pack/index.rs

@@ -417,7 +417,7 @@ fn pack_lookup() -> Result<(), Box<dyn std::error::Error>> {
                 entry.pack_offset,
                 "index entry offset and computed pack offset must match"
             );
-            pack.decompress_entry(&pack_entry, &mut buf)?;
+            pack.decompress_entry(&pack_entry, &mut Default::default(), &mut buf)?;
 
             assert_eq!(
                 buf.len() as u64,