perf: spawn tokio runtime once (#5263)

* perf: spawn tokio runtime once

* ci

* ci: fix deny workflow

* fix: use multi-thread runtime for running tests

Author: DaniPopes

.github/workflows/deny.yml

@@ -1,3 +1,5 @@
+name: deny
+
 on:
     push:
         branches: [master]
@@ -18,3 +20,6 @@ jobs:
             - uses: EmbarkStudios/cargo-deny-action@v1
               with:
                   command: check all
+                  # Clear out arguments to not pass `--all-features` to `cargo deny`.
+                  # `foundry-cli` has an `openssl` feature which enables banned dependencies
+                  arguments: ""

.github/workflows/test.yml

@@ -85,7 +85,7 @@ jobs:
                   cargo nextest run --retries 3 --archive-file nextest-unit.tar.zst -E '${{ matrix.job.filter }}'
 
     issue-repros-tests:
-        name: issue reproduction tests / ${{ matrix.job.name }}
+        name: issue reproduction tests / ${{ matrix.job.name }} / ${{ matrix.job.partition }}
         runs-on: ubuntu-latest
         needs: build-tests
         strategy:

Cargo.lock

@@ -295,7 +295,7 @@ async fn rejects_different_chain_id() {
     assert!(err.to_string().contains("signed for another chain"));
 }
 
-#[tokio::test]
+#[tokio::test(flavor = "multi_thread")]
 async fn rejects_invalid_chain_id() {
     let (_api, handle) = spawn(NodeConfig::test()).await;
     let wallet = handle.dev_wallets().next().unwrap().with_chain_id(99u64);

anvil/tests/it/sign.rs

@@ -319,7 +319,7 @@ mod tests {
             }
         }
     }
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn builder_new_non_legacy() -> eyre::Result<()> {
         let provider = MyProvider {};
         let builder =
@@ -338,7 +338,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn builder_new_legacy() -> eyre::Result<()> {
         let provider = MyProvider {};
         let builder =
@@ -354,7 +354,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn builder_fields() -> eyre::Result<()> {
         let provider = MyProvider {};
         let mut builder =
@@ -376,7 +376,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn builder_args() -> eyre::Result<()> {
         let provider = MyProvider {};
         let mut builder =

cast/src/tx.rs

@@ -239,13 +239,17 @@ impl SessionSource {
         let env = self.config.evm_opts.evm_env().await;
 
         // Create an in-memory backend
-        let backend = self.config.backend.take().unwrap_or_else(|| {
-            let backend = Backend::spawn(
-                self.config.evm_opts.get_fork(&self.config.foundry_config, env.clone()),
-            );
-            self.config.backend = Some(backend.clone());
-            backend
-        });
+        let backend = match self.config.backend.take() {
+            Some(backend) => backend,
+            None => {
+                let backend = Backend::spawn(
+                    self.config.evm_opts.get_fork(&self.config.foundry_config, env.clone()),
+                )
+                .await;
+                self.config.backend = Some(backend.clone());
+                backend
+            }
+        };
 
         // Build a new executor
         let executor = ExecutorBuilder::default()

chisel/src/executor.rs

@@ -98,7 +98,7 @@ impl RunArgs {
         // can safely disable base fee checks on replaying txs because can
         // assume those checks already passed on confirmed txs
         env.cfg.disable_base_fee = true;
-        let db = Backend::spawn(evm_opts.get_fork(&config, env.clone()));
+        let db = Backend::spawn(evm_opts.get_fork(&config, env.clone())).await;
 
         // configures a bare version of the evm executor: no cheatcode inspector is enabled,
         // tracing will be enabled only for the targeted transaction

cli/src/cmd/cast/run.rs

@@ -2,7 +2,7 @@
 use crate::{
     cmd::{
         forge::{build::CoreBuildArgs, install, test::FilterArgs},
-        Cmd, LoadConfig,
+        LoadConfig,
     },
     utils::{p_println, STATIC_FUZZ_SEED},
 };
@@ -31,7 +31,7 @@ use foundry_common::{compile::ProjectCompiler, evm::EvmArgs, fs};
 use foundry_config::Config;
 use foundry_evm::utils::evm_spec;
 use semver::Version;
-use std::{collections::HashMap, sync::mpsc::channel, thread};
+use std::{collections::HashMap, sync::mpsc::channel};
 use tracing::trace;
 
 // Loads project's figment and merges the build cli arguments into it
@@ -61,12 +61,8 @@ impl CoverageArgs {
     pub fn build_args(&self) -> &CoreBuildArgs {
         &self.opts
     }
-}
-
-impl Cmd for CoverageArgs {
-    type Output = ();
 
-    fn run(self) -> eyre::Result<Self::Output> {
+    pub async fn run(self) -> eyre::Result<()> {
         let (mut config, evm_opts) = self.load_config_and_evm_opts_emit_warnings()?;
 
         // install missing dependencies
@@ -85,7 +81,7 @@ impl Cmd for CoverageArgs {
         let report = self.prepare(&config, output.clone())?;
 
         p_println!(!self.opts.silent => "Running tests...");
-        self.collect(project, output, report, config, evm_opts)
+        self.collect(project, output, report, config, evm_opts).await
     }
 }
 
@@ -255,7 +251,7 @@ impl CoverageArgs {
     }
 
     /// Runs tests, collects coverage data and generates the final report.
-    fn collect(
+    async fn collect(
         self,
         project: Project,
         output: ProjectCompileOutput,
@@ -267,7 +263,7 @@ impl CoverageArgs {
 
         // Build the contract runner
         let evm_spec = evm_spec(&config.evm_version);
-        let env = evm_opts.evm_env_blocking()?;
+        let env = evm_opts.evm_env().await;
         let mut runner = MultiContractRunnerBuilder::default()
             .initial_balance(evm_opts.initial_balance)
             .evm_spec(evm_spec)
@@ -280,8 +276,12 @@ impl CoverageArgs {
 
         // Run tests
         let known_contracts = runner.known_contracts.clone();
+        let filter = self.filter;
         let (tx, rx) = channel::<(String, SuiteResult)>();
-        let handle = thread::spawn(move || runner.test(&self.filter, Some(tx), Default::default()));
+        let handle =
+            tokio::task::spawn(
+                async move { runner.test(filter, Some(tx), Default::default()).await },
+            );
 
         // Add hit data to the coverage report
         for (artifact_id, hits) in rx
@@ -313,7 +313,7 @@ impl CoverageArgs {
         }
 
         // Reattach the thread
-        let _ = handle.join();
+        let _ = handle.await;
 
         // Output final report
         for report_kind in self.report {

cli/src/cmd/forge/coverage.rs

@@ -291,7 +291,8 @@ impl ScriptArgs {
                 None => {
                     let backend = Backend::spawn(
                         script_config.evm_opts.get_fork(&script_config.config, env.clone()),
-                    );
+                    )
+                    .await;
                     script_config.backends.insert(url.clone(), backend);
                     script_config.backends.get(url).unwrap().clone()
                 }
@@ -301,6 +302,7 @@ impl ScriptArgs {
                 // no need to cache it, since there won't be any onchain simulation that we'd need
                 // to cache the backend for.
                 Backend::spawn(script_config.evm_opts.get_fork(&script_config.config, env.clone()))
+                    .await
             }
         };
 

cli/src/cmd/forge/script/executor.rs

@@ -1,12 +1,9 @@
 //! Snapshot command
 use crate::{
-    cmd::{
-        forge::{
-            build::CoreBuildArgs,
-            test,
-            test::{Test, TestOutcome},
-        },
-        Cmd,
+    cmd::forge::{
+        build::CoreBuildArgs,
+        test,
+        test::{Test, TestOutcome},
     },
     utils::STATIC_FUZZ_SEED,
 };
@@ -107,16 +104,12 @@ impl SnapshotArgs {
     pub fn build_args(&self) -> &CoreBuildArgs {
         self.test.build_args()
     }
-}
-
-impl Cmd for SnapshotArgs {
-    type Output = ();
 
-    fn run(mut self) -> eyre::Result<()> {
+    pub async fn run(mut self) -> eyre::Result<()> {
         // Set fuzz seed so gas snapshots are deterministic
         self.test.fuzz_seed = Some(U256::from_big_endian(&STATIC_FUZZ_SEED));
 
-        let outcome = self.test.execute_tests()?;
+        let outcome = self.test.execute_tests().await?;
         outcome.ensure_ok()?;
         let tests = self.config.apply(outcome);