Merge pull request #1621 from brian-team/interrupt_hook

Interrupt hook (graceful stop with Ctrl+C)

Author: mstimberg

brian2/__init__.py

@@ -3,6 +3,7 @@
 """
 
 import logging
+import signal
 
 
 def _check_dependencies():
@@ -225,3 +226,37 @@ def _check_caches():
 
 
 _check_caches()
+
+
+class _InterruptHandler:
+    """
+    Class to turn a Ctrl+C interruption (SIGINT signal) into a `stop` signal for
+    a running simulation (i.e., finish simulating the current time step and then
+    stop). This handler is activated by default, but can be switched off by
+    setting the `core.stop_on_keyboard_interrupt` preference to ``False``.
+    Note that this will only handle interruptions during a `Network.run`,
+    interrupting at any other time will raise a `KeyboardInterrupt` in the
+    usual way. In case that finishing the current time step takes a long time
+    (or hangs for some reason), interrupting with Ctrl+C a second time will
+    force the usual interrupt, regardless of the preference setting.
+    """
+
+    def __init__(self, previous_handler):
+        self.previous_handler = previous_handler
+
+    def __call__(self, signalnum, stack_frame):
+        if (
+            not prefs.core.stop_on_keyboard_interrupt
+            or not Network._globally_running
+            or Network._globally_stopped
+        ):
+            self.previous_handler(signalnum, stack_frame)
+        else:
+            logging.getLogger("brian2").warning(
+                "Simulation stop requested. Press Ctrl+C again to interrupt."
+            )
+            Network._globally_stopped = True
+
+
+_int_handler = _InterruptHandler(signal.getsignal(signal.SIGINT))
+signal.signal(signal.SIGINT, _int_handler)

brian2/core/core_preferences.py

@@ -43,6 +43,14 @@ def default_float_dtype_validator(dtype):
         a warning (``False``).
         """,
     ),
+    stop_on_keyboard_interrupt=BrianPreference(
+        default=True,
+        docs="""
+        Whether to "gracefully" stop a simulation after pressing Ctrl+C (defaults to
+        ``True``). Note that pressing Ctrl+C a second time will force the usual
+        interruption mechanism.
+        """,
+    ),
 )
 
 prefs.register_preferences(

brian2/core/network.py

@@ -484,6 +484,7 @@ def profiling_info(self):
         return self.get_profiling_info()
 
     _globally_stopped = False
+    _globally_running = False
 
     def __getitem__(self, item):
         if not isinstance(item, str):
@@ -1197,6 +1198,7 @@ def run(
 
         active_objects = [obj for obj in all_objects if obj.active]
 
+        Network._globally_running = True
         while running and not self._stopped and not Network._globally_stopped:
             if not single_clock:
                 timestep, t, dt = self._clock_variables[clock]
@@ -1258,6 +1260,7 @@ def run(
                 running = timestep[0] < clock._i_end
 
         end_time = time.time()
+        Network._globally_running = False
         if self._stopped or Network._globally_stopped:
             self.t_ = clock.t_
         else:
@@ -1275,7 +1278,12 @@ def run(
                 obj._check_for_invalid_states()
 
         if report is not None:
-            report_callback((end_time - start_time) * second, 1.0, t_start, duration)
+            report_callback(
+                (end_time - start_time) * second,
+                device._last_run_completed_fraction,
+                t_start,
+                duration,
+            )
         self.after_run()
 
         logger.debug(

brian2/devices/cpp_standalone/device.py

@@ -24,6 +24,7 @@
 from brian2.codegen.generators.cpp_generator import c_data_type
 from brian2.core.functions import Function
 from brian2.core.namespace import get_local_namespace
+from brian2.core.network import Network
 from brian2.core.preferences import BrianPreference, prefs
 from brian2.core.variables import (
     ArrayVariable,
@@ -1287,15 +1288,19 @@ def run(
                 stdout = None
             if os.name == "nt":
                 start_time = time.time()
+                Network._globally_running = True
                 x = subprocess.call(["main"] + run_args, stdout=stdout)
                 self.timers["run_binary"] = time.time() - start_time
+                Network._globally_running = False
             else:
                 run_cmd = prefs.devices.cpp_standalone.run_cmd_unix
                 if isinstance(run_cmd, str):
                     run_cmd = [run_cmd]
                 start_time = time.time()
+                Network._globally_running = True
                 x = subprocess.call(run_cmd + run_args, stdout=stdout)
                 self.timers["run_binary"] = time.time() - start_time
+                Network._globally_running = False
             if stdout is not None:
                 stdout.close()
             if x:

brian2/devices/cpp_standalone/templates/main.cpp

@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include "objects.h"
+#include <csignal>
 #include <ctime>
 #include <time.h>
 {{ openmp_pragma('include') }}
@@ -33,8 +34,21 @@ void set_from_command_line(const std::vector<std::string> args)
 		brian::set_variable_by_name(name, value);
 	}
 }
+
+void _int_handler(int signal_num) {
+	if (Network::_globally_running and !Network::_globally_stopped) {
+		Network::_globally_stopped = true;
+	} else {
+		std::signal(signal_num, SIG_DFL);
+		std::raise(signal_num);
+	}
+}
+
 int main(int argc, char **argv)
 {
+	{% if prefs.core.stop_on_keyboard_interrupt %}
+	std::signal(SIGINT, _int_handler);
+	{% endif %}
 	std::random_device _rd;
 	std::vector<std::string> args(argv + 1, argv + argc);
 	if (args.size() >=2 && args[0] == "--results_dir")

brian2/devices/cpp_standalone/templates/network.cpp

@@ -12,6 +12,8 @@
 
 double Network::_last_run_time = 0.0;
 double Network::_last_run_completed_fraction = 0.0;
+bool Network::_globally_stopped = false;
+bool Network::_globally_running = false;
 
 Network::Network()
 {
@@ -63,7 +65,9 @@ void Network::run(const double duration, void (*report_func)(const double, const
     double elapsed_realtime;
     bool did_break_early = false;
 
-    while(clock && clock->running())
+    Network::_globally_running = true;
+    Network::_globally_stopped = false;
+    while(clock && clock->running() && !Network::_globally_stopped)
     {
         t = clock->t[0];
 
@@ -112,8 +116,12 @@ void Network::run(const double duration, void (*report_func)(const double, const
         {% endif %}
 
     }
+    Network::_globally_running = false;
 
-    if(!did_break_early) t = t_end;
+    if(!did_break_early && !Network::_globally_stopped)
+        t = t_end;
+    else
+        t = clock->t[0];
 
     _last_run_time = elapsed_realtime;
     if(duration>0)
@@ -124,7 +132,7 @@ void Network::run(const double duration, void (*report_func)(const double, const
     }
     if (report_func)
     {
-        report_func(elapsed_realtime, 1.0, t_start, duration);
+        report_func(elapsed_realtime, _last_run_completed_fraction, t_start, duration);
     }
 }
 
@@ -189,6 +197,8 @@ class Network
     double t;
     static double _last_run_time;
     static double _last_run_completed_fraction;
+    static bool _globally_stopped;
+    static bool _globally_running;
 
     Network();
     void clear();