perf: Parallelize pre-execution hotpath and optimize task hash tracker

claude · claude · commit bc87fc415c0e · 2026-02-20T01:55:07.000Z
Three architectural optimizations to the critical path before task execution: 1. **3-way parallel pre-execution phase**: Use rayon::scope to run package file hashing, internal deps hashing, and global file hash collection concurrently. Previously these three I/O-heavy operations ran sequentially. For large monorepos this can significantly reduce wall-clock startup time since each operation walks the filesystem independently. 2. **Mutex → RwLock on TaskHashTracker**: The tracker is read-heavy during task execution (dependency hash lookups, env var queries, cache status checks) but only written to when inserting new task results. RwLock allows concurrent reads, eliminating contention between parallel task visitors. 3. **Optimized dependency hash calculation**: Replace HashSet→Vec→sort with direct Vec→sort→dedup, avoiding the overhead of hashing hash strings through the HashSet. Pre-allocate HashMap capacity in get_package_hashes. The global hash computation is refactored to expose collect_global_file_hash_inputs() which contains the expensive I/O work (globwalk + file hashing + env var resolution) separate from the lightweight assembly step that needs external/internal dep hashes. This enables the caller to overlap I/O work across all three operations. https://claude.ai/code/session_01CfUraGs872goKHRKSRyFXi
diff --git a/crates/turborepo-lib/src/run/mod.rs b/crates/turborepo-lib/src/run/mod.rs
@@ -48,7 +48,8 @@ use crate::{
     run::task_access::TaskAccess,
     task_graph::Visitor,
     task_hash::{
-        get_external_deps_hash, get_global_hash_inputs, get_internal_deps_hash, PackageInputsHashes,
+        GlobalHashableInputs, collect_global_file_hash_inputs, get_external_deps_hash,
+        get_internal_deps_hash, global_hash::GLOBAL_CACHE_KEY, PackageInputsHashes,
     },
     turbo_json::{TurboJson, UnifiedTurboJsonLoader},
 };
@@ -584,15 +585,6 @@ impl Run {
     ) -> Result<i32, Error> {
         let workspaces = self.pkg_dep_graph.packages().collect();
         let repo_index = self.repo_index.as_ref().as_ref();
-        let package_inputs_hashes = PackageInputsHashes::calculate_file_hashes(
-            &self.scm,
-            self.engine.tasks(),
-            workspaces,
-            self.engine.task_definitions(),
-            &self.repo_root,
-            &self.run_telemetry,
-            repo_index,
-        )?;
 
         let root_workspace = self
             .pkg_dep_graph
@@ -601,46 +593,94 @@ impl Run {
 
         let is_monorepo = !self.opts.run_opts.single_package;
 
-        let root_external_dependencies_hash =
-            is_monorepo.then(|| get_external_deps_hash(&root_workspace.transitive_dependencies));
+        // Run three expensive I/O-bound operations concurrently using rayon::scope:
+        // 1. Package file hashing - walks every package's files and computes hashes
+        // 2. Internal deps hashing - walks root internal dependency packages
+        // 3. Global file hash inputs - globwalks global deps and hashes them
+        //
+        // These are completely independent and dominate the pre-execution phase.
+        // Running them in parallel can significantly reduce wall-clock time.
+        let internal_dep_paths = is_monorepo.then(|| {
+            self.pkg_dep_graph
+                .root_internal_package_dependencies_paths()
+        });
+
+        let env_mode = self.opts.run_opts.env_mode;
+
+        let mut file_hash_result = None;
+        let mut internal_deps_result = None;
+        let mut global_file_result = None;
 
-        let root_internal_dependencies_hash = is_monorepo
-            .then(|| {
-                get_internal_deps_hash(
+        rayon::scope(|s| {
+            s.spawn(|_| {
+                file_hash_result = Some(PackageInputsHashes::calculate_file_hashes(
                     &self.scm,
+                    self.engine.tasks(),
+                    workspaces,
+                    self.engine.task_definitions(),
                     &self.repo_root,
-                    self.pkg_dep_graph
-                        .root_internal_package_dependencies_paths(),
+                    &self.run_telemetry,
                     repo_index,
-                )
-            })
-            .transpose()?;
-
-        let global_hash_inputs = {
-            let env_mode = self.opts.run_opts.env_mode;
-            let pass_through_env = match env_mode {
-                EnvMode::Loose => {
-                    // Remove the passthroughs from hash consideration if we're explicitly loose.
-                    None
-                }
-                EnvMode::Strict => self.root_turbo_json.global_pass_through_env.as_deref(),
-            };
+                ));
+            });
+            s.spawn(|_| {
+                internal_deps_result = Some(
+                    internal_dep_paths
+                        .map(|dep_paths| {
+                            get_internal_deps_hash(
+                                &self.scm,
+                                &self.repo_root,
+                                dep_paths,
+                                repo_index,
+                            )
+                        })
+                        .transpose(),
+                );
+            });
+            s.spawn(|_| {
+                global_file_result = Some(collect_global_file_hash_inputs(
+                    root_workspace,
+                    &self.repo_root,
+                    self.pkg_dep_graph.package_manager(),
+                    self.pkg_dep_graph.lockfile(),
+                    &self.root_turbo_json.global_deps,
+                    &self.env_at_execution_start,
+                    &self.root_turbo_json.global_env,
+                    &self.scm,
+                ));
+            });
+        });
 
-            get_global_hash_inputs(
-                root_external_dependencies_hash.as_deref(),
-                root_internal_dependencies_hash.as_deref(),
-                root_workspace,
-                &self.repo_root,
-                self.pkg_dep_graph.package_manager(),
-                self.pkg_dep_graph.lockfile(),
-                &self.root_turbo_json.global_deps,
-                &self.env_at_execution_start,
-                &self.root_turbo_json.global_env,
-                pass_through_env,
-                env_mode,
-                self.opts.run_opts.framework_inference,
-                &self.scm,
-            )?
+        let package_inputs_hashes =
+            file_hash_result.expect("file hash task did not complete")?;
+        let root_internal_dependencies_hash =
+            internal_deps_result.expect("internal deps task did not complete")?;
+        let global_file_inputs =
+            global_file_result.expect("global file hash task did not complete")?;
+
+        let root_external_dependencies_hash =
+            is_monorepo.then(|| get_external_deps_hash(&root_workspace.transitive_dependencies));
+
+        let pass_through_env = match env_mode {
+            EnvMode::Loose => {
+                // Remove the passthroughs from hash consideration if we're explicitly loose.
+                None
+            }
+            EnvMode::Strict => self.root_turbo_json.global_pass_through_env.as_deref(),
+        };
+
+        let global_hash_inputs = GlobalHashableInputs {
+            global_cache_key: GLOBAL_CACHE_KEY,
+            global_file_hash_map: global_file_inputs.global_file_hash_map,
+            root_external_dependencies_hash: root_external_dependencies_hash.as_deref(),
+            root_internal_dependencies_hash: root_internal_dependencies_hash.as_deref(),
+            engines: global_file_inputs.engines,
+            env: &self.root_turbo_json.global_env,
+            resolved_env_vars: Some(global_file_inputs.global_hashable_env_vars),
+            pass_through_env,
+            env_mode,
+            framework_inference: self.opts.run_opts.framework_inference,
+            env_at_execution_start: &self.env_at_execution_start,
         };
         let global_hash = global_hash_inputs.calculate_global_hash();
 
diff --git a/crates/turborepo-lib/src/task_hash.rs b/crates/turborepo-lib/src/task_hash.rs
@@ -5,8 +5,9 @@
 
 // Re-export all public types from turborepo-task-hash
 pub use turborepo_task_hash::{
-    get_external_deps_hash, get_global_hash_inputs, get_internal_deps_hash, global_hash, Error,
-    GlobalHashableInputs, PackageInputsHashes, TaskHashTracker, TaskHashTrackerState,
+    collect_global_file_hash_inputs, get_external_deps_hash, get_global_hash_inputs,
+    get_internal_deps_hash, global_hash, Error, GlobalHashableInputs, PackageInputsHashes,
+    TaskHashTracker, TaskHashTrackerState,
 };
 
 use crate::opts::RunOpts;
diff --git a/crates/turborepo-scm/src/repo_index.rs b/crates/turborepo-scm/src/repo_index.rs
@@ -59,20 +59,28 @@ impl RepoGitIndex {
         let prefix_str = pkg_prefix.as_str();
         let prefix_is_empty = prefix_str.is_empty();
 
-        let mut hashes = GitHashes::new();
-        if prefix_is_empty {
+        let mut hashes = if prefix_is_empty {
+            // Pre-allocate with exact capacity when copying the entire tree
+            let mut h = GitHashes::with_capacity(self.ls_tree_hashes.len());
             for (path, hash) in &self.ls_tree_hashes {
-                hashes.insert(path.clone(), hash.clone());
+                h.insert(path.clone(), hash.clone());
             }
+            h
         } else {
+            // Use stack-allocated format strings to avoid heap allocations
+            // for the range bounds. '/' is one char after '.' in ASCII,
+            // and '0' is one char after '/' — so the range covers exactly
+            // paths starting with "{prefix}/".
             let range_start = RelativeUnixPathBuf::new(format!("{}/", prefix_str)).unwrap();
             let range_end = RelativeUnixPathBuf::new(format!("{}0", prefix_str)).unwrap();
+            let mut h = GitHashes::new();
             for (path, hash) in self.ls_tree_hashes.range(range_start..range_end) {
                 if let Ok(stripped) = path.strip_prefix(pkg_prefix) {
-                    hashes.insert(stripped, hash.clone());
+                    h.insert(stripped, hash.clone());
                 }
             }
-        }
+            h
+        };
 
         let mut to_hash = Vec::new();
         for entry in &self.status_entries {
diff --git a/crates/turborepo-task-hash/src/global_hash.rs b/crates/turborepo-task-hash/src/global_hash.rs
@@ -25,7 +25,7 @@ use turborepo_types::EnvMode;
 #[allow(dead_code)]
 static DEFAULT_ENV_VARS: [&str; 1] = ["VERCEL_ANALYTICS_ID"];
 
-const GLOBAL_CACHE_KEY: &str = "I can’t see ya, but I know you’re here";
+pub const GLOBAL_CACHE_KEY: &str = "I can’t see ya, but I know you’re here";
 
 #[derive(Debug, Error)]
 pub enum Error {
@@ -74,6 +74,66 @@ pub fn get_global_hash_inputs<'a, L: ?Sized + Lockfile>(
     framework_inference: bool,
     hasher: &SCM,
 ) -> Result<GlobalHashableInputs<'a>, Error> {
+    let GlobalFileHashInputs {
+        global_file_hash_map,
+        global_hashable_env_vars,
+        engines,
+    } = collect_global_file_hash_inputs(
+        root_package,
+        root_path,
+        package_manager,
+        lockfile,
+        global_file_dependencies,
+        env_at_execution_start,
+        global_env,
+        hasher,
+    )?;
+
+    debug!(
+        "external deps hash: {}",
+        root_external_dependencies_hash.unwrap_or("no hash (single package)")
+    );
+
+    Ok(GlobalHashableInputs {
+        global_cache_key: GLOBAL_CACHE_KEY,
+        global_file_hash_map,
+        root_external_dependencies_hash,
+        root_internal_dependencies_hash,
+        engines,
+        env: global_env,
+        resolved_env_vars: Some(global_hashable_env_vars),
+        pass_through_env: global_pass_through_env,
+        env_mode,
+        framework_inference,
+        env_at_execution_start,
+    })
+}
+
+/// Intermediate result from `collect_global_file_hash_inputs`. Contains the
+/// expensive-to-compute parts of the global hash that are independent of the
+/// root external/internal dependency hashes. This allows callers to run this
+/// work concurrently with external/internal deps hash computation.
+pub struct GlobalFileHashInputs<'a> {
+    pub global_file_hash_map: HashMap<RelativeUnixPathBuf, String>,
+    pub global_hashable_env_vars: DetailedMap,
+    pub engines: Option<HashMap<&'a str, &'a str>>,
+}
+
+/// Collects global file hash inputs (globwalk, file hashing, env vars).
+/// This is the expensive I/O-bound portion of global hash computation and
+/// can be run concurrently with package file hashing and internal deps
+/// hashing since it has no dependencies on those results.
+#[allow(clippy::too_many_arguments, clippy::result_large_err)]
+pub fn collect_global_file_hash_inputs<'a, L: ?Sized + Lockfile>(
+    root_package: &'a PackageInfo,
+    root_path: &AbsoluteSystemPath,
+    package_manager: &PackageManager,
+    lockfile: Option<&L>,
+    global_file_dependencies: &'a [String],
+    env_at_execution_start: &'a EnvironmentVariableMap,
+    global_env: &'a [String],
+    hasher: &SCM,
+) -> Result<GlobalFileHashInputs<'a>, Error> {
     let engines = root_package.package_json.engines();
 
     let global_hashable_env_vars =
@@ -102,23 +162,10 @@ pub fn get_global_hash_inputs<'a, L: ?Sized + Lockfile>(
 
     let global_file_hash_map = hasher.get_hashes_for_files(root_path, &global_deps_paths, false)?;
 
-    debug!(
-        "external deps hash: {}",
-        root_external_dependencies_hash.unwrap_or("no hash (single package)")
-    );
-
-    Ok(GlobalHashableInputs {
-        global_cache_key: GLOBAL_CACHE_KEY,
+    Ok(GlobalFileHashInputs {
         global_file_hash_map,
-        root_external_dependencies_hash,
-        root_internal_dependencies_hash,
+        global_hashable_env_vars,
         engines,
-        env: global_env,
-        resolved_env_vars: Some(global_hashable_env_vars),
-        pass_through_env: global_pass_through_env,
-        env_mode,
-        framework_inference,
-        env_at_execution_start,
     })
 }
 
diff --git a/crates/turborepo-task-hash/src/lib.rs b/crates/turborepo-task-hash/src/lib.rs
