perf(testing): share tokio runtime across fixture tests (#8567)

Boshen · Boshen · commit 4732a1628af1 · 2026-03-07T02:48:35.000Z
## Summary Each of the ~1,682 fixture tests creates a new `tokio::runtime::Runtime` via `Runtime::new().unwrap().block_on(...)`. This replaces that with a shared static runtime using `OnceLock<Runtime>`, eliminating repeated thread pool creation/teardown overhead. ## Results (`cargo test --workspace --exclude rolldown_binding`) | | Wall clock | User CPU | System CPU | |---|---|---|---| | **Baseline** (per-test runtime) | 33.5s | 133.5s | 65.2s | | **Shared runtime** | 25.3s | 116.1s | 43.0s | | **Improvement** | **-8.2s (24%)** | -17.4s | -22.2s | The shared runtime saves ~8 seconds (24% faster) wall-clock time, with a notable reduction in system CPU time (65s → 43s) from eliminating repeated thread pool creation/teardown. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
diff --git a/crates/rolldown_dev/src/dev_engine.rs b/crates/rolldown_dev/src/dev_engine.rs
@@ -362,9 +362,14 @@ impl DevEngine {
       .map_err_to_unhandleable()
       .context("DevEngine: failed to send Close message to coordinator - coordinator may have already terminated")?;
 
-    // Close the bundler (calls `closeBundle` plugin hook)
-    let mut bundler = self.bundler.lock().await;
-    bundler.close().await?;
+    // Close the bundler (calls `closeBundle` plugin hook).
+    // The bundler lock MUST be released before waiting for the coordinator below.
+    // Otherwise we'd deadlock: the coordinator's Close handler waits for any running
+    // bundling task to finish, and that task may need to acquire the bundler lock.
+    {
+      let mut bundler = self.bundler.lock().await;
+      bundler.close().await?;
+    }
 
     // Wait for coordinator to close (coordinator handles watcher cleanup)
     let coordinator_state = self.coordinator_state.lock().await;
diff --git a/crates/rolldown_testing/src/fixture.rs b/crates/rolldown_testing/src/fixture.rs
@@ -16,6 +16,12 @@ pub struct Fixture {
   fixture_path: PathBuf,
 }
 
+static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
+
+fn shared_runtime() -> &'static tokio::runtime::Runtime {
+  RUNTIME.get_or_init(|| tokio::runtime::Runtime::new().unwrap())
+}
+
 // Using std once lock to store env variable
 static NEEDS_EXTENDED_TESTS: OnceLock<bool> = OnceLock::new();
 /// A function to get the API key.
@@ -36,11 +42,11 @@ impl Fixture {
   }
 
   pub fn run_integration_test(self) {
-    tokio::runtime::Runtime::new().unwrap().block_on(self.run_inner(vec![]));
+    shared_runtime().block_on(self.run_inner(vec![]));
   }
 
   pub fn run_integration_test_with_plugins(self, plugins: Vec<SharedPluginable>) {
-    tokio::runtime::Runtime::new().unwrap().block_on(self.run_inner(plugins));
+    shared_runtime().block_on(self.run_inner(plugins));
   }
 
   async fn run_inner(self, plugins: Vec<SharedPluginable>) {
diff --git a/crates/rolldown_testing/src/integration_test.rs b/crates/rolldown_testing/src/integration_test.rs
@@ -363,7 +363,14 @@ impl IntegrationTest {
 
       build_snapshot.initial_output = Some(initial_build_output);
       artifacts_snapshot.builds.push(build_snapshot);
-      drop(dev_engine);
+      // Explicitly close the dev engine to shut down the background coordinator task.
+      // Without this, the coordinator task would persist across tests under the shared runtime.
+      if let Err(err) = dev_engine.close().await {
+        panic!(
+          "Failed to close dev_engine for integration test in `{}` (title: `{debug_title}`): {err:#?}",
+          test_folder_path.display()
+        );
+      }
     }
 
     artifacts_snapshot

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,12 @@ pub struct Fixture {`
`16`	`16`	`fixture_path: PathBuf,`
`17`	`17`	`}`
`18`	`18`
	`19`	`+static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();`
	`20`	`+`
	`21`	`+fn shared_runtime() -> &'static tokio::runtime::Runtime {`
	`22`	`+ RUNTIME.get_or_init(\|\| tokio::runtime::Runtime::new().unwrap())`
	`23`	`+}`
	`24`	`+`
`19`	`25`	`// Using std once lock to store env variable`
`20`	`26`	`static NEEDS_EXTENDED_TESTS: OnceLock<bool> = OnceLock::new();`
`21`	`27`	`/// A function to get the API key.`
`@@ -36,11 +42,11 @@ impl Fixture {`
`36`	`42`	`}`
`37`	`43`
`38`	`44`	`pub fn run_integration_test(self) {`
`39`		`- tokio::runtime::Runtime::new().unwrap().block_on(self.run_inner(vec![]));`
	`45`	`+ shared_runtime().block_on(self.run_inner(vec![]));`
`40`	`46`	`}`
`41`	`47`
`42`	`48`	`pub fn run_integration_test_with_plugins(self, plugins: Vec<SharedPluginable>) {`
`43`		`- tokio::runtime::Runtime::new().unwrap().block_on(self.run_inner(plugins));`
	`49`	`+ shared_runtime().block_on(self.run_inner(plugins));`
`44`	`50`	`}`
`45`	`51`
`46`	`52`	`async fn run_inner(self, plugins: Vec<SharedPluginable>) {`