remove lock on outgoings module

Author: LingyuCoder

crates/rspack_core/src/build_chunk_graph/code_splitter.rs

@@ -7,6 +7,7 @@ use std::{
 use indexmap::{IndexMap as RawIndexMap, IndexSet as RawIndexSet};
 use itertools::Itertools;
 use num_bigint::BigUint;
+use rayon::prelude::*;
 use rspack_collections::{
   impl_item_ukey, Database, DatabaseItem, IdentifierHasher, IdentifierIndexSet, IdentifierMap,
   Ukey, UkeyIndexMap, UkeyIndexSet, UkeyMap, UkeySet,
@@ -674,15 +675,27 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
     let mut input_entrypoints_and_modules: UkeyIndexMap<ChunkGroupUkey, Vec<ModuleIdentifier>> =
       UkeyIndexMap::default();
     let mut assign_depths_map = IdentifierMap::default();
+    let outgoings = {
+      let mg = compilation.get_module_graph();
+      let all_modules = mg.modules();
+      all_modules
+        .keys()
+        .par_bridge()
+        .map(|mid| {
+          (
+            *mid,
+            mg.get_outgoing_connections(mid)
+              .cloned()
+              .collect::<Vec<_>>(),
+          )
+        })
+        .collect::<IdentifierMap<_>>()
+    };
 
     let entries = compilation.entries.keys().cloned().collect::<Vec<_>>();
     for name in &entries {
       let (entry_point, modules) = self.prepare_entry_input(name, compilation)?;
-      assign_depths(
-        &mut assign_depths_map,
-        &compilation.get_module_graph(),
-        modules.iter(),
-      );
+      assign_depths(&mut assign_depths_map, &modules, &outgoings);
       input_entrypoints_and_modules.insert(entry_point, modules);
     }
 

crates/rspack_core/src/build_chunk_graph/new_code_splitter.rs

@@ -754,12 +754,9 @@ impl CodeSplitter {
     &self,
     module: &ModuleIdentifier,
     runtime: &RuntimeSpec,
-  ) -> (Vec<ModuleIdentifier>, Vec<AsyncDependenciesBlockIdentifier>) {
+  ) -> Option<(Vec<ModuleIdentifier>, Vec<AsyncDependenciesBlockIdentifier>)> {
     let module_map = self.module_deps.get(runtime).expect("should have value");
-    module_map
-      .get(module)
-      .expect("should have outgoing modules")
-      .clone()
+    module_map.get(module).cloned()
   }
 
   pub fn outgoings_modules(
@@ -864,7 +861,13 @@ impl CodeSplitter {
               value
             });
 
-          let (mut outgoing_modules, blocks) = self.get_outgoings_modules(&target_module, runtime);
+          let Some((mut outgoing_modules, blocks)) =
+            self.get_outgoings_modules(&target_module, runtime)
+          else {
+            // not exists when error occurs
+            // just skip it and the errors will be reported in stats
+            continue;
+          };
 
           if ctx.chunk_loading {
             ctx.out_goings.extend(blocks);
@@ -987,7 +990,11 @@ impl CodeSplitter {
             if !self.module_deps.contains_key(runtime) {
               self.module_deps.insert(runtime.clone(), Default::default());
             }
-            let (modules, blocks) = self.get_outgoings_modules(&m, runtime);
+            let Some((modules, blocks)) = self.get_outgoings_modules(&m, runtime) else {
+              // not exists when error occurs
+              // just skip it and the errors will be reported in stats
+              continue;
+            };
 
             for m in modules.iter().rev() {
               queue.push(Task::Enter((*m, runtime)));
@@ -1154,6 +1161,22 @@ impl CodeSplitter {
     let mut async_entrypoints = HashSet::default();
     let mut entrypoints = HashMap::default();
     let mut skipped = HashSet::<usize>::default();
+    let outgoings = {
+      let mg = compilation.get_module_graph();
+      let all_modules = mg.modules();
+      all_modules
+        .keys()
+        .par_bridge()
+        .map(|mid| {
+          (
+            *mid,
+            mg.get_outgoing_connections(mid)
+              .cloned()
+              .collect::<Vec<_>>(),
+          )
+        })
+        .collect::<IdentifierMap<_>>()
+    };
 
     for (idx, (reuse, cache)) in finalize_result.chunks.into_iter().enumerate() {
       let chunk_desc = cache.chunk_desc;
@@ -1335,11 +1358,7 @@ Or do you want to use the entrypoints '{name}' and '{entry_runtime}' independent
 
             if initial {
               let mut assign_depths_map = IdentifierMap::default();
-              assign_depths(
-                &mut assign_depths_map,
-                &compilation.get_module_graph(),
-                entry_modules.iter(),
-              );
+              assign_depths(&mut assign_depths_map, &entry_modules, &outgoings);
               let mut module_graph = compilation.get_module_graph_mut();
               for (m, depth) in assign_depths_map {
                 module_graph.set_depth_if_lower(&m, depth);

crates/rspack_core/src/compiler/compilation.rs

@@ -17,7 +17,8 @@ use rspack_cacheable::{
   with::{AsOption, AsPreset},
 };
 use rspack_collections::{
-  DatabaseItem, Identifiable, IdentifierDashMap, IdentifierMap, IdentifierSet, UkeyMap, UkeySet,
+  DatabaseItem, Identifiable, Identifier, IdentifierDashMap, IdentifierMap, IdentifierSet, UkeyMap,
+  UkeySet,
 };
 use rspack_error::{
   error, miette::diagnostic, Diagnostic, DiagnosticExt, InternalError, Result, RspackSeverity,
@@ -54,9 +55,9 @@ use crate::{
   CompilationLogging, CompilerOptions, DependenciesDiagnosticsArtifact, DependencyCodeGeneration,
   DependencyId, DependencyTemplate, DependencyTemplateType, DependencyType, Entry, EntryData,
   EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId, Filename, ImportVarMap, Logger,
-  ModuleFactory, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphPartial, ModuleIdentifier,
-  ModuleIdsArtifact, ModuleStaticCacheArtifact, PathData, ResolverFactory, RuntimeGlobals,
-  RuntimeMode, RuntimeModule, RuntimeSpecMap, RuntimeTemplate, SharedPluginDriver,
+  ModuleFactory, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphConnection, ModuleGraphPartial,
+  ModuleIdentifier, ModuleIdsArtifact, ModuleStaticCacheArtifact, PathData, ResolverFactory,
+  RuntimeGlobals, RuntimeMode, RuntimeModule, RuntimeSpecMap, RuntimeTemplate, SharedPluginDriver,
   SideEffectsOptimizeArtifact, SourceType, Stats,
 };
 
@@ -2961,8 +2962,8 @@ impl AssetInfoRelated {
 /// the same time.
 pub fn assign_depths(
   assign_map: &mut IdentifierMap<usize>,
-  mg: &ModuleGraph,
-  modules: impl Iterator<Item = &ModuleIdentifier>,
+  modules: &Vec<Identifier>,
+  outgoings: &IdentifierMap<Vec<ModuleGraphConnection>>,
 ) {
   // https://github.com/webpack/webpack/blob/1f99ad6367f2b8a6ef17cce0e058f7a67fb7db18/lib/Compilation.js#L3720
   let mut q = VecDeque::new();
@@ -2978,7 +2979,7 @@ pub fn assign_depths(
         vac.insert(depth);
       }
     };
-    for con in mg.get_outgoing_connections(&id) {
+    for con in outgoings.get(&id).expect("should have value") {
       q.push_back((*con.module_identifier(), depth + 1));
     }
   }