perf: Use ustr for RuntimeSpec (#10480)

Author: quininer

Cargo.lock

@@ -106,6 +106,7 @@ serde                                  = { workspace = true }
 serde_json                             = { workspace = true }
 swc_core                               = { workspace = true, default-features = false, features = ["ecma_transforms_react"] }
 tokio                                  = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "test-util", "tracing"] }
+ustr                                   = { workspace = true }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 tokio = { workspace = true, features = ["parking_lot"] }

crates/node_binding/Cargo.toml

@@ -1,4 +1,4 @@
-use std::{ptr::NonNull, sync::Arc};
+use std::ptr::NonNull;
 
 use napi::{Either, Result};
 use napi_derive::napi;
@@ -173,8 +173,8 @@ impl JsChunkGraph {
   ) -> napi::Result<Option<&str>> {
     let compilation = self.as_ref()?;
     let Some(runtime) = js_runtime.map(|js_runtime| match js_runtime {
-      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+      Either::B(vec) => vec.into_iter().map(Into::into).collect(),
     }) else {
       return Ok(None);
     };

crates/node_binding/src/chunk_graph.rs

@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use napi::Either;
 use rspack_core::{Reflector, WeakBindingCell};
 use rustc_hash::FxHashMap;
@@ -112,8 +110,8 @@ impl CodeGenerationResults {
   pub fn get(&self, module: ModuleObjectRef, runtime: JsRuntimeSpec) -> napi::Result<Reflector> {
     self.with_ref(|code_generation_results| {
       let rt: Option<rspack_core::RuntimeSpec> = runtime.map(|val| match val {
-        Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-        Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+        Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+        Either::B(vec) => vec.into_iter().map(Into::into).collect(),
       });
 
       let code_generation_result = code_generation_results.get(&module.identifier, rt.as_ref());

crates/node_binding/src/compilation/code_generation_results.rs

@@ -1,4 +1,4 @@
-use std::{ptr::NonNull, sync::Arc};
+use std::ptr::NonNull;
 
 use napi::Either;
 use napi_derive::napi;
@@ -40,8 +40,8 @@ impl JsExportsInfo {
   pub fn is_used(&self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let module_graph = self.as_ref()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+      Either::B(vec) => vec.into_iter().map(Into::into).collect(),
     });
     Ok(self.exports_info.is_used(&module_graph, runtime.as_ref()))
   }
@@ -50,8 +50,8 @@ impl JsExportsInfo {
   pub fn is_module_used(&self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let module_graph = self.as_ref()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+      Either::B(vec) => vec.into_iter().map(Into::into).collect(),
     });
     Ok(
       self
@@ -64,8 +64,8 @@ impl JsExportsInfo {
   pub fn set_used_in_unknown_way(&mut self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let mut module_graph = self.as_mut()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+      Either::B(vec) => vec.into_iter().map(Into::into).collect(),
     });
     Ok(
       self
@@ -85,8 +85,8 @@ impl JsExportsInfo {
   ) -> napi::Result<u32> {
     let module_graph = self.as_ref()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
-      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Into::into).collect(),
+      Either::B(vec) => vec.into_iter().map(Into::into).collect(),
     });
     let used = match js_name {
       Either::A(s) => self

crates/node_binding/src/exports_info.rs

@@ -1,9 +1,8 @@
-use std::{ptr::NonNull, sync::Arc};
+use std::ptr::NonNull;
 
 use napi::{Either, Env, JsString};
 use napi_derive::napi;
 use rspack_core::{Compilation, ModuleGraph, RuntimeSpec};
-use rustc_hash::FxHashSet;
 
 use crate::{
   DependencyObject, JsExportsInfo, ModuleGraphConnectionWrapper, ModuleObject, ModuleObjectRef,
@@ -81,13 +80,13 @@ impl JsModuleGraph {
   ) -> napi::Result<Option<Either<bool, Vec<JsString<'a>>>>> {
     let (_, module_graph) = self.as_ref()?;
 
-    let mut runtime: FxHashSet<Arc<str>> = FxHashSet::default();
+    let mut runtime = ustr::UstrSet::default();
     match js_runtime {
       Either::A(s) => {
-        runtime.insert(Arc::from(s));
+        runtime.insert(s.into());
       }
       Either::B(vec) => {
-        runtime.extend(vec.into_iter().map(Arc::from));
+        runtime.extend(vec.iter().map(String::as_str).map(ustr::Ustr::from));
       }
     };
     let used_exports =

crates/node_binding/src/module_graph.rs

@@ -100,3 +100,16 @@ impl AsRefStrConverter for Box<str> {
     s.into()
   }
 }
+
+// for Ustr
+impl AsRefStrConverter for ustr::Ustr {
+  fn as_str(&self) -> &str {
+    self
+  }
+  fn from_str(s: &str) -> Self
+  where
+    Self: Sized,
+  {
+    s.into()
+  }
+}

crates/rspack_cacheable/src/with/as_ref_str.rs

@@ -9,7 +9,7 @@ use std::{
 use dashmap::{DashMap, DashSet};
 use hashlink::{LinkedHashMap, LinkedHashSet};
 use indexmap::{IndexMap, IndexSet};
-use rspack_cacheable::{cacheable, with::AsPreset};
+use rspack_cacheable::{cacheable, with, with::AsPreset};
 use serde::Serialize;
 use ustr::Ustr;
 
@@ -92,3 +92,16 @@ impl fmt::Display for Identifier {
     write!(f, "{}", self.to_string())
   }
 }
+
+// for Identifier
+impl with::AsRefStrConverter for Identifier {
+  fn as_str(&self) -> &str {
+    self.0.as_str()
+  }
+  fn from_str(s: &str) -> Self
+  where
+    Self: Sized,
+  {
+    s.into()
+  }
+}

crates/rspack_collections/src/identifier.rs

@@ -1,7 +1,7 @@
 use std::{
   collections::HashSet as RawHashSet,
   hash::{BuildHasherDefault, Hash},
-  sync::{atomic::AtomicU32, Arc},
+  sync::atomic::AtomicU32,
 };
 
 use indexmap::{IndexMap as RawIndexMap, IndexSet as RawIndexSet};
@@ -130,12 +130,12 @@ impl ChunkGroupInfo {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub(crate) struct OptionalRuntimeSpec(pub Vec<Arc<str>>);
+pub(crate) struct OptionalRuntimeSpec(pub Vec<ustr::Ustr>);
 
 impl From<Option<RuntimeSpec>> for OptionalRuntimeSpec {
   fn from(value: Option<RuntimeSpec>) -> Self {
     let mut vec = value.unwrap_or_default().into_iter().collect::<Vec<_>>();
-    vec.sort();
+    vec.sort_unstable();
     Self(vec)
   }
 }
@@ -1694,8 +1694,8 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
           .chunk_groups_for_merging
           .insert((target_ukey, process_block));
         let mut updated = false;
-        for r in runtime.iter() {
-          updated |= target_cgi.runtime.insert(r.clone());
+        for &r in runtime.iter() {
+          updated |= target_cgi.runtime.insert(r);
         }
         if updated {
           self.outdated_chunk_group_info.insert(target_ukey);

crates/rspack_core/src/build_chunk_graph/code_splitter.rs

@@ -1,9 +1,4 @@
-use std::{
-  borrow::Cow,
-  hash::BuildHasherDefault,
-  iter::once,
-  sync::{atomic::AtomicU32, Arc},
-};
+use std::{borrow::Cow, hash::BuildHasherDefault, iter::once, sync::atomic::AtomicU32};
 
 use dashmap::mapref::one::Ref;
 use indexmap::IndexSet;
@@ -421,7 +416,7 @@ impl CodeSplitter {
         Self::get_entry_runtime(entry, compilation, &mut entry_runtime, &mut visited)
       {
         diagnostics.push(Diagnostic::from(error));
-        let tmp_runtime = once(Arc::from(entry.clone())).collect::<RuntimeSpec>();
+        let tmp_runtime = once(ustr::Ustr::from(entry.as_str())).collect::<RuntimeSpec>();
         entry_runtime.insert(entry, tmp_runtime.clone());
       };
     }
@@ -695,12 +690,12 @@ impl CodeSplitter {
           entry
         ));
       }
-      let mut runtime = None;
+      let mut runtime: Option<RuntimeSpec> = None;
       for dep in depend_on {
         let other_runtime = Self::get_entry_runtime(dep, compilation, entry_runtime, visited)?;
         match &mut runtime {
           Some(runtime) => {
-            *runtime = merge_runtime(runtime, &other_runtime);
+            runtime.extend(&other_runtime);
           }
           None => {
             runtime = Some(other_runtime);

crates/rspack_core/src/build_chunk_graph/new_code_splitter.rs

@@ -12,7 +12,7 @@ use rspack_hash::{RspackHash, RspackHashDigest};
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet, FxHasher};
 
 use crate::{
-  chunk_graph_chunk::ChunkId, compare_chunk_group, merge_runtime, sort_group_by_index, ChunkGraph,
+  chunk_graph_chunk::ChunkId, compare_chunk_group, sort_group_by_index, ChunkGraph,
   ChunkGroupByUkey, ChunkGroupOrderKey, ChunkGroupUkey, ChunkHashesArtifact, ChunkIdsArtifact,
   ChunkUkey, Compilation, EntryOptions, Filename, ModuleGraph, RenderManifestEntry, RuntimeSpec,
   SourceType,
@@ -324,7 +324,7 @@ impl Chunk {
         new_chunk.add_group(group.ukey);
       });
     new_chunk.id_name_hints.extend(self.id_name_hints.clone());
-    new_chunk.runtime = merge_runtime(&new_chunk.runtime, &self.runtime);
+    new_chunk.runtime.extend(&self.runtime);
   }
 
   pub fn can_be_initial(&self, chunk_group_by_ukey: &ChunkGroupByUkey) -> bool {

crates/rspack_core/src/chunk.rs

@@ -630,7 +630,7 @@ impl Module for ConcatenatedModule {
       Some(Cow::Owned(
         generation_runtime
           .intersection(self_runtime)
-          .cloned()
+          .copied()
           .collect::<RuntimeSpec>(),
       ))
     } else {
@@ -1301,7 +1301,7 @@ impl Module for ConcatenatedModule {
       Some(Cow::Owned(
         generation_runtime
           .intersection(self_runtime)
-          .cloned()
+          .copied()
           .collect::<RuntimeSpec>(),
       ))
     } else {

crates/rspack_core/src/concatenated_module.rs

@@ -1037,7 +1037,7 @@ impl ExportInfo {
       let mut max = UsageState::Unused;
       if let Some(runtime) = runtime {
         for item in runtime.iter() {
-          let Some(usage) = used_in_runtime.get(item.as_ref()) else {
+          let Some(usage) = used_in_runtime.get(item) else {
             continue;
           };
           match usage {
@@ -1081,7 +1081,7 @@ impl ExportInfo {
         if let Some(runtime) = runtime {
           if runtime
             .iter()
-            .all(|item| !used_in_runtime.contains_key(item.as_ref()))
+            .all(|item| !used_in_runtime.contains_key(item))
           {
             return None;
           }
@@ -1295,12 +1295,10 @@ impl ExportInfo {
   ) -> bool {
     if let Some(runtime) = runtime {
       let export_info_mut = mg.get_export_info_mut_by_id(self);
-      let used_in_runtime = export_info_mut
-        .used_in_runtime
-        .get_or_insert(HashMap::default());
+      let used_in_runtime = export_info_mut.used_in_runtime.get_or_insert_default();
       let mut changed = false;
-      for k in runtime.iter() {
-        match used_in_runtime.entry(k.clone()) {
+      for &k in runtime.iter() {
+        match used_in_runtime.entry(k) {
           Entry::Occupied(mut occ) => match (&new_value, occ.get()) {
             (new, _) if new == &UsageState::Unused => {
               occ.remove();
@@ -1344,13 +1342,11 @@ impl ExportInfo {
   ) -> bool {
     if let Some(runtime) = runtime {
       let export_info_mut = mg.get_export_info_mut_by_id(self);
-      let used_in_runtime = export_info_mut
-        .used_in_runtime
-        .get_or_insert(HashMap::default());
+      let used_in_runtime = export_info_mut.used_in_runtime.get_or_insert_default();
       let mut changed = false;
 
-      for k in runtime.iter() {
-        match used_in_runtime.entry(k.clone()) {
+      for &k in runtime.iter() {
+        match used_in_runtime.entry(k) {
           Entry::Occupied(mut occ) => match (&new_value, occ.get()) {
             (new, old) if condition(old) && new == &UsageState::Unused => {
               occ.remove();
@@ -1507,7 +1503,7 @@ pub struct ExportInfoData {
   has_use_in_runtime_info: bool,
   can_mangle_use: Option<bool>,
   global_used: Option<UsageState>,
-  used_in_runtime: Option<HashMap<Arc<str>, UsageState>>,
+  used_in_runtime: Option<ustr::UstrMap<UsageState>>,
 }
 
 #[derive(Debug, Hash, Clone, Copy)]