feat: index-backed tree traversal with a form of work-stealing. (#851)

When delta-trees are unbalanced, in pathological cases it's possible that that one thread
ends up with more than half of the work. In this case it's required that it manages to
spawn its own threads to parallelize the work it has.

Author: Byron

gix-pack/src/cache/delta/traverse/mod.rs

@@ -152,13 +152,15 @@ where
                 }
             },
             {
-                move |node, state, _scope, _threads_left, should_interrupt| {
+                move |node, state, scope, threads_left, should_interrupt| {
                     resolve::deltas(
                         object_counter.clone(),
                         size_counter.clone(),
                         node,
                         state,
                         object_hash.len_in_bytes(),
+                        scope,
+                        threads_left,
                         should_interrupt,
                     )
                 }

gix-pack/src/cache/delta/traverse/resolve.rs

@@ -1,4 +1,4 @@
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, AtomicIsize};
 use std::{cell::RefCell, collections::BTreeMap, sync::atomic::Ordering};
 
 use gix_features::{progress::Progress, zlib};
@@ -28,6 +28,8 @@ pub(crate) fn deltas<T, F, P, MBFN, S, E>(
         ItemSliceSend<Item<T>>,
     ),
     hash_len: usize,
+    _scope: &gix_features::parallel::Scope<'_, '_>,
+    _threads_left: &AtomicIsize,
     should_interrupt: &AtomicBool,
 ) -> Result<(), Error>
 where
@@ -105,7 +107,7 @@ where
             assert_eq!(
                 base_bytes.len(),
                 base_size as usize,
-                "recorded base size in delta does not match"
+                "recorded base size in delta does match the actual one"
             );
             let (result_size, consumed) = crate::data::delta::decode_header_size(&delta_bytes[consumed..]);
             header_ofs += consumed;
@@ -142,6 +144,10 @@ where
                     .map(|c| c.fetch_add(base_bytes.len(), Ordering::SeqCst));
             }
         }
+
+        // After the first round, see if we can use additional threads, and if so we enter multi-threaded mode.
+        // In it we will keep using new threads as they become available while using this thread for coordination.
+        // We optimize for a low memory footprint as we are likely to get here if long delta-chains with large objects are involved.
     }
 
     Ok(())