extract provider and chain_id, add reporting table

Cargo.toml

@@ -172,6 +172,7 @@ tracing-subscriber = { version = "0.3", features = [
   "registry",
 ] }
 tracing-appender = "0.2.3"
+text-tables = "0.3.1"
 url = { version = "2.4.1", features = ["serde"] }
 zeroize = "1.6"
 

fendermint/testing/materializer/Cargo.toml

@@ -29,6 +29,7 @@ tendermint-rpc = { workspace = true }
 tokio = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
+text-tables = { workspace = true }
 url = { workspace = true }
 
 arbitrary = { workspace = true, optional = true }

fendermint/testing/materializer/src/concurrency/reporting.rs

@@ -5,7 +5,8 @@ use crate::bencher::Bencher;
 use crate::concurrency::config;
 use crate::concurrency::config::ExecutionStep;
 use anyhow::anyhow;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
+use std::io;
 use std::time::Duration;
 
 #[derive(Debug)]
@@ -89,4 +90,38 @@ impl ExecutionSummary {
         }
         errs
     }
+
+    pub fn print(&self) {
+        let mut data = vec![];
+
+        let latencies: HashSet<String> = self
+            .summaries
+            .iter()
+            .flat_map(|summary| summary.avg_latencies.keys().cloned())
+            .collect();
+
+        let mut header = vec!["max_concurrency".to_string(), "duration".to_string()];
+        header.extend(latencies.iter().map(|key| format!("{} latency (ms)", key)));
+        data.push(header);
+
+        for summary in self.summaries.iter() {
+            let mut row = vec![];
+            row.push(summary.cfg.max_concurrency.to_string());
+            row.push(summary.cfg.duration.as_secs().to_string());
+
+            for key in &latencies {
+                let latency = summary
+                    .avg_latencies
+                    .get(key)
+                    .map_or(String::from("-"), |duration| {
+                        duration.as_millis().to_string()
+                    });
+                row.push(latency);
+            }
+
+            data.push(row);
+        }
+
+        text_tables::render(&mut io::stdout(), data).unwrap();
+    }
 }

fendermint/testing/materializer/tests/docker_tests/benches.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 
 use crate::make_testnet;
 use anyhow::{bail, Context};
+use ethers::types::U256;
 use ethers::{
     core::k256::ecdsa::SigningKey,
     middleware::SignerMiddleware,
@@ -31,15 +32,11 @@ pub type TestMiddleware<C> = SignerMiddleware<Provider<C>, Wallet<SigningKey>>;
 async fn make_middleware<C>(
     provider: Provider<C>,
     sender: &DefaultAccount,
+    chain_id: U256,
 ) -> anyhow::Result<TestMiddleware<C>>
 where
     C: JsonRpcClient,
 {
-    let chain_id = provider
-        .get_chainid()
-        .await
-        .context("failed to get chain ID")?;
-
     let wallet: Wallet<SigningKey> = Wallet::from_bytes(sender.secret_key().serialize().as_ref())?
         .with_chain_id(chain_id.as_u64());
 
@@ -51,32 +48,37 @@ where
 async fn test_concurrent_transfer() -> Result<(), anyhow::Error> {
     let (testnet, cleanup) = make_testnet(MANIFEST, |_| {}).await?;
 
+    let pangea = testnet.node(&testnet.root().node("pangea"))?;
+    let provider = pangea
+        .ethapi_http_provider()?
+        .expect("ethapi should be enabled");
+    let chain_id = provider
+        .get_chainid()
+        .await
+        .context("failed to get chain ID")?;
+
     // Drive concurrency.
     let cfg = Execution::new()
         .add_step(10, 5)
         .add_step(100, 5)
-        .add_step(200, 5);
+        .add_step(150, 5);
     let testnet = Arc::new(testnet);
     let testnet_clone = testnet.clone();
     let nonce_manager = Arc::new(NonceManager::new());
+
     let results = concurrency::execute(cfg.clone(), move |test_id: usize, mut bencher: Bencher| {
         let testnet = testnet_clone.clone();
         let nonce_manager = nonce_manager.clone();
+        let provider = provider.clone();
 
         let test = async move {
             let sender = testnet.account_mod_nth(test_id);
             let recipient = testnet.account_mod_nth(test_id + 1);
             println!("running (test_id={})", test_id);
 
-            let pangea = testnet.node(&testnet.root().node("pangea"))?;
-            let provider = pangea
-                .ethapi_http_provider()?
-                .expect("ethapi should be enabled");
-
-            let middleware = make_middleware(provider, sender)
+            let middleware = make_middleware(provider, sender, chain_id)
                 .await
                 .context("failed to set up middleware")?;
-            println!("middleware ready, pending tests (test_id={})", test_id);
 
             let sender: H160 = sender.eth_addr().into();
             let nonce = nonce_manager.get_and_increment(sender).await;
@@ -126,12 +128,12 @@ async fn test_concurrent_transfer() -> Result<(), anyhow::Error> {
     .await;
 
     let summary = concurrency::ExecutionSummary::new(cfg.clone(), results);
-    println!("{:?}", summary);
+    summary.print();
 
+    let res = summary.to_result();
     let Ok(testnet) = Arc::try_unwrap(testnet) else {
         bail!("Arc::try_unwrap(testnet)");
     };
-    let res = summary.to_result();
     cleanup(res.is_err(), testnet).await;
     res
 }