perf: mem cache for chunk render source (#8528)

crates/rspack_binding_values/src/compilation/mod.rs

@@ -533,9 +533,10 @@ impl JsCompilation {
   ) -> napi::Result<PathWithInfo> {
     let compilation = self.as_ref()?;
 
-    let path_and_asset_info =
-      compilation.get_path_with_info(&filename.into(), data.to_path_data())?;
-    Ok(path_and_asset_info.into())
+    let mut asset_info = AssetInfo::default();
+    let path =
+      compilation.get_path_with_info(&filename.into(), data.to_path_data(), &mut asset_info)?;
+    Ok((path, asset_info).into())
   }
 
   #[napi]

crates/rspack_core/src/chunk.rs

@@ -5,11 +5,13 @@ use std::{fmt::Debug, hash::Hash};
 use indexmap::IndexMap;
 use itertools::Itertools;
 use rspack_collections::{DatabaseItem, UkeyIndexMap, UkeyIndexSet, UkeyMap, UkeySet};
+use rspack_error::Diagnostic;
 use rspack_hash::{RspackHash, RspackHashDigest};
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet, FxHasher};
 
 use crate::{
   compare_chunk_group, merge_runtime, sort_group_by_index, ChunkGraph, ChunkGroupOrderKey,
+  RenderManifestEntry,
 };
 use crate::{ChunkGroupByUkey, ChunkGroupUkey, ChunkUkey, SourceType};
 use crate::{Compilation, EntryOptions, Filename, ModuleGraph, RuntimeSpec};
@@ -42,6 +44,12 @@ impl ChunkHashesResult {
   }
 }
 
+#[derive(Debug, Clone)]
+pub struct ChunkRenderResult {
+  pub manifests: Vec<RenderManifestEntry>,
+  pub diagnostics: Vec<Diagnostic>,
+}
+
 #[derive(Debug, Clone)]
 pub struct Chunk {
   ukey: ChunkUkey,

crates/rspack_core/src/compiler/compilation.rs

@@ -39,12 +39,12 @@ use crate::{
   old_cache::{use_code_splitting_cache, Cache as OldCache, CodeSplittingCache},
   to_identifier, BoxDependency, BoxModule, CacheCount, CacheOptions, Chunk, ChunkByUkey,
   ChunkContentHash, ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkHashesResult, ChunkKind,
-  ChunkUkey, CodeGenerationJob, CodeGenerationResult, CodeGenerationResults, CompilationLogger,
-  CompilationLogging, CompilerOptions, DependencyId, DependencyType, Entry, EntryData,
-  EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId, Filename, ImportVarMap, LocalFilenameFn,
-  Logger, ModuleFactory, ModuleGraph, ModuleGraphPartial, ModuleIdentifier, PathData,
-  ResolverFactory, RuntimeGlobals, RuntimeModule, RuntimeSpecMap, SharedPluginDriver, SourceType,
-  Stats,
+  ChunkRenderResult, ChunkUkey, CodeGenerationJob, CodeGenerationResult, CodeGenerationResults,
+  CompilationLogger, CompilationLogging, CompilerOptions, DependencyId, DependencyType, Entry,
+  EntryData, EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId, Filename, ImportVarMap,
+  LocalFilenameFn, Logger, ModuleFactory, ModuleGraph, ModuleGraphPartial, ModuleIdentifier,
+  PathData, ResolverFactory, RuntimeGlobals, RuntimeModule, RuntimeSpecMap, SharedPluginDriver,
+  SourceType, Stats,
 };
 
 pub type BuildDependency = (
@@ -175,7 +175,7 @@ pub struct Compilation {
   pub cgm_runtime_requirements_results: CgmRuntimeRequirementsResults,
   pub cgc_runtime_requirements_results: UkeyMap<ChunkUkey, RuntimeGlobals>,
   pub chunk_hashes_results: UkeyMap<ChunkUkey, ChunkHashesResult>,
-  pub chunk_render_results: UkeyMap<ChunkUkey, (Vec<RenderManifestEntry>, Vec<Diagnostic>)>,
+  pub chunk_render_results: UkeyMap<ChunkUkey, ChunkRenderResult>,
   pub built_modules: IdentifierSet,
   pub code_generated_modules: IdentifierSet,
   pub build_time_executed_modules: IdentifierSet,
@@ -972,15 +972,21 @@ impl Compilation {
     let chunk_render_results = chunks
       .iter()
       .map(|chunk| async {
-        let mut manifest = Vec::new();
+        let mut manifests = Vec::new();
         let mut diagnostics = Vec::new();
         plugin_driver
           .compilation_hooks
           .render_manifest
-          .call(self, chunk, &mut manifest, &mut diagnostics)
+          .call(self, chunk, &mut manifests, &mut diagnostics)
           .await?;
 
-        Ok((*chunk, (manifest, diagnostics)))
+        Ok((
+          *chunk,
+          ChunkRenderResult {
+            manifests,
+            diagnostics,
+          },
+        ))
       })
       .collect::<FuturesResults<Result<_>>>();
     let chunk_render_results = chunk_render_results
@@ -995,11 +1001,18 @@ impl Compilation {
       chunk_render_results
     };
 
-    for (chunk_ukey, (manifest, diagnostics)) in chunk_ukey_and_manifest {
+    for (
+      chunk_ukey,
+      ChunkRenderResult {
+        manifests,
+        diagnostics,
+      },
+    ) in chunk_ukey_and_manifest
+    {
       self.extend_diagnostics(diagnostics);
 
-      for file_manifest in manifest {
-        let filename = file_manifest.filename().to_string();
+      for file_manifest in manifests {
+        let filename = file_manifest.filename;
         let current_chunk = self.chunk_by_ukey.expect_get_mut(&chunk_ukey);
 
         current_chunk.set_rendered(true);
@@ -1996,13 +2009,13 @@ impl Compilation {
     &'a self,
     filename: &Filename<F>,
     mut data: PathData<'b>,
-  ) -> Result<(String, AssetInfo), F::Error> {
-    let mut info = AssetInfo::default();
+    info: &mut AssetInfo,
+  ) -> Result<String, F::Error> {
     if data.hash.is_none() {
       data.hash = self.get_hash();
     }
-    let path = filename.render(data, Some(&mut info))?;
-    Ok((path, info))
+    let path = filename.render(data, Some(info))?;
+    Ok(path)
   }
 
   pub fn get_asset_path<F: LocalFilenameFn>(
@@ -2324,42 +2337,10 @@ pub fn set_depth_if_lower(
 #[derive(Debug, Clone)]
 pub struct RenderManifestEntry {
   pub source: BoxSource,
-  filename: String,
+  pub filename: String,
+  pub has_filename: bool, /* webpack only asset has filename, js/css/wasm has filename template */
   pub info: AssetInfo,
-  // pub identifier: String,
-  // hash?: string;
-  pub(crate) auxiliary: bool,
-  has_filename: bool, /* webpack only asset has filename, js/css/wasm has filename template */
-}
-
-impl RenderManifestEntry {
-  pub fn new(
-    source: BoxSource,
-    filename: String,
-    info: AssetInfo,
-    auxiliary: bool,
-    has_filename: bool,
-  ) -> Self {
-    Self {
-      source,
-      filename,
-      info,
-      auxiliary,
-      has_filename,
-    }
-  }
-
-  pub fn source(&self) -> &BoxSource {
-    &self.source
-  }
-
-  pub fn filename(&self) -> &str {
-    &self.filename
-  }
-
-  pub fn has_filename(&self) -> bool {
-    self.has_filename
-  }
+  pub auxiliary: bool,
 }
 
 fn process_runtime_requirement_hook(

crates/rspack_core/src/old_cache/mod.rs

@@ -12,17 +12,15 @@ mod local;
 mod occasion;
 mod storage;
 pub use local::*;
-use occasion::{
-  CodeGenerateOccasion, CreateChunkAssetsOccasion, ProcessRuntimeRequirementsOccasion,
-};
+use occasion::{ChunkRenderOccasion, CodeGenerateOccasion, ProcessRuntimeRequirementsOccasion};
 use storage::new_storage;
 
 #[derive(Debug)]
 pub struct Cache {
   is_idle: AtomicBool,
   pub code_generate_occasion: CodeGenerateOccasion,
   pub process_runtime_requirements_occasion: ProcessRuntimeRequirementsOccasion,
-  pub create_chunk_assets_occasion: CreateChunkAssetsOccasion,
+  pub chunk_render_occasion: ChunkRenderOccasion,
 }
 
 impl Cache {
@@ -33,7 +31,7 @@ impl Cache {
       process_runtime_requirements_occasion: ProcessRuntimeRequirementsOccasion::new(new_storage(
         &options.cache,
       )),
-      create_chunk_assets_occasion: CreateChunkAssetsOccasion::new(new_storage(&options.cache)),
+      chunk_render_occasion: ChunkRenderOccasion::new(new_storage(&options.cache)),
     }
   }
 

crates/rspack_core/src/old_cache/occasion/chunk_render.rs

@@ -0,0 +1,51 @@
+use futures::Future;
+use rspack_collections::Identifier;
+use rspack_error::{Diagnostic, Result};
+use rspack_sources::BoxSource;
+
+use crate::{old_cache::storage, Chunk, Compilation, SourceType};
+
+type Storage = dyn storage::Storage<(BoxSource, Vec<Diagnostic>)>;
+
+#[derive(Debug)]
+pub struct ChunkRenderOccasion {
+  storage: Option<Box<Storage>>,
+}
+
+impl ChunkRenderOccasion {
+  pub fn new(storage: Option<Box<Storage>>) -> Self {
+    Self { storage }
+  }
+
+  pub async fn use_cache<G, F>(
+    &self,
+    compilation: &Compilation,
+    chunk: &Chunk,
+    source_type: &SourceType,
+    generator: G,
+  ) -> Result<(BoxSource, Vec<Diagnostic>)>
+  where
+    G: FnOnce() -> F,
+    F: Future<Output = Result<(BoxSource, Vec<Diagnostic>)>>,
+  {
+    let storage = match &self.storage {
+      Some(s) => s,
+      // no cache return directly
+      None => return generator().await,
+    };
+
+    let Some(content_hash) =
+      chunk.content_hash_by_source_type(&compilation.chunk_hashes_results, source_type)
+    else {
+      return generator().await;
+    };
+    let cache_key = Identifier::from(content_hash.encoded());
+    if let Some(value) = storage.get(&cache_key) {
+      Ok(value)
+    } else {
+      let res = generator().await?;
+      storage.set(cache_key, res.clone());
+      Ok(res)
+    }
+  }
+}

crates/rspack_core/src/old_cache/occasion/mod.rs

@@ -2,5 +2,5 @@ mod code_generate;
 pub use code_generate::*;
 mod process_runtime_requirements;
 pub use process_runtime_requirements::*;
-mod create_chunk_assets;
-pub use create_chunk_assets::*;
+mod chunk_render;
+pub use chunk_render::*;

crates/rspack_core/src/options/output.rs

@@ -379,7 +379,6 @@ impl From<String> for PublicPath {
   }
 }
 
-#[allow(clippy::if_same_then_else)]
 pub fn get_css_chunk_filename_template<'filename>(
   chunk: &'filename Chunk,
   output_options: &'filename OutputOptions,
@@ -395,23 +394,20 @@ pub fn get_css_chunk_filename_template<'filename>(
   }
 }
 
-#[allow(clippy::if_same_then_else)]
-pub fn get_js_chunk_filename_template<'filename>(
-  chunk: &'filename Chunk,
-  output_options: &'filename OutputOptions,
+pub fn get_js_chunk_filename_template(
+  chunk: &Chunk,
+  output_options: &OutputOptions,
   chunk_group_by_ukey: &ChunkGroupByUkey,
-) -> &'filename Filename {
+) -> Filename {
   // Align with https://github.com/webpack/webpack/blob/8241da7f1e75c5581ba535d127fa66aeb9eb2ac8/lib/javascript/JavascriptModulesPlugin.js#L480
   if let Some(filename_template) = chunk.filename_template() {
-    filename_template
-  } else if chunk.can_be_initial(chunk_group_by_ukey) {
-    &output_options.filename
+    filename_template.clone()
   } else if matches!(chunk.kind(), ChunkKind::HotUpdate) {
-    // TODO: Should return output_options.hotUpdateChunkFilename
-    // See https://github.com/webpack/webpack/blob/8241da7f1e75c5581ba535d127fa66aeb9eb2ac8/lib/javascript/JavascriptModulesPlugin.js#L484
-    &output_options.chunk_filename
+    output_options.hot_update_chunk_filename.clone().into()
+  } else if chunk.can_be_initial(chunk_group_by_ukey) {
+    output_options.filename.clone()
   } else {
-    &output_options.chunk_filename
+    output_options.chunk_filename.clone()
   }
 }
 

crates/rspack_plugin_asset/src/lib.rs

@@ -612,13 +612,13 @@ async fn render_manifest(
           .get::<CodeGenerationDataAssetInfo>()
           .expect("should have asset_info")
           .inner();
-        RenderManifestEntry::new(
-          source.clone(),
-          asset_filename.to_owned(),
-          asset_info.to_owned(),
-          true,
-          true,
-        )
+        RenderManifestEntry {
+          source: source.clone(),
+          filename: asset_filename.to_owned(),
+          has_filename: true,
+          info: asset_info.to_owned(),
+          auxiliary: true,
+        }
       });
 
       Ok(result)