core: use old suspension mechanism

.ci/scripts/clang/docker.sh

@@ -3,12 +3,14 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e
 
+cd /yuzu
+
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -GNinja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
+cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
 
-ninja
+make -j$(nproc)
 
 ccache -s
 

.ci/scripts/clang/exec.sh

@@ -4,5 +4,5 @@ mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/clang/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh "$1"
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh $1
 sudo chown -R $UID ./

.ci/scripts/common/post-upload.sh

@@ -4,10 +4,8 @@
 cp license.txt "$DIR_NAME"
 cp README.md "$DIR_NAME"
 
-if [[ -z "${NO_SOURCE_PACK}" ]]; then
-  tar -cJvf "${REV_NAME}-source.tar.xz" src externals CMakeLists.txt README.md license.txt
-  cp -v "${REV_NAME}-source.tar.xz" "$DIR_NAME"
-fi
+tar -cJvf "${REV_NAME}-source.tar.xz" src externals CMakeLists.txt README.md license.txt
+cp "${REV_NAME}-source.tar.xz" "$DIR_NAME"
 
 tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"
 

.ci/scripts/format/exec.sh

@@ -3,5 +3,5 @@
 chmod a+x ./.ci/scripts/format/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
+docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
 sudo chown -R $UID ./

.ci/scripts/linux/docker.sh

@@ -3,6 +3,8 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e
 
+cd /yuzu
+
 ccache -s
 
 mkdir build || true && cd build
@@ -17,16 +19,15 @@ cmake .. \
       -DENABLE_QT_TRANSLATION=ON \
       -DUSE_DISCORD_PRESENCE=ON \
       -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
-      -DYUZU_USE_BUNDLED_FFMPEG=ON \
-      -GNinja
+      -DYUZU_USE_BUNDLED_FFMPEG=ON
 
-ninja
+make -j$(nproc)
 
 ccache -s
 
 ctest -VV -C Release
 
-DESTDIR="$PWD/AppDir" ninja install
+make install DESTDIR=AppDir
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester
 
 # Download tools needed to build an AppImage

.ci/scripts/linux/exec.sh

@@ -4,5 +4,5 @@ mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh "$1"
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh $1
 sudo chown -R $UID ./

.ci/scripts/linux/upload.sh

@@ -24,11 +24,6 @@ cd build
 wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/appimagetool-x86_64.AppImage
 chmod 755 appimagetool-x86_64.AppImage
 
-# if FUSE is not available, then fallback to extract and run
-if ! ./appimagetool-x86_64.AppImage --version; then
-    export APPIMAGE_EXTRACT_AND_RUN=1
-fi
-
 if [ "${RELEASE_NAME}" = "mainline" ]; then
     # Generate update information if releasing to mainline
     ./appimagetool-x86_64.AppImage -u "gh-releases-zsync|yuzu-emu|yuzu-${RELEASE_NAME}|latest|yuzu-*.AppImage.zsync" AppDir "${APPIMAGE_NAME}"

.ci/scripts/windows/docker.sh

@@ -2,23 +2,19 @@
 
 set -e
 
-#cd /yuzu
+cd /yuzu
 
-ccache -sv
+ccache -s
 
-mkdir -p "$HOME/.conan/profiles"
-wget -c "https://github.com/yuzu-emu/build-environments/raw/master/linux-mingw/default" -O "$HOME/.conan/profiles/default"
-wget -c "https://github.com/yuzu-emu/build-environments/raw/master/linux-mingw/settings.yml" -O "$HOME/.conan/settings.yml"
-
-mkdir -p build && cd build
-export LDFLAGS="-fuse-ld=lld"
+mkdir build || true && cd build
+LDFLAGS="-fuse-ld=lld"
 # -femulated-tls required due to an incompatibility between GCC and Clang
 # TODO(lat9nq): If this is widespread, we probably need to add this to CMakeLists where appropriate
-export CXXFLAGS="-femulated-tls"
 cmake .. \
     -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWClangCross.cmake" \
-    -DDISPLAY_VERSION="$1" \
+    -DCMAKE_CXX_FLAGS="-femulated-tls" \
+    -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWClangCross.cmake" \
+    -DDISPLAY_VERSION=$1 \
     -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
     -DENABLE_QT_TRANSLATION=ON \
     -DUSE_CCACHE=ON \
@@ -27,7 +23,7 @@ cmake .. \
     -GNinja
 ninja yuzu yuzu-cmd
 
-ccache -sv
+ccache -s
 
 echo "Tests skipped"
 #ctest -VV -C Release

.ci/scripts/windows/exec.sh

@@ -4,5 +4,5 @@ mkdir -p "ccache" || true
 chmod a+x ./.ci/scripts/windows/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh "$1"
+docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh $1
 sudo chown -R $UID ./

.github/workflows/verify.yml

@@ -1,115 +0,0 @@
-name: 'yuzu verify'
-
-on:
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  format:
-    name: 'verify format'
-    runs-on: ubuntu-latest
-    container:
-      image: yuzuemu/build-environments:linux-clang-format
-      options: -u 1001
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: false
-      - name: 'Verify Formatting'
-        run: bash -ex ./.ci/scripts/format/script.sh
-  build:
-    name: 'test build'
-    needs: format
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - type: clang
-            image: linux-fresh
-          - type: linux
-            image: linux-fresh
-          - type: windows
-            image: linux-mingw
-    container:
-      image: yuzuemu/build-environments:${{ matrix.image }}
-      options: -u 1001
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Set up cache
-        uses: actions/cache@v2
-        id: ccache-restore
-        with:
-          path: ~/.ccache
-          key: ${{ runner.os }}-${{ matrix.type }}-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.type }}-
-      - name: Create ccache directory
-        if: steps.ccache-restore.outputs.cache-hit != 'true'
-        run: mkdir -p ~/.ccache
-      - name: Build
-        run: ./.ci/scripts/${{ matrix.type }}/docker.sh
-        env:
-          ENABLE_COMPATIBILITY_REPORTING: "ON"
-      - name: Pack
-        run: ./.ci/scripts/${{ matrix.type }}/upload.sh
-        env:
-          NO_SOURCE_PACK: "YES"
-      - name: Upload
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.type }}
-          path: artifacts/
-  build-msvc:
-    name: 'test build (windows, msvc)'
-    needs: format
-    runs-on: windows-2019
-    steps:
-      - name: Set up cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.buildcache
-          key: ${{ runner.os }}-msvc-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-msvc-
-      - name: Install dependencies
-        # due to how chocolatey works, only cmd.exe is supported here
-        shell: cmd
-        run: |
-          choco install vulkan-sdk wget
-          python -m pip install --upgrade pip conan
-          call refreshenv
-          wget https://github.com/mbitsnbites/buildcache/releases/download/v0.27.6/buildcache-windows.zip
-          7z x buildcache-windows.zip
-          copy buildcache\bin\buildcache.exe C:\ProgramData\chocolatey\bin
-          rmdir buildcache
-          echo %PATH% >> %GITHUB_PATH%
-      - name: Set up MSVC
-        uses: ilammy/msvc-dev-cmd@v1
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Configure
-        env:
-          CC: cl.exe
-          CXX: cl.exe
-        run: |
-          glslangValidator --version
-          mkdir build
-          cmake . -B build -GNinja -DCMAKE_TOOLCHAIN_FILE="CMakeModules/MSVCCache.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_BUILD_TYPE=Release
-      - name: Build
-        run: cmake --build build
-      - name: Cache Summary
-        run: buildcache -s
-      - name: Pack
-        shell: pwsh
-        run: .\.ci\scripts\windows\upload.ps1
-      - name: Upload
-        uses: actions/upload-artifact@v3
-        with:
-          name: msvc
-          path: artifacts/

CMakeLists.txt

@@ -627,14 +627,6 @@ add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
     -DBOOST_DATE_TIME_NO_LIB
     -DBOOST_REGEX_NO_LIB
 )
-# Adjustments for MSVC + Ninja
-if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
-    add_compile_options(
-        /wd4711 # function 'function' selected for automatic inline expansion
-        /wd4464 # relative include path contains '..'
-        /wd4820 # 'identifier1': '4' bytes padding added after data member 'identifier2'
-    )
-endif()
 
 enable_testing()
 add_subdirectory(externals)

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -2,6 +2,5 @@ function(copy_yuzu_FFmpeg_deps target_dir)
     include(WindowsCopyFiles)
     set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
     file(READ "${FFmpeg_PATH}/requirements.txt" FFmpeg_REQUIRED_DLLS)
-    string(STRIP "${FFmpeg_REQUIRED_DLLS}" FFmpeg_REQUIRED_DLLS)
     windows_copy_files(${target_dir} ${FFmpeg_DLL_DIR} ${DLL_DEST} ${FFmpeg_REQUIRED_DLLS})
 endfunction(copy_yuzu_FFmpeg_deps)

CMakeModules/MSVCCache.cmake

@@ -1,12 +0,0 @@
-# buildcache wrapper
-OPTION(USE_CCACHE "Use buildcache for compilation" OFF)
-IF(USE_CCACHE)
-    FIND_PROGRAM(CCACHE buildcache)
-    IF (CCACHE)
-        MESSAGE(STATUS "Using buildcache found in PATH")
-        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
-        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
-    ELSE(CCACHE)
-        MESSAGE(WARNING "USE_CCACHE enabled, but no buildcache executable found")
-    ENDIF(CCACHE)
-ENDIF(USE_CCACHE)

src/CMakeLists.txt

@@ -36,6 +36,7 @@ if (MSVC)
     # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
+        /Zi
         /Zm200
         /Zo
         /permissive-
@@ -78,13 +79,6 @@ if (MSVC)
         /we5245 # 'function': unreferenced function with internal linkage has been removed
     )
 
-    if (USE_CCACHE)
-    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cachable format
-        add_compile_options(/Z7)
-    else()
-        add_compile_options(/Zi)
-    endif()
-
     if (ARCHITECTURE_x86_64)
         add_compile_options(/QIntel-jcc-erratum)
     endif()

src/common/wall_clock.cpp

@@ -67,7 +67,7 @@ std::unique_ptr<WallClock> CreateBestMatchingClock(u64 emulated_cpu_frequency,
     const auto& caps = GetCPUCaps();
     u64 rtsc_frequency = 0;
     if (caps.invariant_tsc) {
-        rtsc_frequency = caps.tsc_frequency ? caps.tsc_frequency : EstimateRDTSCFrequency();
+        rtsc_frequency = EstimateRDTSCFrequency();
     }
 
     // Fallback to StandardWallClock if the hardware TSC does not have the precision greater than:

src/common/x64/cpu_detect.cpp

@@ -161,22 +161,6 @@ static CPUCaps Detect() {
         caps.invariant_tsc = Common::Bit<8>(cpu_id[3]);
     }
 
-    if (max_std_fn >= 0x15) {
-        __cpuid(cpu_id, 0x15);
-        caps.tsc_crystal_ratio_denominator = cpu_id[0];
-        caps.tsc_crystal_ratio_numerator = cpu_id[1];
-        caps.crystal_frequency = cpu_id[2];
-        // Some CPU models might not return a crystal frequency.
-        // The CPU model can be detected to use the values from turbostat
-        // https://github.com/torvalds/linux/blob/master/tools/power/x86/turbostat/turbostat.c#L5569
-        // but it's easier to just estimate the TSC tick rate for these cases.
-        if (caps.tsc_crystal_ratio_denominator) {
-            caps.tsc_frequency = static_cast<u64>(caps.crystal_frequency) *
-                                 caps.tsc_crystal_ratio_numerator /
-                                 caps.tsc_crystal_ratio_denominator;
-        }
-    }
-
     if (max_std_fn >= 0x16) {
         __cpuid(cpu_id, 0x16);
         caps.base_frequency = cpu_id[0];

src/common/x64/cpu_detect.h

@@ -30,11 +30,6 @@ struct CPUCaps {
     u32 max_frequency;
     u32 bus_frequency;
 
-    u32 tsc_crystal_ratio_denominator;
-    u32 tsc_crystal_ratio_numerator;
-    u32 crystal_frequency;
-    u64 tsc_frequency; // Derived from the above three values
-
     bool sse : 1;
     bool sse2 : 1;
     bool sse3 : 1;

src/core/core.cpp

@@ -138,6 +138,7 @@ struct System::Impl {
 
         kernel.Suspend(false);
         core_timing.SyncPause(false);
+        cpu_manager.Pause(false);
         is_paused = false;
 
         return status;
@@ -149,6 +150,7 @@ struct System::Impl {
 
         core_timing.SyncPause(true);
         kernel.Suspend(true);
+        cpu_manager.Pause(true);
         is_paused = true;
 
         return status;
@@ -158,6 +160,7 @@ struct System::Impl {
         std::unique_lock<std::mutex> lk(suspend_guard);
         kernel.Suspend(true);
         core_timing.SyncPause(true);
+        cpu_manager.Pause(true);
         return lk;
     }
 
@@ -165,6 +168,7 @@ struct System::Impl {
         if (!is_paused) {
             core_timing.SyncPause(false);
             kernel.Suspend(false);
+            cpu_manager.Pause(false);
         }
     }
 
@@ -330,8 +334,6 @@ struct System::Impl {
             gpu_core->NotifyShutdown();
         }
 
-        kernel.ShutdownCores();
-        cpu_manager.Shutdown();
         debugger.reset();
         services.reset();
         service_manager.reset();

src/core/cpu_manager.cpp

@@ -25,8 +25,10 @@ void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager
 }
 
 void CpuManager::Initialize() {
+    running_mode = true;
     num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
     gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
+    pause_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
 
     for (std::size_t core = 0; core < num_cores; core++) {
         core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
@@ -34,11 +36,8 @@ void CpuManager::Initialize() {
 }
 
 void CpuManager::Shutdown() {
-    for (std::size_t core = 0; core < num_cores; core++) {
-        if (core_data[core].host_thread.joinable()) {
-            core_data[core].host_thread.join();
-        }
-    }
+    running_mode = false;
+    Pause(false);
 }
 
 void CpuManager::GuestThreadFunction() {
@@ -65,10 +64,6 @@ void CpuManager::IdleThreadFunction() {
     }
 }
 
-void CpuManager::ShutdownThreadFunction() {
-    ShutdownThread();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 ///                             MultiCore                                   ///
 ///////////////////////////////////////////////////////////////////////////////
@@ -181,13 +176,41 @@ void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
     }
 }
 
-void CpuManager::ShutdownThread() {
+void CpuManager::SuspendThread() {
     auto& kernel = system.Kernel();
-    auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
-    auto* current_thread = kernel.GetCurrentEmuThread();
+    kernel.CurrentScheduler()->OnThreadStart();
 
-    Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
-    UNREACHABLE();
+    while (true) {
+        auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
+        auto& scheduler = *kernel.CurrentScheduler();
+        Kernel::KThread* current_thread = scheduler.GetSchedulerCurrentThread();
+        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
+
+        // This shouldn't be here. This is here because the scheduler needs the current
+        // thread to have dispatch disabled before explicitly rescheduling. Ideally in the
+        // future this will be called by RequestScheduleOnInterrupt and explicitly disabling
+        // dispatch outside the scheduler will not be necessary.
+        current_thread->DisableDispatch();
+
+        scheduler.RescheduleCurrentCore();
+    }
+}
+
+void CpuManager::Pause(bool paused) {
+    std::scoped_lock lk{pause_lock};
+
+    if (pause_state == paused) {
+        return;
+    }
+
+    // Set the new state
+    pause_state.store(paused);
+
+    // Wake up any waiting threads
+    pause_state.notify_all();
+
+    // Wait for all threads to successfully change state before returning
+    pause_barrier->Sync();
 }
 
 void CpuManager::RunThread(std::size_t core) {
@@ -218,9 +241,27 @@ void CpuManager::RunThread(std::size_t core) {
         system.GPU().ObtainContext();
     }
 
-    auto* current_thread = system.Kernel().CurrentScheduler()->GetIdleThread();
-    Kernel::SetCurrentThread(system.Kernel(), current_thread);
-    Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
+    {
+        // Set the current thread on entry
+        auto* current_thread = system.Kernel().CurrentScheduler()->GetIdleThread();
+        Kernel::SetCurrentThread(system.Kernel(), current_thread);
+    }
+
+    while (running_mode) {
+        if (pause_state.load(std::memory_order_relaxed)) {
+            // Wait for caller to acknowledge pausing
+            pause_barrier->Sync();
+
+            // Wait until unpaused
+            pause_state.wait(true, std::memory_order_relaxed);
+
+            // Wait for caller to acknowledge unpausing
+            pause_barrier->Sync();
+        }
+
+        auto current_thread = system.Kernel().CurrentScheduler()->GetSchedulerCurrentThread();
+        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
+    }
 }
 
 } // namespace Core

src/core/cpu_manager.h

@@ -50,14 +50,16 @@ public:
     void Initialize();
     void Shutdown();
 
+    void Pause(bool paused);
+
     std::function<void()> GetGuestThreadStartFunc() {
         return [this] { GuestThreadFunction(); };
     }
     std::function<void()> GetIdleThreadStartFunc() {
         return [this] { IdleThreadFunction(); };
     }
-    std::function<void()> GetShutdownThreadStartFunc() {
-        return [this] { ShutdownThreadFunction(); };
+    std::function<void()> GetSuspendThreadStartFunc() {
+        return [this] { SuspendThread(); };
     }
 
     void PreemptSingleCore(bool from_running_enviroment = true);
@@ -70,7 +72,6 @@ private:
     void GuestThreadFunction();
     void GuestRewindFunction();
     void IdleThreadFunction();
-    void ShutdownThreadFunction();
 
     void MultiCoreRunGuestThread();
     void MultiCoreRunGuestLoop();
@@ -82,7 +83,7 @@ private:
 
     static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
 
-    void ShutdownThread();
+    void SuspendThread();
     void RunThread(std::size_t core);
 
     struct CoreData {
@@ -90,7 +91,12 @@ private:
         std::jthread host_thread;
     };
 
+    std::atomic<bool> running_mode{};
+    std::atomic<bool> pause_state{};
+    std::unique_ptr<Common::Barrier> pause_barrier{};
     std::unique_ptr<Common::Barrier> gpu_barrier{};
+    std::mutex pause_lock{};
+
     std::array<CoreData, Core::Hardware::NUM_CPU_CORES> core_data{};
 
     bool is_async_gpu{};

src/core/hle/kernel/k_thread.cpp

@@ -269,7 +269,7 @@ Result KThread::InitializeIdleThread(Core::System& system, KThread* thread, s32
 Result KThread::InitializeHighPriorityThread(Core::System& system, KThread* thread,
                                              KThreadFunction func, uintptr_t arg, s32 virt_core) {
     return InitializeThread(thread, func, arg, {}, {}, virt_core, nullptr, ThreadType::HighPriority,
-                            system.GetCpuManager().GetShutdownThreadStartFunc());
+                            system.GetCpuManager().GetSuspendThreadStartFunc());
 }
 
 Result KThread::InitializeUserThread(Core::System& system, KThread* thread, KThreadFunction func,
@@ -741,19 +741,6 @@ void KThread::Continue() {
     KScheduler::OnThreadStateChanged(kernel, this, old_state);
 }
 
-void KThread::WaitUntilSuspended() {
-    // Make sure we have a suspend requested.
-    ASSERT(IsSuspendRequested());
-
-    // Loop until the thread is not executing on any core.
-    for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) {
-        KThread* core_thread{};
-        do {
-            core_thread = kernel.Scheduler(i).GetSchedulerCurrentThread();
-        } while (core_thread == this);
-    }
-}
-
 Result KThread::SetActivity(Svc::ThreadActivity activity) {
     // Lock ourselves.
     KScopedLightLock lk(activity_pause_lock);

src/core/hle/kernel/k_thread.h

@@ -208,8 +208,6 @@ public:
 
     void Continue();
 
-    void WaitUntilSuspended();
-
     constexpr void SetSyncedIndex(s32 index) {
         synced_index = index;
     }

src/core/hle/kernel/kernel.cpp

@@ -76,7 +76,7 @@ struct KernelCore::Impl {
         InitializeMemoryLayout();
         Init::InitializeKPageBufferSlabHeap(system);
         InitializeSchedulers();
-        InitializeShutdownThreads();
+        InitializeSuspendThreads();
         InitializePreemption(kernel);
 
         RegisterHostThread();
@@ -143,9 +143,9 @@ struct KernelCore::Impl {
         CleanupObject(system_resource_limit);
 
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            if (shutdown_threads[core_id]) {
-                shutdown_threads[core_id]->Close();
-                shutdown_threads[core_id] = nullptr;
+            if (suspend_threads[core_id]) {
+                suspend_threads[core_id]->Close();
+                suspend_threads[core_id] = nullptr;
             }
 
             schedulers[core_id]->Finalize();
@@ -247,13 +247,13 @@ struct KernelCore::Impl {
         system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
     }
 
-    void InitializeShutdownThreads() {
+    void InitializeSuspendThreads() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            shutdown_threads[core_id] = KThread::Create(system.Kernel());
-            ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {},
+            suspend_threads[core_id] = KThread::Create(system.Kernel());
+            ASSERT(KThread::InitializeHighPriorityThread(system, suspend_threads[core_id], {}, {},
                                                          core_id)
                        .IsSuccess());
-            shutdown_threads[core_id]->SetName(fmt::format("SuspendThread:{}", core_id));
+            suspend_threads[core_id]->SetName(fmt::format("SuspendThread:{}", core_id));
         }
     }
 
@@ -775,7 +775,7 @@ struct KernelCore::Impl {
     std::weak_ptr<ServiceThread> default_service_thread;
     Common::ThreadWorker service_threads_manager;
 
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads;
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> suspend_threads;
     std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
@@ -1085,27 +1085,16 @@ const Kernel::KSharedMemory& KernelCore::GetHidBusSharedMem() const {
 
 void KernelCore::Suspend(bool suspended) {
     const bool should_suspend{exception_exited || suspended};
-    const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;
-
-    for (auto* process : GetProcessList()) {
-        process->SetActivity(activity);
-
-        if (should_suspend) {
-            // Wait for execution to stop
-            for (auto* thread : process->GetThreadList()) {
-                thread->WaitUntilSuspended();
-            }
+    const auto state{should_suspend ? ThreadState::Runnable : ThreadState::Waiting};
+    {
+        KScopedSchedulerLock lk{*this};
+        for (auto* thread : impl->suspend_threads) {
+            thread->SetState(state);
+            thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Suspended);
         }
     }
 }
 
-void KernelCore::ShutdownCores() {
-    for (auto* thread : impl->shutdown_threads) {
-        void(thread->Run());
-    }
-    InterruptAllPhysicalCores();
-}
-
 bool KernelCore::IsMulticore() const {
     return impl->is_multicore;
 }

src/core/hle/kernel/kernel.h

@@ -280,9 +280,6 @@ public:
     /// Exceptional exit all processes.
     void ExceptionalExit();
 
-    /// Notify emulated CPU cores to shut down.
-    void ShutdownCores();
-
     bool IsMulticore() const;
 
     bool IsShuttingDown() const;