perf: Use stack-allocated OidHash in FileHashes and skip expanded hashes on normal runs

Two memory optimizations for large monorepos:

1. FileHashes now stores OidHash (40 bytes, stack, Copy) instead of
   heap-allocated String (~80-96 bytes each). OidHash moved from
   turborepo-scm to turborepo-hash where it belongs architecturally.
   The OidHash->String conversion only happens at the JSON serialization
   boundary for --summarize/--dry output.

2. calculate_file_hashes takes a needs_expanded_hashes flag. When false
   (normal turbo run), the per-file hash maps are computed for the
   collapsed task hash but not retained in the TaskHashTracker. This
   skips O(tasks * files) of memory that previously lived for the entire
   run duration but was never read.

Author: anthonyshew

Cargo.lock

@@ -4,11 +4,13 @@
 //! deterministic serialization across languages and platforms, then applies
 //! xxHash64 for fast hashing.
 
+mod oid_hash;
 mod traits;
 
 use std::{collections::HashMap, sync::Arc};
 
 use capnp::message::{Builder, HeapAllocator};
+pub use oid_hash::OidHash;
 pub use traits::TurboHash;
 // Re-export for backward compatibility. New code should import from `turborepo_types`.
 #[deprecated(
@@ -108,7 +110,7 @@ pub struct LockFilePackages(pub Vec<turborepo_lockfiles::Package>);
 pub struct LockFilePackagesRef<'a>(pub Vec<&'a turborepo_lockfiles::Package>);
 
 #[derive(Debug, Clone)]
-pub struct FileHashes(pub Vec<(turbopath::RelativeUnixPathBuf, String)>);
+pub struct FileHashes(pub Vec<(turbopath::RelativeUnixPathBuf, OidHash)>);
 
 /// Wrapper type for TaskOutputs to enable capnp serialization.
 /// This is needed due to Rust's orphan rule - we can't implement From
@@ -244,7 +246,7 @@ impl From<FileHashes> for Builder<HeapAllocator> {
             for (i, (key, value)) in file_hashes.iter().enumerate() {
                 let mut entry = entries.reborrow().get(i as u32);
                 entry.set_key(key.as_str());
-                entry.set_value(value);
+                entry.set_value(&**value);
             }
         }
 
@@ -286,7 +288,7 @@ impl From<&FileHashes> for Builder<HeapAllocator> {
             for (i, (key, value)) in file_hashes.iter().enumerate() {
                 let mut entry = entries.reborrow().get(i as u32);
                 entry.set_key(key.as_str());
-                entry.set_value(value);
+                entry.set_value(&**value);
             }
         }
 
@@ -504,7 +506,8 @@ mod test {
     use turborepo_types::{EnvMode, TaskOutputs};
 
     use super::{
-        FileHashes, GlobalHashable, LockFilePackages, LockFilePackagesRef, TaskHashable, TurboHash,
+        FileHashes, GlobalHashable, LockFilePackages, LockFilePackagesRef, OidHash, TaskHashable,
+        TurboHash,
     };
 
     #[test]
@@ -623,39 +626,46 @@ mod test {
         lock_file_packages(packages.collect(), "4fd770c37194168e");
     }
 
-    fn sorted_file_hashes(pairs: Vec<(String, String)>) -> FileHashes {
-        let mut v: Vec<_> = pairs
+    fn sorted_file_hashes(pairs: Vec<(&str, &str)>) -> FileHashes {
+        let mut v: Vec<(turbopath::RelativeUnixPathBuf, OidHash)> = pairs
             .into_iter()
-            .map(|(a, b)| (turbopath::RelativeUnixPathBuf::new(a).unwrap(), b))
+            .map(|(a, b)| {
+                (
+                    turbopath::RelativeUnixPathBuf::new(a).unwrap(),
+                    OidHash::from_hex_str(b),
+                )
+            })
             .collect();
         v.sort_by(|(a, _), (b, _)| a.cmp(b));
         FileHashes(v)
     }
 
+    // OID-sized test hashes (40 hex chars each)
+    const OID_A: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    const OID_B: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+    const OID_C: &str = "cccccccccccccccccccccccccccccccccccccccc";
+    const OID_D: &str = "dddddddddddddddddddddddddddddddddddddddd";
+
     #[test_case(vec![], "459c029558afe716" ; "empty")]
     #[test_case(vec![
-        ("a".to_string(), "b".to_string()),
-        ("c".to_string(), "d".to_string()),
-    ], "c9301c0bf1899c07" ; "non-empty")]
+        ("a", OID_A),
+        ("c", OID_B),
+    ], "03e24e42bd35dcaf" ; "non-empty")]
     #[test_case(vec![
-        ("c".to_string(), "d".to_string()),
-        ("a".to_string(), "b".to_string()),
-    ], "c9301c0bf1899c07" ; "order resistant")]
-    fn file_hashes(pairs: Vec<(String, String)>, expected: &str) {
+        ("c", OID_B),
+        ("a", OID_A),
+    ], "03e24e42bd35dcaf" ; "order resistant")]
+    fn file_hashes(pairs: Vec<(&str, &str)>, expected: &str) {
         assert_eq!(sorted_file_hashes(pairs).hash(), expected);
     }
 
     #[test]
     fn file_hashes_ref_matches_owned() {
-        let file_hashes = sorted_file_hashes(vec![
-            ("c".to_string(), "d".to_string()),
-            ("a".to_string(), "b".to_string()),
-        ]);
+        let file_hashes = sorted_file_hashes(vec![("c", OID_B), ("a", OID_A)]);
 
         let ref_hash = (&file_hashes).hash();
         let owned_hash = file_hashes.hash();
         assert_eq!(ref_hash, owned_hash);
-        assert_eq!(ref_hash, "c9301c0bf1899c07");
     }
 
     #[test]
@@ -668,7 +678,7 @@ mod test {
                     (
                         turbopath::RelativeUnixPathBuf::new(format!("path/to/file_{i:03}"))
                             .unwrap(),
-                        format!("hash_{i}"),
+                        OidHash::from_hex_str(&format!("{i:040x}")),
                     )
                 })
                 .collect(),
@@ -717,58 +727,49 @@ mod test {
     }
 
     // Regression: FileHashes constructed from a pre-sorted Vec must produce
-    // identical hashes to FileHashes constructed from a HashMap. This captures
-    // the invariant that must hold when switching FileHashes from HashMap to
-    // sorted Vec.
-    // Regression: sorted Vec construction must produce identical hashes to what
-    // the old HashMap-based construction produced. Pinned hash values.
+    // identical hashes regardless of input order.
     #[test]
     fn file_hashes_sorted_vec_pinned_values() {
-        let pairs = [
-            ("c/z.ts", "hash_cz"),
-            ("a/b.ts", "hash_ab"),
-            ("a/a.ts", "hash_aa"),
-            ("b.ts", "hash_b"),
+        let pairs = vec![
+            ("c/z.ts", OID_C),
+            ("a/b.ts", OID_A),
+            ("a/a.ts", OID_B),
+            ("b.ts", OID_D),
         ];
 
-        let fh = sorted_file_hashes(
-            pairs
-                .iter()
-                .map(|(p, h)| (p.to_string(), h.to_string()))
-                .collect(),
-        );
+        let fh = sorted_file_hashes(pairs.clone());
         let hash = fh.hash();
 
         // Verify ref and owned produce same hash
-        let fh2 = sorted_file_hashes(
-            pairs
-                .iter()
-                .map(|(p, h)| (p.to_string(), h.to_string()))
-                .collect(),
-        );
+        let fh2 = sorted_file_hashes(pairs);
         assert_eq!((&fh2).hash(), hash);
     }
 
     // Regression: large FileHashes must produce deterministic hashes regardless
     // of original insertion order.
     #[test]
     fn file_hashes_large_deterministic() {
-        let fh_forward = sorted_file_hashes(
-            (0..1000)
-                .map(|i| (format!("pkg/file_{:04}", i), format!("{:040x}", i)))
-                .collect(),
-        );
+        let pairs_forward: Vec<_> = (0..1000)
+            .map(|i| {
+                // Leak to get &'static str for the test helper
+                let path: &str = Box::leak(format!("pkg/file_{i:04}").into_boxed_str());
+                let hash: &str = Box::leak(format!("{i:040x}").into_boxed_str());
+                (path, hash)
+            })
+            .collect();
 
-        let fh_reverse = sorted_file_hashes(
-            (0..1000)
-                .rev()
-                .map(|i| (format!("pkg/file_{:04}", i), format!("{:040x}", i)))
-                .collect(),
-        );
+        let pairs_reverse: Vec<_> = (0..1000)
+            .rev()
+            .map(|i| {
+                let path: &str = Box::leak(format!("pkg/file_{i:04}").into_boxed_str());
+                let hash: &str = Box::leak(format!("{i:040x}").into_boxed_str());
+                (path, hash)
+            })
+            .collect();
 
         assert_eq!(
-            fh_forward.hash(),
-            fh_reverse.hash(),
+            sorted_file_hashes(pairs_forward).hash(),
+            sorted_file_hashes(pairs_reverse).hash(),
             "insertion order must not affect hash output"
         );
     }

crates/turborepo-hash/src/lib.rs

@@ -0,0 +1,75 @@
+/// A fixed-size, stack-allocated git OID hex string (40 bytes, SHA-1).
+///
+/// Avoids heap allocation for the ~10K+ file hashes created during index
+/// building and per-package hash computation. Implements `Deref<Target=str>`
+/// so all existing `&str` consumers work unchanged.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OidHash([u8; 40]);
+
+impl OidHash {
+    /// Create from a pre-filled 40-byte hex buffer.
+    /// Caller must ensure `buf` contains valid lowercase ASCII hex.
+    pub fn from_hex_buf(buf: [u8; 40]) -> Self {
+        Self(buf)
+    }
+
+    /// Create from a hex-encoded string slice.
+    pub fn from_hex_str(s: &str) -> Self {
+        debug_assert_eq!(s.len(), 40, "OID hex must be exactly 40 chars");
+        let mut buf = [0u8; 40];
+        buf.copy_from_slice(s.as_bytes());
+        Self(buf)
+    }
+}
+
+impl std::ops::Deref for OidHash {
+    type Target = str;
+
+    fn deref(&self) -> &str {
+        // SAFETY: OidHash is always constructed from valid ASCII hex bytes.
+        unsafe { std::str::from_utf8_unchecked(&self.0) }
+    }
+}
+
+impl AsRef<str> for OidHash {
+    fn as_ref(&self) -> &str {
+        self
+    }
+}
+
+impl std::borrow::Borrow<str> for OidHash {
+    fn borrow(&self) -> &str {
+        self
+    }
+}
+
+impl std::fmt::Debug for OidHash {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self)
+    }
+}
+
+impl std::fmt::Display for OidHash {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self)
+    }
+}
+
+impl PartialEq<str> for OidHash {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other.as_bytes()
+    }
+}
+
+impl PartialEq<&str> for OidHash {
+    fn eq(&self, other: &&str) -> bool {
+        self.0 == other.as_bytes()
+    }
+}
+
+impl From<OidHash> for String {
+    fn from(oid: OidHash) -> Self {
+        // SAFETY: OidHash is always valid ASCII hex.
+        unsafe { String::from_utf8_unchecked(oid.0.to_vec()) }
+    }
+}

crates/turborepo-hash/src/oid_hash.rs

@@ -617,6 +617,9 @@ impl Run {
         rayon::scope(|s| {
             s.spawn(|_| {
                 let _span = tracing::info_span!("calculate_file_hashes_task").entered();
+                let needs_expanded = self.opts.run_opts.dry_run.is_some()
+                    || self.opts.run_opts.summarize
+                    || self.observability_handle.is_some();
                 file_hash_result = Some(PackageInputsHashes::calculate_file_hashes(
                     &self.scm,
                     self.engine.tasks(),
@@ -625,6 +628,7 @@ impl Run {
                     &self.repo_root,
                     &self.run_telemetry,
                     repo_index,
+                    needs_expanded,
                 ));
             });
             s.spawn(|_| {

crates/turborepo-lib/src/run/mod.rs

@@ -579,10 +579,7 @@ impl ConfigCache {
                 Err(_) => return Err(CacheError::ConfigCacheError),
             };
 
-        let mut file_hashes: Vec<_> = hash_object
-            .into_iter()
-            .map(|(k, v)| (k, String::from(v)))
-            .collect();
+        let mut file_hashes: Vec<_> = hash_object.into_iter().collect();
         file_hashes.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
         Ok(FileHashes(file_hashes).hash())
     }

crates/turborepo-run-cache/src/lib.rs

@@ -26,6 +26,7 @@ thiserror = { workspace = true }
 tracing = { workspace = true }
 turbopath = { workspace = true }
 turborepo-ci = { workspace = true }
+turborepo-hash = { path = "../turborepo-hash" }
 turborepo-telemetry = { path = "../turborepo-telemetry" }
 wax = { workspace = true }
 which = { workspace = true }