FEXCore: Removes remaining RunningEvents from InternalThreadState

These are all frontend constructs with mostly deprecated constraints.
WaitingToStart isn't used anymore, Running is effectively always true
(and behaviour has changed that if a thread is alive, it's running).

The only one that remains is `ThreadSleeping` which is only handled in
the frontend, and there was some conflation between ThreadSleeping and
Running which was hard to gauge. So delete `Running` and
`WaitingToStart`, but move `ThreadSleeping` to the frontend.

FEXCore/Source/Interface/Core/Core.cpp

@@ -868,15 +868,8 @@ uintptr_t ContextImpl::CompileBlock(FEXCore::Core::CpuStateFrame* Frame, uint64_
 }
 
 void ContextImpl::ExecutionThread(FEXCore::Core::InternalThreadState* Thread) {
-
-  Thread->RunningEvents.WaitingToStart = false;
-
-  Thread->RunningEvents.Running = true;
-
   static_cast<ContextImpl*>(Thread->CTX)->Dispatcher->ExecuteDispatch(Thread->CurrentFrame);
 
-  Thread->RunningEvents.Running = false;
-
   {
     // Ensure the Code Object Serialization service has fully serialized this thread's data before clearing the cache
     // Use the thread's object cache ref counter for this

FEXCore/include/FEXCore/Debug/InternalThreadState.h

@@ -80,15 +80,8 @@ static_assert(!std::is_move_assignable_v<NonMovableUniquePtr<int>>);
 struct InternalThreadState : public FEXCore::Allocator::FEXAllocOperators {
   FEXCore::Core::CpuStateFrame* const CurrentFrame = &BaseFrameState;
 
-  struct {
-    std::atomic_bool Running {false};
-    std::atomic_bool WaitingToStart {true};
-    std::atomic_bool ThreadSleeping {false};
-  } RunningEvents;
-
   FEXCore::Context::Context* const CTX;
 
-
   NonMovableUniquePtr<FEXCore::IR::OpDispatchBuilder> OpDispatcher;
 
   NonMovableUniquePtr<FEXCore::CPU::CPUBackend> CPUBackend;

Source/Tools/LinuxEmulation/LinuxSyscalls/SignalDelegator.cpp

@@ -475,7 +475,7 @@ bool SignalDelegator::HandleSignalPause(FEXCore::Core::InternalThreadState* Thre
     // We need to be a little bit careful here
     // If we were already paused (due to GDB) and we are immediately stopping (due to gdb kill)
     // Then we need to ensure we don't double decrement our idle thread counter
-    if (Thread->RunningEvents.ThreadSleeping) {
+    if (ThreadObject->ThreadSleeping) {
       // If the thread was sleeping then its idle counter was decremented
       // Reincrement it here to not break logic
       FEX::HLE::_SyscallHandler->TM.IncrementIdleRefCount();
@@ -500,10 +500,6 @@ bool SignalDelegator::HandleSignalPause(FEXCore::Core::InternalThreadState* Thre
 
 void SignalDelegator::SignalThread(FEXCore::Core::InternalThreadState* Thread, SignalEvent Event) {
   auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromFEXCoreThread(Thread);
-  if (Event == SignalEvent::Pause && Thread->RunningEvents.Running.load() == false) {
-    // Skip signaling a thread if it is already paused.
-    return;
-  }
   ThreadObject->SignalReason.store(Event);
   FHU::Syscalls::tgkill(ThreadObject->ThreadInfo.PID, ThreadObject->ThreadInfo.TID, SignalDelegator::SIGNAL_FOR_PAUSE);
 }

Source/Tools/LinuxEmulation/LinuxSyscalls/ThreadManager.cpp

@@ -41,9 +41,7 @@ void ThreadManager::DestroyThread(FEX::HLE::ThreadStateObject* Thread, bool Need
 }
 
 void ThreadManager::StopThread(FEX::HLE::ThreadStateObject* Thread) {
-  if (Thread->Thread->RunningEvents.Running.exchange(false)) {
-    SignalDelegation->SignalThread(Thread->Thread, SignalEvent::Stop);
-  }
+  SignalDelegation->SignalThread(Thread->Thread, SignalEvent::Stop);
 }
 
 void ThreadManager::HandleThreadDeletion(FEX::HLE::ThreadStateObject* Thread, bool NeedsTLSUninstall) {
@@ -154,9 +152,7 @@ void ThreadManager::Stop(bool IgnoreCurrentThread) {
         continue;
       }
 
-      if (Thread->Thread->RunningEvents.Running.load()) {
-        StopThread(Thread);
-      }
+      StopThread(Thread);
     }
   }
 
@@ -168,19 +164,17 @@ void ThreadManager::Stop(bool IgnoreCurrentThread) {
 
 void ThreadManager::SleepThread(FEXCore::Context::Context* CTX, FEXCore::Core::CpuStateFrame* Frame) {
   auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame);
-  auto Thread = Frame->Thread;
 
   --IdleWaitRefCount;
   IdleWaitCV.notify_all();
 
-  Thread->RunningEvents.ThreadSleeping = true;
+  ThreadObject->ThreadSleeping = true;
 
   // Go to sleep
   ThreadObject->ThreadPaused.Wait();
 
-  Thread->RunningEvents.Running = true;
   ++IdleWaitRefCount;
-  Thread->RunningEvents.ThreadSleeping = false;
+  ThreadObject->ThreadSleeping = false;
 
   IdleWaitCV.notify_all();
 }
@@ -201,9 +195,6 @@ void ThreadManager::UnlockAfterFork(FEXCore::Core::InternalThreadState* LiveThre
       continue;
     }
 
-    // Setting running to false ensures that when they are shutdown we won't send signals to kill them
-    DeadThread->Thread->RunningEvents.Running = false;
-
     // Despite what google searches may susgest, glibc actually has special code to handle forks
     // with multiple active threads.
     // It cleans up the stacks of dead threads and marks them as terminated.

Source/Tools/LinuxEmulation/LinuxSyscalls/ThreadManager.h

@@ -81,6 +81,7 @@ struct ThreadStateObject : public FEXCore::Allocator::FEXAllocOperators {
   std::atomic<SignalEvent> SignalReason {SignalEvent::Nothing};
 
   // Thread pause handling
+  std::atomic_bool ThreadSleeping {false};
   FEXCore::InterruptableConditionVariable ThreadPaused;
 
   int StatusCode {};