Change do_tick to take elapsed time since start instead of since the previous tick

Author: object-Object

src/bin/mlogv32.rs

@@ -143,7 +143,7 @@ enum VMEvent {
 fn tui(stdout: TextContent, debug: TextContent, tx: Sender<VMCommand>, rx: Receiver<VMEvent>) {
     let mut siv = cursive::crossterm().into_runner();
 
-    siv.set_fps(10);
+    siv.set_fps(20);
     siv.set_theme(Theme::terminal_default());
 
     siv.add_fullscreen_layer(
@@ -219,7 +219,7 @@ fn tui(stdout: TextContent, debug: TextContent, tx: Sender<VMCommand>, rx: Recei
                 }
             }
         }
-        if last_state_time.elapsed().as_secs_f64() > (1. / 4.) {
+        if last_state_time.elapsed().as_secs_f64() > (1. / 8.) {
             tx.send(VMCommand::GetState).unwrap();
             last_state_time = Instant::now();
         }
@@ -382,8 +382,10 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     println!("Initializing processors...");
 
+    let mut time = Duration::ZERO;
     for _ in 0..500 {
-        vm.do_tick(Duration::from_secs_f64(1. / 60.));
+        vm.do_tick(time);
+        time += Duration::from_secs_f64(1. / 60.);
     }
 
     // switch to TUI
@@ -433,16 +435,12 @@ fn main() -> Result<(), Box<dyn Error>> {
         prev_single_step = !*single_step;
     }
 
-    tui_println!(debug, "Starting.");
-
     let mut ticks = 0;
-    let mut now = Instant::now() - Duration::from_secs_f64(1. / 60.);
     let mut start = Instant::now();
 
     loop {
-        vm.do_tick(now.elapsed());
+        vm.do_tick(start.elapsed());
         ticks += 1;
-        now = Instant::now();
 
         if let BuildingData::Switch(power) = &mut *power_switch.data.borrow_mut()
             && let BuildingData::Switch(pause) = &mut *pause_switch.data.borrow_mut()
@@ -490,7 +488,9 @@ fn main() -> Result<(), Box<dyn Error>> {
                         if *power != prev_power {
                             tx_event.send(VMEvent::Power(*power))?;
                             prev_power = *power;
-                            if !*power {
+                            if *power {
+                                tui_println!(debug, "Starting.");
+                            } else {
                                 let elapsed = start.elapsed();
                                 tui_println!(debug, "Processor halted.");
                                 if !error_output.is_empty() {

src/logic/vm/mod.rs

@@ -61,12 +61,11 @@ impl LogicVM {
     /// Run the simulation until all processors halt, or until a number of ticks are finished.
     /// Returns true if all processors halted, or false if the tick limit was reached.
     pub fn run(&self, max_ticks: Option<usize>) -> bool {
-        let mut now = Instant::now();
+        let start = Instant::now();
         let mut tick = 0;
 
         loop {
-            self.do_tick(now.elapsed());
-            now = Instant::now();
+            self.do_tick(start.elapsed());
 
             if self.running_processors.get() == 0 {
                 // all processors finished, return true
@@ -85,10 +84,10 @@ impl LogicVM {
 
     /// Execute one tick of the simulation.
     ///
-    /// Note: negative delta values will be ignored.
-    pub fn do_tick(&self, delta: Duration) {
+    /// Note: `time` is the time elapsed since the *start* of the simulation.
+    pub fn do_tick(&self, time: Duration) {
         // never move time backwards
-        let time = self.time.get() + duration_millis_f64(delta).max(0.);
+        let time = duration_millis_f64(time);
         self.time.set(time);
 
         for processor in self.iter_processors() {
@@ -1839,25 +1838,29 @@ mod tests {
             ",
         );
 
-        vm.do_tick(Duration::ZERO);
+        let mut time = Duration::ZERO;
+        vm.do_tick(time);
 
         with_processor(&mut vm, (0, 0), |p| {
             assert_eq!(p.state.decode_printbuffer(), "123");
         });
 
-        vm.do_tick(Duration::from_secs_f64(1. / 60.));
+        time += Duration::from_secs_f64(1. / 60.);
+        vm.do_tick(time);
 
         with_processor(&mut vm, (0, 0), |p| {
             assert_eq!(p.state.decode_printbuffer(), "1234");
         });
 
-        vm.do_tick(Duration::from_millis(500));
+        time += Duration::from_millis(500);
+        vm.do_tick(time);
 
         with_processor(&mut vm, (0, 0), |p| {
             assert_eq!(p.state.decode_printbuffer(), "1234");
         });
 
-        vm.do_tick(Duration::from_millis(500));
+        time += Duration::from_millis(500);
+        vm.do_tick(time);
 
         with_processor(&mut vm, (0, 0), |p| {
             assert_eq!(p.state.decode_printbuffer(), "12345");
@@ -2584,17 +2587,22 @@ mod tests {
             ",
         );
 
-        vm.do_tick(Duration::ZERO);
-        vm.do_tick(Duration::ZERO);
+        let mut time = Duration::ZERO;
 
-        vm.do_tick(Duration::from_secs(1));
-        vm.do_tick(Duration::ZERO);
+        vm.do_tick(time);
+        vm.do_tick(time);
 
-        vm.do_tick(Duration::from_millis(1));
-        vm.do_tick(Duration::ZERO);
+        time += Duration::from_secs(1);
+        vm.do_tick(time);
+        vm.do_tick(time);
 
-        vm.do_tick(Duration::from_secs(60));
-        vm.do_tick(Duration::ZERO);
+        time += Duration::from_millis(1);
+        vm.do_tick(time);
+        vm.do_tick(time);
+
+        time += Duration::from_secs(60);
+        vm.do_tick(time);
+        vm.do_tick(time);
 
         let processor = take_processor(&mut vm, (0, 0));
         assert_variables_epsilon(