fixup! 19581f3

Author: f3r10

simln-lib/src/lib.rs

@@ -628,7 +628,6 @@ struct ExecutorKit {
 struct PaymentEvent {
     pubkey: PublicKey,
     absolute_time: SystemTime,
-    wait_time: Duration,
     destination: NodeInfo,
     capacity: Option<u64>,
 }
@@ -1069,15 +1068,15 @@ impl<C: Clock + 'static> Simulation<C> {
 
         // in order to choose a deterministic destination is necessary to sort the nodes by its public key
         executors.sort_by(|ex1, ex2| ex1.source_info.pubkey.cmp(&ex2.source_info.pubkey));
-
+        let now = SystemTime::now();
         for executor in executors {
             let pubkey = executor.source_info.pubkey;
             let payload = PaymentEventPayload {
                 executor,
                 current_count: 0,
             };
             payment_event_payloads.insert(pubkey, payload);
-            generate_payment(&mut heap, pubkey, 0, &mut payment_event_payloads).await?;
+            generate_payment(&mut heap, pubkey, 0, &mut payment_event_payloads, now).await?;
         }
 
         let listener = self.shutdown_listener.clone();
@@ -1097,11 +1096,22 @@ impl<C: Clock + 'static> Simulation<C> {
                     match heap.pop() {
                         Some(Reverse(PaymentEvent {
                             pubkey,
-                            absolute_time: _,
-                            wait_time,
+                            absolute_time,
                             destination,
                             capacity
                         })) => {
+                            let internal_now = SystemTime::now();
+                            let wait_time = match absolute_time.duration_since(internal_now) {
+                                Ok(elapsed) => {
+                                    // the output of duration_since is not perfectly round affecting the waiting time
+                                    // and as consequence the results are not deterministic; for this reason
+                                    // it is necessary to round the output.
+                                    Duration::from_secs(elapsed.as_secs_f64().round() as u64)
+                                },
+                                Err(_e) => {
+                                    Duration::from_secs(0)
+                                }
+                            };
                             let payload = payment_event_payloads.get(&pubkey).ok_or(SimulationError::PaymentGenerationError(
                                     PaymentGenerationError(format!("executor {} not found", pubkey)),
                             ))?;
@@ -1122,22 +1132,24 @@ impl<C: Clock + 'static> Simulation<C> {
                             // a payment amount something has gone wrong (because we should have validated that we can always
                             // generate amounts), so we exit.
                             let amount = payload.executor.payment_generator.payment_amount(capacity).map_err(SimulationError::PaymentGenerationError)?;
-                            generate_payment(&mut heap, pubkey, payload.current_count + 1, &mut payment_event_payloads).await?;
                             if amount == 0 {
                                 log::debug!(
                                     "Skipping zero amount payment for {source} -> {}.", destination
                                 );
+                                generate_payment(&mut heap, pubkey, payload.current_count, &mut payment_event_payloads, SystemTime::now()).await?;
                                 continue;
                             }
 
                             // Wait until our time to next payment has elapsed then execute a random amount payment to a random
                             // destination.
+                            let next_payment_count = payload.current_count + 1;
                             select! {
                                 biased;
                                 _ = listener.clone()  => {
                                     return Ok(())
                                 },
                                 _ = pe_clock.sleep(wait_time) => {
+                                    generate_payment(&mut heap, pubkey, next_payment_count, &mut payment_event_payloads, SystemTime::now()).await?;
                                     task_clone.spawn(async move {
                                         log::debug!("Generated payment: {source} -> {}: {amount} msat.", destination);
 
@@ -1501,19 +1513,19 @@ async fn generate_payment(
     pubkey: PublicKey,
     current_count: u64,
     payloads: &mut HashMap<PublicKey, PaymentEventPayload>,
+    base_time: SystemTime,
 ) -> Result<(), SimulationError> {
     let payload = payloads
         .get(&pubkey)
         .ok_or(SimulationError::PaymentGenerationError(
             PaymentGenerationError(format!("executor {} not found", pubkey)),
         ))?;
-    let now = SystemTime::now();
     let wait_time = get_payment_delay(
         current_count,
         &payload.executor.source_info,
         payload.executor.payment_generator.as_ref(),
     )?;
-    let absolute_time = now
+    let absolute_time = base_time
         .checked_add(wait_time)
         .ok_or("Overflow adding duration")
         .map_err(|e| {
@@ -1533,7 +1545,6 @@ async fn generate_payment(
     let payment_event = PaymentEvent {
         pubkey,
         absolute_time,
-        wait_time,
         destination,
         capacity,
     };
@@ -2054,24 +2065,25 @@ mod tests {
         let elapsed = start.elapsed();
 
         let expected_payment_list = vec![
-            node_2.pubkey,
             node_2.pubkey,
             node_4.pubkey,
             node_2.pubkey,
-            node_4.pubkey,
             node_2.pubkey,
             node_4.pubkey,
             node_2.pubkey,
+            node_2.pubkey,
+            node_4.pubkey,
             node_4.pubkey,
             node_4.pubkey,
         ];
 
-        // Check that simulation ran 30 because
+        // Check that simulation ran 20ish seconds because
         // from activity_1 there are 5 payments with a wait_time of 2s -> 10s
         // from activity_2 there are 5 payments with a wait_time of 4s -> 20s
+        // but the wait time is interleave between the payments.
         assert!(
-            elapsed >= Duration::from_secs(30),
-            "Simulation should have run at least for 30s, took {:?}",
+            elapsed <= Duration::from_secs(21),
+            "Simulation should have run no more than 21, took {:?}",
             elapsed
         );
 
@@ -2270,7 +2282,9 @@ mod tests {
             "Simulation should have run at least for 25s, took {:?}",
             elapsed
         );
-        let expected_payment_list = vec![pk1, pk2, pk1, pk1, pk1, pk3, pk3, pk2, pk4];
+        let expected_payment_list = vec![
+            pk1, pk2, pk1, pk1, pk1, pk3, pk3, pk3, pk4, pk3, pk2, pk1, pk4,
+        ];
         assert!(
             payments_list.lock().unwrap().as_ref() == expected_payment_list,
             "The expected order of payments is not correct"