Add the parallel front-end test suit

Co-authored-by: SparrowLii <liyuan179@huawei.com>

Author: ywxt

rustfmt.toml

@@ -18,6 +18,7 @@ ignore = [
     "/tests/crashes/",                # Many of these tests contain syntax errors.
     "/tests/debuginfo/",              # These tests are somewhat sensitive to source code layout.
     "/tests/incremental/",            # These tests are somewhat sensitive to source code layout.
+    "/tests/parallel/",               # Some have syntax errors.
     "/tests/pretty/",                 # These tests are very sensitive to source code layout.
     "/tests/run-make/export",         # These tests contain syntax errors.
     "/tests/run-make/translation/test.rs", # This test contains syntax errors.

src/bootstrap/src/core/build_steps/test.rs

@@ -1402,6 +1402,8 @@ test!(RustdocJson {
     only_hosts: true,
 });
 
+test!(Parallel { path: "tests/parallel", mode: "parallel", suite: "parallel", default: true });
+
 test!(Pretty {
     path: "tests/pretty",
     mode: "pretty",

src/bootstrap/src/core/builder/mod.rs

@@ -1057,6 +1057,7 @@ impl<'a> Builder<'a> {
                 test::UiFullDeps,
                 test::Rustdoc,
                 test::CoverageRunRustdoc,
+                test::Parallel,
                 test::Pretty,
                 test::CodegenCranelift,
                 test::CodegenGCC,

src/tools/compiletest/src/common.rs

@@ -30,6 +30,7 @@ string_enum! {
         CoverageMap => "coverage-map",
         CoverageRun => "coverage-run",
         Crashes => "crashes",
+        Parallel => "parallel",
     }
 }
 
@@ -66,6 +67,7 @@ string_enum! {
         Debuginfo => "debuginfo",
         Incremental => "incremental",
         MirOpt => "mir-opt",
+        Parallel => "parallel",
         Pretty => "pretty",
         RunMake => "run-make",
         Rustdoc => "rustdoc",

src/tools/compiletest/src/directives.rs

@@ -150,6 +150,9 @@ pub struct TestProps {
     // empty before the test starts. Incremental mode tests will reuse the
     // incremental directory between passes in the same test.
     pub incremental: bool,
+    // Number of times to run the test, for the parallel front-end test suit.
+    // Repeat tests to ensure no ICEs occur.
+    pub iteration_count: Option<usize>,
     // If `true`, this test is a known bug.
     //
     // When set, some requirements are relaxed. Currently, this only means no
@@ -238,6 +241,7 @@ mod directives {
     pub const ASSEMBLY_OUTPUT: &'static str = "assembly-output";
     pub const STDERR_PER_BITWIDTH: &'static str = "stderr-per-bitwidth";
     pub const INCREMENTAL: &'static str = "incremental";
+    pub const ITERATION_COUNT: &'static str = "iteration-count";
     pub const KNOWN_BUG: &'static str = "known-bug";
     pub const TEST_MIR_PASS: &'static str = "test-mir-pass";
     pub const REMAP_SRC_BASE: &'static str = "remap-src-base";
@@ -280,6 +284,7 @@ impl TestProps {
             forbid_output: vec![],
             incremental_dir: None,
             incremental: false,
+            iteration_count: None,
             known_bug: false,
             pass_mode: None,
             fail_mode: None,
@@ -540,6 +545,16 @@ impl TestProps {
                         &mut self.stderr_per_bitwidth,
                     );
                     config.set_name_directive(ln, INCREMENTAL, &mut self.incremental);
+                    config.set_name_value_directive(
+                        ln,
+                        ITERATION_COUNT,
+                        &mut self.iteration_count,
+                        |s| {
+                            s.trim()
+                                .parse()
+                                .expect("The value of iteration-count must be a positive integer.")
+                        },
+                    );
 
                     // Unlike the other `name_value_directive`s this needs to be handled manually,
                     // because it sets a `bool` flag.
@@ -892,6 +907,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-x86_64-pc-windows-gnu",
     "ignore-x86_64-unknown-linux-gnu",
     "incremental",
+    "iteration-count",
     "known-bug",
     "llvm-cov-flags",
     "max-llvm-major-version",

src/tools/compiletest/src/runtest.rs

@@ -41,6 +41,7 @@ mod debuginfo;
 mod incremental;
 mod js_doc;
 mod mir_opt;
+mod parallel;
 mod pretty;
 mod run_make;
 mod rustdoc;
@@ -272,6 +273,7 @@ impl<'test> TestCx<'test> {
             TestMode::CoverageMap => self.run_coverage_map_test(), // see self::coverage
             TestMode::CoverageRun => self.run_coverage_run_test(), // see self::coverage
             TestMode::Crashes => self.run_crash_test(),
+            TestMode::Parallel => self.run_parallel_test(),
         }
     }
 
@@ -1518,8 +1520,10 @@ impl<'test> TestCx<'test> {
         };
         rustc.arg(input_file);
 
-        // Use a single thread for efficiency and a deterministic error message order
-        rustc.arg("-Zthreads=1");
+        if self.config.mode != TestMode::Parallel {
+            // Use a single thread for efficiency and a deterministic error message order
+            rustc.arg("-Zthreads=1");
+        }
 
         // Hide libstd sources from ui tests to make sure we generate the stderr
         // output that users will see.
@@ -1705,7 +1709,8 @@ impl<'test> TestCx<'test> {
             | TestMode::Rustdoc
             | TestMode::RustdocJson
             | TestMode::RunMake
-            | TestMode::RustdocJs => {
+            | TestMode::RustdocJs
+            | TestMode::Parallel => {
                 // do not use JSON output
             }
         }

src/tools/compiletest/src/runtest/parallel.rs

@@ -0,0 +1,16 @@
+use crate::runtest::{TestCx, WillExecute};
+
+impl TestCx<'_> {
+    pub(super) fn run_parallel_test(&self) {
+        let pm = self.pass_mode();
+        let emit_metadata = self.should_emit_metadata(pm);
+
+        // Repeated testing due to instability in multithreaded environments.
+        let iteration_count = self.props.iteration_count.unwrap_or(50);
+        for _ in 0..iteration_count {
+            let proc_res = self.compile_test(WillExecute::No, emit_metadata);
+            // Ensure there is no ICE during parallel complication.
+            self.check_no_compiler_crash(&proc_res, false);
+        }
+    }
+}

src/tools/opt-dist/src/tests.rs

@@ -105,6 +105,7 @@ llvm-config = "{llvm_config}"
             "tests/codegen-units",
             "tests/incremental",
             "tests/mir-opt",
+            "tests/parallel",
             "tests/pretty",
             // Make sure that we don't use too new GLIBC symbols on x64
             "tests/run-make/glibc-symbols-x86_64-unknown-linux-gnu",

tests/parallel/SUMMARY.md

@@ -0,0 +1,8 @@
+This directory contains the robustness test for prallel front end, which means deadlocks
+and other ice bugs. In other words, we don't care whether the compiler output in these tests,
+but whether they can compile normally without deadlock or other ice bugs.
+
+So when a test in this directory fails, please pay attention to whether it causes any ice problems.
+If so(it should do), please post your comments in the issue corresponding to each test (or create a new issue
+with the `wg-parallel-rustc` label). Even if it is an existing issue, please add a new comment,
+which will help us determine the reproducibility of the bug.

tests/parallel/cache-after-waiting-issue-111528.rs

@@ -0,0 +1,14 @@
+// Test for #111528, the ice issue cause waiting on a query that panicked
+//
+//@ compile-flags: -Z threads=16
+
+#![crate_type = "rlib"]
+#![allow(warnings)]
+
+#[export_name = "fail"]
+pub fn a() {}
+
+#[export_name = "fail"]
+pub fn b() {}
+
+fn main() {}