refactor: rspack module profiler (#11712)

* refactor: rspack module profiler

* refactor: Option<Box<ModuleProfile>> to Option<ModuleProfile>

* fix typo

Author: jerrykingxyz

crates/node_binding/napi-binding.d.ts

@@ -1353,11 +1353,6 @@ export interface JsStatsLogging {
   trace?: Array<string>
 }
 
-export interface JsStatsMillisecond {
-  secs: number
-  subsecMillis: number
-}
-
 export interface JsStatsModule {
   commonAttributes: JsStatsModuleCommonAttributes
   dependent?: boolean
@@ -1402,8 +1397,8 @@ export interface JsStatsModuleIssuer {
 }
 
 export interface JsStatsModuleProfile {
-  factory: JsStatsMillisecond
-  building: JsStatsMillisecond
+  factory: number
+  building: number
 }
 
 export interface JsStatsModuleReason {

crates/rspack_binding_api/src/stats.rs

@@ -680,30 +680,17 @@ impl<'a> TryFrom<StatsModule<'a>> for JsStatsModule<'a> {
 
 #[napi(object, object_from_js = false)]
 pub struct JsStatsModuleProfile {
-  pub factory: JsStatsMillisecond,
-  pub building: JsStatsMillisecond,
+  // use f64 to make js side as a number type
+  pub factory: f64,
+  pub building: f64,
 }
 
 impl From<rspack_core::StatsModuleProfile> for JsStatsModuleProfile {
   fn from(value: rspack_core::StatsModuleProfile) -> Self {
     Self {
-      factory: value.factory.into(),
-      building: value.building.into(),
-    }
-  }
-}
-
-#[napi(object, object_from_js = false)]
-pub struct JsStatsMillisecond {
-  pub secs: u32,
-  pub subsec_millis: u32,
-}
-
-impl From<rspack_core::StatsMillisecond> for JsStatsMillisecond {
-  fn from(value: rspack_core::StatsMillisecond) -> Self {
-    Self {
-      secs: value.secs as u32,
-      subsec_millis: value.subsec_millis,
+      // The time is short and no data will be lost when converting from u64 to f64
+      factory: value.factory as f64,
+      building: value.building as f64,
     }
   }
 }

crates/rspack_core/src/compilation/make/graph_updater/repair/add.rs

@@ -14,7 +14,7 @@ pub struct AddTask {
   pub module: Box<dyn Module>,
   pub module_graph_module: Box<ModuleGraphModule>,
   pub dependencies: Vec<BoxDependency>,
-  pub current_profile: Option<Box<ModuleProfile>>,
+  pub current_profile: Option<ModuleProfile>,
   pub from_unlazy: bool,
 }
 

crates/rspack_core/src/compilation/make/graph_updater/repair/build.rs

@@ -18,7 +18,7 @@ pub struct BuildTask {
   pub compiler_id: CompilerId,
   pub compilation_id: CompilationId,
   pub module: Box<dyn Module>,
-  pub current_profile: Option<Box<ModuleProfile>>,
+  pub current_profile: Option<ModuleProfile>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub compiler_options: Arc<CompilerOptions>,
   pub plugin_driver: SharedPluginDriver,
@@ -38,12 +38,12 @@ impl Task<TaskContext> for BuildTask {
       compiler_options,
       resolver_factory,
       plugin_driver,
-      current_profile,
+      mut current_profile,
       mut module,
       fs,
       forwarded_ids,
     } = *self;
-    if let Some(current_profile) = &current_profile {
+    if let Some(current_profile) = &mut current_profile {
       current_profile.mark_building_start();
     }
 
@@ -67,7 +67,7 @@ impl Task<TaskContext> for BuildTask {
       )
       .await;
 
-    if let Some(current_profile) = &current_profile {
+    if let Some(current_profile) = &mut current_profile {
       current_profile.mark_building_end();
     }
 
@@ -88,7 +88,7 @@ struct BuildResultTask {
   pub module: Box<dyn Module>,
   pub build_result: Box<BuildResult>,
   pub plugin_driver: SharedPluginDriver,
-  pub current_profile: Option<Box<ModuleProfile>>,
+  pub current_profile: Option<ModuleProfile>,
   pub forwarded_ids: ForwardedIdSet,
 }
 

crates/rspack_core/src/compilation/make/graph_updater/repair/factorize.rs

@@ -25,7 +25,7 @@ pub struct FactorizeTask {
   pub dependencies: Vec<BoxDependency>,
   pub resolve_options: Option<Arc<Resolve>>,
   pub options: Arc<CompilerOptions>,
-  pub current_profile: Option<Box<ModuleProfile>>,
+  pub current_profile: Option<ModuleProfile>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub from_unlazy: bool,
 }
@@ -35,8 +35,8 @@ impl Task<TaskContext> for FactorizeTask {
   fn get_task_type(&self) -> TaskType {
     TaskType::Background
   }
-  async fn background_run(self: Box<Self>) -> TaskResult<TaskContext> {
-    if let Some(current_profile) = &self.current_profile {
+  async fn background_run(mut self: Box<Self>) -> TaskResult<TaskContext> {
+    if let Some(current_profile) = &mut self.current_profile {
       current_profile.mark_factory_start();
     }
     let dependency = &self.dependencies[0];
@@ -110,7 +110,7 @@ impl Task<TaskContext> for FactorizeTask {
       }
     };
 
-    if let Some(current_profile) = &self.current_profile {
+    if let Some(current_profile) = &mut self.current_profile {
       current_profile.mark_factory_end();
     }
 
@@ -145,7 +145,7 @@ pub struct FactorizeResultTask {
   /// Result will be available if [crate::ModuleFactory::create] returns `Ok`.
   pub factory_result: Option<ModuleFactoryResult>,
   pub dependencies: Vec<BoxDependency>,
-  pub current_profile: Option<Box<ModuleProfile>>,
+  pub current_profile: Option<ModuleProfile>,
   pub exports_info_related: ExportsInfoData,
   pub factorize_info: FactorizeInfo,
   pub from_unlazy: bool,

crates/rspack_core/src/compilation/make/graph_updater/repair/mod.rs

@@ -45,10 +45,7 @@ pub async fn repair(
           let dependency = module_graph
             .dependency_by_id(&dep_id)
             .expect("dependency not found");
-          let current_profile = compilation
-            .options
-            .profile
-            .then(Box::<ModuleProfile>::default);
+          let current_profile = compilation.options.profile.then(ModuleProfile::default);
           Box::new(factorize::FactorizeTask {
             compiler_id: compilation.compiler_id(),
             compilation_id: compilation.id(),

crates/rspack_core/src/compilation/make/graph_updater/repair/process_dependencies.rs

@@ -73,7 +73,7 @@ impl Task<TaskContext> for ProcessDependenciesTask {
       let current_profile = context
         .compiler_options
         .profile
-        .then(Box::<ModuleProfile>::default);
+        .then(ModuleProfile::default);
       let original_module_source = module_graph
         .module_by_identifier(&original_module_identifier)
         .and_then(|m| m.as_normal_module())

crates/rspack_core/src/compilation/make/module_executor/entry.rs

@@ -78,7 +78,7 @@ impl Task<ExecutorTaskContext> for EntryTask {
           current_profile: origin_context
             .compiler_options
             .profile
-            .then(Box::<ModuleProfile>::default),
+            .then(ModuleProfile::default),
           resolver_factory: origin_context.resolver_factory.clone(),
           from_unlazy: false,
         })]));

crates/rspack_core/src/module_graph/module.rs

@@ -23,7 +23,7 @@ pub struct ModuleGraphModule {
   pub post_order_index: Option<u32>,
   pub exports: ExportsInfo,
   #[cacheable(with=Skip)]
-  pub profile: Option<Box<ModuleProfile>>,
+  pub profile: Option<ModuleProfile>,
   pub depth: Option<usize>,
   pub optimization_bailout: Vec<String>,
 }
@@ -70,12 +70,12 @@ impl ModuleGraphModule {
     &self.outgoing_connections
   }
 
-  pub fn set_profile(&mut self, profile: Box<ModuleProfile>) {
+  pub fn set_profile(&mut self, profile: ModuleProfile) {
     self.profile = Some(profile);
   }
 
   pub fn profile(&self) -> Option<&ModuleProfile> {
-    self.profile.as_deref()
+    self.profile.as_ref()
   }
 
   pub fn set_issuer_if_unset(&mut self, issuer: Option<ModuleIdentifier>) {

crates/rspack_core/src/module_profile.rs

@@ -1,48 +1,34 @@
-use std::time::{Duration, Instant};
-
-use once_cell::sync::OnceCell;
+use std::time::Instant;
 
 #[derive(Debug, Default, Clone)]
-pub struct TimeRange {
-  start: OnceCell<Instant>,
-  end: OnceCell<Instant>,
+enum ProfileState {
+  #[default]
+  Pending,
+  Started(Instant),
+  // u64 is enough to store the time consumption
+  Finish(u64),
 }
 
-impl TimeRange {
-  pub fn with_value(start: Instant, end: Instant) -> Self {
-    Self {
-      start: OnceCell::with_value(start),
-      end: OnceCell::with_value(end),
-    }
+impl ProfileState {
+  fn start(&mut self) {
+    *self = Self::Started(Instant::now())
   }
 
-  pub fn duration(&self) -> Option<Duration> {
-    if let Some(end) = self.end.get()
-      && let Some(start) = self.start.get()
-    {
-      Some(end.duration_since(*start))
-    } else {
-      None
+  fn end(&mut self) {
+    match self {
+      Self::Started(i) => {
+        let time = Instant::now().duration_since(*i);
+        *self = Self::Finish(time.as_millis() as u64)
+      }
+      _ => panic!("Unable to end an unstarted profiler"),
     }
   }
-}
 
-#[derive(Debug, Default, Clone)]
-pub struct ModulePhaseProfile {
-  range: TimeRange,
-  parallelism_factor: OnceCell<u16>,
-}
-
-impl ModulePhaseProfile {
-  pub fn duration(&self) -> Option<Duration> {
-    self.range.duration()
-  }
-
-  pub fn set_parallelism_factor(&self, factor: u16) {
-    self
-      .parallelism_factor
-      .set(factor)
-      .expect("should only call once");
+  fn duration(&self) -> Option<u64> {
+    match self {
+      Self::Finish(time) => Some(*time),
+      _ => None,
+    }
   }
 }
 
@@ -51,44 +37,32 @@ impl ModulePhaseProfile {
 
 #[derive(Debug, Default, Clone)]
 pub struct ModuleProfile {
-  pub factory: ModulePhaseProfile,
-  pub building: ModulePhaseProfile,
+  factory: ProfileState,
+  building: ProfileState,
 }
 
 impl ModuleProfile {
-  pub fn mark_factory_start(&self) {
-    self
-      .factory
-      .range
-      .start
-      .set(Instant::now())
-      .expect("should only call once");
+  pub fn mark_factory_start(&mut self) {
+    self.factory.start();
+  }
+
+  pub fn mark_factory_end(&mut self) {
+    self.factory.end();
+  }
+
+  pub fn mark_building_start(&mut self) {
+    self.building.start();
   }
 
-  pub fn mark_factory_end(&self) {
-    self
-      .factory
-      .range
-      .end
-      .set(Instant::now())
-      .expect("should only call once");
+  pub fn mark_building_end(&mut self) {
+    self.building.end();
   }
 
-  pub fn mark_building_start(&self) {
-    self
-      .building
-      .range
-      .start
-      .set(Instant::now())
-      .expect("should only call once");
+  pub fn factory_duration(&self) -> Option<u64> {
+    self.factory.duration()
   }
 
-  pub fn mark_building_end(&self) {
-    self
-      .building
-      .range
-      .end
-      .set(Instant::now())
-      .expect("should only call once");
+  pub fn building_duration(&self) -> Option<u64> {
+    self.building.duration()
   }
 }