sim-rs: support configuring tx-conflict-fraction

Author: SupernaviX

data/simulation/config.d.ts

@@ -75,6 +75,10 @@ export interface Config {
   "tx-validation-cpu-time-ms": number;
   /** Only supported by Rust simulation. */
   "tx-max-size-bytes": bigint;
+  /**
+   * What fraction of TXs (from 0 to 1) should introduce conflicts with transactions which were produced before?
+   * Only supported by Rust simulation.  */
+  "tx-conflict-fraction": number | null;
   /**
    * When the first transaction should appear.
    * Only supported by Rust simulation.  */

data/simulation/config.default.yaml

@@ -48,6 +48,7 @@ tx-size-bytes-distribution:
   sigma: 1.127
 tx-validation-cpu-time-ms: 1.5
 tx-max-size-bytes: 16384
+tx-conflict-fraction: 0
 
 ################################################################################
 # Ranking Block Configuration

data/simulation/config.schema.json

@@ -355,6 +355,10 @@
       "description": "When `true`, any delays and message sizes are calculated as if\neach block contained as much data as the expected average, rounded up.\nIn particular, for the sake of the above, we consider that:\n  - Each RB includes a certificate.\n  - Certificates contain votes from `vote-threshold` nodes.\n  - Vote bundles vote for `ceil eb-generation-probability` EBs.\n  - EBs reference `ceil (ib-generation-probability * leios-stage-length-slots)` IBs.\nOnly supported by Haskell simulation.",
       "type": "boolean"
     },
+    "tx-conflict-fraction": {
+      "description": "What fraction of TXs (from 0 to 1) should introduce conflicts with transactions which were produced before?\nOnly supported by Rust simulation.",
+      "type": "number"
+    },
     "tx-generation-distribution": {
       "$ref": "#/definitions/Distribution",
       "description": "Only supported by Rust simulation."

data/simulation/topology.d.ts

@@ -9,12 +9,12 @@
  */
 export interface Topology {
   nodes:
-    | {
-        [name: NodeName]: Node<Cluster>;
-      }
-    | {
-        [name: NodeName]: Node<Coord2D>;
-      };
+  | {
+    [name: NodeName]: Node<Cluster>;
+  }
+  | {
+    [name: NodeName]: Node<Coord2D>;
+  };
 }
 
 /** A node. */
@@ -23,6 +23,10 @@ export interface Node<Location> {
   "cpu-core-count"?: bigint | null;
   location: Location;
   producers: { [producer: NodeName]: LinkInfo };
+  /**
+   * What fraction of TXs (from 0 to 1) should introduce conflicts with transactions which were produced before?
+   * Only supported by Rust simulation.  */
+  "tx-conflict-fraction"?: number | null;
   /** If not null, the node will behave according to the given Behaviour.
   *
   * Only supported by Haskell simulation.

data/simulation/topology.schema.json

@@ -48,6 +48,10 @@
           "additionalProperties": false,
           "properties": {},
           "type": "number"
+        },
+        "tx-conflict-fraction": {
+          "description": "What fraction of TXs (from 0 to 1) should introduce conflicts with transactions which were produced before?\nOnly supported by Rust simulation.",
+          "type": "number"
         }
       },
       "type": "object"
@@ -87,6 +91,10 @@
           "additionalProperties": false,
           "properties": {},
           "type": "number"
+        },
+        "tx-conflict-fraction": {
+          "description": "What fraction of TXs (from 0 to 1) should introduce conflicts with transactions which were produced before?\nOnly supported by Rust simulation.",
+          "type": "number"
         }
       },
       "type": "object"

sim-rs/sim-cli/src/bin/gen-test-data/strategy/utils.rs

@@ -170,6 +170,7 @@ impl GraphBuilder {
                     stake: n.stake,
                     location: RawNodeLocation::Coords(n.location),
                     cpu_core_count: n.cores,
+                    tx_conflict_fraction: None,
                     producers: BTreeMap::new(),
                 };
                 (name, node)

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

@@ -76,6 +76,7 @@ pub struct RawParameters {
     pub tx_size_bytes_distribution: DistributionConfig,
     pub tx_validation_cpu_time_ms: f64,
     pub tx_max_size_bytes: u64,
+    pub tx_conflict_fraction: Option<f64>,
     pub tx_start_time: Option<f64>,
     pub tx_stop_time: Option<f64>,
 
@@ -177,6 +178,8 @@ pub struct RawNode {
     pub location: RawNodeLocation,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cpu_core_count: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tx_conflict_fraction: Option<f64>,
     pub producers: BTreeMap<String, RawLinkInfo>,
 }
 
@@ -254,6 +257,7 @@ impl From<RawTopology> for Topology {
                     stake: node.stake.unwrap_or_default(),
                     cpu_multiplier: 1.0,
                     cores: node.cpu_core_count,
+                    tx_conflict_fraction: node.tx_conflict_fraction,
                     consumers: vec![],
                 },
             );
@@ -403,6 +407,7 @@ impl TransactionConfig {
                 max_size: params.tx_max_size_bytes,
                 frequency_ms: params.tx_generation_distribution.into(),
                 size_bytes: params.tx_size_bytes_distribution.into(),
+                conflict_fraction: params.tx_conflict_fraction.unwrap_or_default(),
                 start_time: params
                     .tx_start_time
                     .map(|t| Timestamp::zero() + Duration::from_secs_f64(t)),
@@ -425,6 +430,7 @@ pub(crate) struct RealTransactionConfig {
     pub max_size: u64,
     pub frequency_ms: FloatDistribution,
     pub size_bytes: FloatDistribution,
+    pub conflict_fraction: f64,
     pub start_time: Option<Timestamp>,
     pub stop_time: Option<Timestamp>,
 }
@@ -547,6 +553,7 @@ pub struct NodeConfiguration {
     pub stake: u64,
     pub cpu_multiplier: f64,
     pub cores: Option<u64>,
+    pub tx_conflict_fraction: Option<f64>,
     pub consumers: Vec<NodeId>,
 }
 

sim-rs/sim-core/src/sim/tx.rs

@@ -11,10 +11,15 @@ use crate::{
     model::{Transaction, TransactionId},
 };
 
+struct NodeState {
+    sink: mpsc::UnboundedSender<Arc<Transaction>>,
+    tx_conflict_fraction: Option<f64>,
+}
+
 pub struct TransactionProducer {
     rng: ChaChaRng,
     clock: ClockBarrier,
-    node_tx_sinks: HashMap<NodeId, mpsc::UnboundedSender<Arc<Transaction>>>,
+    nodes: HashMap<NodeId, NodeState>,
     ib_shards: u64,
     config: Option<RealTransactionConfig>,
 }
@@ -23,13 +28,25 @@ impl TransactionProducer {
     pub fn new(
         rng: ChaChaRng,
         clock: ClockBarrier,
-        node_tx_sinks: HashMap<NodeId, mpsc::UnboundedSender<Arc<Transaction>>>,
+        mut node_tx_sinks: HashMap<NodeId, mpsc::UnboundedSender<Arc<Transaction>>>,
         config: &SimConfiguration,
     ) -> Self {
+        let nodes = config
+            .nodes
+            .iter()
+            .map(|node| {
+                let sink = node_tx_sinks.remove(&node.id).unwrap();
+                let state = NodeState {
+                    sink,
+                    tx_conflict_fraction: node.tx_conflict_fraction,
+                };
+                (node.id, state)
+            })
+            .collect();
         Self {
             rng,
             clock,
-            node_tx_sinks,
+            nodes,
             ib_shards: config.ib_shards,
             config: match &config.transactions {
                 TransactionConfig::Real(config) => Some(config.clone()),
@@ -43,7 +60,7 @@ impl TransactionProducer {
             self.clock.wait_forever().await;
             return Ok(());
         };
-        let node_count = self.node_tx_sinks.len();
+        let node_count = self.nodes.len();
         let mut next_tx_id = 0;
         let mut next_tx_at = Timestamp::zero();
         let mut next_input_id = 0;
@@ -55,27 +72,35 @@ impl TransactionProducer {
         };
 
         loop {
+            let node_index = rng.random_range(0..node_count);
+            let node_id = NodeId::new(node_index);
+            let node = self.nodes.get(&node_id).unwrap();
+
+            let conflict_fraction = node
+                .tx_conflict_fraction
+                .unwrap_or(config.conflict_fraction);
+
             let id = TransactionId::new(next_tx_id);
             let shard = rng.random_range(0..self.ib_shards);
             let bytes = (config.size_bytes.sample(&mut rng) as u64).min(config.max_size);
-            let input_id = next_input_id;
+            let input_id = if next_input_id > 0 && rng.random_bool(conflict_fraction) {
+                next_input_id - 1
+            } else {
+                let id = next_input_id;
+                next_input_id += 1;
+                id
+            };
+
             let tx = Transaction {
                 id,
                 shard,
                 bytes,
                 input_id,
             };
 
-            let node_index = rng.random_range(0..node_count);
-            let node_id = NodeId::new(node_index);
-
-            self.node_tx_sinks
-                .get(&node_id)
-                .unwrap()
-                .send(Arc::new(tx))?;
+            node.sink.send(Arc::new(tx))?;
 
             next_tx_id += 1;
-            next_input_id += 1;
             let millis_until_tx = config.frequency_ms.sample(&mut rng) as u64;
             next_tx_at += Duration::from_millis(millis_until_tx);