From c46a57bfda3a1ec59220d408cdbb86327fd868e5 Mon Sep 17 00:00:00 2001 From: hardfist Date: Thu, 15 Jan 2026 14:11:23 +0800 Subject: [PATCH 1/2] refactor: move logger into pass and reorg some passes --- .../src/compilation/build_module_graph/mod.rs | 35 ++++- .../src/compilation/finish_make/mod.rs | 19 +++ .../compilation/finish_module_graph/mod.rs | 45 ++++++ .../{finish_module => finish_modules}/mod.rs | 34 +++-- .../rspack_core/src/compilation/make/mod.rs | 21 +++ crates/rspack_core/src/compilation/mod.rs | 28 +--- .../compilation/optimize_chunk_modules/mod.rs | 11 +- .../src/compilation/optimize_chunks/mod.rs | 6 + .../src/compilation/optimize_modules/mod.rs | 11 +- .../src/compilation/optimize_tree/mod.rs | 11 +- .../src/compilation/rspack_passes.md | 49 ++++--- .../rspack_core/src/compilation/run_passes.rs | 75 ++-------- .../rspack_core/src/compilation/seal/mod.rs | 23 ++++ .../rspack-test/statsAPICases/verbose-time.js | 128 +++++++++--------- .../logging/__snapshots__/stats.txt | 8 +- .../preset-verbose/__snapshots__/stats.txt | 8 +- 16 files changed, 315 insertions(+), 197 deletions(-) create mode 100644 crates/rspack_core/src/compilation/finish_make/mod.rs create mode 100644 crates/rspack_core/src/compilation/finish_module_graph/mod.rs rename crates/rspack_core/src/compilation/{finish_module => finish_modules}/mod.rs (87%) create mode 100644 crates/rspack_core/src/compilation/make/mod.rs create mode 100644 crates/rspack_core/src/compilation/seal/mod.rs diff --git a/crates/rspack_core/src/compilation/build_module_graph/mod.rs b/crates/rspack_core/src/compilation/build_module_graph/mod.rs index a7eb0bdcfac5..9afcfecd0800 100644 --- a/crates/rspack_core/src/compilation/build_module_graph/mod.rs +++ b/crates/rspack_core/src/compilation/build_module_graph/mod.rs @@ -3,7 +3,11 @@ mod graph_updater; mod lazy_barrel_artifact; mod module_executor; +use std::sync::atomic::Ordering; + use rspack_error::Result; +use rspack_util::tracing_preset::TRACING_BENCH_TARGET; +use tracing::instrument; pub use self::{ artifact::{BuildModuleGraphArtifact, BuildModuleGraphArtifactState}, @@ -13,7 +17,36 @@ pub use self::{ }, module_executor::{ExecuteModuleId, ExecutedRuntimeModule, ModuleExecutor}, }; -use crate::Compilation; +use crate::{Compilation, logger::Logger}; + +pub async fn build_module_graph_pass(compilation: &mut Compilation) -> Result<()> { + let logger = compilation.get_logger("rspack.Compiler"); + let start = logger.time("build module graph"); + compilation.do_build_module_graph().await?; + logger.time_end(start); + Ok(()) +} + +impl Compilation { + #[instrument("Compilation:build_module_graph",target=TRACING_BENCH_TARGET, skip_all)] + async fn do_build_module_graph(&mut self) -> Result<()> { + // run module_executor + if let Some(module_executor) = &mut self.module_executor { + let mut module_executor = std::mem::take(module_executor); + module_executor.hook_before_make(self).await?; + self.module_executor = Some(module_executor); + } + + let artifact = self.build_module_graph_artifact.take(); + self + .build_module_graph_artifact + .replace(build_module_graph(self, artifact).await?); + + self.in_finish_make.store(true, Ordering::Release); + + Ok(()) + } +} /// make module graph, support incremental rebuild /// diff --git a/crates/rspack_core/src/compilation/finish_make/mod.rs b/crates/rspack_core/src/compilation/finish_make/mod.rs new file mode 100644 index 000000000000..114414853a6a --- /dev/null +++ b/crates/rspack_core/src/compilation/finish_make/mod.rs @@ -0,0 +1,19 @@ +use rspack_error::Result; + +use crate::{Compilation, SharedPluginDriver, logger::Logger}; + +pub async fn finish_make_pass( + compilation: &mut Compilation, + plugin_driver: SharedPluginDriver, +) -> Result<()> { + let logger = compilation.get_logger("rspack.Compiler"); + let start = logger.time("finish make hook"); + plugin_driver + .compiler_hooks + .finish_make + .call(compilation) + .await?; + logger.time_end(start); + + Ok(()) +} diff --git a/crates/rspack_core/src/compilation/finish_module_graph/mod.rs b/crates/rspack_core/src/compilation/finish_module_graph/mod.rs new file mode 100644 index 000000000000..31b41da2dfa5 --- /dev/null +++ b/crates/rspack_core/src/compilation/finish_module_graph/mod.rs @@ -0,0 +1,45 @@ +use std::sync::atomic::Ordering; + +use rspack_error::Result; +use rspack_util::tracing_preset::TRACING_BENCH_TARGET; +use tracing::instrument; + +use crate::{ + Compilation, cache::Cache, compilation::build_module_graph::finish_build_module_graph, + logger::Logger, +}; + +pub async fn finish_module_graph_pass( + compilation: &mut Compilation, + cache: &mut dyn Cache, +) -> Result<()> { + let logger = compilation.get_logger("rspack.Compiler"); + let start = logger.time("finish compilation"); + compilation.finish_build_module_graph().await?; + cache + .after_build_module_graph(&compilation.build_module_graph_artifact) + .await; + logger.time_end(start); + + Ok(()) +} + +impl Compilation { + #[instrument("Compilation:finish",target=TRACING_BENCH_TARGET, skip_all)] + pub async fn finish_build_module_graph(&mut self) -> Result<()> { + self.in_finish_make.store(false, Ordering::Release); + // clean up the entry deps + let make_artifact = self.build_module_graph_artifact.take(); + self + .build_module_graph_artifact + .replace(finish_build_module_graph(self, make_artifact).await?); + // sync assets to module graph from module_executor + if let Some(module_executor) = &mut self.module_executor { + let mut module_executor = std::mem::take(module_executor); + module_executor.hook_after_finish_modules(self).await?; + self.module_executor = Some(module_executor); + } + // make finished, make artifact should be readonly thereafter. + Ok(()) + } +} diff --git a/crates/rspack_core/src/compilation/finish_module/mod.rs b/crates/rspack_core/src/compilation/finish_modules/mod.rs similarity index 87% rename from crates/rspack_core/src/compilation/finish_module/mod.rs rename to crates/rspack_core/src/compilation/finish_modules/mod.rs index 23549acbc18b..ce70e2d0d57f 100644 --- a/crates/rspack_core/src/compilation/finish_module/mod.rs +++ b/crates/rspack_core/src/compilation/finish_modules/mod.rs @@ -1,25 +1,23 @@ +use rspack_error::Result; + use super::*; use crate::logger::Logger; -impl Compilation { - #[instrument("Compilation:finish",target=TRACING_BENCH_TARGET, skip_all)] - pub async fn finish_build_module_graph(&mut self) -> Result<()> { - self.in_finish_make.store(false, Ordering::Release); - // clean up the entry deps - let make_artifact = self.build_module_graph_artifact.take(); - self - .build_module_graph_artifact - .replace(finish_build_module_graph(self, make_artifact).await?); - // sync assets to module graph from module_executor - if let Some(module_executor) = &mut self.module_executor { - let mut module_executor = std::mem::take(module_executor); - module_executor.hook_after_finish_modules(self).await?; - self.module_executor = Some(module_executor); - } - // make finished, make artifact should be readonly thereafter. - Ok(()) - } +pub async fn finish_modules_pass(compilation: &mut Compilation) -> Result<()> { + let dependencies_diagnostics_artifact = compilation.dependencies_diagnostics_artifact.clone(); + let async_modules_artifact = compilation.async_modules_artifact.clone(); + let diagnostics = compilation + .collect_build_module_graph_effects( + &mut dependencies_diagnostics_artifact.borrow_mut(), + &mut async_modules_artifact.borrow_mut(), + ) + .await?; + compilation.extend_diagnostics(diagnostics); + + Ok(()) +} +impl Compilation { #[tracing::instrument("Compilation:collect_build_module_graph_effects", skip_all)] pub async fn collect_build_module_graph_effects( &mut self, diff --git a/crates/rspack_core/src/compilation/make/mod.rs b/crates/rspack_core/src/compilation/make/mod.rs new file mode 100644 index 000000000000..a151ef1b2e6d --- /dev/null +++ b/crates/rspack_core/src/compilation/make/mod.rs @@ -0,0 +1,21 @@ +use rspack_error::Result; + +use crate::{Compilation, SharedPluginDriver, cache::Cache, logger::Logger}; + +pub async fn make_hook_pass( + compilation: &mut Compilation, + plugin_driver: SharedPluginDriver, + cache: &mut dyn Cache, +) -> Result<()> { + let logger = compilation.get_logger("rspack.Compiler"); + + cache + .before_build_module_graph(&mut compilation.build_module_graph_artifact) + .await; + + let start = logger.time("make hook"); + plugin_driver.compiler_hooks.make.call(compilation).await?; + logger.time_end(start); + + Ok(()) +} diff --git a/crates/rspack_core/src/compilation/mod.rs b/crates/rspack_core/src/compilation/mod.rs index b1e18cc9bbee..18be47aa53b3 100644 --- a/crates/rspack_core/src/compilation/mod.rs +++ b/crates/rspack_core/src/compilation/mod.rs @@ -8,7 +8,10 @@ mod create_chunk_assets; mod create_hash; mod create_module_assets; mod create_module_hashes; -mod finish_module; +mod finish_make; +mod finish_module_graph; +mod finish_modules; +mod make; mod module_ids; mod optimize_chunk_modules; mod optimize_chunks; @@ -19,6 +22,7 @@ mod optimize_tree; mod process_assets; mod run_passes; mod runtime_requirements; +mod seal; use std::{ collections::{VecDeque, hash_map}, fmt::{self, Debug}, @@ -74,8 +78,7 @@ use crate::{ SourceType, Stats, ValueCacheVersions, build_chunk_graph::artifact::BuildChunkGraphArtifact, compilation::build_module_graph::{ - BuildModuleGraphArtifact, ModuleExecutor, UpdateParam, build_module_graph, - finish_build_module_graph, update_module_graph, + BuildModuleGraphArtifact, ModuleExecutor, UpdateParam, update_module_graph, }, compiler::{CompilationRecords, CompilerId}, get_runtime_key, @@ -990,25 +993,6 @@ impl Compilation { ukey } - #[instrument("Compilation:build_module_graph",target=TRACING_BENCH_TARGET, skip_all)] - pub async fn build_module_graph(&mut self) -> Result<()> { - // run module_executor - if let Some(module_executor) = &mut self.module_executor { - let mut module_executor = std::mem::take(module_executor); - module_executor.hook_before_make(self).await?; - self.module_executor = Some(module_executor); - } - - let artifact = self.build_module_graph_artifact.take(); - self - .build_module_graph_artifact - .replace(build_module_graph(self, artifact).await?); - - self.in_finish_make.store(true, Ordering::Release); - - Ok(()) - } - pub async fn rebuild_module( &mut self, module_identifiers: IdentifierSet, diff --git a/crates/rspack_core/src/compilation/optimize_chunk_modules/mod.rs b/crates/rspack_core/src/compilation/optimize_chunk_modules/mod.rs index 15b157d10de0..222ad5ba2003 100644 --- a/crates/rspack_core/src/compilation/optimize_chunk_modules/mod.rs +++ b/crates/rspack_core/src/compilation/optimize_chunk_modules/mod.rs @@ -1,14 +1,21 @@ use super::*; +use crate::logger::Logger; pub async fn optimize_chunk_modules_pass( compilation: &mut Compilation, plugin_driver: SharedPluginDriver, ) -> Result<()> { - plugin_driver + let logger = compilation.get_logger("rspack.Compilation"); + let start = logger.time("optimize chunk modules"); + + let result = plugin_driver .compilation_hooks .optimize_chunk_modules .call(compilation) .await .map(|_| ()) - .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeChunkModules")) + .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeChunkModules")); + + logger.time_end(start); + result } diff --git a/crates/rspack_core/src/compilation/optimize_chunks/mod.rs b/crates/rspack_core/src/compilation/optimize_chunks/mod.rs index 6bc6a593c054..fda4f268b7be 100644 --- a/crates/rspack_core/src/compilation/optimize_chunks/mod.rs +++ b/crates/rspack_core/src/compilation/optimize_chunks/mod.rs @@ -1,9 +1,13 @@ use super::*; +use crate::logger::Logger; pub async fn optimize_chunks_pass( compilation: &mut Compilation, plugin_driver: SharedPluginDriver, ) -> Result<()> { + let logger = compilation.get_logger("rspack.Compilation"); + let start = logger.time("optimize chunks"); + while matches!( plugin_driver .compilation_hooks @@ -13,5 +17,7 @@ pub async fn optimize_chunks_pass( .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeChunks"))?, Some(true) ) {} + + logger.time_end(start); Ok(()) } diff --git a/crates/rspack_core/src/compilation/optimize_modules/mod.rs b/crates/rspack_core/src/compilation/optimize_modules/mod.rs index 72a6779165f3..af48e3cb3604 100644 --- a/crates/rspack_core/src/compilation/optimize_modules/mod.rs +++ b/crates/rspack_core/src/compilation/optimize_modules/mod.rs @@ -1,9 +1,13 @@ use super::*; +use crate::logger::Logger; pub async fn optimize_modules_pass( compilation: &mut Compilation, plugin_driver: SharedPluginDriver, ) -> Result<()> { + let logger = compilation.get_logger("rspack.Compilation"); + let start = logger.time("optimize modules"); + let mut diagnostics = vec![]; while matches!( plugin_driver @@ -16,10 +20,13 @@ pub async fn optimize_modules_pass( ) {} compilation.extend_diagnostics(diagnostics); - plugin_driver + let result = plugin_driver .compilation_hooks .after_optimize_modules .call(compilation) .await - .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.afterOptimizeModules")) + .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.afterOptimizeModules")); + + logger.time_end(start); + result } diff --git a/crates/rspack_core/src/compilation/optimize_tree/mod.rs b/crates/rspack_core/src/compilation/optimize_tree/mod.rs index ff62eba916a2..f1ba8821b710 100644 --- a/crates/rspack_core/src/compilation/optimize_tree/mod.rs +++ b/crates/rspack_core/src/compilation/optimize_tree/mod.rs @@ -1,13 +1,20 @@ use super::*; +use crate::logger::Logger; pub async fn optimize_tree_pass( compilation: &mut Compilation, plugin_driver: SharedPluginDriver, ) -> Result<()> { - plugin_driver + let logger = compilation.get_logger("rspack.Compilation"); + let start = logger.time("optimize tree"); + + let result = plugin_driver .compilation_hooks .optimize_tree .call(compilation) .await - .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeTree")) + .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeTree")); + + logger.time_end(start); + result } diff --git a/crates/rspack_core/src/compilation/rspack_passes.md b/crates/rspack_core/src/compilation/rspack_passes.md index b849dd6a8545..b8583f8bc1dd 100644 --- a/crates/rspack_core/src/compilation/rspack_passes.md +++ b/crates/rspack_core/src/compilation/rspack_passes.md @@ -12,14 +12,18 @@ The compilation process is organized into independent modules, each responsible compilation/ ├── mod.rs # Main Compilation struct which exposes the public API ├── run_passes.rs # Pass driver invoked from Compiler that runs make + seal passes -├── build_module_graph/ # Module graph construction -│ └── finish_module/ # Finalize module graph, async modules, dependency diagnostics +├── make/ # make_hook_pass: make hook + cache.before_build_module_graph +├── build_module_graph/ # build_module_graph_pass: module graph construction +├── finish_make/ # finish_make_pass: finish_make hook +├── finish_module_graph/ # finish_module_graph_pass: finalize module graph + cache +├── finish_modules/ # finish_modules_pass: finish_modules hook, diagnostics, checkpoint +├── seal/ # seal_pass: seal hook ├── optimize_dependencies/ # optimizeDependencies hook + side effects artifact ├── build_chunk_graph/ # Chunk graph construction (code splitting cache + pass wrapper) ├── optimize_modules/ # optimizeModules + afterOptimizeModules hooks ├── optimize_chunks/ # optimizeChunks hook ├── optimize_tree/ # optimizeTree hook -├── optimize_chunk_modules # optimizeChunkModules hook +├── optimize_chunk_modules/ # optimizeChunkModules hook ├── module_ids/ # Module ID assignment + diagnostics ├── chunk_ids/ # Chunk ID assignment + diagnostics ├── assign_runtime_ids/ # Runtime ID assignment for runtime chunks @@ -43,21 +47,24 @@ compilation/ `run_passes` orchestrates the full pipeline (make + seal) in this order: -1. Make: `make` hook → `build_module_graph` → `finish_make` hook → `finish_build_module_graph` -2. Collect make diagnostics (`collect_build_module_graph_effects`) -3. Incremental checkpoint (`module_graph`), freeze module static cache in production -4. Seal kickoff: `CompilationHooks::seal` -5. `optimize_dependencies_pass` -6. `build_chunk_graph_pass` → `optimize_modules_pass` → `optimize_chunks_pass` -7. `optimize_tree_pass` → `optimize_chunk_modules_pass` -8. `module_ids_pass` → `chunk_ids_pass` → `assign_runtime_ids` -9. `optimize_code_generation_pass` -10. `create_module_hashes_pass` -11. `code_generation_pass` -12. `runtime_requirements_pass` -13. `create_hash_pass` (also runs runtime module code generation) -14. `create_module_assets_pass` -15. `create_chunk_assets_pass` -16. `process_assets_pass` -17. `after_seal_pass` -18. Unfreeze module static cache in production +1. `make_hook_pass`: `make` hook + cache.before_build_module_graph +2. `build_module_graph_pass`: build module graph +3. `finish_make_pass`: `finish_make` hook +4. `finish_module_graph_pass`: `finish_build_module_graph` + cache.after_build_module_graph +5. `finish_modules_pass`: `finish_modules` hook, collect diagnostics, incremental checkpoint +6. Freeze module static cache in production +7. `seal_pass`: `seal` hook +8. `optimize_dependencies_pass` +9. `build_chunk_graph_pass` → `optimize_modules_pass` → `optimize_chunks_pass` +10. `optimize_tree_pass` → `optimize_chunk_modules_pass` +11. `module_ids_pass` → `chunk_ids_pass` → `assign_runtime_ids` +12. `optimize_code_generation_pass` +13. `create_module_hashes_pass` +14. `code_generation_pass` +15. `runtime_requirements_pass` +16. `create_hash_pass` (also runs runtime module code generation) +17. `create_module_assets_pass` +18. `create_chunk_assets_pass` +19. `process_assets_pass` +20. `after_seal_pass` +21. Unfreeze module static cache in production diff --git a/crates/rspack_core/src/compilation/run_passes.rs b/crates/rspack_core/src/compilation/run_passes.rs index d6be8a9c4fba..9b0c4cca45a8 100644 --- a/crates/rspack_core/src/compilation/run_passes.rs +++ b/crates/rspack_core/src/compilation/run_passes.rs @@ -1,18 +1,18 @@ use super::{ after_seal::after_seal_pass, assign_runtime_ids::assign_runtime_ids, - build_chunk_graph::pass::build_chunk_graph_pass, chunk_ids::chunk_ids_pass, - code_generation::code_generation_pass, create_chunk_assets::create_chunk_assets_pass, - create_hash::create_hash_pass, create_module_assets::create_module_assets_pass, - create_module_hashes::create_module_hashes_pass, module_ids::module_ids_pass, + build_chunk_graph::pass::build_chunk_graph_pass, build_module_graph::build_module_graph_pass, + chunk_ids::chunk_ids_pass, code_generation::code_generation_pass, + create_chunk_assets::create_chunk_assets_pass, create_hash::create_hash_pass, + create_module_assets::create_module_assets_pass, create_module_hashes::create_module_hashes_pass, + finish_make::finish_make_pass, finish_module_graph::finish_module_graph_pass, + finish_modules::finish_modules_pass, make::make_hook_pass, module_ids::module_ids_pass, optimize_chunk_modules::optimize_chunk_modules_pass, optimize_chunks::optimize_chunks_pass, optimize_code_generation::optimize_code_generation_pass, optimize_dependencies::optimize_dependencies_pass, optimize_modules::optimize_modules_pass, optimize_tree::optimize_tree_pass, process_assets::process_assets_pass, - runtime_requirements::runtime_requirements_pass, *, -}; -use crate::{ - Compilation, SharedPluginDriver, cache::Cache, incremental::IncrementalPasses, logger::Logger, + runtime_requirements::runtime_requirements_pass, seal::seal_pass, *, }; +use crate::{Compilation, SharedPluginDriver, cache::Cache}; impl Compilation { pub async fn run_passes( @@ -20,76 +20,31 @@ impl Compilation { plugin_driver: SharedPluginDriver, cache: &mut dyn Cache, ) -> Result<()> { - let logger = self.get_logger("rspack.Compiler"); - - let make_start = logger.time("make"); - let make_hook_start = logger.time("make hook"); - cache - .before_build_module_graph(&mut self.build_module_graph_artifact) - .await; - - plugin_driver.compiler_hooks.make.call(self).await?; - logger.time_end(make_hook_start); - self.build_module_graph().await?; - logger.time_end(make_start); - - let start = logger.time("finish make hook"); - plugin_driver.compiler_hooks.finish_make.call(self).await?; - logger.time_end(start); - - let start = logger.time("finish compilation"); - self.finish_build_module_graph().await?; - cache - .after_build_module_graph(&self.build_module_graph_artifact) - .await; - logger.time_end(start); - - let dependencies_diagnostics_artifact = self.dependencies_diagnostics_artifact.clone(); - let async_modules_artifact = self.async_modules_artifact.clone(); - let diagnostics = self - .collect_build_module_graph_effects( - &mut dependencies_diagnostics_artifact.borrow_mut(), - &mut async_modules_artifact.borrow_mut(), - ) - .await?; - self.extend_diagnostics(diagnostics); - + make_hook_pass(self, plugin_driver.clone(), cache).await?; + build_module_graph_pass(self).await?; + finish_make_pass(self, plugin_driver.clone()).await?; + finish_module_graph_pass(self, cache).await?; + finish_modules_pass(self).await?; + // This is the end of first pass of build module graph which will be recovered for next compilation // add a checkpoint here since we may modify module graph later in incremental compilation // and we can recover to this checkpoint in the future if self.incremental.passes_enabled(IncrementalPasses::MAKE) { self.build_module_graph_artifact.module_graph.checkpoint(); } - if !self.options.mode.is_development() { self.module_static_cache_artifact.freeze(); } - #[cfg(feature = "debug_tool")] - { - use rspack_util::debug_tool::wait_for_signal; - wait_for_signal("seal compilation"); - } - let logger = self.get_logger("rspack.Compilation"); - // https://github.com/webpack/webpack/blob/main/lib/Compilation.js#L2809 - plugin_driver - .compilation_hooks - .seal - .call(self) - .await - .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.seal"))?; + seal_pass(self, plugin_driver.clone()).await?; optimize_dependencies_pass(self, plugin_driver.clone()).await?; - let create_chunks_start = logger.time("create chunks"); build_chunk_graph_pass(self).await?; optimize_modules_pass(self, plugin_driver.clone()).await?; optimize_chunks_pass(self, plugin_driver.clone()).await?; - logger.time_end(create_chunks_start); - let optimize_start = logger.time("optimize"); optimize_tree_pass(self, plugin_driver.clone()).await?; optimize_chunk_modules_pass(self, plugin_driver.clone()).await?; - logger.time_end(optimize_start); module_ids_pass(self, plugin_driver.clone()).await?; chunk_ids_pass(self, plugin_driver.clone()).await?; diff --git a/crates/rspack_core/src/compilation/seal/mod.rs b/crates/rspack_core/src/compilation/seal/mod.rs new file mode 100644 index 000000000000..94d12e17cd6b --- /dev/null +++ b/crates/rspack_core/src/compilation/seal/mod.rs @@ -0,0 +1,23 @@ +use rspack_error::Result; + +use crate::{Compilation, SharedPluginDriver}; + +pub async fn seal_pass( + compilation: &mut Compilation, + plugin_driver: SharedPluginDriver, +) -> Result<()> { + #[cfg(feature = "debug_tool")] + { + use rspack_util::debug_tool::wait_for_signal; + wait_for_signal("seal compilation"); + } + // https://github.com/webpack/webpack/blob/main/lib/Compilation.js#L2809 + plugin_driver + .compilation_hooks + .seal + .call(compilation) + .await + .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.seal"))?; + + Ok(()) +} diff --git a/tests/rspack-test/statsAPICases/verbose-time.js b/tests/rspack-test/statsAPICases/verbose-time.js index 50e7aabb4177..e86b4920a5f6 100644 --- a/tests/rspack-test/statsAPICases/verbose-time.js +++ b/tests/rspack-test/statsAPICases/verbose-time.js @@ -13,76 +13,78 @@ module.exports = { ?.toString({ all: false, logging: "verbose" }) .replace(/\d+ ms/g, "X ms") ).toMatchInlineSnapshot(` - LOG from rspack.Compilation - finish modules: X ms - optimize dependencies: X ms - rebuild chunk graph: X ms - create chunks: X ms - optimize: X ms - module ids: X ms - chunk ids: X ms - optimize code generation: X ms - code generation: X ms - runtime requirements.modules: X ms - runtime requirements.chunks: X ms - runtime requirements.entries: X ms - runtime requirements: X ms - hashing: hash chunks: X ms - hashing: hash runtime chunks: X ms - hashing: process full hash chunks: X ms - hashing: X ms - create module assets: X ms - create chunk assets: X ms - process assets: X ms - after process assets: X ms - after seal: X ms + LOG from rspack.Compilation + finish modules: X ms + optimize dependencies: X ms + rebuild chunk graph: X ms + optimize modules: X ms + optimize chunks: X ms + optimize tree: X ms + optimize chunk modules: X ms + module ids: X ms + chunk ids: X ms + optimize code generation: X ms + code generation: X ms + runtime requirements.modules: X ms + runtime requirements.chunks: X ms + runtime requirements.entries: X ms + runtime requirements: X ms + hashing: hash chunks: X ms + hashing: hash runtime chunks: X ms + hashing: process full hash chunks: X ms + hashing: X ms + create module assets: X ms + create chunk assets: X ms + process assets: X ms + after process assets: X ms + after seal: X ms - LOG from rspack.Compiler - make hook: X ms - make: X ms - finish make hook: X ms - finish compilation: X ms - seal compilation: X ms - emitAssets: X ms + LOG from rspack.Compiler + make hook: X ms + build module graph: X ms + finish make hook: X ms + finish compilation: X ms + seal compilation: X ms + emitAssets: X ms - LOG from rspack.EnsureChunkConditionsPlugin - ensure chunk conditions: X ms + LOG from rspack.EnsureChunkConditionsPlugin + ensure chunk conditions: X ms - LOG from rspack.ModuleConcatenationPlugin - select relevant modules: X ms - 0 potential root modules, 0 potential inner modules - sort relevant modules: X ms - find modules to concatenate: X ms - 0 candidates were considered for adding (0 cached failure, 0 already in config, 0 invalid module, 0 incorrect chunks, 0 incorrect dependency, 0 incorrect chunks of importer, 0 incorrect module dependency, 0 incorrect runtime condition, 0 importer failed, 0 added) - sort concat configurations: X ms + LOG from rspack.ModuleConcatenationPlugin + select relevant modules: X ms + 0 potential root modules, 0 potential inner modules + sort relevant modules: X ms + find modules to concatenate: X ms + 0 candidates were considered for adding (0 cached failure, 0 already in config, 0 invalid module, 0 incorrect chunks, 0 incorrect dependency, 0 incorrect chunks of importer, 0 incorrect module dependency, 0 incorrect runtime condition, 0 importer failed, 0 added) + sort concat configurations: X ms - LOG from rspack.RealContentHashPlugin - hash to asset names: X ms + LOG from rspack.RealContentHashPlugin + hash to asset names: X ms - LOG from rspack.RemoveEmptyChunksPlugin - remove empty chunks: X ms + LOG from rspack.RemoveEmptyChunksPlugin + remove empty chunks: X ms - LOG from rspack.SideEffectsFlagPlugin - prepare connections: X ms - find optimizable connections: X ms - do optimize connections: X ms - update connections: X ms - optimized 0 connections + LOG from rspack.SideEffectsFlagPlugin + prepare connections: X ms + find optimizable connections: X ms + do optimize connections: X ms + update connections: X ms + optimized 0 connections - LOG from rspack.SplitChunksPlugin - prepare module data: X ms - prepare cache groups: X ms - process cache groups: X ms - ensure max size fit: X ms + LOG from rspack.SplitChunksPlugin + prepare module data: X ms + prepare cache groups: X ms + process cache groups: X ms + ensure max size fit: X ms - LOG from rspack.buildChunkGraph - prepare entrypoints: X ms - process queue: X ms - extend chunkGroup runtime: X ms - 8 queue items processed (4 blocks) - 0 chunk groups connected - 0 chunk groups processed for merging (0 module sets) - 0 chunk group info updated (0 already connected chunk groups reconnected) - `); + LOG from rspack.buildChunkGraph + prepare entrypoints: X ms + process queue: X ms + extend chunkGroup runtime: X ms + 8 queue items processed (4 blocks) + 0 chunk groups connected + 0 chunk groups processed for merging (0 module sets) + 0 chunk group info updated (0 already connected chunk groups reconnected) + `); } }; diff --git a/tests/rspack-test/statsOutputCases/logging/__snapshots__/stats.txt b/tests/rspack-test/statsOutputCases/logging/__snapshots__/stats.txt index dc544d347102..6ed8f2d18b6c 100644 --- a/tests/rspack-test/statsOutputCases/logging/__snapshots__/stats.txt +++ b/tests/rspack-test/statsOutputCases/logging/__snapshots__/stats.txt @@ -76,8 +76,10 @@ LOG from rspack.Compilation finish modules: xx ms optimize dependencies: xx ms rebuild chunk graph: xx ms - create chunks: xx ms - optimize: xx ms + optimize modules: xx ms + optimize chunks: xx ms + optimize tree: xx ms + optimize chunk modules: xx ms module ids: xx ms chunk ids: xx ms optimize code generation: xx ms @@ -98,7 +100,7 @@ LOG from rspack.Compilation LOG from rspack.Compiler make hook: xx ms - make: xx ms + build module graph: xx ms finish make hook: xx ms finish compilation: xx ms seal compilation: xx ms diff --git a/tests/rspack-test/statsOutputCases/preset-verbose/__snapshots__/stats.txt b/tests/rspack-test/statsOutputCases/preset-verbose/__snapshots__/stats.txt index 76c1fcef61a2..7bc82c753174 100644 --- a/tests/rspack-test/statsOutputCases/preset-verbose/__snapshots__/stats.txt +++ b/tests/rspack-test/statsOutputCases/preset-verbose/__snapshots__/stats.txt @@ -48,8 +48,10 @@ LOG from rspack.Compilation finish modules: xx ms optimize dependencies: xx ms rebuild chunk graph: xx ms - create chunks: xx ms - optimize: xx ms + optimize modules: xx ms + optimize chunks: xx ms + optimize tree: xx ms + optimize chunk modules: xx ms module ids: xx ms chunk ids: xx ms optimize code generation: xx ms @@ -70,7 +72,7 @@ LOG from rspack.Compilation LOG from rspack.Compiler make hook: xx ms - make: xx ms + build module graph: xx ms finish make hook: xx ms finish compilation: xx ms seal compilation: xx ms From 86ab65fdde6070cb710292c331db7f9ef89fc755 Mon Sep 17 00:00:00 2001 From: hardfist Date: Thu, 15 Jan 2026 14:26:54 +0800 Subject: [PATCH 2/2] chore: fix bench check --- xtask/benchmark/benches/groups/build_chunk_graph.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/xtask/benchmark/benches/groups/build_chunk_graph.rs b/xtask/benchmark/benches/groups/build_chunk_graph.rs index f41612a55531..6fa00b983ff1 100644 --- a/xtask/benchmark/benches/groups/build_chunk_graph.rs +++ b/xtask/benchmark/benches/groups/build_chunk_graph.rs @@ -5,7 +5,9 @@ use criterion::criterion_group; use rspack::builder::Builder as _; use rspack_benchmark::Criterion; use rspack_core::{ - Compilation, Compiler, Experiments, Optimization, build_chunk_graph, fast_set, + Compilation, Compiler, Experiments, Optimization, build_chunk_graph, + build_module_graph::build_module_graph_pass, + fast_set, incremental::{Incremental, IncrementalOptions}, }; use rspack_error::Diagnostic; @@ -175,7 +177,9 @@ pub fn build_chunk_graph_benchmark_inner(c: &mut Criterion) { .call(&mut compiler.compilation) .await .unwrap(); - compiler.compilation.build_module_graph().await.unwrap(); + build_module_graph_pass(&mut compiler.compilation) + .await + .unwrap(); let mut side_effects_optimize_artifact = compiler.compilation.side_effects_optimize_artifact.take();