Use timeout instead of dedicated PV for dispatching simulation

Author: JJL772

simulation_server/beamdriver.py

@@ -8,6 +8,7 @@
 from typing import Dict, Callable, Any
 from simulation_server.virtual_accelerator import VirtualAccelerator
 import threading
+from .utils.timer import Timer
 
 class SimServer(SimpleServer):
     """
@@ -83,6 +84,10 @@ def __init__(self, pvdb: dict, prefix: str = "", threading: bool = True):
         self._db[self.sim_pv_name] = {
             "value": 0
         }
+        self.sim_timeout_name = "VIRT:BEAM:SIMULATE_TIMEOUT"
+        self._db[self.sim_timeout_name] = {
+            "value": 0.5
+        }
 
         # Create CA PVs
         self.createPV(prefix, self._db)
@@ -287,6 +292,8 @@ def __init__(
         self.thread = threading.Thread(target=self._model_update_thread)
         self.new_data = {}
 
+        self.timer = Timer(0.5, self._trigger_sim, periodic=True, manual=True)
+
         # get list of pvs that should be updated every time we write to a PV
         self.measurement_pvs = self.get_measurement_pvs()
 
@@ -299,6 +306,12 @@ def __init__(
         self.update_cache(self.measurement_pvs, True)
 
         self.thread.start()
+        if self.server.threaded:
+            self.timer.start()
+
+    def _trigger_sim(self):
+        with self.write_guard:
+            self.thread_cond.notify_all()
 
     def _set_and_simulate(self, new_data: dict):
         """Updates PVs on the model, then updates the PV cache with results"""
@@ -316,9 +329,11 @@ def _model_update_thread(self):
             # Unlocked by thread_cond.wait()
             self.write_guard.acquire()
 
-            # Wait for a trigger
+            # Wait for a trigger (unlocks write_guard)
             self.thread_cond.wait()
 
+            print('Simulation triggered')
+
             start = time.time()
 
             # run simulation
@@ -435,24 +450,32 @@ def write(self, reason, value):
         """write to a PV, run the simulation, and then update all other PVs"""
         print(f"Writing {value} to {reason}")
 
+        # Update internal values quickly so readbacks dont fail
+        self.set_cached_value(reason, value, True)
+
+        # Halt countdown
+        self.timer.cancel()
+
         # Re-run the entire simulation if requested
         if reason == self.server.sim_pv_name:
             with self.write_guard:
-                self.set_cached_value(reason, value, True)
                 self.thread_cond.notify_all()
             return
 
+        # Adjust simulation timeout
+        if reason == self.server.sim_timeout_name:
+            self.timer.interval = int(value)
+            return
+
         # Single threaded mode; do all updates immediately
         if not self.server.threaded:
-            # Set new value for this PV and update monitors to make caput readback behave nicely
-            self.set_cached_value(reason, value, True)
             # Set changed PVs, and update the new values
             self._set_and_simulate({reason: value})
             return
 
         with self.write_guard:
-            # update the control PV fast
-            self.set_cached_value(reason, value, True)
-
             # this is sent to the updater thread
             self.new_data[reason] = value
+
+            # Begin simulation timeout period
+            self.timer.reset()

simulation_server/utils/timer.py

@@ -0,0 +1,91 @@
+
+from threading import Thread, Event
+
+class Timer(Thread):
+    """
+    Simple timer class that's better than the one provided by threading.Timer()
+    """
+    def __init__(self, interval: float, method, arg = None, periodic = False, manual = False):
+        """
+        Parameters
+        ----------
+        interval: float
+            Timer interval in seconds
+        method: Any
+            Callback on timer expiration
+        arg: Any
+            Argument for method()
+        periodic: bool
+            If set, the timer will continue executing after expiration. May be paired with manual
+        manual: bool
+            If set, the timer must be manually reset after expiration
+        """
+        Thread.__init__(self)
+        self._interval = interval
+        self._cancel_event = Event()
+        self._relaunch_event = Event()
+        self._periodic = periodic
+        self._arg = arg
+        self._method = method
+        self._manual = manual
+
+    @property
+    def interval(self) -> float:
+        return self._interval
+
+    @interval.setter
+    def interval(self, i: float):
+        """
+        Sets the interval to a specific value.
+        """
+        self._interval = i
+
+    @property
+    def periodic(self) -> bool:
+        return self._periodic
+    
+    @property
+    def manual(self) -> bool:
+        return self._manual
+
+    def reset(self):
+        """
+        Reset the timer
+        Manual timers need to call this explicitly to get a relaunch and initial launch.
+        For periodic timers, this method is equivalent to cancel()
+        """
+        self._cancel_event.set()
+        self._relaunch_event.set()
+
+    def cancel(self):
+        """
+        Cancels the timer.
+        Periodic timers will relaunch immediately.
+        For manual timers, this will halt the timer until a subsequent call to reset() is performed.
+        """
+        self._cancel_event.set()
+
+    def run(self):
+        """Do not call me directly! Use start() instead!"""
+        while True:
+            # manual threads must be relaunched explicitly
+            if self._manual:
+                self._relaunch_event.wait()
+            self._relaunch_event.clear()
+
+            # Wait for a timeout, or cancellation
+            self._cancel_event.clear()
+            if self._cancel_event.wait(self._interval):
+                self._cancel_event.clear() # Timer cancelled, restart
+                if not self._periodic:
+                    return
+                continue
+            self._cancel_event.clear()
+
+            if self._arg:
+                self._method(self._arg)
+            else:
+                self._method()
+
+            if not self._periodic:
+                return