perf: box large compilation artifacts

Author: intellild

Cargo.toml

@@ -501,9 +501,10 @@ trivial_numeric_casts                  = "warn"
 unused_import_braces                   = "warn"
 unused_lifetimes                       = "warn"
 unused_macro_rules                     = "warn"
+large_assignments                      = "warn"
 
 [workspace.lints.rust.unexpected_cfgs]
-check-cfg = ['cfg(allocative)', 'cfg(codspeed)', 'cfg(dylint_lib, values("rspack_collection_hasher"))']
+check-cfg = ['cfg(allocative)', 'cfg(codspeed)', 'cfg(dylint_lib, values("rspack_collection_hasher", "rspack_large_stack_type"))']
 level     = "warn"
 
 [workspace.lints.clippy]
@@ -531,7 +532,9 @@ index_refutable_slice        = "warn"
 inefficient_to_string        = "warn"
 invalid_upcast_comparisons   = "warn"
 iter_not_returning_iterator  = "warn"
+large_futures                = "warn"
 large_stack_arrays           = "warn"
+large_stack_frames           = "warn"
 large_types_passed_by_value  = "warn"
 macro_use_imports            = "warn"
 manual_ok_or                 = "warn"

clippy.toml

@@ -1,6 +1,9 @@
 allow-dbg-in-tests    = true
 allow-unwrap-in-tests = true
 
+pass-by-value-size-limit = 256
+stack-size-threshold     = 65536
+
 disallowed-methods = [
 
   { path = "str::to_ascii_lowercase", reason = "To avoid memory allocation, use `cow_utils::CowUtils::cow_to_ascii_lowercase` instead." },

crates/rspack_core/src/artifacts/code_generate_cache_artifact.rs

@@ -46,10 +46,10 @@ impl CodeGenerateCacheArtifact {
     &self,
     job: &CodeGenerationJob,
     generator: G,
-  ) -> (Result<CodeGenerationResult>, bool)
+  ) -> (Result<Box<CodeGenerationResult>>, bool)
   where
     G: FnOnce() -> F,
-    F: Future<Output = Result<CodeGenerationResult>>,
+    F: Future<Output = Result<Box<CodeGenerationResult>>>,
   {
     let Some(storage) = &self.storage else {
       let res = generator().await;
@@ -63,11 +63,11 @@ impl CodeGenerateCacheArtifact {
       self.runtime_mode
     ));
     if let Some(value) = storage.get(&cache_key) {
-      (Ok(value), true)
+      (Ok(Box::new(value)), true)
     } else {
       match generator().await {
         Ok(res) => {
-          storage.set(cache_key, res.clone());
+          storage.set(cache_key, (*res).clone());
           (Ok(res), false)
         }
         Err(err) => (Err(err), false),

crates/rspack_core/src/artifacts/code_generation_results.rs

@@ -224,7 +224,7 @@ impl CodeGenerationResults {
   pub fn insert(
     &mut self,
     module_identifier: ModuleIdentifier,
-    codegen_res: CodeGenerationResult,
+    codegen_res: Box<CodeGenerationResult>,
     runtimes: impl IntoIterator<Item = RuntimeSpec>,
   ) {
     let codegen_res_id = codegen_res.id;

crates/rspack_core/src/artifacts/mod.rs

@@ -73,7 +73,7 @@ impl<T: ArtifactExt> ArtifactExt for Box<T> {
 
 // Implementation for BindingCell<T> - used when "napi" feature is enabled
 #[cfg(feature = "napi")]
-impl<T: ArtifactExt + Into<crate::BindingCell<T>>> ArtifactExt for crate::BindingCell<T> {
+impl<T: ArtifactExt> ArtifactExt for crate::BindingCell<T> {
   const PASS: IncrementalPasses = T::PASS;
 
   fn recover(incremental: &Incremental, new: &mut Self, old: &mut Self) {

crates/rspack_core/src/binding/cell.rs

@@ -222,8 +222,7 @@ mod napi_binding {
   }
 
   impl BindingCell<CodeGenerationResults> {
-    pub fn new(code_generation_results: CodeGenerationResults) -> Self {
-      let boxed = Box::new(code_generation_results);
+    pub fn new(boxed: Box<CodeGenerationResults>) -> Self {
       let ptr = boxed.as_ref() as *const CodeGenerationResults as *mut CodeGenerationResults;
       let heap = Arc::new(Heap {
         variant: HeapVariant::CodeGenerationResults(boxed),
@@ -233,15 +232,14 @@ mod napi_binding {
     }
   }
 
-  impl From<CodeGenerationResults> for BindingCell<CodeGenerationResults> {
-    fn from(code_generation_results: CodeGenerationResults) -> Self {
+  impl From<Box<CodeGenerationResults>> for BindingCell<CodeGenerationResults> {
+    fn from(code_generation_results: Box<CodeGenerationResults>) -> Self {
       Self::new(code_generation_results)
     }
   }
 
   impl BindingCell<CodeGenerationResult> {
-    pub fn new(code_generation_result: CodeGenerationResult) -> Self {
-      let boxed = Box::new(code_generation_result);
+    pub fn new(boxed: Box<CodeGenerationResult>) -> Self {
       let ptr = boxed.as_ref() as *const CodeGenerationResult as *mut CodeGenerationResult;
       let heap = Arc::new(Heap {
         variant: HeapVariant::CodeGenerationResult(boxed),
@@ -251,8 +249,8 @@ mod napi_binding {
     }
   }
 
-  impl From<CodeGenerationResult> for BindingCell<CodeGenerationResult> {
-    fn from(code_generation_result: CodeGenerationResult) -> Self {
+  impl From<Box<CodeGenerationResult>> for BindingCell<CodeGenerationResult> {
+    fn from(code_generation_result: Box<CodeGenerationResult>) -> Self {
       Self::new(code_generation_result)
     }
   }
@@ -339,6 +337,18 @@ mod napi_binding {
     }
   }
 
+  impl Clone for BindingCell<CodeGenerationResults> {
+    fn clone(&self) -> Self {
+      Box::new(self.as_ref().clone()).into()
+    }
+  }
+
+  impl Clone for BindingCell<CodeGenerationResult> {
+    fn clone(&self) -> Self {
+      Box::new(self.as_ref().clone()).into()
+    }
+  }
+
   impl<T: ?Sized + Hash> Hash for BindingCell<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
       self.as_ref().hash(state);

crates/rspack_core/src/cache/persistent/build_dependencies/mod.rs

@@ -101,21 +101,24 @@ impl BuildDeps {
   /// Validate build dependencies
   ///
   /// If any build dependencies have changed, this method will return an invalid result.
-  pub async fn validate(&mut self, storage: &dyn Storage) -> Result<BuildDepsValidationResult> {
+  pub async fn validate(
+    &mut self,
+    storage: &dyn Storage,
+  ) -> Result<Box<BuildDepsValidationResult>> {
     let (_, modified_files, removed_files, no_changed_files) = self
       .snapshot
       .calc_modified_paths(storage, SnapshotScope::BUILD)
       .await?;
 
     if !modified_files.is_empty() || !removed_files.is_empty() {
-      return Ok(BuildDepsValidationResult::Invalid {
+      return Ok(Box::new(BuildDepsValidationResult::Invalid {
         modified_files,
         removed_files,
-      });
+      }));
     }
     let tracked_files = no_changed_files.len();
     self.added = no_changed_files;
-    Ok(BuildDepsValidationResult::Valid { tracked_files })
+    Ok(Box::new(BuildDepsValidationResult::Valid { tracked_files }))
   }
 }
 
@@ -216,7 +219,7 @@ mod test {
       .await
       .expect("should validate success");
     assert!(matches!(
-      validate_result,
+      validate_result.as_ref(),
       BuildDepsValidationResult::Invalid { .. }
     ));
     storage.reset(scope);

crates/rspack_core/src/cache/persistent/context.rs

@@ -71,28 +71,30 @@ impl CacheContext {
   pub async fn load_build_deps(&mut self, build_deps: &mut BuildDeps) {
     let start = self.logger().time("validate build dependencies");
     match build_deps.validate(&*self.storage).await {
-      Ok(BuildDepsValidationResult::Valid { tracked_files }) => {
-        self.invalid = false;
-        self.logger().info(format!(
-          "build dependencies are valid ({tracked_files} tracked)"
-        ));
-      }
-      Ok(BuildDepsValidationResult::Invalid {
-        modified_files,
-        removed_files,
-      }) => {
-        self.invalid = true;
-        self.load_failed = true;
-        let reason = format_path_changes(&modified_files, &removed_files);
-        self.logger().warn(format!(
-          "persistent cache invalidated because build dependencies changed:\n{reason}"
-        ));
-        if self.readonly {
-          self
-            .logger()
-            .warn("persistent cache is readonly, stale entries will not be rewritten");
+      Ok(result) => match result.as_ref() {
+        BuildDepsValidationResult::Valid { tracked_files } => {
+          self.invalid = false;
+          self.logger().info(format!(
+            "build dependencies are valid ({tracked_files} tracked)"
+          ));
         }
-      }
+        BuildDepsValidationResult::Invalid {
+          modified_files,
+          removed_files,
+        } => {
+          self.invalid = true;
+          self.load_failed = true;
+          let reason = format_path_changes(&modified_files, &removed_files);
+          self.logger().warn(format!(
+            "persistent cache invalidated because build dependencies changed:\n{reason}"
+          ));
+          if self.readonly {
+            self
+              .logger()
+              .warn("persistent cache is readonly, stale entries will not be rewritten");
+          }
+        }
+      },
       Err(err) => {
         self.load_failed = true;
         self
@@ -229,7 +231,7 @@ impl CacheContext {
   /// Returns `None` and resets the occasion's scope when the cache is
   /// invalid or recovery fails.
   #[tracing::instrument("Cache::Context::load_occasion", skip_all)]
-  pub async fn load_occasion<O: Occasion>(&mut self, occasion: &O) -> Option<O::Artifact> {
+  pub async fn load_occasion<O: Occasion>(&mut self, occasion: &O) -> Option<Box<O::Artifact>> {
     if !self.load_failed {
       let start = self
         .logger()

crates/rspack_core/src/cache/persistent/mod.rs

@@ -211,7 +211,7 @@ impl Cache for PersistentCache {
     }
 
     if let Some(artifact) = self.ctx.load_occasion(&self.make_occasion).await {
-      *compilation.build_module_graph_artifact = artifact;
+      compilation.build_module_graph_artifact = artifact.into();
       for (module, _) in compilation
         .build_module_graph_artifact
         .get_module_graph()
@@ -253,14 +253,16 @@ impl Cache for PersistentCache {
 
   async fn after_process_assets(&mut self, compilation: &Compilation) {
     if let Some(artifact) = &compilation.minimize_persistent_cache_artifact {
-      self.ctx.save_occasion(&self.minimize_occasion, artifact);
+      self
+        .ctx
+        .save_occasion(&self.minimize_occasion, artifact.as_ref());
     }
     if compilation.use_source_map_dev_tool_plugin_cache
       && let Some(artifact) = &compilation.source_map_dev_tool_plugin_cache_artifact
     {
       self
         .ctx
-        .save_occasion(&self.source_map_dev_tool_plugin_occasion, artifact);
+        .save_occasion(&self.source_map_dev_tool_plugin_occasion, artifact.as_ref());
     }
   }
 

crates/rspack_core/src/cache/persistent/occasion/devtool/mod.rs

@@ -278,7 +278,10 @@ impl Occasion for SourceMapDevToolPluginOccasion {
   }
 
   #[tracing::instrument(name = "Cache::Occasion::SourceMap::recovery", skip_all)]
-  async fn recovery(&self, storage: &dyn Storage) -> Result<SourceMapDevToolPluginCacheArtifact> {
+  async fn recovery(
+    &self,
+    storage: &dyn Storage,
+  ) -> Result<Box<SourceMapDevToolPluginCacheArtifact>> {
     let items = storage.load(SCOPE).await?;
     let entries = items
       .into_par_iter()
@@ -312,10 +315,10 @@ impl Occasion for SourceMapDevToolPluginOccasion {
       "recovered {} source map persistent cache entries",
       entries.len()
     );
-    Ok(SourceMapDevToolPluginCacheArtifact {
+    Ok(Box::new(SourceMapDevToolPluginCacheArtifact {
       entries,
       pending_writes: Vec::new(),
       pending_removes: Vec::new(),
-    })
+    }))
   }
 }