CLI update and fixes

Signed-off-by: Andrei Sandu <[email protected]>

cumulus/pallets/xcmp-queue/src/tests.rs

@@ -410,9 +410,11 @@ fn verify_fee_factor_increase_and_decrease() {
 		assert_eq!(DeliveryFeeFactor::<Test>::get(sibling_para_id), initial);
 
 		// Sending the message right now is cheap
-		let (_, delivery_fees) = validate_send::<XcmpQueue>(destination, xcm.clone())
-			.expect("message can be sent; qed");
-		let Fungible(delivery_fee_amount) = delivery_fees.inner()[0].fun else { unreachable!("asset is fungible; qed"); };
+		let (_, delivery_fees) =
+			validate_send::<XcmpQueue>(destination, xcm.clone()).expect("message can be sent; qed");
+		let Fungible(delivery_fee_amount) = delivery_fees.inner()[0].fun else {
+			unreachable!("asset is fungible; qed");
+		};
 		assert_eq!(delivery_fee_amount, 402_000_000);
 
 		let smaller_xcm = Xcm(vec![ClearOrigin; 30]);
@@ -422,19 +424,23 @@ fn verify_fee_factor_increase_and_decrease() {
 		assert_ok!(send_xcm::<XcmpQueue>(destination, xcm.clone())); // Size 520
 		assert_eq!(DeliveryFeeFactor::<Test>::get(sibling_para_id), FixedU128::from_float(1.05));
 
-		for _ in 0..12 { // We finish at size 929
+		for _ in 0..12 {
+			// We finish at size 929
 			assert_ok!(send_xcm::<XcmpQueue>(destination, smaller_xcm.clone()));
 		}
 		assert!(DeliveryFeeFactor::<Test>::get(sibling_para_id) > FixedU128::from_float(1.88));
 
 		// Sending the message right now is expensive
-		let (_, delivery_fees) = validate_send::<XcmpQueue>(destination, xcm.clone())
-			.expect("message can be sent; qed");
-		let Fungible(delivery_fee_amount) = delivery_fees.inner()[0].fun else { unreachable!("asset is fungible; qed"); };
+		let (_, delivery_fees) =
+			validate_send::<XcmpQueue>(destination, xcm.clone()).expect("message can be sent; qed");
+		let Fungible(delivery_fee_amount) = delivery_fees.inner()[0].fun else {
+			unreachable!("asset is fungible; qed");
+		};
 		assert_eq!(delivery_fee_amount, 758_030_955);
 
 		// Fee factor only decreases in `take_outbound_messages`
-		for _ in 0..5 { // We take 5 100 byte pages
+		for _ in 0..5 {
+			// We take 5 100 byte pages
 			XcmpQueue::take_outbound_messages(1);
 		}
 		assert!(DeliveryFeeFactor::<Test>::get(sibling_para_id) < FixedU128::from_float(1.72));

polkadot/node/network/availability-recovery/Cargo.toml

@@ -7,6 +7,7 @@ license.workspace = true
 
 [dependencies]
 futures = "0.3.21"
+tokio = "1.24.2"
 schnellru = "0.2.1"
 rand = "0.8.5"
 fatality = "0.0.6"
@@ -36,3 +37,6 @@ sc-network = { path = "../../../../substrate/client/network" }
 
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
+
+[features]
+subsystem-benchmarks = []

polkadot/node/network/availability-recovery/src/lib.rs

@@ -617,12 +617,9 @@ impl AvailabilityRecoverySubsystem {
 		.into_iter()
 		.cycle();
 
-		gum::debug!("Subsystem running");
 		loop {
 			let recv_req = req_receiver.recv(|| vec![COST_INVALID_REQUEST]).fuse();
 			pin_mut!(recv_req);
-			gum::debug!("waiting for message");
-
 			futures::select! {
 				erasure_task = erasure_task_rx.next() => {
 					match erasure_task {
@@ -729,6 +726,8 @@ impl AvailabilityRecoverySubsystem {
 					}
 				}
 				output = state.ongoing_recoveries.select_next_some() => {
+					// No caching for benchmark.
+					#[cfg(not(feature = "subsystem-benchmarks"))]
 					if let Some((candidate_hash, result)) = output {
 						if let Ok(recovery) = CachedRecovery::try_from(result) {
 							state.availability_lru.insert(candidate_hash, recovery);
@@ -829,5 +828,10 @@ async fn erasure_task_thread(
 				break
 			},
 		}
+
+		// In benchmarks this is a very hot loop not yielding at all.
+		// To update promehteus metrics for the task we need to yield.
+		#[cfg(feature = "subsystem-benchmarks")]
+		tokio::task::yield_now().await;
 	}
 }

polkadot/node/subsystem-bench/Cargo.toml

@@ -22,7 +22,7 @@ polkadot-node-subsystem-types = { path = "../subsystem-types" }
 polkadot-node-primitives = { path = "../primitives" }
 polkadot-primitives = { path = "../../primitives" }
 polkadot-node-network-protocol = { path = "../network/protocol" }
-polkadot-availability-recovery = { path = "../network/availability-recovery" }
+polkadot-availability-recovery = { path = "../network/availability-recovery", features=["subsystem-benchmarks"]}
 color-eyre = { version = "0.6.1", default-features = false }
 assert_matches = "1.5"
 async-trait = "0.1.57"
@@ -38,7 +38,7 @@ env_logger = "0.9.0"
 rand = "0.8.5"
 parity-scale-codec = { version = "3.6.1", features = ["std", "derive"] }
 tokio = "1.24.2"
-
+clap-num = "1.0.2"
 polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" }
 sp-keyring = { path = "../../../substrate/primitives/keyring" }
 sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" }

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

@@ -17,7 +17,7 @@
 use super::*;
 
 /// Peer response latency configuration.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct PeerLatency {
 	/// Min latency for `NetworkAction` completion.
 	pub min_latency: Duration,
@@ -36,15 +36,15 @@ pub struct TestConfiguration {
 	pub n_cores: usize,
 	/// The PoV size
 	pub pov_sizes: Vec<usize>,
-	/// This parameter is used to determine how many recoveries we batch in parallel
-	/// to simulate tranche0 recoveries.
-	pub max_parallel_recoveries: usize,
-	/// The amount of bandiwdht remote validators have.
+	/// The amount of bandiwdth remote validators have.
 	pub bandwidth: usize,
 	/// Optional peer emulation latency
 	pub latency: Option<PeerLatency>,
 	/// Error probability
 	pub error: usize,
+	/// Number of loops
+	/// In one loop `n_cores` candidates are recovered
+	pub num_loops: usize,
 }
 
 impl Default for TestConfiguration {
@@ -54,80 +54,78 @@ impl Default for TestConfiguration {
 			n_validators: 10,
 			n_cores: 10,
 			pov_sizes: vec![5 * 1024 * 1024],
-			max_parallel_recoveries: 6,
 			bandwidth: 60 * 1024 * 1024,
 			latency: None,
 			error: 0,
+			num_loops: 1,
 		}
 	}
 }
 
 impl TestConfiguration {
 	/// An unconstrained standard configuration matching Polkadot/Kusama
-	pub fn unconstrained_300_validators_60_cores(pov_sizes: Vec<usize>) -> TestConfiguration {
+	pub fn ideal_network(
+		num_loops: usize,
+		use_fast_path: bool,
+		n_validators: usize,
+		n_cores: usize,
+		pov_sizes: Vec<usize>,
+	) -> TestConfiguration {
 		Self {
-			use_fast_path: false,
-			n_validators: 300,
-			n_cores: 100,
+			use_fast_path,
+			n_cores,
+			n_validators,
 			pov_sizes,
-			max_parallel_recoveries: 100,
 			// HW specs node bandwidth
-			bandwidth: 60 * 1024 * 1024,
-			// No latency
-			latency: None,
-			error: 0,
-		}
-	}
-	pub fn unconstrained_1000_validators_60_cores(pov_sizes: Vec<usize>) -> TestConfiguration {
-		Self {
-			use_fast_path: false,
-			n_validators: 300,
-			n_cores: 60,
-			pov_sizes,
-			max_parallel_recoveries: 30,
-			// HW specs node bandwidth
-			bandwidth: 60 * 1024 * 1024,
+			bandwidth: 50 * 1024 * 1024,
 			// No latency
 			latency: None,
 			error: 0,
+			num_loops,
 		}
 	}
 
-	/// Polkadot/Kusama configuration with typical latency constraints.
-	pub fn healthy_network_300_validators_60_cores(pov_sizes: Vec<usize>) -> TestConfiguration {
+	pub fn healthy_network(
+		num_loops: usize,
+		use_fast_path: bool,
+		n_validators: usize,
+		n_cores: usize,
+		pov_sizes: Vec<usize>,
+	) -> TestConfiguration {
 		Self {
-			use_fast_path: true,
-			n_validators: 300,
-			n_cores: 60,
+			use_fast_path,
+			n_cores,
+			n_validators,
 			pov_sizes,
-			max_parallel_recoveries: 6,
-			// HW specs node bandwidth
-			bandwidth: 60 * 1024 * 1024,
+			bandwidth: 50 * 1024 * 1024,
 			latency: Some(PeerLatency {
 				min_latency: Duration::from_millis(1),
-				max_latency: Duration::from_millis(50),
+				max_latency: Duration::from_millis(100),
 			}),
-			error: 5,
+			error: 3,
+			num_loops,
 		}
 	}
 
-	/// Polkadot/Kusama configuration with degraded due to latencies.
-	/// TODO: implement errors.
-	pub fn degraded_network_300_validators_60_cores(pov_sizes: Vec<usize>) -> TestConfiguration {
+	pub fn degraded_network(
+		num_loops: usize,
+		use_fast_path: bool,
+		n_validators: usize,
+		n_cores: usize,
+		pov_sizes: Vec<usize>,
+	) -> TestConfiguration {
 		Self {
-			use_fast_path: false,
-			n_validators: 300,
-			n_cores: 100,
+			use_fast_path,
+			n_cores,
+			n_validators,
 			pov_sizes,
-			max_parallel_recoveries: 20,
-			// HW specs node bandwidth
-			bandwidth: 60 * 1024 * 1024,
-			// A range of latencies to expect in a degraded network
+			bandwidth: 50 * 1024 * 1024,
 			latency: Some(PeerLatency {
-				min_latency: Duration::from_millis(1),
+				min_latency: Duration::from_millis(10),
 				max_latency: Duration::from_millis(500),
 			}),
-			error: 30,
+			error: 33,
+			num_loops,
 		}
 	}
 }