feat(log): log available parallelism

Otherwise HTML replay from logs will not have this info

Author: weihanglo

src/cargo/core/compiler/timings/mod.rs

@@ -437,6 +437,9 @@ impl<'gctx> Timings<'gctx> {
                 .iter()
                 .map(|kind| build_runner.bcx.target_data.short_name(kind))
                 .collect::<Vec<_>>();
+            let num_cpus = std::thread::available_parallelism()
+                .ok()
+                .map(|x| x.get() as u64);
 
             let unit_data = report::to_unit_data(&self.unit_times, &self.unit_to_index);
             let concurrency = report::compute_concurrency(&unit_data);
@@ -454,6 +457,7 @@ impl<'gctx> Timings<'gctx> {
                 host: &build_runner.bcx.rustc().host,
                 requested_targets,
                 jobs: build_runner.bcx.jobs(),
+                num_cpus,
                 error,
             };
             report::write_html(ctx, &mut f)?;

src/cargo/core/compiler/timings/report.rs

@@ -124,6 +124,8 @@ pub struct RenderContext<'a> {
     pub requested_targets: &'a [&'a str],
     /// The number of jobs specified for this build.
     pub jobs: u32,
+    /// Available parallelism of the compilation environment.
+    pub num_cpus: Option<u64>,
     /// Fatal error during the build.
     pub error: &'a Option<anyhow::Error>,
 }
@@ -185,9 +187,10 @@ fn write_summary_table(
     let total_time = format!("{:.1}s{}", duration, time_human);
 
     let max_concurrency = ctx.concurrency.iter().map(|c| c.active).max().unwrap_or(0);
-    let num_cpus = std::thread::available_parallelism()
-        .map(|x| x.get().to_string())
-        .unwrap_or_else(|_| "n/a".into());
+    let num_cpus = ctx
+        .num_cpus
+        .map(|x| x.to_string())
+        .unwrap_or_else(|| "n/a".into());
 
     let requested_targets = ctx.requested_targets.join(", ");
 

src/cargo/ops/cargo_compile/mod.rs

@@ -162,10 +162,14 @@ pub fn compile_ws<'a>(
 
     if let Some(ref logger) = logger {
         let rustc = ws.gctx().load_global_rustc(Some(ws))?;
+        let num_cpus = std::thread::available_parallelism()
+            .ok()
+            .map(|x| x.get() as u64);
         logger.log(LogMessage::BuildStarted {
             cwd: ws.gctx().cwd().to_path_buf(),
             host: rustc.host.to_string(),
             jobs: options.build_config.jobs,
+            num_cpus,
             profile: options.build_config.requested_profile.to_string(),
             rustc_version: rustc.version.to_string(),
             rustc_version_verbose: rustc.verbose_version.clone(),

src/cargo/util/log_message.rs

@@ -24,6 +24,8 @@ pub enum LogMessage {
         host: String,
         /// Number of parallel jobs.
         jobs: u32,
+        /// Available parallelism of the compilation environment.
+        num_cpus: Option<u64>,
         /// Build profile name (e.g., "dev", "release").
         profile: String,
         /// The rustc version (`1.23.4-beta.2`).

tests/testsuite/build_analysis.rs

@@ -80,6 +80,7 @@ fn log_msg_build_started() {
     "cwd": "[ROOT]/foo",
     "host": "[HOST_TARGET]",
     "jobs": "{...}",
+    "num_cpus": "{...}",
     "profile": "dev",
     "reason": "build-started",
     "run_id": "[..]T[..]Z-[..]",