Mining Rule Engine: Blue Only Mergeset Rule

Author: coderofstuff

consensus/core/src/api/counters.rs

@@ -11,6 +11,8 @@ pub struct ProcessingCounters {
     pub chain_block_counts: AtomicU64,
     pub chain_disqualified_counts: AtomicU64,
     pub mass_counts: AtomicU64,
+    pub build_block_template_above_threshold: AtomicU64,
+    pub build_block_template_within_threshold: AtomicU64,
     pub submit_block_bad_merkle_root_count: AtomicU64,
     pub submit_block_success_count: AtomicU64,
 }
@@ -27,6 +29,8 @@ impl ProcessingCounters {
             chain_block_counts: self.chain_block_counts.load(Ordering::Relaxed),
             chain_disqualified_counts: self.chain_disqualified_counts.load(Ordering::Relaxed),
             mass_counts: self.mass_counts.load(Ordering::Relaxed),
+            build_block_template_above_threshold: self.build_block_template_above_threshold.load(Ordering::Relaxed),
+            build_block_template_within_threshold: self.build_block_template_within_threshold.load(Ordering::Relaxed),
             submit_block_bad_merkle_root_count: self.submit_block_bad_merkle_root_count.load(Ordering::Relaxed),
             submit_block_success_count: self.submit_block_success_count.load(Ordering::Relaxed),
         }
@@ -44,6 +48,8 @@ pub struct ProcessingCountersSnapshot {
     pub chain_block_counts: u64,
     pub chain_disqualified_counts: u64,
     pub mass_counts: u64,
+    pub build_block_template_above_threshold: u64,
+    pub build_block_template_within_threshold: u64,
     pub submit_block_bad_merkle_root_count: u64,
     pub submit_block_success_count: u64,
 }
@@ -62,6 +68,12 @@ impl core::ops::Sub for &ProcessingCountersSnapshot {
             chain_block_counts: self.chain_block_counts.saturating_sub(rhs.chain_block_counts),
             chain_disqualified_counts: self.chain_disqualified_counts.saturating_sub(rhs.chain_disqualified_counts),
             mass_counts: self.mass_counts.saturating_sub(rhs.mass_counts),
+            build_block_template_above_threshold: self
+                .build_block_template_above_threshold
+                .saturating_sub(rhs.build_block_template_above_threshold),
+            build_block_template_within_threshold: self
+                .build_block_template_within_threshold
+                .saturating_sub(rhs.build_block_template_within_threshold),
             submit_block_bad_merkle_root_count: self
                 .submit_block_bad_merkle_root_count
                 .saturating_sub(rhs.submit_block_bad_merkle_root_count),

consensus/core/src/mining_rules.rs

@@ -3,11 +3,12 @@ use std::sync::{atomic::AtomicBool, Arc};
 #[derive(Debug)]
 pub struct MiningRules {
     pub no_transactions: Arc<AtomicBool>,
+    pub blue_only_mergeset: Arc<AtomicBool>,
 }
 
 impl MiningRules {
     pub fn new() -> Self {
-        Self { no_transactions: Arc::new(AtomicBool::new(false)) }
+        Self { no_transactions: Arc::new(AtomicBool::new(false)), blue_only_mergeset: Arc::new(AtomicBool::new(false)) }
     }
 }
 

consensus/src/pipeline/virtual_processor/processor.rs

@@ -77,7 +77,11 @@ use kaspa_consensus_notify::{
     root::ConsensusNotificationRoot,
 };
 use kaspa_consensusmanager::SessionLock;
-use kaspa_core::{debug, info, time::unix_now, trace, warn};
+use kaspa_core::{
+    debug, info,
+    time::{unix_now, Stopwatch},
+    trace, warn,
+};
 use kaspa_database::prelude::{StoreError, StoreResultEmptyTuple, StoreResultExtensions};
 use kaspa_hashes::{Hash, ZERO_HASH};
 use kaspa_muhash::MuHash;
@@ -106,6 +110,10 @@ use std::{
     sync::{atomic::Ordering, Arc},
 };
 
+// 100ms - since at 10BPS, average block time is 100ms and so must expect
+// the block template to build faster than that
+pub const BUILD_BLOCK_TEMPLATE_SPEED_THRESHOLD: u128 = 100;
+
 pub struct VirtualStateProcessor {
     // Channels
     receiver: CrossbeamReceiver<VirtualStateProcessingMessage>,
@@ -715,7 +723,10 @@ impl VirtualStateProcessor {
         let max_candidates = self.max_virtual_parent_candidates(max_block_parents);
 
         // Prioritize half the blocks with highest blue work and pick the rest randomly to ensure diversity between nodes
-        if candidates.len() > max_candidates {
+        if self.mining_rules.blue_only_mergeset.load(Ordering::Relaxed) {
+            // pick 100% of the top blue work blocks
+            candidates.truncate(max_candidates);
+        } else if candidates.len() > max_candidates {
             // make_contiguous should be a no op since the deque was just built
             let slice = candidates.make_contiguous();
 
@@ -804,25 +815,32 @@ impl VirtualStateProcessor {
         let mut ghostdag_data = self.ghostdag_manager.ghostdag(&virtual_parents);
         let merge_depth_root = self.depth_manager.calc_merge_depth_root(&ghostdag_data, current_pruning_point);
         let mut kosherizing_blues: Option<Vec<Hash>> = None;
-        let mut bad_reds = Vec::new();
+        let bad_reds = if self.mining_rules.blue_only_mergeset.load(Ordering::Relaxed) {
+            // Treat all reds as bad reds when this rule is triggered
+            ghostdag_data.mergeset_reds.as_ref().to_vec()
+        } else {
+            let mut inner_bad_reds = Vec::new();
 
-        //
-        // Note that the code below optimizes for the usual case where there are no merge-bound-violating blocks.
-        //
+            //
+            // Note that the code below optimizes for the usual case where there are no merge-bound-violating blocks.
+            //
 
-        // Find red blocks violating the merge bound and which are not kosherized by any blue
-        for red in ghostdag_data.mergeset_reds.iter().copied() {
-            if self.reachability_service.is_dag_ancestor_of(merge_depth_root, red) {
-                continue;
-            }
-            // Lazy load the kosherizing blocks since this case is extremely rare
-            if kosherizing_blues.is_none() {
-                kosherizing_blues = Some(self.depth_manager.kosherizing_blues(&ghostdag_data, merge_depth_root).collect());
-            }
-            if !self.reachability_service.is_dag_ancestor_of_any(red, &mut kosherizing_blues.as_ref().unwrap().iter().copied()) {
-                bad_reds.push(red);
+            // Find red blocks violating the merge bound and which are not kosherized by any blue
+            for red in ghostdag_data.mergeset_reds.iter().copied() {
+                if self.reachability_service.is_dag_ancestor_of(merge_depth_root, red) {
+                    continue;
+                }
+                // Lazy load the kosherizing blocks since this case is extremely rare
+                if kosherizing_blues.is_none() {
+                    kosherizing_blues = Some(self.depth_manager.kosherizing_blues(&ghostdag_data, merge_depth_root).collect());
+                }
+                if !self.reachability_service.is_dag_ancestor_of_any(red, &mut kosherizing_blues.as_ref().unwrap().iter().copied()) {
+                    inner_bad_reds.push(red);
+                }
             }
-        }
+
+            inner_bad_reds
+        };
 
         if !bad_reds.is_empty() {
             // Remove all parents which lead to merging a bad red
@@ -1053,6 +1071,7 @@ impl VirtualStateProcessor {
         mut txs: Vec<Transaction>,
         calculated_fees: Vec<u64>,
     ) -> Result<BlockTemplate, RuleError> {
+        let swo = Stopwatch::new("virtual_processor.resolve_virtual");
         // [`calc_block_parents`] can use deep blocks below the pruning point for this calculation, so we
         // need to hold the pruning lock.
         let _prune_guard = self.pruning_lock.blocking_read();
@@ -1102,6 +1121,13 @@ impl VirtualStateProcessor {
         let selected_parent_hash = virtual_state.ghostdag_data.selected_parent;
         let selected_parent_timestamp = self.headers_store.get_timestamp(selected_parent_hash).unwrap();
         let selected_parent_daa_score = self.headers_store.get_daa_score(selected_parent_hash).unwrap();
+
+        if swo.elapsed().as_millis() <= BUILD_BLOCK_TEMPLATE_SPEED_THRESHOLD {
+            self.counters.build_block_template_within_threshold.fetch_add(1, Ordering::SeqCst);
+        } else {
+            self.counters.build_block_template_above_threshold.fetch_add(1, Ordering::SeqCst);
+        }
+
         Ok(BlockTemplate::new(
             MutableBlock::new(header, txs),
             miner_data,

protocol/mining/src/rule_engine.rs

@@ -21,7 +21,10 @@ use kaspa_core::{
 };
 use kaspa_p2p_lib::Hub;
 
-use crate::rules::{mining_rule::MiningRule, no_transactions_rule::NoTransactionsRule, sync_rate_rule::SyncRateRule, ExtraData};
+use crate::rules::{
+    blue_only_mergeset_rule::BlueOnlyMergesetRule, mining_rule::MiningRule, no_transactions_rule::NoTransactionsRule,
+    sync_rate_rule::SyncRateRule, ExtraData,
+};
 
 const RULE_ENGINE: &str = "mining-rule-engine";
 pub const SNAPSHOT_INTERVAL: u64 = 10;
@@ -103,6 +106,7 @@ impl MiningRuleEngine {
         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(BlueOnlyMergesetRule::new(mining_rules.blue_only_mergeset.clone())),
             Arc::new(NoTransactionsRule::new(mining_rules.no_transactions.clone())),
         ];
 

protocol/mining/src/rules/blue_only_mergeset_rule.rs

@@ -0,0 +1,86 @@
+use std::sync::{
+    atomic::{AtomicBool, AtomicU64, Ordering},
+    Arc,
+};
+
+use kaspa_consensus_core::api::counters::ProcessingCountersSnapshot;
+use kaspa_core::{trace, warn};
+
+use super::{mining_rule::MiningRule, ExtraData};
+
+/// BlueOnlyMergesetRule
+/// Attempt to recover from high build block template times (possibly caused by merging red blocks)
+/// by disallowing reds in the mergeset.
+///
+/// Trigger:
+/// - build block template call durations above threshold were observed, AND
+/// - there were no build block template calls that were within threshold
+///
+/// Recovery:
+/// - build block template call durations within threshold observed, AND
+/// - a merge depth bound period has passed
+pub struct BlueOnlyMergesetRule {
+    pub is_enabled: Arc<AtomicBool>,
+    pub trigger_daa_score: AtomicU64,
+    pub within_threshold_calls_after_trigger: AtomicU64,
+    pub above_threshold_calls_after_trigger: AtomicU64,
+}
+
+impl BlueOnlyMergesetRule {
+    pub fn new(is_enabled: Arc<AtomicBool>) -> Self {
+        Self {
+            is_enabled,
+            trigger_daa_score: AtomicU64::new(0),
+            within_threshold_calls_after_trigger: AtomicU64::new(0),
+            above_threshold_calls_after_trigger: AtomicU64::new(0),
+        }
+    }
+}
+
+impl MiningRule for BlueOnlyMergesetRule {
+    fn check_rule(&self, delta: &ProcessingCountersSnapshot, extra_data: &ExtraData) {
+        let sink_daa_score = extra_data.sink_daa_score_timestamp.daa_score;
+        // DAA score may not be monotonic, so use saturating_sub
+        let score_since_trigger = sink_daa_score.saturating_sub(self.trigger_daa_score.load(Ordering::Relaxed));
+
+        if self.is_enabled.load(Ordering::SeqCst) {
+            // Rule is triggered. Check for recovery
+            let within_threshold_calls =
+                self.within_threshold_calls_after_trigger.fetch_add(delta.build_block_template_within_threshold, Ordering::SeqCst)
+                    + delta.build_block_template_within_threshold;
+            let above_threshold_calls =
+                self.above_threshold_calls_after_trigger.fetch_add(delta.build_block_template_above_threshold, Ordering::SeqCst)
+                    + delta.build_block_template_above_threshold;
+
+            if score_since_trigger >= extra_data.merge_depth && within_threshold_calls > 0 {
+                // Recovery condition met: A merge depth bound has passed and calls within threshold were observed
+                self.is_enabled.store(false, Ordering::SeqCst);
+                self.within_threshold_calls_after_trigger.store(0, Ordering::SeqCst);
+                self.above_threshold_calls_after_trigger.store(0, Ordering::SeqCst);
+                warn!("BlueParentsOnlyRule: recovered  | No. of Block Template Build Times within/above threshold since trigger: {}/{} | Score since trigger: {}",
+                    within_threshold_calls, above_threshold_calls, score_since_trigger);
+            } else {
+                warn!(
+                    "BlueParentsOnlyRule: active | No. of Block Template Build Times within/above threshold since trigger: {}/{} | Score since trigger: {}",
+                    within_threshold_calls, above_threshold_calls, score_since_trigger
+                );
+            }
+        } else {
+            // Rule is not triggered. Check for trigger
+            if delta.build_block_template_within_threshold == 0 && delta.build_block_template_above_threshold > 0 {
+                self.is_enabled.store(true, Ordering::SeqCst);
+                self.trigger_daa_score.store(sink_daa_score, Ordering::SeqCst);
+                warn!(
+                    "BlueParentsOnlyRule: triggered | No. of Block Template Build Times within/above threshold: {}/{}",
+                    delta.build_block_template_within_threshold, delta.build_block_template_above_threshold
+                );
+            } else {
+                trace!(
+                    "BlueParentsOnlyRule: normal | No. of Block Template Build Times within/above threshold: {}/{}",
+                    delta.build_block_template_within_threshold,
+                    delta.build_block_template_above_threshold
+                );
+            }
+        }
+    }
+}

protocol/mining/src/rules/mod.rs

@@ -2,6 +2,7 @@ use std::time::Duration;
 
 use kaspa_consensus_core::daa_score_timestamp::DaaScoreTimestamp;
 
+pub mod blue_only_mergeset_rule;
 pub mod no_transactions_rule;
 pub mod sync_rate_rule;