perf: improve bundle splitting

Author: LingyuCoder

crates/rspack_core/src/chunk_graph/chunk_graph_chunk.rs

@@ -353,6 +353,39 @@ impl ChunkGraph {
     }
   }
 
+  pub fn disconnect_chunks_and_modules(
+    &mut self,
+    chunks: &[ChunkUkey],
+    modules: &[ModuleIdentifier],
+  ) {
+    for chunk in chunks.iter() {
+      let cgc = self.expect_chunk_graph_chunk_mut(*chunk);
+      for module in modules.iter() {
+        cgc.modules.remove(module);
+        if let Some(source_types_by_module) = &mut cgc.source_types_by_module {
+          source_types_by_module.remove(module);
+        }
+      }
+    }
+    for module in modules.iter() {
+      let cgm = self.expect_chunk_graph_module_mut(*module);
+      for chunk in chunks.iter() {
+        cgm.chunks.remove(chunk);
+      }
+    }
+  }
+
+  pub fn connect_chunk_and_modules(&mut self, chunk: ChunkUkey, modules: &[ModuleIdentifier]) {
+    for module in modules.iter() {
+      let cgm = self.expect_chunk_graph_module_mut(*module);
+      cgm.chunks.insert(chunk);
+    }
+    let cgc = self.expect_chunk_graph_chunk_mut(chunk);
+    for module in modules.iter() {
+      cgc.modules.insert(*module);
+    }
+  }
+
   pub fn get_chunk_modules<'module>(
     &self,
     chunk: &ChunkUkey,

crates/rspack_plugin_split_chunks/src/plugin/chunk.rs

@@ -164,29 +164,31 @@ impl SplitChunksPlugin {
     original_chunks: &UkeySet<ChunkUkey>,
     compilation: &mut Compilation,
   ) {
-    for module_identifier in &item.modules {
-      if let Some(module) = compilation.module_by_identifier(module_identifier)
-        && module
-          .chunk_condition(&new_chunk, compilation)
-          .is_some_and(|condition| !condition)
-      {
-        continue;
-      }
+    let modules = item
+      .modules
+      .iter()
+      .filter(|mid| {
+        if let Some(module) = compilation.module_by_identifier(mid)
+          && module
+            .chunk_condition(&new_chunk, compilation)
+            .is_some_and(|condition| !condition)
+        {
+          return false;
+        }
+        true
+      })
+      .copied()
+      .collect::<Vec<_>>();
 
-      // First, we remove modules from old chunks
+    let chunks = original_chunks.iter().copied().collect::<Vec<_>>();
 
-      // Remove module from old chunks
-      for used_chunk in original_chunks {
-        compilation
-          .chunk_graph
-          .disconnect_chunk_and_module(used_chunk, *module_identifier);
-      }
+    compilation
+      .chunk_graph
+      .disconnect_chunks_and_modules(&chunks, &modules);
 
-      // Add module to new chunk
-      compilation
-        .chunk_graph
-        .connect_chunk_and_module(new_chunk, *module_identifier);
-    }
+    compilation
+      .chunk_graph
+      .connect_chunk_and_modules(new_chunk, &modules);
   }
 
   /// Since the modules are moved into the `new_chunk`, we should

crates/rspack_plugin_split_chunks/src/plugin/mod.rs

@@ -4,7 +4,7 @@ mod max_size;
 mod min_size;
 mod module_group;
 
-use std::{borrow::Cow, fmt::Debug};
+use std::{borrow::Cow, collections::BinaryHeap, fmt::Debug};
 
 use rspack_collections::UkeyMap;
 use rspack_core::{ChunkUkey, Compilation, CompilationOptimizeChunks, Logger, Plugin};

crates/rspack_plugin_split_chunks/src/plugin/module_group.rs

@@ -488,10 +488,22 @@ impl SplitChunksPlugin {
           .intersection(used_chunks)
           .next()?;
 
-        current_module_group.modules.iter().for_each(|module| {
-          tracing::trace!("remove module({module}) from {key}");
-          other_module_group.remove_module(*module, module_sizes);
-        });
+        let module_count = other_module_group.modules.len();
+
+        let duplicated_modules = if other_module_group.modules.len() > current_module_group.modules.len() {
+          current_module_group.modules.intersection(&other_module_group.modules).copied().collect::<Vec<_>>()
+        } else {
+          other_module_group.modules.intersection(&current_module_group.modules).copied().collect::<Vec<_>>()
+        };
+
+        for module in duplicated_modules {
+          other_module_group.remove_module(module, module_sizes);
+        }
+
+        if module_count == other_module_group.modules.len() {
+          // nothing is removed
+          return None;
+        }
 
         if other_module_group.modules.is_empty() {
           tracing::trace!(
@@ -543,66 +555,6 @@ impl SplitChunksPlugin {
       module_group_map.remove(&key);
     });
   }
-
-  // #[allow(clippy::type_complexity)]
-  // fn prepare_combination_maps(
-  //   module_graph: &ModuleGraph,
-  //   chunk_graph: &ChunkGraph,
-  //   used_exports: bool,
-  //   chunk_by_ukey: &ChunkByUkey,
-  // ) -> (
-  //   HashMap<ChunksKey, UkeySet<ChunkUkey>, ChunksKeyHashBuilder>,
-  //   FxHashMap<usize, Vec<UkeySet<ChunkUkey>>>,
-  //   Option<FxHashMap<ModuleIdentifier, Vec<UkeySet<ChunkUkey>>>>,
-  // ) {
-  //   let mut chunk_sets_in_graph =
-  //     HashMap::<ChunksKey, UkeySet<ChunkUkey>, ChunksKeyHashBuilder>::default();
-  //   let mut chunk_sets_by_count = FxHashMap::<usize, Vec<UkeySet<ChunkUkey>>>::default();
-
-  //   let mut grouped_by_exports_map: Option<FxHashMap<ModuleIdentifier, Vec<UkeySet<ChunkUkey>>>> =
-  //     None;
-
-  //   if used_exports {
-  //     let mut grouped_by_exports: FxHashMap<ModuleIdentifier, Vec<UkeySet<ChunkUkey>>> =
-  //       Default::default();
-  //     for module in module_graph.modules().keys() {
-  //       let grouped_chunks = Self::group_chunks_by_exports(
-  //         module,
-  //         chunk_graph.get_module_chunks(*module).iter().cloned(),
-  //         module_graph,
-  //         chunk_by_ukey,
-  //       );
-  //       for chunks in &grouped_chunks {
-  //         let chunk_key = get_key(chunks.iter());
-  //         chunk_sets_in_graph.insert(chunk_key, chunks.clone());
-  //       }
-
-  //       grouped_by_exports.insert(*module, grouped_chunks);
-  //     }
-
-  //     grouped_by_exports_map = Some(grouped_by_exports);
-  //   } else {
-  //     for module in module_graph.modules().keys() {
-  //       let chunks = chunk_graph.get_module_chunks(*module);
-  //       let chunk_key = get_key(chunks.iter());
-  //       chunk_sets_in_graph.insert(chunk_key, chunks.clone());
-  //     }
-  //   }
-
-  //   for chunks in chunk_sets_in_graph.values() {
-  //     let count = chunks.len();
-  //     chunk_sets_by_count
-  //       .entry(count)
-  //       .and_modify(|set| set.push(chunks.clone()))
-  //       .or_insert(vec![chunks.clone()]);
-  //   }
-
-  //   (
-  //     chunk_sets_in_graph,
-  //     chunk_sets_by_count,
-  //     grouped_by_exports_map,
-  //   )
-  // }
 }
 
 async fn merge_matched_item_into_module_group_map(