perf: parallel mangle exports (#10877)

* perf: parallelize mangle exports info

* perf: parallelize mangle exports info

Author: LingyuCoder

crates/rspack_core/src/exports/export_info.rs

@@ -21,8 +21,8 @@ pub enum ExportName {
 
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
 pub struct ExportInfo {
-  exports_info: ExportsInfo,
-  export_name: ExportName,
+  pub exports_info: ExportsInfo,
+  pub export_name: ExportName,
 }
 
 impl ExportInfo {

crates/rspack_core/src/module_graph/mod.rs

@@ -9,8 +9,8 @@ use swc_core::ecma::atoms::Atom;
 
 use crate::{
   AsyncDependenciesBlock, AsyncDependenciesBlockIdentifier, Compilation, DependenciesBlock,
-  Dependency, ExportProvided, ExportsInfoGetter, ModuleGraphCacheArtifact, PrefetchExportsInfoMode,
-  PrefetchedExportsInfoWrapper, RuntimeSpec,
+  Dependency, ExportInfo, ExportName, ExportProvided, ExportsInfoGetter, ModuleGraphCacheArtifact,
+  PrefetchExportsInfoMode, PrefetchedExportsInfoWrapper, RuntimeSpec,
 };
 mod module;
 pub use module::*;
@@ -1256,4 +1256,37 @@ impl<'a> ModuleGraph<'a> {
       active_partial.module_graph_modules.insert(mid, Some(mgm));
     }
   }
+
+  pub fn batch_set_export_info_used_name(&mut self, tasks: Vec<(ExportInfo, Atom)>) {
+    if self.active.is_none() {
+      panic!("should have active partial");
+    }
+
+    let active_partial = self.active.as_mut().expect("should have active partial");
+    for (export_info, used_name) in tasks {
+      let ExportInfo {
+        exports_info,
+        export_name,
+      } = export_info;
+
+      let data = active_partial
+        .exports_info_map
+        .get_mut(&exports_info)
+        .expect("should have exports info");
+      match export_name {
+        ExportName::Named(name) => {
+          data
+            .named_exports_mut(&name)
+            .expect("should have named export")
+            .set_used_name(used_name);
+        }
+        ExportName::Other => {
+          data.other_exports_info_mut().set_used_name(used_name);
+        }
+        ExportName::SideEffects => {
+          data.side_effects_only_info_mut().set_used_name(used_name);
+        }
+      }
+    }
+  }
 }

crates/rspack_plugin_javascript/src/plugin/mangle_exports_plugin.rs

@@ -54,7 +54,6 @@ enum Manglable {
 #[derive(Debug)]
 struct ExportInfoCache {
   id: ExportInfo,
-  deterministic: bool,
   exports_info: Option<ExportsInfo>,
   can_mangle: Manglable,
 }
@@ -75,19 +74,14 @@ async fn optimize_code_generation(&self, compilation: &mut Compilation) -> Resul
   // TODO: should bailout if compilation.moduleMemCache is enable, https://github.com/webpack/webpack/blob/1f99ad6367f2b8a6ef17cce0e058f7a67fb7db18/lib/optimize/MangleExportsPlugin.js#L160-L164
   // We don't do that cause we don't have this option
   let mut mg = compilation.get_module_graph_mut();
-  let module_id_list = mg.modules().keys().cloned().collect::<Vec<_>>();
+  let modules = mg.modules();
 
   let mut exports_info_cache = FxHashMap::default();
 
-  let mut q = module_id_list
+  let mut q = modules
     .iter()
-    .filter_map(|id| {
-      let (Some(mgm), Some(module)) = (
-        mg.module_graph_module_by_identifier(id),
-        mg.module_by_identifier(id),
-      ) else {
-        return None;
-      };
+    .filter_map(|(mid, module)| {
+      let mgm = mg.module_graph_module_by_identifier(mid)?;
       let is_namespace = matches!(
         module.build_meta().exports_type,
         BuildMetaExportsType::Namespace
@@ -163,7 +157,6 @@ async fn optimize_code_generation(&self, compilation: &mut Compilation) -> Resul
 
               ExportInfoCache {
                 id: export_info_data.id(),
-                deterministic,
                 exports_info: nested_exports_info,
                 can_mangle,
               }
@@ -184,21 +177,32 @@ async fn optimize_code_generation(&self, compilation: &mut Compilation) -> Resul
     }
   }
 
-  for identifier in module_id_list {
-    let (Some(mgm), Some(_)) = (
-      mg.module_graph_module_by_identifier(&identifier),
-      mg.module_by_identifier(&identifier),
-    ) else {
-      continue;
-    };
-    let exports_info = mgm.exports;
-    mangle_exports_info(
-      &mut mg,
-      self.deterministic,
-      exports_info,
-      &exports_info_cache,
-    );
+  let mut queue = modules
+    .into_iter()
+    .filter_map(|(mid, _)| {
+      let mgm = mg.module_graph_module_by_identifier(&mid)?;
+      Some(mgm.exports)
+    })
+    .collect_vec();
+
+  while !queue.is_empty() {
+    let tasks = std::mem::take(&mut queue);
+    let batch = tasks
+      .into_par_iter()
+      .map(|exports_info| {
+        mangle_exports_info(&mg, self.deterministic, exports_info, &exports_info_cache)
+      })
+      .collect::<Vec<_>>();
+
+    let mut used_name_tasks = vec![];
+    for (changes, nested_exports) in batch {
+      used_name_tasks.extend(changes);
+      queue.extend(nested_exports);
+    }
+
+    mg.batch_set_export_info_used_name(used_name_tasks);
   }
+
   Ok(())
 }
 
@@ -224,23 +228,25 @@ static MANGLE_NAME_DETERMINISTIC_REG: LazyLock<Regex> = LazyLock::new(|| {
 
 /// Function to mangle exports information.
 fn mangle_exports_info(
-  mg: &mut ModuleGraph,
+  mg: &ModuleGraph,
   deterministic: bool,
   exports_info: ExportsInfo,
   exports_info_cache: &FxHashMap<ExportsInfo, Vec<ExportInfoCache>>,
-) {
+) -> (Vec<(ExportInfo, Atom)>, Vec<ExportsInfo>) {
+  let mut changes = vec![];
+  let mut nested_exports = vec![];
   let mut used_names = FxHashSet::default();
   let mut mangleable_exports = Vec::new();
   let Some(export_list) = exports_info_cache.get(&exports_info) else {
-    return;
+    return (changes, nested_exports);
   };
 
   let mut mangleable_export_names = FxHashMap::default();
 
   for export_info in export_list {
     match &export_info.can_mangle {
       Manglable::CanNotMangle(name) => {
-        export_info.id.as_data_mut(mg).set_used_name(name.clone());
+        changes.push((export_info.id.clone(), name.clone()));
         used_names.insert(name.to_string());
       }
       Manglable::CanMangle(name) => {
@@ -251,12 +257,7 @@ fn mangle_exports_info(
     }
 
     if let Some(nested_exports_info) = export_info.exports_info {
-      mangle_exports_info(
-        mg,
-        export_info.deterministic,
-        nested_exports_info,
-        exports_info_cache,
-      );
+      nested_exports.push(nested_exports_info);
     }
   }
 
@@ -297,7 +298,7 @@ fn mangle_exports_info(
       0,
     );
     for (export_info, name) in export_info_used_name {
-      export_info.as_data_mut(mg).set_used_name(name.into());
+      changes.push((export_info, name.into()));
     }
   } else {
     let mut used_exports = Vec::new();
@@ -336,8 +337,9 @@ fn mangle_exports_info(
           }
           i += 1;
         }
-        export_info.as_data_mut(mg).set_used_name(name.into());
+        changes.push((export_info, name.into()));
       }
     }
   }
+  (changes, nested_exports)
 }