perf(test): 并行跑测试 + 全绿时不再逐个复驱动 —— 热跑 5.3s → 2.15s

接着上一条(189.7s → 5.3s)。剩下的 5.3s 是 build 3.35s + run 1.84s,两边各修一处。

**1. 全绿时不必逐个复驱动后端(3.35s → 1.85s)**

Phase B 先做一次 `-k 0` 的批量构建,然后每个测试再单独驱动一次后端 —— 注释说
"成功的是缓存命中,近似 no-op"。修完 rule E 之后它确实"近似"了,但仍是每次 ~39ms
(重发 build.ninja、重写 compile_commands.json、spawn ninja、复核运行期闭包),
83 次就是 3.2s,而且问的是批量构建刚刚已经一次性回答过的问题。

`-k 0` 的退出码当且仅当所有目标都构建成功时为 0 —— 正是那个循环在重新推导的信息。
于是:批量成功 ⇒ 跳过复驱动;批量失败 ⇒ 循环照旧,每个失败仍然归属到自己的测试。
按"故意编坏一个测试"验证过:只有它 FAIL,诊断就在它那一行下面。

**2. 并行跑测试(1.84s → 0.08s)**

原来没有并行执行能力 —— 这是用户问的那一点。但要先说清楚:**它从来不是慢的原因**,
83 个测试的运行阶段总共只有 1.8s / 190s。修完构建侧之后它才变成剩余时间的一半,
这时候才值得做。

- 多于一个测试时**捕获**输出,测试结束时整块打印。直接流式输出 N 个测试会逐行交错,
  那不只是难看 —— 失败的断言会变得无法归属,而归属正是这个循环存在的理由。
- **只有一个测试时保持前台流式**。那是调试场景:一个长测试的实时进度比省下的
  ~0ms 更值钱,而捕获会把输出一直压到测试结束 —— 包括它挂住的时候,恰恰是最需要
  看到输出的时候。
- 汇总时间取**整个阶段的墙钟**而不是各测试耗时之和:并发下后者会超过命令总时长。

并发度走 `resolve_jobs`(`--jobs` / `[build] jobs` / 机器),和构建同一个答案。

热跑 3 次:2.14 / 2.17 / 2.15s。合计 **189.74s → 2.15s(88×)**。
e2e 15/16/17/152/153/154/155/158/159/160/178 全过。

Author: speak-agent

src/build/execute.cppm

@@ -30,6 +30,7 @@ import mcpp.platform.runtime_binding;
 import mcpp.log;
 import mcpp.platform;
 import mcpp.platform.capacity;
+import mcpp.build.schedule.policy;   // resolve_jobs — one answer to "how many at once"
 import mcpp.fetcher.progress;
 import mcpp.project;
 import mcpp.ui;
@@ -1331,9 +1332,21 @@ export int run_tests(std::span<const std::string> passthrough,
     // 6. Phase B. First a single keep-going bulk build over every selected
     //    test goal — ninja parallelizes across tests and a failing test does
     //    not stop the rest (-k 0). The result is deliberately ignored: the
-    //    per-test loop below re-drives each goal, where successes are cache
-    //    hits (near no-ops) and failures re-fail fast, yielding cleanly
-    //    attributed per-test diagnostics without sacrificing parallelism.
+    //    per-test loop below re-drives each goal so a failure is attributed to
+    //    exactly one test.
+    //
+    //    ...but ONLY when this bulk build failed. A re-drive was assumed to be
+    //    a near no-op, and it is not: a drive re-emits build.ninja, rewrites
+    //    compile_commands.json, spawns ninja and re-validates the runtime
+    //    closure. Measured on the 83-test suite AFTER the rule E fix, that is
+    //    still ~39ms x 83 = 3.2s of a 5.3s hot run — spent re-asking a question
+    //    the bulk build just answered for every test at once.
+    //
+    //    `-k 0` means the bulk exit code is 0 IFF every selected goal built, so
+    //    it carries exactly the information the loop was re-deriving. When it
+    //    is non-zero the loop runs as before and each failure still names its
+    //    own test.
+    bool bulkBuiltEverything = false;
     {
         mcpp::build::BuildOptions bulk;
         bulk.keepGoing = true;
@@ -1343,7 +1356,7 @@ export int run_tests(std::span<const std::string> passthrough,
                 bulk.ninjaTargets.push_back(lu.output.generic_string());
         if (!bulk.ninjaTargets.empty()) {
             auto tBulk = std::chrono::steady_clock::now();
-            (void)backend->build(ctx->plan, bulk);
+            bulkBuiltEverything = backend->build(ctx->plan, bulk).has_value();
             summary.buildMs += std::chrono::duration_cast<std::chrono::milliseconds>(
                 std::chrono::steady_clock::now() - tBulk).count();
         }
@@ -1374,6 +1387,117 @@ export int run_tests(std::span<const std::string> passthrough,
         }
     }
 
+    // How many test binaries run at once.
+    //
+    // The tests themselves were never the slow part — MEASURED on the 83-test
+    // suite, the whole run phase is 1.8s against a 190s total — so this is the
+    // tail, not the fix. It is still worth having: after the build-side work
+    // (rule E, the per-test re-drive) the run phase is HALF of what is left.
+    //
+    // ONE test runs in the foreground, unbuffered. That is the debugging case:
+    // a single long test streaming its progress is worth more than the ~0ms
+    // concurrency would save on it, and capturing would hold that output back
+    // until the test ended — including when it hangs, which is exactly when a
+    // reader needs it.
+    const int runJobs = [&] {
+        int j = mcpp::build::schedule::resolve_jobs(ctx->manifest);
+        if (j <= 0) j = static_cast<int>(std::thread::hardware_concurrency());
+        return j > 0 ? j : 1;
+    }();
+
+    struct Runnable {
+        std::string name;
+        std::vector<std::string> argv;
+        std::vector<std::pair<std::string, std::string>> env;
+        std::chrono::steady_clock::time_point started;
+    };
+    std::vector<Runnable> runnable;
+
+    // Executes `list`, appending to `results` and emitting the per-test line.
+    //
+    // Output is CAPTURED whenever more than one test runs, and printed as one
+    // contiguous block when that test finishes. Streaming N tests straight to
+    // the terminal interleaves them line by line, which does not just look
+    // untidy — it makes a failing assertion unattributable, and the whole
+    // reason the per-test loop exists is attribution.
+    auto run_tests_now = [&](std::vector<Runnable>& list) {
+        if (list.empty()) return;
+        const bool capture = json || list.size() > 1;
+        const auto deadline = std::chrono::milliseconds(
+            static_cast<long long>(testOpts.timeoutSecs) * 1000);
+        const int workers = capture
+            ? std::min<int>(runJobs, static_cast<int>(list.size())) : 1;
+
+        auto tRunPhase = std::chrono::steady_clock::now();
+        std::atomic<std::size_t> next{0};
+        std::mutex reportMutex;
+
+        auto worker = [&] {
+            for (;;) {
+                std::size_t i = next.fetch_add(1);
+                if (i >= list.size()) return;
+                auto& r = list[i];
+
+                bool timedOut = false;
+                int exitCode = 0;
+                std::string runOutput;
+                if (capture) {
+                    auto rr = mcpp::platform::process::capture_exec_deadline(
+                        r.argv, r.env, deadline, &timedOut);
+                    exitCode  = rr.exit_code;
+                    runOutput = std::move(rr.output);
+                } else {
+                    mcpp::ui::status("Running", std::format("bin/{}", r.name));
+                    exitCode = mcpp::platform::process::run_exec_deadline(
+                        r.argv, r.env, deadline, &timedOut);
+                }
+                auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                    std::chrono::steady_clock::now() - r.started).count();
+
+                std::scoped_lock lock(reportMutex);
+                if (timedOut) {
+                    if (!json) mcpp::ui::plain(std::format(
+                        "{} ... FAIL (timeout after {}s)", r.name, testOpts.timeoutSecs));
+                    results.push_back({r.name, TestResult::St::RunFail, exitCode, {},
+                                       runOutput, ms, true});
+                } else if (exitCode == 0) {
+                    if (!json) mcpp::ui::plain(std::format(
+                        "{} ... ok ({:.2f}s)", r.name, static_cast<double>(ms) / 1000.0));
+                    results.push_back({r.name, TestResult::St::Pass, 0, {},
+                                       runOutput, ms});
+                } else {
+                    if (!json) mcpp::ui::plain(std::format(
+                        "{} ... FAIL (exit {}, {:.2f}s)", r.name, exitCode,
+                        static_cast<double>(ms) / 1000.0));
+                    results.push_back({r.name, TestResult::St::RunFail, exitCode, {},
+                                       runOutput, ms});
+                }
+                // The captured output belongs directly under its own line, or
+                // it is attributable to nothing.
+                if (!json && capture && !runOutput.empty()) {
+                    std::fputs(runOutput.c_str(), stdout);
+                    if (runOutput.back() != '\n') std::fputc('\n', stdout);
+                }
+                std::fflush(stdout);
+                emit_json(results.back());
+            }
+        };
+
+        if (workers <= 1) {
+            worker();
+        } else {
+            std::vector<std::thread> pool;
+            pool.reserve(static_cast<std::size_t>(workers));
+            for (int w = 0; w < workers; ++w) pool.emplace_back(worker);
+            for (auto& t : pool) t.join();
+        }
+        // WALL time of the phase, not the sum of the per-test durations: with
+        // N running at once that sum exceeds the elapsed time and the summary
+        // would report a run phase longer than the whole command.
+        summary.runMs += std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - tRunPhase).count();
+    };
+
     for (auto& lu : ctx->plan.linkUnits) {
         if (!filter_match(lu)) continue;
 
@@ -1385,13 +1509,16 @@ export int run_tests(std::span<const std::string> passthrough,
 
         mcpp::ui::status("Compiling", std::format("{} (test)", lu.targetName));
 
-        mcpp::build::BuildOptions bOpts;
-        bOpts.ninjaTargets = {lu.output.generic_string()};
-        bOpts.buildTimeoutSecs = static_cast<unsigned>(testOpts.buildTimeoutSecs);
-        auto tBuild = std::chrono::steady_clock::now();
-        auto b = backend->build(ctx->plan, bOpts);
-        summary.buildMs += std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - tBuild).count();
+        std::expected<mcpp::build::BuildResult, mcpp::build::BuildError> b{};
+        if (!bulkBuiltEverything) {
+            mcpp::build::BuildOptions bOpts;
+            bOpts.ninjaTargets = {lu.output.generic_string()};
+            bOpts.buildTimeoutSecs = static_cast<unsigned>(testOpts.buildTimeoutSecs);
+            auto tBuild = std::chrono::steady_clock::now();
+            b = backend->build(ctx->plan, bOpts);
+            summary.buildMs += std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - tBuild).count();
+        }
         if (!b) {
             if (!json) {
                 // The test's own diagnostics, right under its FAIL line — a
@@ -1418,7 +1545,6 @@ export int run_tests(std::span<const std::string> passthrough,
         }
 
         auto exe = ctx->outputDir / lu.output;
-        mcpp::ui::status("Running", std::format("bin/{}", lu.targetName));
 
         std::vector<std::string> argv;
         argv.push_back(exe.string());
@@ -1448,45 +1574,13 @@ export int run_tests(std::span<const std::string> passthrough,
             }
         }
 
-        // JSON mode captures the test's combined stdout+stderr into the
-        // record; human mode streams it to the terminal as before.
-        auto deadline = std::chrono::milliseconds(
-            static_cast<long long>(testOpts.timeoutSecs) * 1000);
-        bool timedOut = false;
-        int exitCode;
-        std::string runOutput;
-        auto tRun = std::chrono::steady_clock::now();
-        if (json) {
-            auto rr = mcpp::platform::process::capture_exec_deadline(
-                argv, childEnv, deadline, &timedOut);
-            exitCode  = rr.exit_code;
-            runOutput = std::move(rr.output);
-        } else {
-            exitCode = mcpp::platform::process::run_exec_deadline(
-                argv, childEnv, deadline, &timedOut);
-        }
-        summary.runMs += std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - tRun).count();
-
-        if (timedOut) {
-            if (!json) mcpp::ui::plain(std::format("{} ... FAIL (timeout after {}s)",
-                                                   lu.targetName, testOpts.timeoutSecs));
-            results.push_back({lu.targetName, TestResult::St::RunFail, exitCode, {},
-                               std::move(runOutput), test_ms(), true});
-        } else if (exitCode == 0) {
-            if (!json) mcpp::ui::plain(std::format("{} ... ok ({:.2f}s)", lu.targetName,
-                                                   static_cast<double>(test_ms()) / 1000.0));
-            results.push_back({lu.targetName, TestResult::St::Pass, 0, {},
-                               std::move(runOutput), test_ms()});
-        } else {
-            if (!json) mcpp::ui::plain(std::format("{} ... FAIL (exit {}, {:.2f}s)",
-                                                   lu.targetName, exitCode,
-                                                   static_cast<double>(test_ms()) / 1000.0));
-            results.push_back({lu.targetName, TestResult::St::RunFail, exitCode, {},
-                               std::move(runOutput), test_ms()});
-        }
-        emit_json(results.back());
+        runnable.push_back({lu.targetName, std::move(argv), std::move(childEnv),
+                            tTest});
     }
+
+    // Pass 2: run them. Concurrently unless there is exactly one — see
+    // `runJobs` for why the single-test case is deliberately different.
+    run_tests_now(runnable);
     summary.elapsedMs = member_ms();
 
     // 7. Summary.