ParallelFrontend scenario added for -Zthreads=8 run, check only

collector/src/bin/collector.rs

@@ -177,7 +177,10 @@ fn generate_diffs(
                     return vec![];
                 }
                 match scenario {
-                    Scenario::Full | Scenario::IncrFull | Scenario::IncrUnchanged => {
+                    Scenario::Full
+                    | Scenario::IncrFull
+                    | Scenario::IncrUnchanged
+                    | Scenario::ParallelFrontend => {
                         vec![format!("{:?}", scenario)]
                     }
                     Scenario::IncrPatched => (0..benchmark.patches.len())

collector/src/compile/benchmark/mod.rs

@@ -451,6 +451,13 @@ impl Benchmark {
                         .await?;
                 }
 
+                if scenarios.contains(&Scenario::ParallelFrontend) {
+                    self.mk_cargo_process(toolchain, cwd, profile, backend, target)
+                        .processor(processor, Scenario::ParallelFrontend, "ParFront", None)
+                        .run_rustc(true)
+                        .await?;
+                }
+
                 // Rustdoc does not support incremental compilation
                 if !profile.is_doc() {
                     // An incremental build from scratch (slowest incremental case).
@@ -524,6 +531,10 @@ impl Benchmark {
         if scenario.is_incr() && profile.is_doc() {
             return false;
         }
+        // Testing parallel frontend only for 'check' profile
+        if *scenario == Scenario::ParallelFrontend && *profile != Profile::Check {
+            return false;
+        }
 
         let benchmark = database::Benchmark::from(self.name.0.as_str());
         let profile: database::Profile = (*profile).into();
@@ -532,7 +543,10 @@ impl Benchmark {
 
         match scenario {
             // For these scenarios, we can simply check if they were benchmarked or not
-            Scenario::Full | Scenario::IncrFull | Scenario::IncrUnchanged => {
+            Scenario::Full
+            | Scenario::IncrFull
+            | Scenario::IncrUnchanged
+            | Scenario::ParallelFrontend => {
                 let test_case = CompileTestCase {
                     benchmark,
                     profile,
@@ -542,6 +556,7 @@ impl Benchmark {
                         Scenario::Full => database::Scenario::Empty,
                         Scenario::IncrFull => database::Scenario::IncrementalEmpty,
                         Scenario::IncrUnchanged => database::Scenario::IncrementalFresh,
+                        Scenario::ParallelFrontend => database::Scenario::ParallelFrontend,
                         Scenario::IncrPatched => unreachable!(),
                     },
                 };

collector/src/compile/benchmark/scenario.rs

@@ -5,6 +5,7 @@ pub enum Scenario {
     IncrFull,
     IncrUnchanged,
     IncrPatched,
+    ParallelFrontend,
 }
 
 impl Scenario {
@@ -14,11 +15,12 @@ impl Scenario {
             Scenario::IncrFull,
             Scenario::IncrUnchanged,
             Scenario::IncrPatched,
+            Scenario::ParallelFrontend,
         ]
     }
 
     pub fn all_non_incr() -> Vec<Scenario> {
-        vec![Scenario::Full]
+        vec![Scenario::Full, Scenario::ParallelFrontend]
     }
 
     pub fn is_incr(self) -> bool {

collector/src/compile/execute/bencher.rs

@@ -173,6 +173,7 @@ impl Processor for BenchProcessor<'_> {
                         Scenario::Full => database::Scenario::Empty,
                         Scenario::IncrFull => database::Scenario::IncrementalEmpty,
                         Scenario::IncrUnchanged => database::Scenario::IncrementalFresh,
+                        Scenario::ParallelFrontend => database::Scenario::ParallelFrontend,
                         Scenario::IncrPatched => {
                             let patch = data.patch.unwrap();
                             database::Scenario::IncrementalPatch(patch.name)

collector/src/compile/execute/mod.rs

@@ -112,8 +112,12 @@ impl PerfTool {
             | ProfileTool(LlvmIr)
             | ProfileTool(Eprintln) => true,
             // only incremental
-            ProfileTool(DepGraph) => scenario != Scenario::Full,
-            ProfileTool(LlvmLines) => scenario == Scenario::Full,
+            ProfileTool(DepGraph) => {
+                !matches!(scenario, Scenario::Full | Scenario::ParallelFrontend)
+            }
+            ProfileTool(LlvmLines) => {
+                matches!(scenario, Scenario::Full | Scenario::ParallelFrontend)
+            }
         }
     }
 }
@@ -409,6 +413,10 @@ impl<'a> CargoProcess<'a> {
             match self.profile {
                 Profile::Check => {
                     cmd.arg("--profile").arg("check");
+                    if Some(Scenario::ParallelFrontend) == self.processor_etc.as_ref().map(|v| v.1)
+                    {
+                        cmd.env("RUSTC_THREAD_COUNT", "8");
+                    }
                 }
                 Profile::Clippy => {
                     cmd.arg("--profile").arg("check");

database/src/lib.rs

@@ -286,6 +286,8 @@ pub enum Scenario {
     IncrementalFresh,
     /// Cache is mostly up-to-date but some code has been changed
     IncrementalPatch(PatchName),
+    /// Parallel frontend
+    ParallelFrontend,
 }
 
 intern!(pub struct PatchName);
@@ -297,6 +299,7 @@ impl std::str::FromStr for Scenario {
             "full" => Scenario::Empty,
             "incr-full" => Scenario::IncrementalEmpty,
             "incr-unchanged" => Scenario::IncrementalFresh,
+            "par-front" => Scenario::ParallelFrontend,
             _ => {
                 if let Some(stripped) = s.strip_prefix("incr-patched: ") {
                     Scenario::IncrementalPatch(PatchName::from(stripped))
@@ -314,6 +317,7 @@ impl fmt::Display for Scenario {
             Scenario::Empty => write!(f, "full"),
             Scenario::IncrementalEmpty => write!(f, "incr-full"),
             Scenario::IncrementalFresh => write!(f, "incr-unchanged"),
+            Scenario::ParallelFrontend => write!(f, "par-front"),
             Scenario::IncrementalPatch(name) => write!(f, "incr-patched: {name}"),
         }
     }
@@ -325,6 +329,7 @@ impl Scenario {
             Scenario::Empty => "full".to_string(),
             Scenario::IncrementalEmpty => "incr-full".to_string(),
             Scenario::IncrementalFresh => "incr-unchanged".to_string(),
+            Scenario::ParallelFrontend => "par-front".to_string(),
             Scenario::IncrementalPatch(name) => format!("incr-patched-{name}"),
         }
     }
@@ -345,9 +350,14 @@ impl Ord for Scenario {
             (Scenario::IncrementalFresh, Scenario::Empty) => Ordering::Greater,
             (Scenario::IncrementalFresh, Scenario::IncrementalEmpty) => Ordering::Greater,
             (Scenario::IncrementalFresh, _) => Ordering::Less,
+            (Scenario::ParallelFrontend, Scenario::Empty) => Ordering::Greater,
+            (Scenario::ParallelFrontend, Scenario::IncrementalEmpty) => Ordering::Greater,
+            (Scenario::ParallelFrontend, Scenario::IncrementalFresh) => Ordering::Greater,
+            (Scenario::ParallelFrontend, _) => Ordering::Less,
             (Scenario::IncrementalPatch(_), Scenario::Empty) => Ordering::Greater,
             (Scenario::IncrementalPatch(_), Scenario::IncrementalEmpty) => Ordering::Greater,
             (Scenario::IncrementalPatch(_), Scenario::IncrementalFresh) => Ordering::Greater,
+            (Scenario::IncrementalPatch(_), Scenario::ParallelFrontend) => Ordering::Greater,
             (Scenario::IncrementalPatch(a), Scenario::IncrementalPatch(b)) => {
                 if a == "println" {
                     Ordering::Less

site/src/load.rs

@@ -99,6 +99,7 @@ impl SiteCtxt {
             database::Scenario::Empty,
             database::Scenario::IncrementalEmpty,
             database::Scenario::IncrementalFresh,
+            database::Scenario::ParallelFrontend,
             database::Scenario::IncrementalPatch("println".into()),
         ]
     }

site/src/request_handlers/dashboard.rs

@@ -126,6 +126,7 @@ pub async fn handle_dashboard(
                     Scenario::Empty => cases.clean_averages = points,
                     Scenario::IncrementalEmpty => cases.base_incr_averages = points,
                     Scenario::IncrementalFresh => cases.clean_incr_averages = points,
+                    Scenario::ParallelFrontend => cases.clean_averages = points,
                     // we only have println patches here
                     Scenario::IncrementalPatch(_) => cases.println_incr_averages = points,
                 }