perf: Use Arc<str> for task dependency hashes to avoid heap clones

Store task hashes as Arc<str> in TaskHashTrackerState instead of String.
In calculate_dependency_hashes, cloning an Arc<str> is a ref count bump
instead of a heap allocation. For the api monorepo (1687 tasks, ~3 deps
each), this eliminates ~5000 String heap allocations per run.

Author: anthonyshew

crates/turborepo-hash/src/lib.rs

@@ -6,7 +6,7 @@
 
 mod traits;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 use capnp::message::{Builder, HeapAllocator};
 pub use traits::TurboHash;
@@ -58,7 +58,7 @@ pub type EnvironmentVariablePairs = Vec<String>;
 pub struct TaskHashable<'a> {
     // hashes
     pub global_hash: &'a str,
-    pub task_dependency_hashes: Vec<String>,
+    pub task_dependency_hashes: Vec<Arc<str>>,
     pub hash_of_files: &'a str,
     pub external_deps_hash: Option<&'a str>,
 
@@ -338,7 +338,7 @@ impl From<TaskHashable<'_>> for Builder<HeapAllocator> {
                 .reborrow()
                 .init_task_dependency_hashes(task_hashable.task_dependency_hashes.len() as u32);
             for (i, hash) in task_hashable.task_dependency_hashes.iter().enumerate() {
-                task_dependency_hashes_builder.set(i as u32, hash);
+                task_dependency_hashes_builder.set(i as u32, &**hash);
             }
         }
 
@@ -497,6 +497,8 @@ impl From<GlobalHashable<'_>> for Builder<HeapAllocator> {
 
 #[cfg(test)]
 mod test {
+    use std::sync::Arc;
+
     use test_case::test_case;
     use turborepo_lockfiles::Package;
     use turborepo_types::{EnvMode, TaskOutputs};
@@ -509,7 +511,7 @@ mod test {
     fn task_hashable() {
         let task_hashable = TaskHashable {
             global_hash: "global_hash",
-            task_dependency_hashes: vec!["task_dependency_hash".to_string()],
+            task_dependency_hashes: vec![Arc::from("task_dependency_hash")],
             package_dir: Some(turbopath::RelativeUnixPathBuf::new("package_dir").unwrap()),
             hash_of_files: "hash_of_files",
             external_deps_hash: Some("external_deps_hash"),
@@ -528,6 +530,36 @@ mod test {
         assert_eq!(task_hashable.hash(), "1f8b13161f57fca1");
     }
 
+    #[test]
+    fn task_hashable_multiple_dependency_hashes() {
+        let task_hashable = TaskHashable {
+            global_hash: "global_hash",
+            task_dependency_hashes: vec![
+                Arc::from("dep_hash_a"),
+                Arc::from("dep_hash_b"),
+                Arc::from("dep_hash_c"),
+            ],
+            package_dir: Some(turbopath::RelativeUnixPathBuf::new("package_dir").unwrap()),
+            hash_of_files: "hash_of_files",
+            external_deps_hash: Some("external_deps_hash"),
+            task: "task",
+            outputs: TaskOutputs {
+                inclusions: vec!["inclusions".to_string()],
+                exclusions: vec!["exclusions".to_string()],
+            },
+            pass_through_args: &["pass_thru_args".to_string()],
+            env: &["env".to_string()],
+            resolved_env_vars: vec![],
+            pass_through_env: &["pass_thru_env".to_string()],
+            env_mode: EnvMode::Strict,
+        };
+
+        let hash = task_hashable.hash();
+        assert!(!hash.is_empty());
+        // Pin the hash so any serialization change is caught
+        assert_eq!(hash, "7676d7bb7c86d257");
+    }
+
     #[test]
     fn global_hashable() {
         let global_file_hash_map = vec![(

crates/turborepo-task-hash/src/lib.rs

@@ -230,7 +230,7 @@ pub struct TaskHashTracker {
 pub struct TaskHashTrackerState {
     #[serde(skip)]
     package_task_env_vars: HashMap<TaskId<'static>, DetailedMap>,
-    package_task_hashes: HashMap<TaskId<'static>, String>,
+    package_task_hashes: HashMap<TaskId<'static>, Arc<str>>,
     #[serde(skip)]
     package_task_framework: HashMap<TaskId<'static>, FrameworkSlug>,
     #[serde(skip)]
@@ -431,10 +431,11 @@ impl<'a, R: RunOptsHashInfo> TaskHasher<'a, R> {
 
         let task_hash = task_hashable.calculate_task_hash();
 
+        let task_hash_arc: Arc<str> = Arc::from(task_hash.as_str());
         self.task_hash_tracker.insert_hash(
             task_id.clone(),
             env_vars,
-            task_hash.clone(),
+            task_hash_arc,
             framework_slug,
         );
 
@@ -453,17 +454,14 @@ impl<'a, R: RunOptsHashInfo> TaskHasher<'a, R> {
     fn calculate_dependency_hashes(
         &self,
         dependency_set: HashSet<&TaskNode>,
-    ) -> Result<Vec<String>, Error> {
+    ) -> Result<Vec<Arc<str>>, Error> {
         let state = self
             .task_hash_tracker
             .state
             .read()
             .expect("hash tracker rwlock poisoned");
 
-        // Collect owned strings directly to avoid borrow lifetime issues with
-        // the RwLock guard. We sort + dedup instead of using a HashSet to avoid
-        // the overhead of hashing the hash strings.
-        let mut dependency_hash_list: Vec<String> = Vec::with_capacity(dependency_set.len());
+        let mut dependency_hash_list: Vec<Arc<str>> = Vec::with_capacity(dependency_set.len());
         for dependency_task in &dependency_set {
             let TaskNode::Task(dependency_task_id) = dependency_task else {
                 continue;
@@ -473,7 +471,7 @@ impl<'a, R: RunOptsHashInfo> TaskHasher<'a, R> {
                 .package_task_hashes
                 .get(dependency_task_id)
                 .ok_or_else(|| Error::MissingDependencyTaskHash(dependency_task.to_string()))?;
-            dependency_hash_list.push(dependency_hash.clone());
+            dependency_hash_list.push(Arc::clone(dependency_hash));
         }
         drop(state);
 
@@ -591,7 +589,7 @@ impl TaskHashTracker {
         }
     }
 
-    pub fn hash(&self, task_id: &TaskId) -> Option<String> {
+    pub fn hash(&self, task_id: &TaskId) -> Option<Arc<str>> {
         let state = self.state.read().expect("hash tracker rwlock poisoned");
         state.package_task_hashes.get(task_id).cloned()
     }
@@ -600,7 +598,7 @@ impl TaskHashTracker {
         &self,
         task_id: TaskId<'static>,
         env_vars: DetailedMap,
-        hash: String,
+        hash: Arc<str>,
         framework_slug: Option<FrameworkSlug>,
     ) {
         let mut state = self.state.write().expect("hash tracker rwlock poisoned");
@@ -664,7 +662,7 @@ impl TaskHashTracker {
 // proper dependency direction (task-hash doesn't depend on run-summary).
 impl HashTrackerInfo for TaskHashTracker {
     fn hash(&self, task_id: &TaskId) -> Option<String> {
-        TaskHashTracker::hash(self, task_id)
+        TaskHashTracker::hash(self, task_id).map(|arc| arc.to_string())
     }
 
     fn env_vars(&self, task_id: &TaskId) -> Option<HashTrackerDetailedMap> {
@@ -738,7 +736,7 @@ mod test {
         tracker.insert_hash(
             task_id.clone(),
             DetailedMap::default(),
-            "abc123".to_string(),
+            Arc::from("abc123"),
             None,
         );
 
@@ -777,7 +775,7 @@ mod test {
                     tracker.insert_hash(
                         task_id.clone(),
                         DetailedMap::default(),
-                        format!("hash-{i}"),
+                        Arc::from(format!("hash-{i}").as_str()),
                         None,
                     );
                 }
@@ -990,7 +988,7 @@ mod test {
             tracker.insert_hash(
                 task_id.clone(),
                 DetailedMap::default(),
-                format!("hash-{i}"),
+                Arc::from(format!("hash-{i}").as_str()),
                 None,
             );
             assert_eq!(