Refactor Sync Rate Rule

- Makes it look like any other mining rule

Author: coderofstuff

protocol/mining/src/rule_engine.rs

@@ -1,8 +1,5 @@
 use std::{
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    sync::{atomic::AtomicBool, Arc},
     time::{Duration, Instant},
 };
 
@@ -20,14 +17,16 @@ use kaspa_core::{
         tick::{TickReason, TickService},
     },
     time::unix_now,
-    trace, warn,
+    trace,
 };
 use kaspa_p2p_lib::Hub;
 
-use crate::rules::{blue_parents_only_rule::BlueParentsOnlyRule, mining_rule::MiningRule, no_transactions_rule::NoTransactionsRule};
+use crate::rules::{
+    blue_parents_only_rule::BlueParentsOnlyRule, mining_rule::MiningRule, no_transactions_rule::NoTransactionsRule,
+    sync_rate_rule::SyncRateRule, ExtraData,
+};
 
 const RULE_ENGINE: &str = "mining-rule-engine";
-const SYNC_RATE_THRESHOLD: f64 = 0.10;
 
 #[derive(Clone)]
 pub struct MiningRuleEngine {
@@ -68,59 +67,25 @@ impl MiningRuleEngine {
             let delta = &snapshot - &last_snapshot;
 
             if elapsed_time.as_secs() > 0 {
-                let expected_blocks = (elapsed_time.as_millis() as u64) / self.config.target_time_per_block;
-                let received_blocks = delta.body_counts.max(delta.header_counts);
-                let rate: f64 = (received_blocks as f64) / (expected_blocks as f64);
-
                 let session = self.consensus_manager.consensus().unguarded_session();
 
                 let finality_point = session.async_finality_point().await;
                 let finality_point_timestamp = session.async_get_header(finality_point).await.unwrap().timestamp;
-                // Finality point is considered "recent" if it is within 3 finality durations from the current time
-                let is_finality_recent = finality_point_timestamp >= unix_now().saturating_sub(self.config.finality_duration() * 3);
-
-                trace!(
-                    "Sync rate: {:.2} | Finality point recent: {} | Elapsed time: {}s | Connected: {} | Found/Expected blocks: {}/{}",
-                    rate,
-                    is_finality_recent,
-                    elapsed_time.as_secs(),
-                    delta.body_counts,
-                    self.has_sufficient_peer_connectivity(),
-                    expected_blocks,
-                );
-
-                if is_finality_recent && rate < SYNC_RATE_THRESHOLD {
-                    // if sync rate rule conditions are met:
-                    if let Ok(false) = self.use_sync_rate_rule.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) {
-                        warn!("Sync rate {:.2} is below threshold: {}", rate, SYNC_RATE_THRESHOLD);
-                    }
-                } else {
-                    // else when sync rate conditions are not met:
-                    if let Ok(true) = self.use_sync_rate_rule.compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed) {
-                        if !is_finality_recent {
-                            warn!("Sync rate {:.2} recovered: {} by entering IBD", rate, SYNC_RATE_THRESHOLD);
-                        } else {
-                            warn!("Sync rate {:.2} recovered: {}", rate, SYNC_RATE_THRESHOLD);
-                        }
-                    } else if !is_finality_recent {
-                        trace!("Finality period is old. Timestamp: {}. Sync rate: {:.2}", finality_point_timestamp, rate);
-                    }
-                }
 
-                // END - Sync monitor
+                let extra_data = ExtraData {
+                    finality_point_timestamp,
+                    target_time_per_block: self.config.target_time_per_block,
+                    has_sufficient_peer_connectivity: self.has_sufficient_peer_connectivity(),
+                    finality_duration: self.config.finality_duration(),
+                    elapsed_time,
+                };
 
-                // START - Rule Engine
                 trace!("Current Mining Rule: {:?}", self.mining_rules);
 
-                // Blue Parents Only Check:
+                // Check for all the rules
                 for rule in &self.rules {
-                    rule.check_rule(&snapshot);
+                    rule.check_rule(&delta, &extra_data);
                 }
-
-                // No Transactions Check:
-                // TODO: implement this part
-
-                // End - Rule Engine
             }
 
             last_snapshot = snapshot;
@@ -136,21 +101,14 @@ impl MiningRuleEngine {
         hub: Hub,
         mining_rules: Arc<MiningRules>,
     ) -> Self {
+        let use_sync_rate_rule = Arc::new(AtomicBool::new(false));
         let rules: Vec<Arc<(dyn MiningRule + 'static)>> = vec![
+            Arc::new(SyncRateRule::new(use_sync_rate_rule.clone())),
             Arc::new(BlueParentsOnlyRule::new(mining_rules.blue_parents_only.clone())),
             Arc::new(NoTransactionsRule::new(mining_rules.no_transactions.clone())),
         ];
 
-        Self {
-            consensus_manager,
-            config,
-            processing_counters,
-            tick_service,
-            hub,
-            use_sync_rate_rule: Arc::new(AtomicBool::new(false)),
-            mining_rules,
-            rules,
-        }
+        Self { consensus_manager, config, processing_counters, tick_service, hub, use_sync_rate_rule, mining_rules, rules }
     }
 
     pub fn should_mine(&self, sink_daa_score_timestamp: DaaScoreTimestamp) -> bool {

protocol/mining/src/rules/blue_parents_only_rule.rs

@@ -6,7 +6,7 @@ use std::sync::{
 use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
 use kaspa_core::{trace, warn};
 
-use super::mining_rule::MiningRule;
+use super::{mining_rule::MiningRule, ExtraData};
 
 const VIRTUAL_PROCESSING_TRIGGER_THRESHOLD: f64 = 500.0; // 500 milliseconds
 const VIRTUAL_PROCESSING_RECOVERY_THRESHOLD: f64 = 100.0; // 100 milliseconds
@@ -22,7 +22,7 @@ impl BlueParentsOnlyRule {
 }
 
 impl MiningRule for BlueParentsOnlyRule {
-    fn check_rule(&self, delta: &ProcessingCountersSnapshot) {
+    fn check_rule(&self, delta: &ProcessingCountersSnapshot, _extra_data: &ExtraData) {
         let received_blocks = delta.body_counts.max(delta.header_counts) as f64;
         let virtual_processing_avg_time_per_block_ms =
             if received_blocks > 0.0 { (delta.virtual_processing_time as f64) / received_blocks } else { 0.0 };

protocol/mining/src/rules/mining_rule.rs

@@ -1,5 +1,7 @@
 use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
 
+use super::ExtraData;
+
 pub trait MiningRule: Send + Sync + 'static {
-    fn check_rule(&self, delta: &ProcessingCountersSnapshot);
+    fn check_rule(&self, delta: &ProcessingCountersSnapshot, extra_data: &ExtraData);
 }

protocol/mining/src/rules/mod.rs

@@ -1,4 +1,15 @@
+use std::time::Duration;
+
 pub mod blue_parents_only_rule;
 pub mod no_transactions_rule;
+pub mod sync_rate_rule;
 
 pub mod mining_rule;
+
+pub struct ExtraData {
+    pub finality_point_timestamp: u64,
+    pub target_time_per_block: u64,
+    pub has_sufficient_peer_connectivity: bool,
+    pub finality_duration: u64,
+    pub elapsed_time: Duration,
+}

protocol/mining/src/rules/no_transactions_rule.rs

@@ -2,7 +2,7 @@ use std::sync::{atomic::AtomicBool, Arc};
 
 use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
 
-use super::mining_rule::MiningRule;
+use super::{mining_rule::MiningRule, ExtraData};
 
 pub struct NoTransactionsRule {
     pub is_enabled: Arc<AtomicBool>,
@@ -15,7 +15,7 @@ impl NoTransactionsRule {
 }
 
 impl MiningRule for NoTransactionsRule {
-    fn check_rule(&self, _delta: &ProcessingCountersSnapshot) {
+    fn check_rule(&self, _delta: &ProcessingCountersSnapshot, _extra_data: &ExtraData) {
         // TODO: Add the rule and recovery condition
     }
 }

protocol/mining/src/rules/sync_rate_rule.rs

@@ -0,0 +1,60 @@
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
+use kaspa_core::{time::unix_now, trace, warn};
+
+use super::{mining_rule::MiningRule, ExtraData};
+
+const SYNC_RATE_THRESHOLD: f64 = 0.10;
+
+pub struct SyncRateRule {
+    pub use_sync_rate_rule: Arc<AtomicBool>,
+}
+
+impl SyncRateRule {
+    pub fn new(use_sync_rate_rule: Arc<AtomicBool>) -> Self {
+        Self { use_sync_rate_rule }
+    }
+}
+
+impl MiningRule for SyncRateRule {
+    fn check_rule(&self, delta: &ProcessingCountersSnapshot, extra_data: &ExtraData) {
+        let expected_blocks = (extra_data.elapsed_time.as_millis() as u64) / extra_data.target_time_per_block;
+        let received_blocks = delta.body_counts.max(delta.header_counts);
+        let rate: f64 = (received_blocks as f64) / (expected_blocks as f64);
+
+        // Finality point is considered "recent" if it is within 3 finality durations from the current time
+        let is_finality_recent = extra_data.finality_point_timestamp >= unix_now().saturating_sub(extra_data.finality_duration * 3);
+
+        trace!(
+            "Sync rate: {:.2} | Finality point recent: {} | Elapsed time: {}s | Connected: {} | Found/Expected blocks: {}/{}",
+            rate,
+            is_finality_recent,
+            extra_data.elapsed_time.as_secs(),
+            extra_data.has_sufficient_peer_connectivity,
+            delta.body_counts,
+            expected_blocks,
+        );
+
+        if is_finality_recent && rate < SYNC_RATE_THRESHOLD {
+            // if sync rate rule conditions are met:
+            if let Ok(false) = self.use_sync_rate_rule.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) {
+                warn!("Sync rate {:.2} is below threshold: {}", rate, SYNC_RATE_THRESHOLD);
+            }
+        } else {
+            // else when sync rate conditions are not met:
+            if let Ok(true) = self.use_sync_rate_rule.compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed) {
+                if !is_finality_recent {
+                    warn!("Sync rate {:.2} recovered: {} by entering IBD", rate, SYNC_RATE_THRESHOLD);
+                } else {
+                    warn!("Sync rate {:.2} recovered: {}", rate, SYNC_RATE_THRESHOLD);
+                }
+            } else if !is_finality_recent {
+                trace!("Finality period is old. Timestamp: {}. Sync rate: {:.2}", extra_data.finality_point_timestamp, rate);
+            }
+        }
+    }
+}