[WIP] subsystem-bench: Add real networking stack

polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs

@@ -24,27 +24,29 @@ use polkadot_subsystem_bench::{
 	usage::BenchmarkUsage,
 	utils::save_to_file,
 };
-use std::io::Write;
+use std::{io::Write, sync::Arc};
 
 const BENCH_COUNT: usize = 50;
 
 fn main() -> Result<(), String> {
+	sp_tracing::try_init_simple();
 	let mut messages = vec![];
 	let mut config = TestConfiguration::default();
-	config.n_cores = 100;
-	config.n_validators = 500;
+	config.n_cores = 2;
+	config.n_validators = 10;
 	config.num_blocks = 10;
 	config.connectivity = 100;
 	config.generate_pov_sizes();
-	let state = TestState::new(&config);
+	let state = Arc::new(TestState::new(&config));
 
 	println!("Benchmarking...");
 	let usages: Vec<BenchmarkUsage> = (0..BENCH_COUNT)
 		.map(|n| {
 			print!("\r[{}{}]", "#".repeat(n), "_".repeat(BENCH_COUNT - n));
 			std::io::stdout().flush().unwrap();
-			let (mut env, _cfgs) = prepare_test(&state, false);
-			env.runtime().block_on(benchmark_statement_distribution(&mut env, &state))
+			let (mut env, _cfgs) = prepare_test(Arc::clone(&state), false);
+			env.runtime()
+				.block_on(benchmark_statement_distribution(&mut env, Arc::clone(&state)))
 		})
 		.collect();
 	println!("\rDone!{}", " ".repeat(BENCH_COUNT));

polkadot/node/subsystem-bench/Cargo.toml

@@ -96,6 +96,11 @@ pyroscope = { workspace = true }
 pyroscope_pprofrs = { workspace = true }
 strum = { features = ["derive"], workspace = true, default-features = true }
 
+parking_lot = { workspace = true, default-features = true }
+polkadot-network-bridge = { workspace = true, default-features = true }
+sc-network-common = { workspace = true, default-features = true }
+array-bytes = { workspace = true, default-features = true }
+
 [features]
 default = []
 memprofile = [

polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs

@@ -24,7 +24,7 @@ use polkadot_subsystem_bench::{approval, availability, configuration, statement}
 use pyroscope::PyroscopeAgent;
 use pyroscope_pprofrs::{pprof_backend, PprofConfig};
 use serde::{Deserialize, Serialize};
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
 mod valgrind;
 
@@ -164,10 +164,11 @@ impl BenchCli {
 					env.runtime().block_on(approval::bench_approvals(&mut env, state))
 				},
 				TestObjective::StatementDistribution => {
-					let state = statement::TestState::new(&test_config);
-					let (mut env, _protocol_config) = statement::prepare_test(&state, true);
+					let state = Arc::new(statement::TestState::new(&test_config));
+					let (mut env, _protocol_config) =
+						statement::prepare_test(Arc::clone(&state), true);
 					env.runtime()
-						.block_on(statement::benchmark_statement_distribution(&mut env, &state))
+						.block_on(statement::benchmark_statement_distribution(&mut env, state))
 				},
 			};
 			println!("\n{}\n{}", benchmark_name.purple(), usage);

polkadot/node/subsystem-bench/src/lib/configuration.rs

@@ -21,7 +21,8 @@ use itertools::Itertools;
 use polkadot_primitives::{AssignmentId, AuthorityDiscoveryId, ValidatorId, ValidatorPair};
 use rand::thread_rng;
 use rand_distr::{Distribution, Normal, Uniform};
-use sc_network_types::PeerId;
+use sc_network::config::{NodeKeyConfig, Secret};
+use sc_network_types::{ed25519::SecretKey, PeerId};
 use serde::{Deserialize, Serialize};
 use sp_consensus_babe::AuthorityId;
 use sp_core::Pair;
@@ -199,6 +200,15 @@ impl TestConfiguration {
 
 	/// Generates the authority keys we need for the network emulation.
 	pub fn generate_authorities(&self) -> TestAuthorities {
+		let node_key_configs = (0..self.n_validators)
+			.map(|_| NodeKeyConfig::Ed25519(Secret::Input(SecretKey::generate())))
+			.collect_vec();
+		let peer_ids = node_key_configs
+			.iter()
+			.cloned()
+			.map(|node_key_config| node_key_config.into_keypair().unwrap().public().to_peer_id())
+			.collect_vec();
+
 		let keyring = Keyring::default();
 
 		let key_seeds = (0..self.n_validators)
@@ -210,7 +220,7 @@ impl TestConfiguration {
 			.map(|seed| keyring.sr25519_new(seed.as_str()))
 			.collect::<Vec<_>>();
 
-		// Generate keys and peers ids in each of the format needed by the tests.
+		// Generate keys in each of the format needed by the tests.
 		let validator_public: Vec<ValidatorId> =
 			keys.iter().map(|key| (*key).into()).collect::<Vec<_>>();
 
@@ -222,7 +232,6 @@ impl TestConfiguration {
 
 		let validator_assignment_id: Vec<AssignmentId> =
 			keys.iter().map(|key| (*key).into()).collect::<Vec<_>>();
-		let peer_ids: Vec<PeerId> = keys.iter().map(|_| PeerId::random()).collect::<Vec<_>>();
 
 		let peer_id_to_authority = peer_ids
 			.iter()
@@ -239,6 +248,7 @@ impl TestConfiguration {
 			keyring,
 			validator_public,
 			validator_authority_id,
+			node_key_configs,
 			peer_ids,
 			validator_babe_id,
 			validator_assignment_id,
@@ -275,6 +285,7 @@ pub struct TestAuthorities {
 	pub peer_ids: Vec<PeerId>,
 	pub peer_id_to_authority: HashMap<PeerId, AuthorityDiscoveryId>,
 	pub validator_pairs: Vec<ValidatorPair>,
+	pub node_key_configs: Vec<NodeKeyConfig>,
 }
 
 /// Sample latency (in milliseconds) from a normal distribution with parameters

polkadot/node/subsystem-bench/src/lib/lib.rs

@@ -16,6 +16,7 @@
 
 // The validator index that represents the node that is under test.
 pub const NODE_UNDER_TEST: u32 = 0;
+pub const SESSION_INDEX: u32 = 0;
 
 pub mod approval;
 pub mod availability;

polkadot/node/subsystem-bench/src/lib/mock/mod.rs

@@ -27,6 +27,7 @@ pub mod dummy;
 pub mod network_bridge;
 pub mod prospective_parachains;
 pub mod runtime_api;
+pub mod statement_distribution;
 
 pub struct AlwaysSupportsParachains {}