VERY experimental Nintendo Switch 2 emulator
C++
[core, gpu, threads] Multithreading refactor (#4254)
CamilleLaVey3f52bf4b4b34
diff --git a/src/android/app/build.gradle.kts b/src/android/app/build.gradle.ktsindex a4076978a1..0cef7e7196 100644--- a/src/android/app/build.gradle.kts+++ b/src/android/app/build.gradle.kts@@ -188,6 +188,7 @@ android {create("mainline") {dimension = "version"isDefault = true+ minSdk = 33manifestPlaceholders += mapOf("appNameBase" to "Eden")resValue("string", "app_name_suffixed", "Eden")@@ -199,6 +200,7 @@ android {create("genshinSpoof") {dimension = "version"+ minSdk = 35manifestPlaceholders += mapOf("appNameBase" to "Eden Optimized")resValue("string", "app_name_suffixed", "Eden Optimized")applicationId = "com.miHoYo.Yuanshen"@@ -216,6 +218,7 @@ android {create("legacy") {dimension = "version"+ minSdk = 29manifestPlaceholders += mapOf("appNameBase" to "Eden Legacy")resValue("string", "app_name_suffixed", "Eden Legacy")applicationId = "dev.legacy.eden_emulator"diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.ktindex a8d6eaf6e1..797ac803eb 100644--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt@@ -218,6 +218,8 @@ object NativeLibrary {external fun logSettings()+ external fun refreshThreadPolicies()+external fun getDebugKnobAt(index: Int): Boolean/**diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.ktindex 7c6063988f..63ac7b0630 100644--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt@@ -594,7 +594,7 @@ abstract class SettingsItem(IntSetting.ANDROID_PIPELINE_WORKERS,titleId = R.string.pipeline_worker_cores,descriptionId = R.string.pipeline_worker_cores_description,- min = 4,+ min = 2,max = 8,units = "cores")diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.ktindex 81702d7110..594099f159 100644--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt@@ -250,8 +250,9 @@ class SettingsFragmentPresenter(add(BooleanSetting.USE_CUSTOM_RTC.key)add(LongSetting.CUSTOM_RTC.key)- add(HeaderSetting(R.string.cpu))+ add(HeaderSetting(R.string.clocks))add(IntSetting.FAST_CPU_TIME.key)+ add(IntSetting.FAST_GPU_TIME.key)add(BooleanSetting.CORE_SYNC_CORE_SPEED.key)add(IntSetting.MEMORY_LAYOUT.key)@@ -298,7 +299,6 @@ class SettingsFragmentPresenter(add(HeaderSetting(R.string.hacks))- add(IntSetting.FAST_GPU_TIME.key)add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)add(BooleanSetting.FIX_BLOOM_EFFECTS.key)add(BooleanSetting.EMULATE_BGR565.key)diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.ktindex 0069e169b3..5b93c88161 100644--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt@@ -1451,6 +1451,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {override fun onResume() {super.onResume()+ NativeLibrary.refreshThreadPolicies()val b = _binding ?: returnupdateStatsPosition(IntSetting.PERF_OVERLAY_POSITION.getInt())updateSocPosition(IntSetting.SOC_OVERLAY_POSITION.getInt())diff --git a/src/android/app/src/main/jni/native.cpp b/src/android/app/src/main/jni/native.cppindex 41ba1b2019..c367a06dfd 100644--- a/src/android/app/src/main/jni/native.cpp+++ b/src/android/app/src/main/jni/native.cpp@@ -50,6 +50,7 @@ extern "C" {#include "common/scope_exit.h"#include "common/settings.h"#include "common/string_util.h"+#include "common/thread.h"#include "frontend_common/play_time_manager.h"#include "core/constants.h"#include "core/core.h"@@ -1182,6 +1183,10 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_logSettings(JNIEnv* env, jobject jobjSettings::LogSettings();}+void Java_org_yuzu_yuzu_1emu_NativeLibrary_refreshThreadPolicies(JNIEnv* env, jobject jobj) {+ Common::RefreshThreadPolicies();+}+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_getDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {return static_cast<jboolean>(Settings::getDebugKnobAt(static_cast<u8>(index)));}diff --git a/src/android/app/src/main/res/values-ar/strings.xml b/src/android/app/src/main/res/values-ar/strings.xmlindex 616f160fd1..dd03ec453f 100644--- a/src/android/app/src/main/res/values-ar/strings.xml+++ b/src/android/app/src/main/res/values-ar/strings.xml@@ -958,7 +958,6 @@<string name="clock_fast">سريع (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">تعطيل</string><string name="fast_gpu_medium">متوسط (256)</string><string name="fast_gpu_high">مرتفع (512)</string>diff --git a/src/android/app/src/main/res/values-de/strings.xml b/src/android/app/src/main/res/values-de/strings.xmlindex 182247580c..1c3b6c148f 100644--- a/src/android/app/src/main/res/values-de/strings.xml+++ b/src/android/app/src/main/res/values-de/strings.xml@@ -884,7 +884,6 @@ Wirklich fortfahren?</string><string name="clock_fast">Schnell (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">Aus</string><string name="fast_gpu_medium">Mittel (256)</string><string name="fast_gpu_high">Hoch (512)</string>diff --git a/src/android/app/src/main/res/values-es/strings.xml b/src/android/app/src/main/res/values-es/strings.xmlindex 37bd14b2d1..a5092c4b2f 100644--- a/src/android/app/src/main/res/values-es/strings.xml+++ b/src/android/app/src/main/res/values-es/strings.xml@@ -950,7 +950,6 @@<string name="clock_fast">Rápido (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">Desactivado</string><string name="fast_gpu_medium">Medio (256)</string><string name="fast_gpu_high">Alto (512)</string>diff --git a/src/android/app/src/main/res/values-fr/strings.xml b/src/android/app/src/main/res/values-fr/strings.xmlindex 2cf6a1da91..602a542c5f 100644--- a/src/android/app/src/main/res/values-fr/strings.xml+++ b/src/android/app/src/main/res/values-fr/strings.xml@@ -897,7 +897,6 @@<string name="clock_fast">Rapide (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">Désactivé</string><string name="fast_gpu_medium">Moyen (256)</string><string name="fast_gpu_high">Élevé (512)</string>diff --git a/src/android/app/src/main/res/values-pl/strings.xml b/src/android/app/src/main/res/values-pl/strings.xmlindex d96d420a98..4bcebd5a8c 100644--- a/src/android/app/src/main/res/values-pl/strings.xml+++ b/src/android/app/src/main/res/values-pl/strings.xml@@ -871,7 +871,6 @@<string name="clock_fast">Szybkie (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">Wyłączone</string><string name="fast_gpu_medium">Średnie (256)</string><string name="fast_gpu_high">Wysokie (512)</string>diff --git a/src/android/app/src/main/res/values-ru/strings.xml b/src/android/app/src/main/res/values-ru/strings.xmlindex 6e85084b77..3dbeb6ffdb 100644--- a/src/android/app/src/main/res/values-ru/strings.xml+++ b/src/android/app/src/main/res/values-ru/strings.xml@@ -954,7 +954,6 @@<string name="clock_fast">Быстрая (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">Выкл.</string><string name="fast_gpu_medium">Среднее (256)</string><string name="fast_gpu_high">Высокое (512)</string>diff --git a/src/android/app/src/main/res/values-uk/strings.xml b/src/android/app/src/main/res/values-uk/strings.xmlindex 86ea6ba787..83893210bd 100644--- a/src/android/app/src/main/res/values-uk/strings.xml+++ b/src/android/app/src/main/res/values-uk/strings.xml@@ -943,7 +943,6 @@<string name="clock_fast">Швидко (2000 МГц)</string><!-- GPU overclock factors -->- <string name="off">Вимкнено</string><string name="fast_gpu_medium">Середньо (256)</string><string name="fast_gpu_high">Високо (512)</string>diff --git a/src/android/app/src/main/res/values-zh-rCN/strings.xml b/src/android/app/src/main/res/values-zh-rCN/strings.xmlindex ff2db086e3..1e6ba26041 100644--- a/src/android/app/src/main/res/values-zh-rCN/strings.xml+++ b/src/android/app/src/main/res/values-zh-rCN/strings.xml@@ -948,7 +948,6 @@<string name="clock_fast">快速 (2000MHz)</string><!-- GPU overclock factors -->- <string name="off">关闭</string><string name="fast_gpu_medium">中 (256)</string><string name="fast_gpu_high">高 (512)</string>diff --git a/src/android/app/src/main/res/values/arrays.xml b/src/android/app/src/main/res/values/arrays.xmlindex 7a69d5b48b..1bad110d14 100644--- a/src/android/app/src/main/res/values/arrays.xml+++ b/src/android/app/src/main/res/values/arrays.xml@@ -34,7 +34,7 @@</integer-array><string-array name="clockNames">- <item>@string/off</item>+ <item>@string/clock_normal</item><item>@string/clock_boost</item><item>@string/clock_fast</item></string-array>@@ -547,7 +547,7 @@</integer-array><string-array name="gpuEntries">- <item>@string/off</item>+ <item>@string/fast_gpu_normal</item><item>@string/fast_gpu_medium</item><item>@string/fast_gpu_high</item></string-array>diff --git a/src/android/app/src/main/res/values/strings.xml b/src/android/app/src/main/res/values/strings.xmlindex 3023327f14..bb1d85db82 100644--- a/src/android/app/src/main/res/values/strings.xml+++ b/src/android/app/src/main/res/values/strings.xml@@ -450,8 +450,8 @@<string name="set_custom_rtc">Set custom RTC</string><!-- CPU -->- <string name="fast_cpu_time">CPU Overclock</string>- <string name="fast_cpu_time_description">Forces the emulated CPU to run at a higher clock, reducing certain FPS limiters. Use Boost (1700MHz) to run at the Switch\'s highest native clock, or Fast (2000MHz) to run at 2x clock.</string>+ <string name="fast_cpu_time">CPU Clocks</string>+ <string name="fast_cpu_time_description">Raises the clock the emulated CPU reports, which removes some FPS limiters. Weaker CPUs may see reduced performance, and certain games may behave improperly.</string><string name="custom_cpu_ticks">Custom CPU Ticks</string><string name="custom_cpu_ticks_description">Set a custom value of CPU ticks. Higher values can increase performance, but may also cause the game to freeze. A range of 77–21000 is recommended.</string><string name="cpu_ticks">Ticks</string>@@ -512,8 +512,8 @@<string name="hacks">Hacks</string>- <string name="fast_gpu_time">Fast GPU Time</string>- <string name="fast_gpu_time_description">Forces most games to run at their highest native resolution. Use 256 for maximal performance and 512 for maximal graphics fidelity.</string>+ <string name="fast_gpu_time">GPU Clocks</string>+ <string name="fast_gpu_time_description">Makes the game believe GPU work finishes faster than it does, so it stops lowering resolution and render distance to fit the Switch\'s clocks.</string><string name="skip_cpu_inner_invalidation">Skip CPU Inner Invalidation</string><string name="skip_cpu_inner_invalidation_description">Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and improving it\'s performance. This may cause glitches or crashes on some games.</string><string name="fix_bloom_effects">Fix Bloom Effects</string>@@ -560,6 +560,7 @@<!-- Debug settings strings --><string name="cpu">CPU</string>+ <string name="clocks">Clocks</string><string name="use_auto_stub">Use Auto Stub</string><string name="use_auto_stub_description">Automatically stub missing services and functions. This may improve compatibility but can cause crashes and stability issues.</string>@@ -968,14 +969,15 @@<string name="memory_6gb">6GB (Unsafe)</string><string name="memory_8gb">8GB (Unsafe)</string>- <!--CPU clock speeds-->- <string name="clock_boost">Boost (1700MHz)</string>- <string name="clock_fast">Fast (2000MHz)</string>+ <!-- CPU clock levels -->+ <string name="clock_normal">Normal</string>+ <string name="clock_boost">Boost</string>+ <string name="clock_fast">Overclock</string>- <!-- GPU overclock factors -->- <string name="off">Off</string>- <string name="fast_gpu_medium">Medium (256)</string>- <string name="fast_gpu_high">High (512)</string>+ <!-- GPU clock levels -->+ <string name="fast_gpu_normal">Normal</string>+ <string name="fast_gpu_medium">Boost</string>+ <string name="fast_gpu_high">Overclock</string><!-- GPU swizzle texture size --><string name="gpu_texturesizeswizzle_verysmall">Very Small (16 MB)</string>diff --git a/src/android/app/src/main/res/xml/game_mode_config.xml b/src/android/app/src/main/res/xml/game_mode_config.xmlindex 8f6e90d0d2..69e038cb5e 100644--- a/src/android/app/src/main/res/xml/game_mode_config.xml+++ b/src/android/app/src/main/res/xml/game_mode_config.xml@@ -1,7 +1,7 @@<?xml version="1.0" encoding="UTF-8"?><game-mode-configxmlns:android="http://schemas.android.com/apk/res/android"- android:supportsBatteryGameMode="true"+ android:supportsBatteryGameMode="false"android:supportsPerformanceGameMode="true"android:allowGameDownscaling="false"android:allowGameFpsOverride="false"/>\ No newline at end of filediff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txtindex 87c4642f04..923d001442 100644--- a/src/common/CMakeLists.txt+++ b/src/common/CMakeLists.txt@@ -121,6 +121,8 @@ add_library(swap.hthread.cppthread.h+ adpf.cpp+ adpf.hthread_queue_list.hthread_worker.hthreadsafe_queue.hdiff --git a/src/common/adpf.cpp b/src/common/adpf.cppnew file mode 100644index 0000000000..8fa2996173--- /dev/null+++ b/src/common/adpf.cpp@@ -0,0 +1,317 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#include "common/adpf.h"++#ifdef __ANDROID__++#include <algorithm>+#include <array>+#include <atomic>+#include <cstdint>+#include <mutex>+#include <vector>++#include <dlfcn.h>+#include <unistd.h>++#include "common/logging.h"++namespace Common::ADPF {++namespace {++constexpr std::chrono::nanoseconds DEFAULT_TARGET = std::chrono::nanoseconds{16'666'667};++struct AHintManager;+struct AHintSession;++using PFN_GetManager = AHintManager* (*)();+using PFN_CreateSession = AHintSession* (*)(AHintManager*, const s32*, size_t, s64);+using PFN_CloseSession = void (*)(AHintSession*);+using PFN_UpdateTarget = int (*)(AHintSession*, s64);+using PFN_ReportActual = int (*)(AHintSession*, s64);+using PFN_SetThreads = int (*)(AHintSession*, const pid_t*, size_t);+using PFN_SetPowerEfficiency = int (*)(AHintSession*, bool);++struct Api {+ PFN_GetManager get_manager = nullptr;+ PFN_CreateSession create_session = nullptr;+ PFN_CloseSession close_session = nullptr;+ PFN_UpdateTarget update_target = nullptr;+ PFN_ReportActual report_actual = nullptr;+ PFN_SetThreads set_threads = nullptr;+ PFN_SetPowerEfficiency set_power_efficiency = nullptr;+ AHintManager* manager = nullptr;+ bool usable = false;+};++const Api& Resolve() {+ static const Api api = [] {+ Api resolved;+ void* library = dlopen("libandroid.so", RTLD_NOW);+ if (library == nullptr) {+ LOG_INFO(Common, "libandroid.so unavailable, ADPF is disabled");+ return resolved;+ }+ const auto load = [library](const char* name) { return dlsym(library, name); };++ resolved.get_manager = reinterpret_cast<PFN_GetManager>(load("APerformanceHint_getManager"));+ resolved.create_session =+ reinterpret_cast<PFN_CreateSession>(load("APerformanceHint_createSession"));+ resolved.close_session =+ reinterpret_cast<PFN_CloseSession>(load("APerformanceHint_closeSession"));+ resolved.update_target =+ reinterpret_cast<PFN_UpdateTarget>(load("APerformanceHint_updateTargetWorkDuration"));+ resolved.report_actual =+ reinterpret_cast<PFN_ReportActual>(load("APerformanceHint_reportActualWorkDuration"));+ resolved.set_threads =+ reinterpret_cast<PFN_SetThreads>(load("APerformanceHint_setThreads"));+ resolved.set_power_efficiency = reinterpret_cast<PFN_SetPowerEfficiency>(+ load("APerformanceHint_setPreferPowerEfficiency"));++ if (resolved.get_manager == nullptr || resolved.create_session == nullptr ||+ resolved.close_session == nullptr || resolved.update_target == nullptr ||+ resolved.report_actual == nullptr) {+ LOG_INFO(Common, "Performance hint API not exported, ADPF is disabled");+ return resolved;+ }++ resolved.manager = resolved.get_manager();+ if (resolved.manager == nullptr) {+ LOG_INFO(Common, "Device does not provide a performance hint manager");+ return resolved;+ }++ resolved.usable = true;+ LOG_INFO(Common, "ADPF available, setThreads {}, power efficiency {}",+ resolved.set_threads != nullptr ? "yes" : "no",+ resolved.set_power_efficiency != nullptr ? "yes" : "no");+ return resolved;+ }();+ return api;+}++struct SessionState {+ AHintSession* handle = nullptr;+ std::vector<pid_t> threads;+ bool unsupported = false;+};++std::mutex g_mutex;+std::array<SessionState, 2> g_sessions;++constexpr s64 MAX_REPORTED_TARGETS = 4;++std::atomic<s64> g_target_ns{DEFAULT_TARGET.count()};+thread_local std::chrono::steady_clock::time_point t_last_frame{};++SessionState& StateOf(Session session) {+ return g_sessions[static_cast<size_t>(session)];+}++bool IsBackgroundUsable(const Api& api) {+ return api.set_power_efficiency != nullptr;+}++void CloseLocked(SessionState& state) {+ if (state.handle != nullptr) {+ Resolve().close_session(state.handle);+ state.handle = nullptr;+ }+}++AHintSession* CreateSessionFor(Session session, const std::vector<pid_t>& threads) {+ const Api& api = Resolve();+ const s64 target = session == Session::Render ? g_target_ns.load(std::memory_order_relaxed) : 0;++ std::vector<s32> ids;+ ids.reserve(threads.size());+ for (const pid_t tid : threads) {+ ids.push_back(static_cast<s32>(tid));+ }++ AHintSession* handle = api.create_session(api.manager, ids.data(), ids.size(), target);+ if (handle == nullptr && target == 0) {+ handle = api.create_session(api.manager, ids.data(), ids.size(), DEFAULT_TARGET.count());+ }+ if (handle == nullptr) {+ return nullptr;+ }+ if (session == Session::Background && api.set_power_efficiency != nullptr) {+ api.set_power_efficiency(handle, true);+ }+ return handle;+}++bool SyncLocked(Session session, SessionState& state) {+ if (state.threads.empty()) {+ CloseLocked(state);+ return false;+ }++ const Api& api = Resolve();+ if (state.handle != nullptr && api.set_threads != nullptr) {+ std::vector<pid_t> ids = state.threads;+ if (api.set_threads(state.handle, ids.data(), ids.size()) == 0) {+ return true;+ }+ }++ AHintSession* const replacement = CreateSessionFor(session, state.threads);+ if (replacement == nullptr) {+ if (state.handle == nullptr) {+ state.unsupported = true;+ }+ LOG_WARNING(Common, "Could not open a performance hint session for {} threads, falling back",+ state.threads.size());+ return false;+ }+ CloseLocked(state);+ state.handle = replacement;+ return true;+}++} // Anonymous namespace++bool IsSessionSupported(Session session) {+ const Api& api = Resolve();+ if (!api.usable) {+ return false;+ }+ if (session == Session::Background && !IsBackgroundUsable(api)) {+ return false;+ }+ std::scoped_lock lock{g_mutex};+ return !StateOf(session).unsupported;+}++bool AddCurrentThread(Session session) {+ if (!IsSessionSupported(session)) {+ return false;+ }++ const pid_t tid = gettid();+ std::scoped_lock lock{g_mutex};++ for (size_t i = 0; i < g_sessions.size(); ++i) {+ SessionState& state = g_sessions[i];+ if (static_cast<size_t>(session) == i) {+ continue;+ }+ const auto it = std::find(state.threads.begin(), state.threads.end(), tid);+ if (it != state.threads.end()) {+ state.threads.erase(it);+ SyncLocked(static_cast<Session>(i), state);+ }+ }++ SessionState& state = StateOf(session);+ const bool added =+ std::find(state.threads.begin(), state.threads.end(), tid) == state.threads.end();+ if (added) {+ state.threads.push_back(tid);+ }+ if (!SyncLocked(session, state)) {+ if (added) {+ std::erase(state.threads, tid);+ }+ return false;+ }+ return true;+}++void RemoveCurrentThread() {+ if (!Resolve().usable) {+ return;+ }+ const pid_t tid = gettid();+ std::scoped_lock lock{g_mutex};+ for (size_t i = 0; i < g_sessions.size(); ++i) {+ SessionState& state = g_sessions[i];+ if (std::erase(state.threads, tid) != 0) {+ SyncLocked(static_cast<Session>(i), state);+ }+ }+}++void SetTargetWorkDuration(std::chrono::nanoseconds target) {+ const Api& api = Resolve();+ if (!api.usable || target.count() <= 0) {+ return;+ }+ if (g_target_ns.exchange(target.count(), std::memory_order_relaxed) == target.count()) {+ return;+ }+ std::scoped_lock lock{g_mutex};+ SessionState& state = StateOf(Session::Render);+ if (state.handle != nullptr) {+ api.update_target(state.handle, target.count());+ }+}++void ReportFrameInterval() {+ const Api& api = Resolve();+ if (!api.usable) {+ return;+ }++ const auto now = std::chrono::steady_clock::now();+ const auto previous = t_last_frame;+ t_last_frame = now;+ if (previous.time_since_epoch().count() == 0) {+ return;+ }++ s64 actual = std::chrono::duration_cast<std::chrono::nanoseconds>(now - previous).count();+ if (actual <= 0) {+ return;+ }++ const s64 ceiling = g_target_ns.load(std::memory_order_relaxed) * MAX_REPORTED_TARGETS;+ actual = (std::min)(actual, ceiling);++ std::scoped_lock lock{g_mutex};+ SessionState& state = StateOf(Session::Render);+ if (state.handle != nullptr) {+ api.report_actual(state.handle, actual);+ }+}++void Shutdown() {+ if (!Resolve().usable) {+ return;+ }+ std::scoped_lock lock{g_mutex};+ for (SessionState& state : g_sessions) {+ CloseLocked(state);+ state.threads.clear();+ state.unsupported = false;+ }+}++} // namespace Common::ADPF++#else++namespace Common::ADPF {++bool IsSessionSupported(Session) {+ return false;+}++bool AddCurrentThread(Session) {+ return false;+}++void RemoveCurrentThread() {}++void SetTargetWorkDuration(std::chrono::nanoseconds) {}++void ReportFrameInterval() {}++void Shutdown() {}++} // namespace Common::ADPF++#endifdiff --git a/src/common/adpf.h b/src/common/adpf.hnew file mode 100644index 0000000000..6f14a0bee4--- /dev/null+++ b/src/common/adpf.h@@ -0,0 +1,26 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include <chrono>++namespace Common::ADPF {++enum class Session {+ Render,+ Background,+};++bool IsSessionSupported(Session session);++bool AddCurrentThread(Session session);+void RemoveCurrentThread();++void SetTargetWorkDuration(std::chrono::nanoseconds target);++void ReportFrameInterval();++void Shutdown();++} // namespace Common::ADPFdiff --git a/src/common/settings.h b/src/common/settings.hindex 00ba7dddc9..d25d5f690b 100644--- a/src/common/settings.h+++ b/src/common/settings.h@@ -260,10 +260,10 @@ struct Values {Category::Cpu};SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,"cpu_accuracy", Category::Cpu};- SwitchableSetting<CpuClock> fast_cpu_time{linkage,- CpuClock::Off,+ SwitchableSetting<CpuClock> cpu_clock{linkage,+ CpuClock::Normal,"fast_cpu_time",- Category::Cpu,+ Category::System,Specialization::Default,true,true};@@ -540,13 +540,13 @@ struct Values {#endif// Renderer Hacks //- SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,- GpuOverclock::Medium,- "fast_gpu_time",- Category::RendererHacks,- Specialization::Default,- true,- true};+ SwitchableSetting<GpuClock> gpu_clock{linkage,+ GpuClock::Boost,+ "fast_gpu_time",+ Category::System,+ Specialization::Default,+ true,+ true};SwitchableSetting<bool> skip_cpu_inner_invalidation{linkage,false,diff --git a/src/common/settings_enums.h b/src/common/settings_enums.hindex 2db0e02a5f..3d0131de70 100644--- a/src/common/settings_enums.h+++ b/src/common/settings_enums.h@@ -140,7 +140,7 @@ ENUM(DmaAccuracy, Default, Unsafe, Safe);ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);ENUM(CpuBackend, Dynarmic, Nce);ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);-ENUM(CpuClock, Off, Boost, Fast)+ENUM(CpuClock, Normal, Boost, Overclock)ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb, Memory_10Gb, Memory_12Gb);ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);ENUM(FullscreenMode, Borderless, Exclusive);@@ -152,7 +152,7 @@ ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);ENUM(ConsoleMode, Handheld, Docked);ENUM(AppletMode, HLE, LLE);ENUM(SpirvOptimizeMode, Never, OnLoad, Always);-ENUM(GpuOverclock, Normal, Medium, High)+ENUM(GpuClock, Normal, Boost, Overclock)ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High)ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High)diff --git a/src/common/thread.cpp b/src/common/thread.cppindex c947c88373..7b4dec3dce 100644--- a/src/common/thread.cpp+++ b/src/common/thread.cpp@@ -1,5 +1,6 @@// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-FileCopyrightText: 2013 Dolphin Emulator Project// SPDX-FileCopyrightText: 2014 Citra Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later@@ -9,6 +10,7 @@#include <string>#include <thread>+#include "common/adpf.h"#include "common/error.h"#include "common/logging.h"#include "common/assert.h"@@ -39,6 +41,402 @@#include <unistd.h>#endif+#ifdef __linux__+#include <sys/resource.h>+#include <algorithm>++namespace {+constexpr int NICE_AUDIO = -16;+constexpr int NICE_URGENT_DISPLAY = -8;+constexpr int NICE_DISPLAY = -4;+constexpr int NICE_DEFAULT = 0;+constexpr int NICE_BACKGROUND = 10;++int LowestAllowedNice() {+ static const int lowest = [] {+ rlimit limit{};+ if (getrlimit(RLIMIT_NICE, &limit) != 0) {+ return 0;+ }+ if (limit.rlim_cur >= 40) {+ return -20;+ }+ return 20 - static_cast<int>(limit.rlim_cur);+ }();+ return lowest;+}++int NiceValueForPriority(Common::ThreadPriority priority) {+ const int wanted = [priority] {+ switch (priority) {+ case Common::ThreadPriority::Low: return NICE_BACKGROUND;+ case Common::ThreadPriority::Normal: return NICE_DEFAULT;+ case Common::ThreadPriority::High: return NICE_DISPLAY;+ case Common::ThreadPriority::VeryHigh: return NICE_URGENT_DISPLAY;+ case Common::ThreadPriority::Critical: return NICE_AUDIO;+ default: return NICE_DEFAULT;+ }+ }();+ return (std::max)(wanted, (std::min)(NICE_DEFAULT, LowestAllowedNice()));+}+} // Anonymous namespace+#endif++#ifdef __ANDROID__+#include <sys/utsname.h>+#include <atomic>+#include <cerrno>+#include <cstdio>+#include <cstdlib>+#include <cstring>+#include <fstream>+#include <mutex>+#include <vector>++namespace {+constexpr size_t ANDROID_MINIMUM_PERFORMANCE_CORES = 4;++// A core counts as a performance core while it is within this much of the fastest one.+constexpr s64 ANDROID_PERFORMANCE_CAPACITY_PERCENT = 50;++constexpr std::chrono::nanoseconds ANDROID_POLICY_POLL_INTERVAL = std::chrono::milliseconds{500};++enum class CoreGroup {+ Unrestricted,+ Performance,+ Efficiency,+};++struct ThreadPolicy {+ pid_t tid;+ CoreGroup group;+ s32 nice_value;+ bool has_nice;+};++struct CoreInfo {+ s64 weight;+ u64 midr;+ s32 cpu;+};++struct CpuTopologyState {+ std::mutex topology_mutex;+ cpu_set_t allowed{};+ cpu_set_t performance{};+ cpu_set_t efficiency{};+ bool separated = false;+ bool initialized = false;++ pid_t canary_tid = 0;+ cpu_set_t canary_mask{};+ bool canary_valid = false;++ std::atomic<s64> next_poll_ns{0};++ std::mutex policy_mutex;+ std::vector<ThreadPolicy> policies;+};++CpuTopologyState& State() {+ static CpuTopologyState* const state = new CpuTopologyState();+ return *state;+}++struct PolicyRegistration {+ ~PolicyRegistration() {+ const pid_t tid = gettid();+ ::Common::ADPF::RemoveCurrentThread();+ CpuTopologyState& state = State();+ std::scoped_lock lock{state.policy_mutex};+ std::erase_if(state.policies,+ [tid](const ThreadPolicy& policy) { return policy.tid == tid; });+ }+};++thread_local PolicyRegistration t_policy_registration;++s32 PossibleCpuCount() {+ std::ifstream file("/sys/devices/system/cpu/possible");+ std::string list;+ if (file && std::getline(file, list) && !list.empty()) {+ s64 highest = -1;+ const char* cursor = list.c_str();+ while (*cursor != '\0') {+ char* end = nullptr;+ const s64 value = std::strtol(cursor, &end, 10);+ if (end == cursor) {+ break;+ }+ highest = (std::max)(highest, value);+ cursor = end;+ while (*cursor == '-' || *cursor == ',') {+ ++cursor;+ }+ }+ if (highest >= 0) {+ return static_cast<s32>((std::min<s64>)(highest + 1, CPU_SETSIZE));+ }+ }+ const s64 configured = sysconf(_SC_NPROCESSORS_CONF);+ if (configured > 0) {+ return static_cast<s32>((std::min<s64>)(configured, CPU_SETSIZE));+ }+ return static_cast<s32>((std::min<s64>)(std::thread::hardware_concurrency(), CPU_SETSIZE));+}++s64 ReadCpuScalar(s32 cpu, const char* node) {+ s64 value = 0;+ std::ifstream file("/sys/devices/system/cpu/cpu" + std::to_string(cpu) + "/" + node);+ if (!file || !(file >> value) || value <= 0) {+ return 0;+ }+ return value;+}++u64 ReadCpuMidr(s32 cpu) {+ u64 midr = 0;+ std::ifstream file("/sys/devices/system/cpu/cpu" + std::to_string(cpu) ++ "/regs/identification/midr_el1");+ if (!file || !(file >> std::hex >> midr)) {+ return 0;+ }+ return midr;+}++std::vector<CoreInfo> CollectCores(const cpu_set_t& allowed, s32 total, const char* node,+ bool require_all) {+ std::vector<CoreInfo> cores;+ for (s32 cpu = 0; cpu < total; ++cpu) {+ if (!CPU_ISSET(cpu, &allowed)) {+ continue;+ }+ const s64 weight = ReadCpuScalar(cpu, node);+ if (weight <= 0) {+ if (require_all) {+ return {};+ }+ LOG_WARNING(Common, "Could not read {} for CPU {}, treating it as an efficiency core",+ node, cpu);+ continue;+ }+ cores.push_back(CoreInfo{weight, ReadCpuMidr(cpu), cpu});+ }+ return cores;+}++bool WeightsAreUniform(const std::vector<CoreInfo>& cores) {+ return std::all_of(cores.begin(), cores.end(),+ [&](const CoreInfo& core) { return core.weight == cores.front().weight; });+}++bool MidrsAreDistinct(const std::vector<CoreInfo>& cores) {+ return std::none_of(cores.begin(), cores.end(),+ [](const CoreInfo& core) { return core.midr == 0; }) &&+ std::any_of(cores.begin(), cores.end(),+ [&](const CoreInfo& core) { return core.midr != cores.front().midr; });+}++void ComputeTopologyLocked(CpuTopologyState& state) {+ state.initialized = true;+ state.separated = false;+ CPU_ZERO(&state.allowed);+ CPU_ZERO(&state.performance);+ CPU_ZERO(&state.efficiency);++ if (sched_getaffinity(getpid(), sizeof(state.allowed), &state.allowed) != 0) {+ LOG_WARNING(Common, "Could not query process CPU affinity: {}",+ ::Common::GetLastErrorMsg());+ return;+ }++ const s32 total = PossibleCpuCount();+ auto cores = CollectCores(state.allowed, total, "cpu_capacity", true);+ if (cores.empty() || (WeightsAreUniform(cores) && MidrsAreDistinct(cores))) {+ auto by_frequency = CollectCores(state.allowed, total, "cpufreq/cpuinfo_max_freq", false);+ if (!by_frequency.empty()) {+ cores = std::move(by_frequency);+ }+ }+ if (cores.empty()) {+ LOG_WARNING(Common, "Could not determine CPU topology, thread placement is disabled");+ return;+ }++ if (WeightsAreUniform(cores)) {+ if (MidrsAreDistinct(cores)) {+ LOG_WARNING(Common, "CPU clusters differ but rank identically, thread placement is "+ "disabled");+ } else {+ LOG_INFO(Common, "CPU cores are symmetric, thread placement is disabled");+ }+ return;+ }++ std::sort(cores.begin(), cores.end(), [](const CoreInfo& lhs, const CoreInfo& rhs) {+ if (lhs.weight != rhs.weight) {+ return lhs.weight > rhs.weight;+ }+ return lhs.cpu < rhs.cpu;+ });++ const s64 fastest = cores.front().weight;+ size_t taken = 0;+ for (const auto& core : cores) {+ const bool fast_enough =+ core.weight * 100 >= fastest * ANDROID_PERFORMANCE_CAPACITY_PERCENT;+ if (!fast_enough && taken >= ANDROID_MINIMUM_PERFORMANCE_CORES) {+ break;+ }+ CPU_SET(core.cpu, &state.performance);+ ++taken;+ }+ if (taken == 0) {+ return;+ }++ for (s32 cpu = 0; cpu < total; ++cpu) {+ if (CPU_ISSET(cpu, &state.allowed) && !CPU_ISSET(cpu, &state.performance)) {+ CPU_SET(cpu, &state.efficiency);+ }+ }++ state.separated = CPU_COUNT(&state.efficiency) > 0;+ LOG_INFO(Common, "CPU topology: {} performance cores, {} efficiency cores, separation {}",+ CPU_COUNT(&state.performance), CPU_COUNT(&state.efficiency),+ state.separated ? "enabled" : "unavailable");+}++void EnsureTopologyLocked(CpuTopologyState& state) {+ if (!state.initialized) {+ ComputeTopologyLocked(state);+ }+}++void RefreshTopologyLocked(CpuTopologyState& state) {+ if (!state.initialized) {+ ComputeTopologyLocked(state);+ return;+ }+ cpu_set_t current;+ CPU_ZERO(¤t);+ if (sched_getaffinity(getpid(), sizeof(current), ¤t) != 0) {+ return;+ }+ if (std::memcmp(¤t, &state.allowed, sizeof(current)) != 0) {+ ComputeTopologyLocked(state);+ }+}++bool ApplyCoreGroupLocked(CpuTopologyState& state, pid_t tid, CoreGroup group,+ bool* gone = nullptr) {+ const bool restrict_group = group != CoreGroup::Unrestricted && state.separated;+ const cpu_set_t* mask = &state.allowed;+ if (restrict_group) {+ mask = group == CoreGroup::Performance ? &state.performance : &state.efficiency;+ }+ if (CPU_COUNT(mask) == 0) {+ return false;+ }+ if (sched_setaffinity(tid, sizeof(*mask), mask) != 0) {+ if (gone != nullptr && errno == ESRCH) {+ *gone = true;+ return false;+ }+ LOG_WARNING(Common, "Could not restrict thread {} to its core group: {}", tid,+ ::Common::GetLastErrorMsg());+ return false;+ }+ return true;+}++bool KernelPreservesRequestedAffinity() {+ utsname info{};+ if (uname(&info) != 0) {+ return false;+ }+ s32 major = 0;+ s32 minor = 0;+ if (std::sscanf(info.release, "%d.%d", &major, &minor) != 2) {+ return false;+ }+ return major > 6 || (major == 6 && minor >= 2);+}++void SnapshotCanaryLocked(CpuTopologyState& state) {+ state.canary_valid = false;+ if (!state.separated) {+ return;+ }+ for (const auto& policy : state.policies) {+ if (policy.group == CoreGroup::Unrestricted) {+ continue;+ }+ cpu_set_t mask;+ CPU_ZERO(&mask);+ if (sched_getaffinity(policy.tid, sizeof(mask), &mask) != 0) {+ continue;+ }+ state.canary_tid = policy.tid;+ state.canary_mask = mask;+ state.canary_valid = true;+ return;+ }+}++bool DueForPoll(CpuTopologyState& state) {+ const auto now = std::chrono::steady_clock::now().time_since_epoch();+ const s64 now_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now).count();+ s64 next = state.next_poll_ns.load(std::memory_order_relaxed);+ if (now_ns < next) {+ return false;+ }+ return state.next_poll_ns.compare_exchange_strong(+ next, now_ns + ANDROID_POLICY_POLL_INTERVAL.count(), std::memory_order_relaxed);+}++ThreadPolicy& AcquirePolicyLocked(CpuTopologyState& state, pid_t tid) {+ for (auto& policy : state.policies) {+ if (policy.tid == tid) {+ return policy;+ }+ }+ return state.policies.emplace_back(ThreadPolicy{tid, CoreGroup::Unrestricted, 0, false});+}++void SetCurrentThreadCoreGroup(CoreGroup group) {+ const pid_t tid = gettid();+ (void)&t_policy_registration;++ CoreGroup effective = group;+ if (tid == getpid() && group != CoreGroup::Unrestricted) {+ LOG_WARNING(Common, "Refusing to place the main thread: the CPU topology is read from it");+ effective = CoreGroup::Unrestricted;+ }++ CpuTopologyState& state = State();+ std::scoped_lock topology_lock{state.topology_mutex};+ EnsureTopologyLocked(state);+ ApplyCoreGroupLocked(state, tid, effective);++ std::scoped_lock policy_lock{state.policy_mutex};+ AcquirePolicyLocked(state, tid).group = effective;+ if (!state.canary_valid) {+ SnapshotCanaryLocked(state);+ }+}++void RememberCurrentThreadNice(pid_t tid, s32 nice_value) {+ (void)&t_policy_registration;+ CpuTopologyState& state = State();+ std::scoped_lock lock{state.policy_mutex};+ ThreadPolicy& policy = AcquirePolicyLocked(state, tid);+ policy.nice_value = nice_value;+ policy.has_nice = true;+}+} // Anonymous namespace+#endif+#include "common/cpu_features.h"#ifdef ARCHITECTURE_x86_64#ifdef _MSC_VER@@ -48,7 +446,6 @@#endif#include "common/x64/rdtsc.h"#endif-#include "core/core_timing.h"namespace Common {@@ -78,21 +475,31 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {}}();set_thread_priority(find_thread(NULL), priority);+#elif defined(__ANDROID__)+ const int nice_value = NiceValueForPriority(new_priority);+ const pid_t tid = gettid();+ if (setpriority(PRIO_PROCESS, static_cast<id_t>(tid), nice_value) != 0) {+ LOG_WARNING(Common, "Could not set thread nice value to {}: {}", nice_value,+ GetLastErrorMsg());+ return;+ }+ RememberCurrentThreadNice(tid, nice_value);+#elif defined(__linux__)+ const int nice_value = NiceValueForPriority(new_priority);+ if (setpriority(PRIO_PROCESS, 0, nice_value) != 0) {+ LOG_DEBUG(Common, "Could not set thread nice value to {}: {}", nice_value,+ GetLastErrorMsg());+ }#else- pthread_t this_thread = pthread_self();- const auto scheduling_type = SCHED_OTHER;- s32 max_prio = sched_get_priority_max(scheduling_type);- s32 min_prio = sched_get_priority_min(scheduling_type);- u32 level = (std::max)(u32(new_priority) + 1, 4U);-- struct sched_param params;+ const s32 max_prio = sched_get_priority_max(SCHED_OTHER);+ const s32 min_prio = sched_get_priority_min(SCHED_OTHER);if (max_prio > min_prio) {- params.sched_priority = min_prio + ((max_prio - min_prio) * level) / 4;- } else {- params.sched_priority = min_prio - ((min_prio - max_prio) * level) / 4;+ const u32 level = (std::min)(static_cast<u32>(new_priority), 4U);+ sched_param params{};+ params.sched_priority =+ min_prio + static_cast<s32>(static_cast<u32>(max_prio - min_prio) * level) / 4;+ pthread_setschedparam(pthread_self(), SCHED_OTHER, ¶ms);}-- pthread_setschedparam(this_thread, scheduling_type, ¶ms);#endif}@@ -132,29 +539,94 @@ void SetCurrentThreadName(const char* name) {#endif}-void PinCurrentThreadToPerformanceCore(size_t core_id) {- ASSERT(core_id < 4);- // If we set a flag for a CPU that doesn't exist, the thread may not be allowed to- // run in ANY processor!- auto const total_cores = std::thread::hardware_concurrency();- if (core_id < total_cores) {+void SetCurrentThreadToPerformanceCores() {#if defined(__ANDROID__)- cpu_set_t set;- CPU_ZERO(&set);- CPU_SET(core_id, &set);- sched_setaffinity(pthread_self(), sizeof(set), &set);-#elif defined(__linux__) || defined(__FreeBSD__)- cpu_set_t set;- CPU_ZERO(&set);- CPU_SET(core_id, &set);- pthread_setaffinity_np(pthread_self(), sizeof(set), &set);-#elif defined(_WIN32)- DWORD set = 1UL << core_id;- SetThreadAffinityMask(GetCurrentThread(), set);-#else- // No pin functionality implemented+ if (ADPF::AddCurrentThread(ADPF::Session::Render)) {+ SetCurrentThreadCoreGroup(CoreGroup::Unrestricted);+ return;+ }+ SetCurrentThreadCoreGroup(CoreGroup::Performance);+#endif+}++void SetCurrentThreadToEfficiencyCores() {+#if defined(__ANDROID__)+ if (ADPF::AddCurrentThread(ADPF::Session::Background)) {+ SetCurrentThreadCoreGroup(CoreGroup::Unrestricted);+ return;+ }+ SetCurrentThreadCoreGroup(CoreGroup::Efficiency);+#endif+}++void SetCurrentThreadToBackgroundWork() {+#if defined(__ANDROID__)+ ADPF::AddCurrentThread(ADPF::Session::Background);+ SetCurrentThreadCoreGroup(CoreGroup::Unrestricted);+#endif+}++void SetCurrentThreadToAllCores() {+#if defined(__ANDROID__)+ ADPF::RemoveCurrentThread();+ SetCurrentThreadCoreGroup(CoreGroup::Unrestricted);+#endif+}++void RefreshThreadPolicies() {+#if defined(__ANDROID__)+ CpuTopologyState& state = State();+ std::scoped_lock topology_lock{state.topology_mutex};+ RefreshTopologyLocked(state);++ std::scoped_lock policy_lock{state.policy_mutex};+ std::erase_if(state.policies, [&state](const ThreadPolicy& policy) {+ bool gone = false;+ if (policy.has_nice &&+ setpriority(PRIO_PROCESS, static_cast<id_t>(policy.tid), policy.nice_value) != 0 &&+ errno == ESRCH) {+ gone = true;+ }+ if (!gone) {+ ApplyCoreGroupLocked(state, policy.tid, policy.group, &gone);+ }+ return gone;+ });+ SnapshotCanaryLocked(state);#endif+}++void PollThreadPolicies() {+#if defined(__ANDROID__)+ static const bool needed = !KernelPreservesRequestedAffinity();+ if (!needed) {+ return;+ }++ CpuTopologyState& state = State();+ if (!DueForPoll(state)) {+ return;+ }++ pid_t tid;+ cpu_set_t expected;+ {+ std::scoped_lock lock{state.topology_mutex};+ if (!state.canary_valid) {+ return;+ }+ tid = state.canary_tid;+ expected = state.canary_mask;}++ cpu_set_t current;+ CPU_ZERO(¤t);+ if (sched_getaffinity(tid, sizeof(current), ¤t) == 0 &&+ std::memcmp(¤t, &expected, sizeof(current)) == 0) {+ return;+ }+ RefreshThreadPolicies();+#endif}#ifdef ARCHITECTURE_x86_64diff --git a/src/common/thread.h b/src/common/thread.hindex a75e342802..4a36295931 100644--- a/src/common/thread.h+++ b/src/common/thread.h@@ -99,8 +99,20 @@ enum class ThreadPriority : u32 {Critical = 4,};+enum class ThreadPlacement : u32 {+ Default = 0,+ Background = 1,+ Efficiency = 2,+};+void SetCurrentThreadPriority(ThreadPriority new_priority);void SetCurrentThreadName(const char* name);-void PinCurrentThreadToPerformanceCore(size_t core_id);+void SetCurrentThreadToPerformanceCores();+void SetCurrentThreadToEfficiencyCores();+void SetCurrentThreadToBackgroundWork();+void SetCurrentThreadToAllCores();++void RefreshThreadPolicies();+void PollThreadPolicies();} // namespace Commondiff --git a/src/common/thread_worker.h b/src/common/thread_worker.hindex 6ec9d6a2bd..ec3ca0af49 100644--- a/src/common/thread_worker.h+++ b/src/common/thread_worker.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project@@ -37,10 +37,25 @@ class StatefulThreadWorker {using StateMaker = std::conditional_t<with_state, std::function<StateType()>, DummyCallable>;public:- explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})+ explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {},+ ThreadPlacement placement = ThreadPlacement::Default): workers_queued{num_workers}, thread_name{std::move(name)} {- const auto lambda = [this, func](std::stop_token stop_token) {+ const auto lambda = [this, func, placement](std::stop_token stop_token) {Common::SetCurrentThreadName(thread_name.c_str());+ if (placement != ThreadPlacement::Default) {+ Common::SetCurrentThreadPriority(ThreadPriority::Low);+ }+ switch (placement) {+ case ThreadPlacement::Efficiency:+ Common::SetCurrentThreadToEfficiencyCores();+ break;+ case ThreadPlacement::Background:+ Common::SetCurrentThreadToBackgroundWork();+ break;+ default:+ Common::SetCurrentThreadToAllCores();+ break;+ }{[[maybe_unused]] std::conditional_t<with_state, StateType, int> state{func()};while (!stop_token.stop_requested()) {diff --git a/src/core/core.cpp b/src/core/core.cppindex 3ff42cf6f5..d110aa5f8b 100644--- a/src/core/core.cpp+++ b/src/core/core.cpp@@ -10,6 +10,7 @@#include "audio_core/audio_core.h"#include "common/fs/fs.h"#include "common/logging.h"+#include "common/adpf.h"#include "common/settings.h"#include "common/settings_enums.h"#include "common/string_util.h"@@ -385,6 +386,7 @@ struct System::Impl {void ShutdownMainProcess() {SetShuttingDown(true);+ Common::ADPF::Shutdown();// Reset per-game flagsSettings::values.use_squashed_iterated_blend = false;diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cppindex 3e4e7bdc68..d2ee6769cc 100644--- a/src/core/core_timing.cpp+++ b/src/core/core_timing.cpp@@ -23,6 +23,21 @@ namespace Core::Timing {constexpr s64 MAX_SLICE_LENGTH = 10000;+constexpr u32 CPU_CLOCK_BASE_MHZ = 1020;+constexpr u32 CPU_CLOCK_BOOST_MHZ = 1734;+constexpr u32 CPU_CLOCK_OVERCLOCK_MHZ = 2040;++constexpr u32 CpuClockTargetMhz(Settings::CpuClock clock) {+ switch (clock) {+ case Settings::CpuClock::Boost:+ return CPU_CLOCK_BOOST_MHZ;+ case Settings::CpuClock::Overclock:+ return CPU_CLOCK_OVERCLOCK_MHZ;+ default:+ return CPU_CLOCK_BASE_MHZ;+ }+}+std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) {return std::make_shared<EventType>(std::move(callback), std::move(name));}@@ -58,7 +73,8 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {if (is_multicore) {timer_thread = std::jthread([this](std::stop_token stop_token) {Common::SetCurrentThreadName("HostTiming");- Common::SetCurrentThreadPriority(Common::ThreadPriority::High);+ Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);+ Common::SetCurrentThreadToPerformanceCores();on_thread_init();has_started = true;@@ -209,8 +225,9 @@ void CoreTiming::ResetTicks() {u64 CoreTiming::GetClockTicks() const {u64 fres = is_multicore ? Common::g_wall_clock.GetCNTPCT() : Common::WallClock::CPUTickToCNTPCT(cpu_ticks);- if (auto const overclock = Settings::values.fast_cpu_time.GetValue(); overclock != Settings::CpuClock::Off) {- fres = u64(f64(fres) * (1.7 + 0.3 * u32(overclock)));+ if (const u32 target = CpuClockTargetMhz(Settings::values.cpu_clock.GetValue());+ target != CPU_CLOCK_BASE_MHZ) {+ fres = fres * target / CPU_CLOCK_BASE_MHZ;}if (::Settings::values.sync_core_speed.GetValue()) {auto const ticks = f64(fres);diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cppindex 7194fa5022..23d5ac3dfd 100644--- a/src/core/cpu_manager.cpp+++ b/src/core/cpu_manager.cpp@@ -174,12 +174,7 @@ void CpuManager::RunThread(std::stop_token token, std::size_t core) {std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"};Common::SetCurrentThreadName(name.c_str());Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);-#ifdef __ANDROID__- // Aimed specifically for Snapdragon 8 Elite devices- // This kills performance on desktop, but boosts perf for UMA devices- // like the S8E. Mediatek and Mali likely won't suffer.- Common::PinCurrentThreadToPerformanceCore(core);-#endif+ Common::SetCurrentThreadToPerformanceCores();auto& data = core_data[core];data.host_context = Common::Fiber::ThreadToFiber();diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cppindex bdbb16ed04..6e9fe9ec07 100644--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp@@ -6,6 +6,7 @@#include <boost/container/small_vector.hpp>+#include "common/adpf.h"#include "common/assert.h"#include "common/logging.h"#include "core/core.h"@@ -86,11 +87,16 @@ void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers}system.GPU().RequestComposite(std::move(output_layers), std::move(output_fences));+ Common::ADPF::ReportFrameInterval();system.SpeedLimiter().DoSpeedLimiting(system.CoreTiming().GetGlobalTimeUs());system.GetPerfStats().EndSystemFrame();system.GetPerfStats().BeginSystemFrame();}+void nvdisp_disp0::WaitForComposite() {+ system.GPU().WaitForComposite();+}+Kernel::KEvent* nvdisp_disp0::QueryEvent(u32 event_id) {LOG_CRITICAL(Service_NVDRV, "Unknown DISP Event {}", event_id);return nullptr;diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.hindex 1082b85c2b..ff0bfb2ec9 100644--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later@@ -37,6 +40,8 @@ public:/// Performs a screen flip, compositing each buffer.void Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers);+ void WaitForComposite();+Kernel::KEvent* QueryEvent(u32 event_id) override;private:diff --git a/src/core/hle/service/nvnflinger/hardware_composer.cpp b/src/core/hle/service/nvnflinger/hardware_composer.cppindex cfd999497b..e491b24a8f 100644--- a/src/core/hle/service/nvnflinger/hardware_composer.cpp+++ b/src/core/hle/service/nvnflinger/hardware_composer.cpp@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project@@ -57,18 +57,8 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,// Set default speed limit to 100%.*out_speed_scale = 1.0f;- // If no layers are available, skip the logic.- bool any_visible = false;- for (auto& layer : display.stack.layers) {- if (layer->visible) {- any_visible = true;- break;- }- }- if (!any_visible) {- *out_speed_scale = 1.0f;- return 1;- }+ nvdisp.WaitForComposite();+ this->ReleaseFramebuffersLocked(display);// Determine the number of vsync periods to wait before composing again.std::optional<s32> swap_interval{};@@ -158,55 +148,30 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,nvdisp.Composite(composition_stack);}- // Batch framebuffer releases, instead of one-into-one.- std::vector<std::pair<Layer*, Framebuffer*>> to_release;- for (auto& [layer_id, framebuffer] : m_framebuffers) {- if (!framebuffer.is_acquired)- continue;-- auto layer = display.stack.FindLayer(layer_id);- if (!layer)- continue;-- // Overlay layers always release after every compose- // Non-overlay layers release based on their swap interval- if (layer->is_overlay || framebuffer.release_frame_number <= m_frame_number) {- to_release.emplace_back(layer.get(), &framebuffer);- }- }- for (auto& [layer, framebuffer] : to_release) {- layer->buffer_item_consumer->ReleaseBuffer(framebuffer->item, android::Fence::NoFence());- framebuffer->is_acquired = false;- }-// Advance by 1 frame (60 FPS compositing)m_frame_number += 1;- // Release any necessary framebuffers (non-overlay layers only, as overlays are already released above).+ return 1;+}++void HardwareComposer::ReleaseFramebuffersLocked(Display& display) {for (auto& [layer_id, framebuffer] : m_framebuffers) {if (!framebuffer.is_acquired) {- // Already released.continue;}- if (framebuffer.release_frame_number > m_frame_number) {+ const auto layer = display.stack.FindLayer(layer_id);+ if (!layer) {continue;}- if (const auto layer = display.stack.FindLayer(layer_id); layer != nullptr) {- // Skip overlay layers as they were already released above- if (layer->is_overlay) {- continue;- }-- // TODO: support release fence- // This is needed to prevent screen tearing- layer->buffer_item_consumer->ReleaseBuffer(framebuffer.item, android::Fence::NoFence());- framebuffer.is_acquired = false;+ if (!layer->is_overlay && framebuffer.release_frame_number > m_frame_number) {+ continue;}- }- return 1;+ layer->buffer_item_consumer->ReleaseBuffer(framebuffer.item, android::Fence::NoFence());+ framebuffer.is_acquired = false;+ }}void HardwareComposer::RemoveLayerLocked(Display& display, ConsumerId consumer_id) {diff --git a/src/core/hle/service/nvnflinger/hardware_composer.h b/src/core/hle/service/nvnflinger/hardware_composer.hindex e9b7194612..9702e0584b 100644--- a/src/core/hle/service/nvnflinger/hardware_composer.h+++ b/src/core/hle/service/nvnflinger/hardware_composer.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project@@ -52,6 +52,7 @@ private:private:bool TryAcquireFramebufferLocked(Layer& layer, Framebuffer& framebuffer);CacheStatus CacheFramebufferLocked(Layer& layer, ConsumerId consumer_id);+ void ReleaseFramebuffersLocked(Display& display);};} // namespace Service::Nvnflingerdiff --git a/src/core/hle/service/vi/conductor.cpp b/src/core/hle/service/vi/conductor.cppindex 002c653b8c..fd7233cf93 100644--- a/src/core/hle/service/vi/conductor.cpp+++ b/src/core/hle/service/vi/conductor.cpp@@ -4,7 +4,11 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later+#include <algorithm>++#include "common/adpf.h"#include "common/settings.h"+#include "common/thread.h"#include "core/core.h"#include "core/core_timing.h"#include "core/hle/service/vi/conductor.h"@@ -14,6 +18,8 @@constexpr auto FrameNs = std::chrono::nanoseconds{1000000000 / 60};+constexpr s64 UNLOCKED_TARGET_DIVISOR = 4;+namespace Service::VI {Conductor::Conductor(Core::System& system, Container& container, DisplayList& displays)@@ -68,6 +74,9 @@ void Conductor::UnlinkVsyncEvent(u64 display_id, Event* event) {}void Conductor::ProcessVsync() {+ Common::PollThreadPolicies();+ Common::ADPF::SetTargetWorkDuration(std::chrono::nanoseconds{this->GetFramePeriodNs()});+for (auto& [display_id, manager] : m_vsync_managers) {m_container.ComposeOnDisplay(&m_swap_interval, &m_compose_speed_scale, display_id);manager.SignalVsync(m_system.Kernel());@@ -76,6 +85,8 @@ void Conductor::ProcessVsync() {void Conductor::VsyncThread(std::stop_token token) {Common::SetCurrentThreadName("VSyncThread");+ Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);+ Common::SetCurrentThreadToPerformanceCores();while (!token.stop_requested()) {m_signal.Wait();@@ -114,4 +125,25 @@ s64 Conductor::GetNextTicks() const {return static_cast<s64>(speed_scale * (1000000000.f / effective_fps));}+s64 Conductor::GetFramePeriodNs() const {+ const auto& settings = Settings::values;+ f32 speed_scale = 1.f;+ bool unlocked = false;+ if (settings.use_multi_core.GetValue()) {+ if (settings.use_speed_limit.GetValue()) {+ speed_scale = 100.f / Settings::SpeedLimit();+ } else {+ unlocked = true;+ }+ }+ speed_scale /= m_compose_speed_scale;++ const f32 effective_fps = 60.f / static_cast<f32>(m_swap_interval);+ s64 period = static_cast<s64>(speed_scale * (1000000000.f / effective_fps));+ if (unlocked) {+ period /= UNLOCKED_TARGET_DIVISOR;+ }+ return std::clamp<s64>(period, 1'000'000, 100'000'000);+}+} // namespace Service::VIdiff --git a/src/core/hle/service/vi/conductor.h b/src/core/hle/service/vi/conductor.hindex 59eb2fd022..7c93c230f7 100644--- a/src/core/hle/service/vi/conductor.h+++ b/src/core/hle/service/vi/conductor.h@@ -44,6 +44,7 @@ private:void ProcessVsync();void VsyncThread(std::stop_token token);s64 GetNextTicks() const;+ s64 GetFramePeriodNs() const;private:Core::System& m_system;diff --git a/src/qt_common/config/shared_translation.cpp b/src/qt_common/config/shared_translation.cppindex 893e4a0854..26597d412c 100644--- a/src/qt_common/config/shared_translation.cpp+++ b/src/qt_common/config/shared_translation.cpp@@ -92,12 +92,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {tr("Change the accuracy of the emulated CPU (for debugging only)."));INSERT(Settings, cpu_backend, tr("Backend:"), QString());- INSERT(Settings, fast_cpu_time, tr("CPU Overclock"),- tr("Overclocks the emulated CPU to remove some FPS limiters. Weaker CPUs may see "- "reduced performance, "- "and certain games may behave improperly.\nUse Boost (1700MHz) to run at the "- "Switch's highest native "- "clock, or Fast (2000MHz) to run at 2x clock."));+ INSERT(Settings, cpu_clock, tr("CPU Clocks"),+ tr("Raises the clock the emulated CPU reports, which removes some FPS limiters.\n"+ "Weaker CPUs may see reduced performance, and certain games may behave improperly."));INSERT(Settings, use_custom_cpu_ticks, QString(), QString());INSERT(Settings, cpu_ticks, tr("Custom CPU Ticks"),@@ -230,9 +227,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),tr("May reduce shader stutter."));- INSERT(Settings, fast_gpu_time, tr("Fast GPU Time"),- tr("Overclocks the emulated GPU to increase dynamic resolution and render "- "distance.\nUse 256 for maximal performance and 512 for maximal graphics fidelity."));+ INSERT(Settings, gpu_clock, tr("GPU Clocks"),+ tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "+ "resolution and render distance to fit the Switch's clocks."));INSERT(Settings, gpu_unswizzle_enabled, tr("GPU Unswizzle"),tr("Accelerates BCn 3D texture decoding using GPU compute.\n""Disable if experiencing crashes or graphical glitches."));@@ -639,9 +636,9 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {}});translations->insert({Settings::EnumMetadata<Settings::CpuClock>::Index(),{- PAIR(CpuClock, Off, tr("Off")),- PAIR(CpuClock, Boost, tr("Boost (1700MHz)")),- PAIR(CpuClock, Fast, tr("Fast (2000MHz)")),+ PAIR(CpuClock, Normal, tr("Normal")),+ PAIR(CpuClock, Boost, tr("Boost")),+ PAIR(CpuClock, Overclock, tr("Overclock")),}});translations->insert({Settings::EnumMetadata<Settings::ConfirmStop>::Index(),@@ -650,11 +647,11 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {PAIR(ConfirmStop, Ask_Based_On_Game, tr("Only if game specifies not to stop")),PAIR(ConfirmStop, Ask_Never, tr("Never ask")),}});- translations->insert({Settings::EnumMetadata<Settings::GpuOverclock>::Index(),+ translations->insert({Settings::EnumMetadata<Settings::GpuClock>::Index(),{- PAIR(GpuOverclock, Normal, tr("Off")),- PAIR(GpuOverclock, Medium, tr("Medium (256)")),- PAIR(GpuOverclock, High, tr("High (512)")),+ PAIR(GpuClock, Normal, tr("Normal")),+ PAIR(GpuClock, Boost, tr("Boost")),+ PAIR(GpuClock, Overclock, tr("Overclock")),}});translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzleSize>::Index(),{diff --git a/src/video_core/fence_manager.h b/src/video_core/fence_manager.hindex 16f19bf009..885c714025 100644--- a/src/video_core/fence_manager.h+++ b/src/video_core/fence_manager.h@@ -195,6 +195,7 @@ private:void ReleaseThreadFunc(std::stop_token stop_token) {Common::SetCurrentThreadName("GPUFencingThread");Common::SetCurrentThreadPriority(Common::ThreadPriority::High);+ Common::SetCurrentThreadToPerformanceCores();TFence current_fence;std::deque<std::function<void()>> current_operations;diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cppindex 548a8bf809..a44015c0dd 100644--- a/src/video_core/gpu.cpp+++ b/src/video_core/gpu.cpp@@ -10,6 +10,7 @@#include <condition_variable>#include <list>#include <memory>+#include <utility>#include "common/assert.h"#include "common/settings.h"@@ -39,6 +40,19 @@namespace Tegra {+namespace {+constexpr u64 GpuClockMultiplier(Settings::GpuClock clock) {+ switch (clock) {+ case Settings::GpuClock::Boost:+ return 256;+ case Settings::GpuClock::Overclock:+ return 512;+ default:+ return 1;+ }+}+} // Anonymous namespace+struct GPU::Impl {explicit Impl(Core::System& system_, bool is_async_, bool use_nvdec_): system{system_}@@ -116,7 +130,7 @@ struct GPU::Impl {[[nodiscard]] u64 RequestSyncOperation(Func&& action) {std::unique_lock lck{sync_request_mutex};const u64 fence = ++last_sync_fence;- sync_requests.emplace_back(action);+ sync_requests.emplace_back(std::forward<Func>(action));return fence;}@@ -145,14 +159,8 @@ struct GPU::Impl {}[[nodiscard]] u64 GetTicks() const {- u64 gpu_tick = system.CoreTiming().GetGPUTicks();- Settings::GpuOverclock overclock = Settings::values.fast_gpu_time.GetValue();-- if (overclock != Settings::GpuOverclock::Normal) {- gpu_tick /= 256 * u64(overclock);- }-- return gpu_tick;+ const u64 gpu_tick = system.CoreTiming().GetGPUTicks();+ return gpu_tick / GpuClockMultiplier(Settings::values.gpu_clock.GetValue());}void RendererFrameEndNotify() {@@ -225,9 +233,9 @@ struct GPU::Impl {}void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers, std::vector<Service::Nvidia::NvFence>&& fences) {- size_t num_fences{fences.size()};+ const size_t num_fences{fences.size()};size_t current_request_counter{};- {+ if (num_fences != 0) {std::unique_lock<std::mutex> lk(request_swap_mutex);if (free_swap_counters.empty()) {current_request_counter = request_swap_counters.size();@@ -238,27 +246,42 @@ struct GPU::Impl {free_swap_counters.pop_front();}}- const auto wait_fence = RequestSyncOperation([this, current_request_counter, &layers, &fences, num_fences] {- auto& syncpoint_manager = system.Host1x().GetSyncpointManager();- if (num_fences == 0) {- renderer->Composite(layers);- }- const auto executer = [this, current_request_counter, layers_copy = layers]() {- {- std::unique_lock<std::mutex> lk(request_swap_mutex);- if (--request_swap_counters[current_request_counter] != 0) {- return;+ pending_composite_fence = RequestSyncOperation(+ [this, current_request_counter, num_fences, composite_layers = std::move(layers),+ composite_fences = std::move(fences)] {+ if (num_fences == 0) {+ renderer->Composite(composite_layers);+ return;+ }+ auto& syncpoint_manager = system.Host1x().GetSyncpointManager();+ const auto executer = [this, current_request_counter, composite_layers]() {+ {+ std::unique_lock<std::mutex> lk(request_swap_mutex);+ if (--request_swap_counters[current_request_counter] != 0) {+ return;+ }+ free_swap_counters.push_back(current_request_counter);}- free_swap_counters.push_back(current_request_counter);+ renderer->Composite(composite_layers);+ };+ for (size_t i = 0; i < num_fences; i++) {+ syncpoint_manager.RegisterGuestAction(composite_fences[i].id,+ composite_fences[i].value, executer);}- renderer->Composite(layers_copy);- };- for (size_t i = 0; i < num_fences; i++) {- syncpoint_manager.RegisterGuestAction(fences[i].id, fences[i].value, executer);- }- });+ });gpu_thread.TickGPU(is_async);- WaitForSyncOperation(wait_fence);+ }++ void WaitForComposite() {+ const u64 fence = pending_composite_fence;+ if (fence == 0) {+ return;+ }+ pending_composite_fence = 0;+ if (shutting_down.load(std::memory_order_relaxed)) {+ return;+ }+ WaitForSyncOperation(fence);}std::vector<u8> GetAppletCaptureBuffer() {@@ -311,6 +334,7 @@ struct GPU::Impl {std::deque<size_t> free_swap_counters;std::deque<size_t> request_swap_counters;std::mutex request_swap_mutex;+ u64 pending_composite_fence{};};GPU::GPU(Core::System& system, bool is_async, bool use_nvdec)@@ -428,6 +452,10 @@ void GPU::RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,impl->RequestComposite(std::move(layers), std::move(fences));}+void GPU::WaitForComposite() {+ impl->WaitForComposite();+}+std::vector<u8> GPU::GetAppletCaptureBuffer() {return impl->GetAppletCaptureBuffer();}diff --git a/src/video_core/gpu.h b/src/video_core/gpu.hindex 538c4da85a..8d4a101fd4 100644--- a/src/video_core/gpu.h+++ b/src/video_core/gpu.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project@@ -218,6 +218,8 @@ public:void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,std::vector<Service::Nvidia::NvFence>&& fences);+ void WaitForComposite();+std::vector<u8> GetAppletCaptureBuffer();/// Performs any additional setup necessary in order to begin GPU emulation.diff --git a/src/video_core/gpu_thread.cpp b/src/video_core/gpu_thread.cppindex 50570b596d..2acf9ac458 100644--- a/src/video_core/gpu_thread.cpp+++ b/src/video_core/gpu_thread.cpp@@ -30,6 +30,7 @@ void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Core::Frontenthread = std::jthread([&](std::stop_token stop_token) {Common::SetCurrentThreadName("GPU");Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);+ Common::SetCurrentThreadToPerformanceCores();system.RegisterHostThread();auto current_context = context.Acquire();diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cppindex 2772a68d7a..785602b33a 100644--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp@@ -305,7 +305,7 @@ size_t GetTotalPipelineWorkers() {std::max<size_t>(static_cast<size_t>(std::thread::hardware_concurrency()), 2ULL) - 1ULL;#ifdef __ANDROID__const int configured = AndroidSettings::values.pipeline_worker_count.GetValue();- const int clamped = std::clamp(configured, 4, 8);+ const int clamped = std::clamp(configured, 2, 8);const size_t desired = static_cast<size_t>(clamped);if (desired == 0) {return 1ULL;@@ -351,8 +351,9 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,use_asynchronous_shaders{Settings::values.use_asynchronous_shaders.GetValue()},use_vulkan_pipeline_cache{Settings::values.use_vulkan_driver_pipeline_cache.GetValue()},workers(device.HasBrokenParallelShaderCompiling() ? 1ULL : GetTotalPipelineWorkers(),- "VkPipelineBuilder"),- serialization_thread(1, "VkPipelineSerialization") {+ "VkPipelineBuilder", {}, Common::ThreadPlacement::Background),+ serialization_thread(1, "VkPipelineSerialization", {},+ Common::ThreadPlacement::Background) {const auto& float_control{device.FloatControlProperties()};const VkDriverId driver_id{device.GetDriverID()};const VkShaderStageFlags subgroup_stages{device.GetSubgroupSupportedStages()};diff --git a/src/video_core/renderer_vulkan/vk_present_manager.cpp b/src/video_core/renderer_vulkan/vk_present_manager.cppindex 53c3f6759f..90ebb55d38 100644--- a/src/video_core/renderer_vulkan/vk_present_manager.cpp+++ b/src/video_core/renderer_vulkan/vk_present_manager.cpp@@ -266,6 +266,8 @@ void PresentManager::WaitPresent() {void PresentManager::PresentThread(std::stop_token token) {Common::SetCurrentThreadName("VulkanPresent");+ Common::SetCurrentThreadPriority(Common::ThreadPriority::High);+ Common::SetCurrentThreadToPerformanceCores();while (!token.stop_requested()) {std::unique_lock lock{queue_mutex};// Wait for presentation framesdiff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cppindex 7432c94cfc..3601a3e891 100644--- a/src/video_core/renderer_vulkan/vk_scheduler.cpp+++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp@@ -258,6 +258,8 @@ bool Scheduler::UpdateDescriptorBufferChunk(u32 descriptor_chunk) {void Scheduler::WorkerThread(std::stop_token stop_token) {Common::SetCurrentThreadName("VulkanWorker");+ Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);+ Common::SetCurrentThreadToPerformanceCores();const auto TryPopQueue{[this](auto& work) -> bool {if (work_queue.empty()) {diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.hindex fbc2bb4cf7..fafc331ef7 100644--- a/src/video_core/texture_cache/texture_cache_base.h+++ b/src/video_core/texture_cache/texture_cache_base.h@@ -509,7 +509,8 @@ private:u64 frame_tick = 0;u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();- Common::ThreadWorker texture_decode_worker{1, "TextureDecoder"};+ Common::ThreadWorker texture_decode_worker{1, "TextureDecoder", {},+ Common::ThreadPlacement::Efficiency};std::vector<std::unique_ptr<AsyncDecodeContext>> async_decodes;std::deque<PendingUnswizzle> unswizzle_queue;diff --git a/src/video_core/textures/workers.cpp b/src/video_core/textures/workers.cppindex 780e0c4da9..a1953c4bf4 100644--- a/src/video_core/textures/workers.cpp+++ b/src/video_core/textures/workers.cpp@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project@@ -11,7 +11,6 @@ namespace Tegra::Texture {Common::ThreadWorker& GetThreadWorkers() {static Common::ThreadWorker workers{(std::max)(std::thread::hardware_concurrency(), 2U) / 2,"ImageTranscode"};-return workers;}diff --git a/src/yuzu/configuration/configure_cpu.cpp b/src/yuzu/configuration/configure_cpu.cppindex 0511465ee6..8c7b15e4e0 100644--- a/src/yuzu/configuration/configure_cpu.cpp+++ b/src/yuzu/configuration/configure_cpu.cpp@@ -76,8 +76,7 @@ void ConfigureCpu::Setup(const ConfigurationShared::Builder& builder) {} else if (setting->Id() == Settings::values.cpu_backend.Id()) {backend_layout->addWidget(widget);backend_combobox = widget->combobox;- } else if (setting->Id() == Settings::values.fast_cpu_time.Id() ||- setting->Id() == Settings::values.cpu_ticks.Id()) {+ } else if (setting->Id() == Settings::values.cpu_ticks.Id()) {ui->general_layout->addWidget(widget);} else {// Presently, all other settings here are unsafe checkboxes