Fix start/stop race condition hang.

Author: Mysticial

SerialPrograms/Source/CommonFramework/Globals.cpp

@@ -26,7 +26,7 @@ namespace PokemonAutomation{
 const bool IS_BETA_VERSION = true;
 const int PROGRAM_VERSION_MAJOR = 0;
 const int PROGRAM_VERSION_MINOR = 54;
-const int PROGRAM_VERSION_PATCH = 15;
+const int PROGRAM_VERSION_PATCH = 16;
 
 const std::string PROGRAM_VERSION_BASE =
     "v" + std::to_string(PROGRAM_VERSION_MAJOR) +

SerialPrograms/Source/NintendoSwitch/Framework/NintendoSwitch_MultiSwitchProgramSession.cpp

@@ -25,13 +25,11 @@ namespace NintendoSwitch{
 
 void MultiSwitchProgramSession::add_listener(Listener& listener){
     auto ScopeCheck = m_sanitizer.check_scope();
-    WriteSpinLock lg(m_lock);
-    m_listeners.insert(&listener);
+    m_listeners.add(listener);
 }
 void MultiSwitchProgramSession::remove_listener(Listener& listener){
     auto ScopeCheck = m_sanitizer.check_scope();
-    WriteSpinLock lg(m_lock);
-    m_listeners.erase(&listener);
+    m_listeners.remove(listener);
 }
 
 
@@ -100,7 +98,13 @@ void MultiSwitchProgramSession::run_program_instance(MultiSwitchProgramEnvironme
         );
     }
 
-    m_scope.store(&scope, std::memory_order_release);
+    {
+        std::lock_guard<std::mutex> lg(program_lock());
+        if (current_state() != ProgramState::RUNNING){
+            return;
+        }
+        m_scope.store(&scope, std::memory_order_release);
+    }
 
     try{
         m_option.instance().program(env, scope);
@@ -114,31 +118,28 @@ void MultiSwitchProgramSession::run_program_instance(MultiSwitchProgramEnvironme
                 env.consoles[c].controller().cancel_all_commands();
             }catch (...){}
         }
+        std::lock_guard<std::mutex> lg(program_lock());
         m_scope.store(nullptr, std::memory_order_release);
         throw;
     }
+
+    std::lock_guard<std::mutex> lg(program_lock());
     m_scope.store(nullptr, std::memory_order_release);
 }
 void MultiSwitchProgramSession::internal_stop_program(){
     auto ScopeCheck = m_sanitizer.check_scope();
-    WriteSpinLock lg(m_lock);
-//    size_t consoles = m_system.count();
-//    for (size_t c = 0; c < consoles; c++){
-//        m_system[c].serial_session().stop();
-//    }
-    CancellableScope* scope = m_scope.load(std::memory_order_acquire);
-    if (scope != nullptr){
-        scope->cancel(std::make_exception_ptr(ProgramCancelledException()));
+    {
+        std::lock_guard<std::mutex> lg(program_lock());
+        CancellableScope* scope = m_scope.load(std::memory_order_acquire);
+        if (scope != nullptr){
+            scope->cancel(std::make_exception_ptr(ProgramCancelledException()));
+        }
     }
 
     //  Wait for program thread to finish.
     while (m_scope.load(std::memory_order_acquire) != nullptr){
         pause();
     }
-
-//    for (size_t c = 0; c < consoles; c++){
-//        m_system[c].serial_session().reset();
-//    }
 }
 void MultiSwitchProgramSession::internal_run_program(){
     auto ScopeCheck = m_sanitizer.check_scope();
@@ -273,11 +274,8 @@ void MultiSwitchProgramSession::shutdown(){
 }
 void MultiSwitchProgramSession::startup(size_t switch_count){
     auto ScopeCheck = m_sanitizer.check_scope();
-    WriteSpinLock lg(m_lock);
     m_option.instance().update_active_consoles(switch_count);
-    for (Listener* listener : m_listeners){
-        listener->redraw_options();
-    }
+    m_listeners.run_method_unique(&Listener::redraw_options);
 }
 
 

SerialPrograms/Source/NintendoSwitch/Framework/NintendoSwitch_MultiSwitchProgramSession.h

@@ -59,10 +59,9 @@ class MultiSwitchProgramSession final : public ProgramSession, private MultiSwit
     MultiSwitchProgramOption& m_option;
     MultiSwitchSystemSession m_system;
 
-    SpinLock m_lock;
     std::atomic<CancellableScope*> m_scope;
 
-    std::set<Listener*> m_listeners;
+    ListenerSet<Listener> m_listeners;
 
     LifetimeSanitizer m_sanitizer;
 };

SerialPrograms/Source/NintendoSwitch/Framework/NintendoSwitch_SingleSwitchProgramSession.cpp

@@ -79,7 +79,13 @@ void SingleSwitchProgramSession::run_program_instance(SingleSwitchProgramEnviron
     );
 
     ControllerContext<AbstractController> context(scope, env.console.controller());
-    m_scope.store(&context, std::memory_order_release);
+    {
+        std::lock_guard<std::mutex> lg(program_lock());
+        if (current_state() != ProgramState::RUNNING){
+            return;
+        }
+        m_scope.store(&context, std::memory_order_release);
+    }
 
 #ifdef PA_CATCH_PROGRAM_SYSTEM_EXCEPTIONS
     try{
@@ -94,18 +100,21 @@ void SingleSwitchProgramSession::run_program_instance(SingleSwitchProgramEnviron
     }
 #else
     {
-        m_option.instance().program(env, scope);
-        env.console.controller().wait_for_all(&scope);
+        m_option.instance().program(env, context);
+        context.wait_for_all_requests();
     }
 #endif
+
+    std::lock_guard<std::mutex> lg(program_lock());
     m_scope.store(nullptr, std::memory_order_release);
 }
 void SingleSwitchProgramSession::internal_stop_program(){
-    WriteSpinLock lg(m_lock);
-
-    CancellableScope* scope = m_scope.load(std::memory_order_acquire);
-    if (scope != nullptr){
-        scope->cancel(std::make_exception_ptr(ProgramCancelledException()));
+    {
+        std::lock_guard<std::mutex> lg(program_lock());
+        CancellableScope* scope = m_scope.load(std::memory_order_acquire);
+        if (scope != nullptr){
+            scope->cancel(std::make_exception_ptr(ProgramCancelledException()));
+        }
     }
 
     //  Wait for program thread to finish.

SerialPrograms/Source/NintendoSwitch/Framework/NintendoSwitch_SingleSwitchProgramSession.h

@@ -15,7 +15,6 @@
 #ifndef PokemonAutomation_NintendoSwitch_SingleSwitchProgramSession_H
 #define PokemonAutomation_NintendoSwitch_SingleSwitchProgramSession_H
 
-#include "Common/Cpp/Concurrency/SpinLock.h"
 #include "CommonFramework/ProgramSession.h"
 #include "NintendoSwitch_SwitchSystemSession.h"
 #include "NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h"
@@ -50,7 +49,6 @@ class SingleSwitchProgramSession final : public ProgramSession{
     SingleSwitchProgramOption& m_option;
     SwitchSystemSession m_system;
 
-    SpinLock m_lock;
     std::atomic<CancellableScope*> m_scope;
 };