perf: Parallelize package.json loading and reduce builder allocations

- Parallelize package.json file I/O and JSON parsing with rayon. Each
  file is read and parsed independently, so this is embarrassingly
  parallel. The sequential add_json processing loop is unchanged.
- Use HashMap entry API in add_json to avoid cloning PackageName on
  every insert. The old code cloned unconditionally for the insert key,
  then cloned again on the error path for the get. Now we only clone
  once in the success path for add_node.
- Pre-allocate workspaces and node_lookup HashMaps with the known
  package count before the add_json loop.

Author: anthonyshew

Cargo.lock

@@ -23,6 +23,7 @@ lazy-regex = "2.5.0"
 miette = { workspace = true }
 node-semver = "2.2.0"
 petgraph = { workspace = true }
+rayon = "1"
 regex = { workspace = true }
 rust-ini = "0.20.0"
 serde = { workspace = true, features = ["derive"] }

crates/turborepo-repository/Cargo.toml

@@ -266,21 +266,23 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedPackageManager, T> {
             package_json_path: relative_json_path,
             ..Default::default()
         };
-        if let Some(existing) = self.workspaces.insert(name.clone(), entry) {
-            let path = self
-                .workspaces
-                .get(&name)
-                .expect("just inserted entry to be present")
-                .package_json_path
-                .clone();
-            return Err(Error::DuplicateWorkspace {
-                name: name.to_string(),
-                path: path.to_string(),
-                existing_path: existing.package_json_path.to_string(),
-            });
+        match self.workspaces.entry(name) {
+            std::collections::hash_map::Entry::Vacant(vacant) => {
+                let name = vacant.key().clone();
+                vacant.insert(entry);
+                self.add_node(PackageNode::Workspace(name));
+                Ok(())
+            }
+            std::collections::hash_map::Entry::Occupied(occupied) => {
+                let existing_path = occupied.get().package_json_path.to_string();
+                let name = occupied.key().to_string();
+                Err(Error::DuplicateWorkspace {
+                    name,
+                    path: entry.package_json_path.to_string(),
+                    existing_path,
+                })
+            }
         }
-        self.add_node(PackageNode::Workspace(name));
-        Ok(())
     }
 
     // need our own type
@@ -293,15 +295,31 @@ impl<'a, T: PackageDiscovery> BuildState<'a, ResolvedPackageManager, T> {
         let package_jsons = match self.package_jsons.take() {
             Some(jsons) => Ok(jsons),
             None => {
-                let mut jsons = HashMap::new();
-                for path in self.package_discovery.discover_packages().await?.workspaces {
-                    let json = PackageJson::load(&path.package_json)?;
-                    jsons.insert(path.package_json, json);
+                let workspace_paths: Vec<_> =
+                    self.package_discovery.discover_packages().await?.workspaces;
+
+                let results: Vec<_> = {
+                    use rayon::prelude::*;
+                    workspace_paths
+                        .into_par_iter()
+                        .map(|path| {
+                            let json = PackageJson::load(&path.package_json)?;
+                            Ok((path.package_json, json))
+                        })
+                        .collect::<Result<Vec<_>, Error>>()?
+                };
+
+                let mut jsons = HashMap::with_capacity(results.len());
+                for (path, json) in results {
+                    jsons.insert(path, json);
                 }
                 Ok::<_, Error>(jsons)
             }
         }?;
 
+        self.workspaces.reserve(package_jsons.len());
+        self.node_lookup.reserve(package_jsons.len());
+
         for (path, json) in package_jsons {
             match self.add_json(path, json) {
                 Ok(()) => {}