fix(sim): Make simulation process actually continuous (#86)

* fix(sim): Make simulation process actually continuous

Right now, the simulator stops as soon as there are no more items to simulate. This actually is not correct behavior, as we could be early in the slot, with more items coming in later in the slot which could yield a higher total payout on the block.

What we actually want, is to simply skip doing the round at all if there are no items, sleep for a certain amount of time (bounded by the deadline), and either break (if we slept until the deadline) or continue if there's still time remaining.

The resulting behavior is that the simulator always runs until the deadline, ensuring that items that come later in the slot, up until the deadline, can be simulated and included in the block.

* chore: properly break if we sleep until deadline

* chore: make amount of time in ms that the sim sleeps a constant

* chore: rm dumb comparison

* chore: rm newline

* chore: simplify logic

* chore:
comment

* chore: bias select!

Author: Evalir

crates/sim/src/task.rs

@@ -1,13 +1,17 @@
 use crate::{env::SimEnv, BuiltBlock, SharedSimEnv, SimCache, SimDb};
 use signet_types::constants::SignetSystemConstants;
-use tokio::select;
+use std::time::Duration;
+use tokio::{select, time::Instant};
 use tracing::{debug, info_span, trace, Instrument};
 use trevm::{
     helpers::Ctx,
     revm::{inspector::NoOpInspector, DatabaseRef, Inspector},
     Block, Cfg,
 };
 
+/// The amount of time to sleep between simulation rounds when there are no items to simulate.
+pub(crate) const SIM_SLEEP_MS: u64 = 50;
+
 /// Builds a single block by repeatedly invoking [`SimEnv`].
 #[derive(Debug)]
 pub struct BlockBuild<Db, Insp = NoOpInspector> {
@@ -76,9 +80,29 @@ where
         loop {
             let span = info_span!("build", round = i);
             let finish_by = self.finish_by.into();
+
+            let next_round_time = Instant::now() + Duration::from_millis(SIM_SLEEP_MS);
+
+            // If the next round time is past the deadline, we stop the simulation loop.
+            // This will stop the simulation even if there are items, but that is an acceptable tradeoff
+            // as we must ensure there's enough time to submit the blob to the host chain.
+            if next_round_time >= finish_by {
+                debug!("Next round time is past the deadline, stopping sim loop");
+                break;
+            }
+
+            // Only simulate if there are items to simulate.
+            // If there are not items, we sleep for [`SIM_SLEEP_MS`] and restart the loop.
+            if self.env.sim_items().is_empty() {
+                tokio::time::sleep_until(next_round_time).await;
+                continue;
+            }
+
+            // If there are items to simulate, we run a simulation round.
             let fut = self.round().instrument(span);
 
             select! {
+                biased;
                 _ = tokio::time::sleep_until(finish_by) => {
                     debug!("Deadline reached, stopping sim loop");
                     break;
@@ -87,10 +111,6 @@ where
                     i+= 1;
                     let remaining = self.env.sim_items().len();
                     trace!(%remaining, round = i, "Round completed");
-                    if remaining == 0 {
-                        debug!("No more items to simulate, stopping sim loop");
-                        break;
-                    }
                 }
             }
         }