wip

Author: axaysagathiya

polkadot/node/network/availability-distribution/src/metrics.rs

@@ -57,16 +57,15 @@ struct MetricsInner {
 	/// query further validators.
 	retries: Counter<U64>,
 
-	/// Number of candidates for which we initiated early chunk fetching.
-	early_candidates_fetched: Counter<U64>,
-	/// Number of candidates for which we initiated on-time (slow path) chunk fetching.
-	slow_candidates_fetched: Counter<U64>,
-	/// Number of early-fetched candidates that never made it on-chain.
-	early_candidates_never_onchain: Counter<U64>,
-
-	/// Number of candidates fetched early that later appeared on slow path, implying we skipped a
-	/// duplicate fetch when they became occupied.
-	early_candidates_skipped_on_slow: Counter<U64>,
+	/// Number of candidates for which we initiated chunk fetching before getting backed on chain (early path).
+	early_fetched_candidates: Counter<U64>,
+
+	/// Number of candidates for which we initiated chunk fetching after getting backed on chain (late path).
+	late_fetched_candidates: Counter<U64>,
+
+	/// Number of early-fetched candidates that appeared on the occupied core as backed,
+	/// avoiding redundant fetches by reusing existing data.
+	early_candidates_backed_on_chain: Counter<U64>,
 }
 
 impl Metrics {
@@ -111,30 +110,23 @@ impl Metrics {
 	}
 
 	/// Increment early candidates fetched counter.
-	pub fn on_early_candidate_fetched(&self) {
-		if let Some(metrics) = &self.0 {
-			metrics.early_candidates_fetched.inc()
-		}
-	}
-
-	/// Increment slow candidates fetched counter.
-	pub fn on_slow_candidate_fetched(&self) {
+	pub fn on_early_fetched_candidate(&self) {
 		if let Some(metrics) = &self.0 {
-			metrics.slow_candidates_fetched.inc()
+			metrics.early_fetched_candidates.inc()
 		}
 	}
 
-	/// Increment early candidates that never made it on-chain counter.
-	pub fn on_early_candidate_never_onchain(&self) {
+	/// Increment late candidates fetched counter.
+	pub fn on_late_fetched_candidate(&self) {
 		if let Some(metrics) = &self.0 {
-			metrics.early_candidates_never_onchain.inc()
+			metrics.late_fetched_candidates.inc()
 		}
 	}
 
-	/// Increment early candidates that later appeared on slow path (duplicate fetch skipped).
-	pub fn on_early_candidate_skipped_on_slow(&self) {
+	/// Increment early fetched candidates that later got backed on chain counter.(skipped duplicate fetch)
+	pub fn on_early_candidate_backed_on_chain(&self) {
 		if let Some(metrics) = &self.0 {
-			metrics.early_candidates_skipped_on_slow.inc()
+			metrics.early_candidates_backed_on_chain.inc()
 		}
 	}
 }
@@ -189,31 +181,24 @@ impl metrics::Metrics for Metrics {
 				)?,
 				registry,
 			)?,
-			early_candidates_fetched: prometheus::register(
+			early_fetched_candidates: prometheus::register(
 				Counter::new(
 					"polkadot_parachain_early_candidates_fetched_total",
-					"Number of candidates for which we initiated early chunk fetching.",
-				)?,
-				registry,
-			)?,
-			slow_candidates_fetched: prometheus::register(
-				Counter::new(
-					"polkadot_parachain_slow_candidates_fetched_total",
-					"Number of candidates for which we initiated on-time (slow path) chunk fetching.",
+					"Number of candidates for which we initiated chunk fetching before getting backed on chain (early path).",
 				)?,
 				registry,
 			)?,
-			early_candidates_never_onchain: prometheus::register(
+			late_fetched_candidates: prometheus::register(
 				Counter::new(
-					"polkadot_parachain_early_candidates_never_onchain_total",
-					"Number of early-fetched candidates that never made it on-chain.",
+					"polkadot_parachain_late_fetched_candidates_total",
+					"Number of candidates for which we initiated chunk fetching after getting backed on chain (late path).",
 				)?,
 				registry,
 			)?,
-			early_candidates_skipped_on_slow: prometheus::register(
+			early_candidates_backed_on_chain: prometheus::register(
 				Counter::new(
-					"polkadot_parachain_early_candidates_skipped_on_slow_total",
-					"Number of early-fetched candidates that later appeared on the slow path (duplicate fetch skipped).",
+					"polkadot_parachain_early_candidates_backed_on_chain_total",
+					"Number of early-fetched candidates that later got backed on chain (duplicate fetch skipped).",
 				)?,
 				registry,
 			)?,

polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs

@@ -60,10 +60,24 @@ mod tests;
 pub struct FetchTaskConfig {
 	prepared_running: Option<RunningTask>,
 	live_in: HashSet<Hash>,
+	fetch_type: FetchType,
+}
+
+pub enum FetchType {
+	/// Early fetched erasure coded chunk, before it was backed on-chain.
+	Early,
+	/// The candidate successfully got backed on-chain for which we already fetched the chunk
+	/// early.
+	EarlyOnChain,
+	/// Late fetched erasure coded chunk, after it was backed on-chain.
+	/// The hash represents the block hash where the candidate was backed on chain.
+	Late(Hash),
 }
 
 /// Information about a task fetching an erasure chunk.
 pub struct FetchTask {
+	pub fetch_type: FetchType,
+
 	/// For what relay parents this task is relevant.
 	///
 	/// In other words, for which relay chain parents this candidate is considered live.
@@ -147,7 +161,7 @@ impl FetchTaskConfig {
 	///
 	/// The result of this function can be passed into [`FetchTask::start`].
 	pub fn new(
-		leaf: Hash,
+		fetch_type: FetchType,
 		core: &CoreInfo,
 		sender: mpsc::Sender<FromFetchTask>,
 		metrics: Metrics,
@@ -156,11 +170,14 @@ impl FetchTaskConfig {
 		req_v1_protocol_name: ProtocolName,
 		req_v2_protocol_name: ProtocolName,
 	) -> Self {
-		let live_in = vec![leaf].into_iter().collect();
+		let live_in = match fetch_type {
+			FetchType::Late(block_hash) => vec![block_hash].into_iter().collect(),
+			_ => vec![].into_iter().collect(),
+		};
 
 		// Don't run tasks for our backing group:
 		if session_info.our_group == Some(core.group_responsible) {
-			return FetchTaskConfig { live_in, prepared_running: None };
+			return FetchTaskConfig { fetch_type, live_in, prepared_running: None };
 		}
 
 		let prepared_running = RunningTask {
@@ -181,7 +198,7 @@ impl FetchTaskConfig {
 			req_v1_protocol_name,
 			req_v2_protocol_name
 		};
-		FetchTaskConfig { live_in, prepared_running: Some(prepared_running) }
+		FetchTaskConfig { fetch_type, live_in, prepared_running: Some(prepared_running) }
 	}
 }
 
@@ -191,17 +208,17 @@ impl FetchTask {
 	///
 	/// A task handling the fetching of the configured chunk will be spawned.
 	pub async fn start<Context>(config: FetchTaskConfig, ctx: &mut Context) -> Result<Self> {
-		let FetchTaskConfig { prepared_running, live_in } = config;
+		let FetchTaskConfig { prepared_running, live_in, fetch_type } = config;
 
 		if let Some(running) = prepared_running {
 			let (handle, kill) = oneshot::channel();
 
 			ctx.spawn("chunk-fetcher", running.run(kill).boxed())
 				.map_err(|e| FatalError::SpawnTask(e))?;
 
-			Ok(FetchTask { live_in, state: FetchedState::Started(handle) })
+			Ok(FetchTask { fetch_type, live_in, state: FetchedState::Started(handle) })
 		} else {
-			Ok(FetchTask { live_in, state: FetchedState::Canceled })
+			Ok(FetchTask { fetch_type, live_in, state: FetchedState::Canceled })
 		}
 	}