Reworking/simplifying exit strategy.

Author: nicolasnoble

src/core/system.h

@@ -163,10 +163,12 @@ class System {
     // Close mem and plugins
     virtual void close() = 0;
     virtual void purgeAllEvents() = 0;
-    bool running() { return m_running; }
+    bool running() {
+        std::atomic_signal_fence(std::memory_order_relaxed);
+        return m_running && !m_quitting;
+    }
     const bool *runningPtr() { return &m_running; }
     bool quitting() { return m_quitting; }
-    bool terminating() { return m_terminating; }
     int exitCode() { return m_exitCode; }
     bool emergencyExit() { return m_emergencyExit; }
     [[gnu::cold]] void pause(bool exception = false) {
@@ -175,22 +177,15 @@ class System {
         m_eventBus->signal(Events::ExecutionFlow::Pause{exception});
     }
     void resume() {
-        if (m_running || m_terminating) return;
+        if (m_running) return;
         m_running = true;
         m_eventBus->signal(Events::ExecutionFlow::Run{});
     }
     virtual void testQuit(int code) = 0;
-    [[gnu::cold]] void terminateSignalSafe() {
-        // about the only thing signal handlers can do safely is switch a flag
-        m_terminating = true;
-        m_running = false;
-    }
+    // This needs to only mutate variables, as it requires to be signal-safe.
     [[gnu::cold]] void quit(int code = 0) {
         m_quitting = true;
-        pause();
         m_exitCode = code;
-        m_eventBus->signal(Events::Quitting{});
-        purgeAllEvents();
     }
 
     std::shared_ptr<EventBus::EventBus> m_eventBus = std::make_shared<EventBus::EventBus>();
@@ -263,9 +258,18 @@ class System {
     std::map<uint64_t, std::string> m_i18n;
     std::map<std::string, decltype(m_i18n)> m_locales;
     std::string m_currentLocale;
+    // If true, indicates that the emulator is currently capturing the main loop
+    // and actively emulates the PSX hardware. If false, the emulator is paused,
+    // waiting for user input or other events inside the UI. The way the UI
+    // is refreshed is by calling update() periodically, so this boolean affects
+    // the moment when and how update() is called.
     bool m_running = false;
+    // If true, indicates that the emulator is quitting. This can be set by a
+    // number of events, including the user pressing the quit button or the
+    // emulator itself requesting a quit due to testing for instance. This will
+    // cause the two main loop to exit: the inner one being the emulator itself,
+    // and the outer one being the main.cc loop.
     bool m_quitting = false;
-    bool m_terminating = false;
     int m_exitCode = 0;
     struct LocaleInfo {
         const std::string filename;

src/main/main.cc

@@ -116,8 +116,6 @@ class SystemImpl final : public PCSX::System {
         // emulator is requesting a shutdown of the emulation
     }
 
-    virtual void purgeAllEvents() final override { uv_run(getLoop(), UV_RUN_DEFAULT); }
-
     virtual void testQuit(int code) final override {
         if (m_args.isTestModeEnabled()) {
             quit(code);
@@ -134,6 +132,8 @@ class SystemImpl final : public PCSX::System {
     const PCSX::Arguments m_args;
 
   public:
+    virtual void purgeAllEvents() final override { uv_run(getLoop(), UV_RUN_DEFAULT); }
+
     void setBinDir(std::filesystem::path path) {
         m_binDir = path;
         m_version.loadFromFile(new PCSX::PosixFile(path / "version.json"));
@@ -167,7 +167,7 @@ struct Cleaner {
 };
 
 void handleSignal(int signal) {
-    PCSX::g_system->terminateSignalSafe();
+    PCSX::g_system->quit(-1);
 }
 
 int pcsxMain(int argc, char **argv) {
@@ -454,15 +454,14 @@ runner.init({
                     emulator->m_cpu->Execute();
                 } else {
                     // The "update" method will be called periodically by the emulator while
-                    // meaning if we want our UI to work, we have to manually call "update"
-                    // when the emulator is paused.
+                    // it's running, meaning if we want our UI to work, we have to manually
+                    // call "update" when the emulator is paused.
                     s_ui->update();
                 }
-				if (system->terminating()) {
-					PCSX::g_system->quit(-1);
-					return exitCode;
-				}
             }
+            system->pause();
+            system->m_eventBus->signal(PCSX::Events::Quitting{});
+            system->purgeAllEvents();
         } catch (...) {
             // This will ensure we don't do certain cleanups that are awaiting other tasks,
             // which could result in deadlocks on exit in case we encountered a serious problem.