sim-rs: support "full without ibs" variant

Author: SupernaviX

data/simulation/config.d.ts

@@ -158,6 +158,14 @@ export interface Config {
    */
   "eb-max-age-for-relay-slots": bigint;
 
+  /**
+   * The maximum size of transactions (in bytes) which an EB can reference.
+   * Only relevant when running with the "full-without-ibs" variant.
+   * 
+   * Only supported by Rust simulation.
+   */
+  "eb-referenced-txs-max-size-bytes": bigint;
+
   // Vote Configuration
   "vote-generation-probability": number;
   "vote-generation-cpu-time-ms-constant": number;
@@ -234,6 +242,10 @@ export enum RelayStrategy {
 }
 
 export enum LeiosVariant {
+  /** Short Leios: EBs only reference IBs */
   Short = "short",
+  /** Full Leios: EBs reference IBs and other EBs */
   Full = "full",
+  /** Full Leios Without IBs: EBs reference TXs directly, as well as other EBs */
+  FullWithoutIbs = "full-without-ibs",
 }

data/simulation/config.default.yaml

@@ -153,6 +153,10 @@ eb-max-age-slots: 100
 # up to slot `s+eb-max-age-for-relay-slots`.
 eb-max-age-for-relay-slots: 40
 
+# The maximum size of transactions (in bytes) which an EB can reference.
+# Only relevant when running with the "full-without-ibs" variant.
+eb-referenced-txs-max-size-bytes: 16384000
+
 ################################################################################
 # Vote Configuration
 ################################################################################

data/simulation/config.schema.json

@@ -73,7 +73,7 @@
       "type": "object"
     },
     "LeiosVariant": {
-      "enum": ["short", "full"],
+      "enum": ["short", "full", "full-without-ibs"],
       "type": "string"
     },
     "LogNormalDistribution": {
@@ -179,6 +179,12 @@
       "properties": {},
       "type": "number"
     },
+    "eb-referenced-txs-max-size-bytes": {
+      "additionalProperties": false,
+      "description": "The maximum size of transactions (in bytes) which an EB can reference.\nOnly relevant when running with the \"full-without-ibs\" variant.\n\nOnly supported by Rust simulation.",
+      "properties": {},
+      "type": "number"
+    },
     "eb-size-bytes-constant": {
       "additionalProperties": false,
       "properties": {},

sim-rs/parameters/no-ibs.yaml

@@ -0,0 +1,3 @@
+leios-variant: full-without-ibs
+leios-late-ib-inclusion: true
+praos-chain-quality: 40

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

@@ -13,7 +13,7 @@ use pretty_bytes_rust::{pretty_bytes, PrettyBytesOptions};
 use serde::Serialize;
 use sim_core::{
     clock::Timestamp,
-    config::{NodeId, SimConfiguration},
+    config::{LeiosVariant, NodeId, SimConfiguration},
     events::{BlockRef, Event, Node},
     model::{BlockId, TransactionId},
 };
@@ -45,6 +45,7 @@ enum OutputFormat {
 }
 
 pub struct EventMonitor {
+    variant: LeiosVariant,
     node_ids: Vec<NodeId>,
     pool_ids: Vec<NodeId>,
     maximum_ib_age: u64,
@@ -69,6 +70,7 @@ impl EventMonitor {
         let stage_length = config.stage_length;
         let maximum_ib_age = stage_length * 3;
         Self {
+            variant: config.variant,
             node_ids,
             pool_ids,
             maximum_ib_age,
@@ -100,6 +102,7 @@ impl EventMonitor {
             self.pool_ids.into_iter().map(|id| (id, 0.0)).collect();
         let mut eb_votes: BTreeMap<EndorserBlockId, f64> = BTreeMap::new();
         let mut ib_txs: BTreeMap<InputBlockId, Vec<TransactionId>> = BTreeMap::new();
+        let mut eb_txs: BTreeMap<EndorserBlockId, Vec<TransactionId>> = BTreeMap::new();
         let mut eb_ibs: BTreeMap<EndorserBlockId, Vec<InputBlockId>> = BTreeMap::new();
         let mut eb_ebs: BTreeMap<EndorserBlockId, Vec<EndorserBlockId>> = BTreeMap::new();
         let mut leios_tx_bytes: BTreeMap<TransactionId, u64> = BTreeMap::new();
@@ -241,16 +244,23 @@ impl EventMonitor {
                         leios_blocks_with_endorsements += 1;
                         pending_ebs.retain(|eb| eb.slot != endorsement.eb.id.slot);
 
-                        let all_eb_ids = eb_ebs
+                        let all_eb_ids: Vec<_> = eb_ebs
                             .get(&endorsement.eb.id)
                             .unwrap()
                             .iter()
-                            .chain(std::iter::once(&endorsement.eb.id));
-                        let block_leios_txs: Vec<_> = all_eb_ids
+                            .chain(std::iter::once(&endorsement.eb.id))
+                            .collect();
+                        let block_ib_leios_txs = all_eb_ids
+                            .iter()
                             .flat_map(|eb| eb_ibs.get(eb).unwrap())
                             .flat_map(|ib| ib_txs.get(ib).unwrap())
-                            .copied()
-                            .collect();
+                            .copied();
+                        let block_eb_leios_txs = all_eb_ids
+                            .iter()
+                            .flat_map(|eb| eb_txs.get(eb).unwrap())
+                            .copied();
+                        let block_leios_txs: Vec<_> =
+                            block_ib_leios_txs.chain(block_eb_leios_txs).collect();
 
                         let mut unique_block_leios_txs: Vec<_> =
                             block_leios_txs.iter().copied().sorted().dedup().collect();
@@ -336,6 +346,7 @@ impl EventMonitor {
                 Event::EBLotteryWon { .. } => {}
                 Event::EBGenerated {
                     id,
+                    transactions,
                     input_blocks,
                     endorser_blocks,
                     size_bytes,
@@ -344,6 +355,7 @@ impl EventMonitor {
                     total_leios_bytes += size_bytes;
                     generated_ebs += 1;
                     pending_ebs.insert(id.clone());
+                    eb_txs.insert(id.clone(), transactions.iter().map(|r| r.id).collect());
                     eb_ibs.insert(
                         id.clone(),
                         input_blocks.iter().map(|r| r.id.clone()).collect(),
@@ -352,6 +364,12 @@ impl EventMonitor {
                         id.clone(),
                         endorser_blocks.into_iter().map(|r| r.id.clone()).collect(),
                     );
+                    for BlockRef { id: tx_id } in &transactions {
+                        let tx = txs.get_mut(tx_id).unwrap();
+                        if tx.included_in_eb.is_none() {
+                            tx.included_in_eb = Some(time);
+                        }
+                    }
                     for BlockRef { id: ib_id } in &input_blocks {
                         *ibs_in_eb.entry(id.clone()).or_default() += 1.0;
                         *ebs_containing_ib.entry(ib_id.clone()).or_default() += 1.0;
@@ -364,9 +382,10 @@ impl EventMonitor {
                         }
                     }
                     info!(
-                        "Pool {} generated an EB with {} IBs(s) in slot {}.",
+                        "Pool {} generated an EB with {} IB(s) and {} TX(s) in slot {}.",
                         id.producer,
                         input_blocks.len(),
+                        transactions.len(),
                         id.slot,
                     )
                 }
@@ -546,7 +565,9 @@ impl EventMonitor {
             info!("{} L1 block(s) had a Leios endorsement.", leios_blocks_with_endorsements);
             info!("{} tx(s) were referenced by a Leios endorsement.", unique_leios_txs);
             info!("{} tx(s) were included directly in a Praos block.", praos_txs);
-            info!("Spatial efficiency: {}/{} ({:.3}%) of Leios bytes were transactions.", pretty_bytes(total_leios_tx_bytes, pbo.clone()), pretty_bytes(total_leios_bytes, pbo.clone()), space_efficiency * 100.);
+            if self.variant != LeiosVariant::FullWithoutIbs {
+                info!("Spatial efficiency: {}/{} ({:.3}%) of Leios bytes were transactions.", pretty_bytes(total_leios_tx_bytes, pbo.clone()), pretty_bytes(total_leios_bytes, pbo.clone()), space_efficiency * 100.);
+            }
             info!("{} tx(s) ({:.3}%) referenced by a Leios endorsement were redundant.", leios_txs - unique_leios_txs, (leios_txs - unique_leios_txs) as f64 / leios_txs as f64 * 100.);
             info!(
                 "Each transaction took an average of {:.3}s (stddev {:.3}) to be included in an IB.",

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

@@ -106,6 +106,7 @@ pub struct RawParameters {
     pub eb_size_bytes_constant: u64,
     pub eb_size_bytes_per_ib: u64,
     pub eb_max_age_slots: u64,
+    pub eb_referenced_txs_max_size_bytes: u64,
 
     // Vote configuration
     pub vote_generation_probability: f64,
@@ -138,6 +139,7 @@ pub enum DiffusionStrategy {
 pub enum LeiosVariant {
     Short,
     Full,
+    FullWithoutIbs,
 }
 
 #[derive(Debug, Copy, Clone, Deserialize, PartialEq, Eq)]
@@ -434,7 +436,7 @@ pub struct SimConfiguration {
     pub stage_length: u64,
     pub max_eb_age: u64,
     pub late_ib_inclusion: bool,
-    pub(crate) variant: LeiosVariant,
+    pub variant: LeiosVariant,
     pub(crate) header_diffusion_time: Duration,
     pub(crate) relay_strategy: RelayStrategy,
     pub(crate) praos_chain_quality: u64,
@@ -446,6 +448,7 @@ pub struct SimConfiguration {
     pub(crate) vote_slot_length: u64,
     pub(crate) max_block_size: u64,
     pub(crate) max_ib_size: u64,
+    pub(crate) max_eb_size: u64,
     pub(crate) ib_diffusion_strategy: DiffusionStrategy,
     pub(crate) max_ib_requests_per_peer: usize,
     pub(crate) ib_shards: u64,
@@ -488,6 +491,7 @@ impl SimConfiguration {
             vote_slot_length: params.leios_stage_active_voting_slots,
             max_block_size: params.rb_body_max_size_bytes,
             max_ib_size: params.ib_body_max_size_bytes,
+            max_eb_size: params.eb_referenced_txs_max_size_bytes,
             ib_diffusion_strategy: params.ib_diffusion_strategy,
             max_ib_requests_per_peer: params.ib_diffusion_max_bodies_to_request as usize,
             ib_shards: params.ib_shards,

sim-rs/sim-core/src/events.rs

@@ -200,6 +200,9 @@ pub enum Event {
         pipeline: u64,
         producer: Node,
         size_bytes: u64,
+        #[serde(skip_serializing_if = "Vec::is_empty")]
+        transactions: Vec<BlockRef<TransactionId>>,
+        #[serde(skip_serializing_if = "Vec::is_empty")]
         input_blocks: Vec<BlockRef<InputBlockId<Node>>>,
         endorser_blocks: Vec<BlockRef<EndorserBlockId<Node>>>,
     },
@@ -526,6 +529,7 @@ impl EventTracker {
             pipeline: block.pipeline,
             producer: self.to_node(block.producer),
             size_bytes: block.bytes,
+            transactions: block.txs.iter().map(|id| BlockRef { id: *id }).collect(),
             input_blocks: block
                 .ibs
                 .iter()

sim-rs/sim-core/src/model.rs

@@ -167,7 +167,7 @@ pub struct EndorserBlock {
     pub pipeline: u64,
     pub producer: NodeId,
     pub bytes: u64,
-    // The real impl will store hashes
+    pub txs: Vec<TransactionId>,
     pub ibs: Vec<InputBlockId>,
     pub ebs: Vec<EndorserBlockId>,
 }