sim-rs: RB includes oldest non-expired EB first

Author: SupernaviX

data/simulation/config.d.ts

@@ -91,9 +91,7 @@ export interface Config {
   /**
    * The maximum age of EBs included in RBs:
    * an EB from slot `s` can only be included in RBs
-   * up to slot `s+eb-max-age-slots`.
-   *
-   * Only supported by Haskell simulation. */
+   * up to slot `s+eb-max-age-slots`. */
   "eb-max-age-slots": bigint;
 
   // Vote Configuration

data/simulation/config.schema.json

@@ -165,7 +165,7 @@
     },
     "eb-max-age-slots": {
       "additionalProperties": false,
-      "description": "The maximum age of EBs included in RBs:\nan EB from slot `s` can only be included in RBs\nup to slot `s+eb-max-age-slots`.\n\nOnly supported by Haskell simulation.",
+      "description": "The maximum age of EBs included in RBs:\nan EB from slot `s` can only be included in RBs\nup to slot `s+eb-max-age-slots`.",
       "properties": {},
       "type": "number"
     },

sim-rs/sim-cli/src/events.rs

@@ -40,8 +40,8 @@ enum OutputFormat {
 pub struct EventMonitor {
     node_ids: Vec<NodeId>,
     pool_ids: Vec<NodeId>,
-    stage_length: u64,
     maximum_ib_age: u64,
+    maximum_eb_age: u64,
     events_source: mpsc::UnboundedReceiver<(Event, Timestamp)>,
     output_path: Option<PathBuf>,
 }
@@ -63,8 +63,8 @@ impl EventMonitor {
         Self {
             node_ids,
             pool_ids,
-            stage_length,
             maximum_ib_age,
+            maximum_eb_age: config.max_eb_age,
             events_source,
             output_path,
         }
@@ -85,6 +85,7 @@ impl EventMonitor {
         let mut ibs_containing_tx: BTreeMap<TransactionId, f64> = BTreeMap::new();
         let mut ebs_containing_ib: BTreeMap<InputBlockId, f64> = BTreeMap::new();
         let mut pending_ibs: BTreeSet<InputBlockId> = BTreeSet::new();
+        let mut pending_ebs: BTreeSet<EndorserBlockId> = BTreeSet::new();
         let mut votes_per_bundle: BTreeMap<VoteBundleId, f64> = BTreeMap::new();
         let mut votes_per_pool: BTreeMap<NodeId, f64> =
             self.pool_ids.into_iter().map(|id| (id, 0.0)).collect();
@@ -99,6 +100,7 @@ impl EventMonitor {
         let mut generated_ibs = 0u64;
         let mut empty_ibs = 0u64;
         let mut expired_ibs = 0u64;
+        let mut expired_ebs = 0u64;
         let mut generated_ebs = 0u64;
         let mut total_votes = 0u64;
         let mut leios_blocks_with_endorsements = 0u64;
@@ -152,19 +154,24 @@ impl EventMonitor {
                 Event::Slot { number } => {
                     info!("Slot {number} has begun.");
                     total_slots = number + 1;
-                    if number % self.stage_length == 0 {
-                        let Some(oldest_live_stage) = number.checked_sub(self.maximum_ib_age)
-                        else {
-                            continue;
-                        };
+                    if let Some(oldest_live_ib_slot) = number.checked_sub(self.maximum_ib_age) {
                         pending_ibs.retain(|ib| {
-                            if ib.slot < oldest_live_stage {
+                            if ib.slot < oldest_live_ib_slot {
                                 expired_ibs += 1;
                                 return false;
                             }
                             true
                         });
                     }
+                    if let Some(oldest_live_eb_slot) = number.checked_sub(self.maximum_eb_age) {
+                        pending_ebs.retain(|eb| {
+                            if eb.slot < oldest_live_eb_slot {
+                                expired_ebs += 1;
+                                return false;
+                            }
+                            true
+                        });
+                    }
                 }
                 Event::CpuTaskScheduled { .. } => {}
                 Event::CpuTaskFinished { .. } => {}
@@ -196,6 +203,8 @@ impl EventMonitor {
                     praos_txs += all_txs.len() as u64;
                     if let Some(endorsement) = endorsement {
                         leios_blocks_with_endorsements += 1;
+                        pending_ebs.retain(|eb| eb.slot != endorsement.eb.slot);
+
                         let block_leios_txs: Vec<_> = eb_ibs
                             .get(&endorsement.eb)
                             .unwrap()
@@ -283,6 +292,7 @@ impl EventMonitor {
                     id, input_blocks, ..
                 } => {
                     generated_ebs += 1;
+                    pending_ebs.insert(id.clone());
                     eb_ibs.insert(id.clone(), input_blocks.clone());
                     for ib_id in &input_blocks {
                         *ibs_in_eb.entry(id.clone()).or_default() += 1.0;
@@ -454,6 +464,10 @@ impl EventMonitor {
                 "{} out of {} IBs expired before they reached an EB.",
                 expired_ibs, generated_ibs,
             );
+            info!(
+                "{} out of {} EBs expired before an EB from their stage reached an RB.",
+                expired_ebs, generated_ebs,
+            );
             info!(
                 "{} out of {} transaction(s) were included in at least one EB.",
                 times_to_reach_eb.len(), txs.len(),

sim-rs/sim-core/src/config.rs

@@ -95,6 +95,7 @@ pub struct RawParameters {
     pub eb_validation_cpu_time_ms: f64,
     pub eb_size_bytes_constant: u64,
     pub eb_size_bytes_per_ib: u64,
+    pub eb_max_age_slots: u64,
 
     // Vote configuration
     pub vote_generation_probability: f64,
@@ -402,6 +403,7 @@ pub struct SimConfiguration {
     pub nodes: Vec<NodeConfiguration>,
     pub links: Vec<LinkConfiguration>,
     pub stage_length: u64,
+    pub max_eb_age: u64,
     pub(crate) relay_strategy: RelayStrategy,
     pub(crate) block_generation_probability: f64,
     pub(crate) ib_generation_probability: f64,
@@ -440,6 +442,7 @@ impl SimConfiguration {
             ib_diffusion_strategy: params.ib_diffusion_strategy,
             max_ib_requests_per_peer: 1,
             ib_shards: params.ib_shards,
+            max_eb_age: params.eb_max_age_slots,
             cpu_times: CpuTimeConfig::new(&params),
             sizes: BlockSizeConfig::new(&params),
             transactions: TransactionConfig::new(&params),

sim-rs/sim-core/src/sim/node.rs

@@ -649,7 +649,7 @@ impl Node {
         };
 
         // Let's see if we are minting an RB
-        let endorsement = self.choose_endorsed_block();
+        let endorsement = self.choose_endorsed_block(slot);
         if let Some(endorsement) = &endorsement {
             // If we are, get all referenced TXs out of the mempool
             let Some(eb) = self.leios.ebs.get(&endorsement.eb) else {
@@ -707,9 +707,11 @@ impl Node {
         Ok(())
     }
 
-    fn choose_endorsed_block(&mut self) -> Option<Endorsement> {
+    fn choose_endorsed_block(&mut self, slot: u64) -> Option<Endorsement> {
         // an EB is eligible for endorsement if it has this many votes
         let vote_threshold = self.sim_config.vote_threshold;
+        // and it is not older than this
+        let max_eb_age = self.sim_config.max_eb_age;
         // and if it is not in a pipeline already represented in the chain
         // (NB: all EBs produced in a pipeline are produced during the same slot)
         let forbidden_slots: HashSet<u64> = self
@@ -720,18 +722,25 @@ impl Node {
             .map(|e| e.eb.slot)
             .collect();
 
+        // Choose an EB based on, in order,
+        //  - the age of the EB (older EBs take priority)
+        //  - the TXs in the EB (more TXs take priority)
+        //  - the number of votes (more votes is better)
         let (&block, _) = self
             .leios
             .votes_by_eb
             .iter()
             .filter_map(|(eb, votes)| {
+                if slot - eb.slot > max_eb_age || forbidden_slots.contains(&eb.slot) {
+                    return None;
+                }
                 let vote_count: usize = votes.values().sum();
-                if (vote_count as u64) < vote_threshold || forbidden_slots.contains(&eb.slot) {
+                if (vote_count as u64) < vote_threshold {
                     return None;
                 }
                 Some((eb, vote_count))
             })
-            .max_by_key(|(eb, votes)| (self.count_txs_in_eb(eb), *votes))?;
+            .max_by_key(|(eb, votes)| (slot - eb.slot, self.count_txs_in_eb(eb), *votes))?;
 
         let (block, votes) = self.leios.votes_by_eb.remove_entry(&block)?;
         let bytes = self.sim_config.sizes.cert(votes.len());