adapt to changes in git-features::fs.

We only use parallel traversal where it matters most, namely
loose object traversal which can be many objects in up to 256 folders.
Being able to parallelize among them will be a noticable speedup
well worth the cost (presumably).

Ref traversals are single-threaded as we expect most refs in packed-refs
anyway.

Furthermore we can now consider parallel traversal safe as we don't
use the global rayon pool anymore, something that can break any parallel
iteration (and just a version of `jwalk` earlier it would deadlock).

Author: Byron

git-odb/src/store_impls/loose/find.rs

@@ -49,11 +49,14 @@ impl Store {
         mut candidates: Option<&mut HashSet<git_hash::ObjectId>>,
     ) -> Result<Option<crate::find::PrefixLookupResult>, crate::loose::iter::Error> {
         let single_directory_iter = crate::loose::Iter {
-            inner: git_features::fs::walkdir_new(&self.path.join(prefix.as_oid().to_hex_with_len(2).to_string()))
-                .min_depth(1)
-                .max_depth(1)
-                .follow_links(false)
-                .into_iter(),
+            inner: git_features::fs::walkdir_new(
+                &self.path.join(prefix.as_oid().to_hex_with_len(2).to_string()),
+                git_features::fs::walkdir::Parallelism::Serial,
+            )
+            .min_depth(1)
+            .max_depth(1)
+            .follow_links(false)
+            .into_iter(),
             hash_hex_len: prefix.as_oid().kind().len_in_hex(),
         };
         let mut candidate = None;

git-odb/src/store_impls/loose/iter.rs

@@ -65,11 +65,16 @@ impl loose::Store {
     /// needed if iterators need to be implemented by hand in the absence of generators.
     pub fn iter(&self) -> loose::Iter {
         loose::Iter {
-            inner: fs::walkdir_new(&self.path)
-                .min_depth(2)
-                .max_depth(3)
-                .follow_links(false)
-                .into_iter(),
+            inner: fs::walkdir_new(
+                &self.path,
+                fs::walkdir::Parallelism::ThreadPoolPerTraversal {
+                    thread_name: "git_odb::loose::Store::iter: fs-walk",
+                },
+            )
+            .min_depth(2)
+            .max_depth(3)
+            .follow_links(false)
+            .into_iter(),
             hash_hex_len: self.object_hash.len_in_hex(),
         }
     }

git-ref/src/store/file/loose/iter.rs

@@ -18,9 +18,10 @@ impl SortedLoosePaths {
         SortedLoosePaths {
             base: base.into(),
             filename_prefix,
-            file_walk: path
-                .is_dir()
-                .then(|| git_features::fs::walkdir_sorted_new(path).into_iter()),
+            file_walk: path.is_dir().then(|| {
+                // serial iteration as we expect most refs in packed-refs anyway.
+                git_features::fs::walkdir_sorted_new(path, git_features::fs::walkdir::Parallelism::Serial).into_iter()
+            }),
         }
     }
 }

git-repository/Cargo.toml

@@ -64,7 +64,7 @@ serde1 = [  "serde",
 
 ## Activate other features that maximize performance, like usage of threads, `zlib-ng` and access to caching in object databases.
 ## Note that some platforms might suffer from compile failures, which is when `max-performance-safe` should be used.
-max-performance = [ "git-features/zlib-ng-compat", "fast-sha1", "max-performance-safe", "git-features/fs-walkdir-parallel" ]
+max-performance = [ "git-features/zlib-ng-compat", "fast-sha1", "max-performance-safe" ]
 
 ## If enabled, use assembly versions of sha1 on supported platforms.
 ## This might cause compile failures as well which is why it can be turned off separately.
@@ -75,7 +75,8 @@ fast-sha1 = [ "git-features/fast-sha1" ]
 max-performance-safe = [
     "git-features/parallel",
     "git-pack/pack-cache-lru-static",
-    "git-pack/pack-cache-lru-dynamic"
+    "git-pack/pack-cache-lru-dynamic",
+    "git-features/fs-walkdir-parallel"
 ]
 ## Print debugging information about usage of object database caches, useful for tuning cache sizes.
 cache-efficiency-debug = ["git-features/cache-efficiency-debug"]