apollo_consensus: use instance fields instead of constants in sim test

Author: asmaastarkware

crates/apollo_consensus/src/simulation_test.rs

@@ -25,8 +25,6 @@ use crate::types::{Decision, ProposalCommitment, Round, ValidatorId};
 use crate::votes_threshold::QuorumType;
 
 const HEIGHT_0: BlockNumber = BlockNumber(0);
-const TOTAL_NODES: usize = 100;
-const THRESHOLD: usize = (2 * TOTAL_NODES / 3) + 1;
 const NODE_0_LEADER_PROBABILITY: f64 = 0.1;
 const NODE_UNDER_TEST: usize = 0;
 
@@ -128,12 +126,16 @@ struct DiscreteEventSimulation {
     rng: StdRng,
     /// The seed used to initialize the simulation.
     seed: u64,
+    /// Total number of nodes in the network.
+    total_nodes: usize,
+    /// Number of honest nodes (the rest are faulty).
+    honest_nodes: usize,
+    /// Quorum threshold for reaching consensus (2/3 + 1 of total nodes).
+    quorum_threshold: usize,
     /// The single height consensus instance.
     shc: SingleHeightConsensus,
     /// All validators in the network.
     validators: Vec<ValidatorId>,
-    /// Number of honest nodes (the rest are faulty).
-    honest_nodes: usize,
     /// Priority queue of pending events that have yet to be processed (min-heap by tick).
     pending_events: BinaryHeap<TimedEvent>,
     /// Current simulation tick.
@@ -178,12 +180,16 @@ impl DiscreteEventSimulation {
             TimeoutsConfig::default(),
         );
 
+        let quorum_threshold = (2 * total_nodes / 3) + 1;
+
         Self {
             rng,
             seed,
+            total_nodes,
+            honest_nodes,
+            quorum_threshold,
             shc,
             validators,
-            honest_nodes,
             pending_events: BinaryHeap::new(),
             current_tick: 0,
             processed_history: Vec::new(),
@@ -219,17 +225,17 @@ impl DiscreteEventSimulation {
     /// Other nodes share the remaining probability (1 - NODE_0_LEADER_PROBABILITY) uniformly.
     /// The selection is deterministic per round - the same round will always return the same
     /// leader index.
-    fn get_leader_index(seed: u64, round: Round) -> usize {
+    fn get_leader_index(&self, round: Round) -> usize {
         let round_u64 = u64::from(round);
-        let round_seed = seed.wrapping_mul(31).wrapping_add(round_u64);
+        let round_seed = self.seed.wrapping_mul(31).wrapping_add(round_u64);
         let mut round_rng = StdRng::seed_from_u64(round_seed);
 
         let random_value: f64 = round_rng.gen();
 
         if random_value < NODE_0_LEADER_PROBABILITY {
             NODE_UNDER_TEST
         } else {
-            round_rng.gen_range(1..TOTAL_NODES)
+            round_rng.gen_range(1..self.total_nodes)
         }
     }
 
@@ -292,7 +298,7 @@ impl DiscreteEventSimulation {
     fn pre_generate_all_rounds(&mut self) {
         for round_idx in 0..self.num_rounds {
             let round = Round::from(u32::try_from(round_idx).unwrap());
-            let leader_idx = Self::get_leader_index(self.seed, round);
+            let leader_idx = self.get_leader_index(round);
             let leader_id = self.validators[leader_idx];
             // Track rounds where NODE_0 is the proposer.
             // We will schedule peer votes for these rounds after the build finish event.
@@ -415,7 +421,7 @@ impl DiscreteEventSimulation {
             }
             FaultType::NonValidator => {
                 // Send votes with a voter ID that is outside the validator set
-                let non_validator_id = ValidatorId::from(u64::try_from(TOTAL_NODES).unwrap());
+                let non_validator_id = ValidatorId::from(u64::try_from(self.total_nodes).unwrap());
                 self.schedule_prevote_and_precommit(
                     non_validator_id,
                     round,
@@ -468,8 +474,17 @@ impl DiscreteEventSimulation {
 
         let validators = self.validators.clone();
         let seed = self.seed;
+        let total_nodes = self.total_nodes;
         let leader_fn = move |r: Round| {
-            let idx = Self::get_leader_index(seed, r);
+            let round_u64 = u64::from(r);
+            let round_seed = seed.wrapping_mul(31).wrapping_add(round_u64);
+            let mut round_rng = StdRng::seed_from_u64(round_seed);
+            let random_value: f64 = round_rng.gen();
+            let idx = if random_value < NODE_0_LEADER_PROBABILITY {
+                NODE_UNDER_TEST
+            } else {
+                round_rng.gen_range(1..total_nodes)
+            };
             validators[idx]
         };
 
@@ -613,7 +628,7 @@ fn verify_result(sim: &DiscreteEventSimulation, result: Option<&Decision>) {
             });
             let total_precommits = peer_precommits + self_vote;
 
-            if total_precommits >= THRESHOLD {
+            if total_precommits >= sim.quorum_threshold {
                 Some((*r, *commitment, precommits.clone()))
             } else {
                 None
@@ -667,10 +682,10 @@ fn verify_result(sim: &DiscreteEventSimulation, result: Option<&Decision>) {
 
             // Verify quorum threshold is met
             assert!(
-                actual.precommits.len() >= THRESHOLD,
+                actual.precommits.len() >= sim.quorum_threshold,
                 "Insufficient precommits in decision: {}/{}. Decision: {:?}, History: {:?}",
                 actual.precommits.len(),
-                THRESHOLD,
+                sim.quorum_threshold,
                 actual,
                 sim.processed_history
             );
@@ -696,13 +711,14 @@ fn verify_result(sim: &DiscreteEventSimulation, result: Option<&Decision>) {
 fn test_consensus_simulation(keep_ratio: f64, honest_nodes: usize) {
     let seed = rand::thread_rng().gen();
     let num_rounds = 5; // Number of rounds to pre-generate
+    let total_nodes = 100;
     println!(
-        "Running consensus simulation with total nodes {TOTAL_NODES}, {num_rounds} rounds, keep \
+        "Running consensus simulation with total nodes {total_nodes}, {num_rounds} rounds, keep \
          ratio {keep_ratio}, honest nodes {honest_nodes} and seed: {seed}"
     );
 
     let mut sim =
-        DiscreteEventSimulation::new(TOTAL_NODES, honest_nodes, seed, num_rounds, keep_ratio);
+        DiscreteEventSimulation::new(total_nodes, honest_nodes, seed, num_rounds, keep_ratio);
 
     let deadline_ticks = u64::try_from(num_rounds).unwrap() * ROUND_DURATION;
     let result = sim.run(deadline_ticks);