Actualizar src/android/app/build.gradle.kts

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/android/app/build.gradle.kts

@@ -65,7 +65,7 @@ android {
 
     defaultConfig {
         applicationId = "dev.eden.eden_emulator"
-        minSdk = 24
+        minSdk = 33
         targetSdk = 36
         versionName = getGitVersion()
         versionCode = autoVersion
@@ -188,7 +188,6 @@ android {
         create("mainline") {
             dimension = "version"
             isDefault = true
-            minSdk = 33
 
             manifestPlaceholders += mapOf("appNameBase" to "Eden")
             resValue("string", "app_name_suffixed", "Eden")
@@ -200,7 +199,6 @@ android {
 
         create("genshinSpoof") {
             dimension = "version"
-            minSdk = 35
             manifestPlaceholders += mapOf("appNameBase" to "Eden Optimized")
             resValue("string", "app_name_suffixed", "Eden Optimized")
             applicationId = "com.miHoYo.Yuanshen"
@@ -218,7 +216,6 @@ android {
 
         create("legacy") {
             dimension = "version"
-            minSdk = 29
             manifestPlaceholders += mapOf("appNameBase" to "Eden Legacy")
             resValue("string", "app_name_suffixed", "Eden Legacy")
             applicationId = "dev.legacy.eden_emulator"

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -218,8 +218,6 @@ object NativeLibrary {
 
     external fun logSettings()
 
-    external fun refreshThreadPolicies()
-
     external fun getDebugKnobAt(index: Int): Boolean
 
     /**

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -27,7 +27,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
     RENDERER_ASYNC_PRESENTATION("async_presentation"),
     RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
-    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),

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 = 2,
+                    min = 4,
                     max = 8,
                     units = "cores"
                 )
@@ -685,13 +685,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.renderer_asynchronous_shaders_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
-                    titleId = R.string.renderer_unified_memory,
-                    descriptionId = R.string.renderer_unified_memory_description
-                )
-            )
             put(
                 SingleChoiceSetting(
                     IntSetting.FAST_GPU_TIME,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -250,9 +250,8 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.USE_CUSTOM_RTC.key)
             add(LongSetting.CUSTOM_RTC.key)
 
-            add(HeaderSetting(R.string.clocks))
+            add(HeaderSetting(R.string.cpu))
             add(IntSetting.FAST_CPU_TIME.key)
-            add(IntSetting.FAST_GPU_TIME.key)
             add(BooleanSetting.CORE_SYNC_CORE_SPEED.key)
 
             add(IntSetting.MEMORY_LAYOUT.key)
@@ -299,12 +298,12 @@ 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)
             add(BooleanSetting.RESCALE_HACK.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
-            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
             add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
             add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -1451,7 +1451,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
     override fun onResume() {
         super.onResume()
-        NativeLibrary.refreshThreadPolicies()
         val b = _binding ?: return
         updateStatsPosition(IntSetting.PERF_OVERLAY_POSITION.getInt())
         updateSocPosition(IntSetting.SOC_OVERLAY_POSITION.getInt())

src/android/app/src/main/jni/game_metadata.cpp

@@ -20,96 +20,132 @@ struct RomMetadata {
     std::vector<u8> icon;
     bool isHomebrew;
 };
-static ankerl::unordered_dense::map<std::string, RomMetadata> m_rom_metadata_cache;
 
-static RomMetadata CacheRomMetadata(const std::string& path) {
-    auto& instance = EmulationSession::GetInstance();
-    const auto file = Core::GetGameFileFromPath(instance.System().GetFilesystem(), path);
-    if (auto loader = Loader::GetLoader(instance.System(), file, 0, 0); loader) {
-        RomMetadata entry;
-        loader->ReadTitle(entry.title);
-        loader->ReadProgramId(entry.programId);
-        loader->ReadIcon(entry.icon);
+ankerl::unordered_dense::map<std::string, RomMetadata> m_rom_metadata_cache;
 
-        const FileSys::PatchManager pm{
-            entry.programId,
-            instance.System().GetFileSystemController(),
-            instance.System().GetContentProvider()
-        };
-        const auto control = pm.GetControlMetadata();
+RomMetadata CacheRomMetadata(const std::string& path) {
+    const auto file =
+        Core::GetGameFileFromPath(EmulationSession::GetInstance().System().GetFilesystem(), path);
+    auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
 
-        if (control.first != nullptr) {
-            entry.developer = control.first->GetDeveloperName();
-            entry.version = control.first->GetVersionString();
+    RomMetadata entry;
+    loader->ReadTitle(entry.title);
+    loader->ReadProgramId(entry.programId);
+    loader->ReadIcon(entry.icon);
+
+    const FileSys::PatchManager pm{
+        entry.programId, EmulationSession::GetInstance().System().GetFileSystemController(),
+        EmulationSession::GetInstance().System().GetContentProvider()};
+    const auto control = pm.GetControlMetadata();
+
+    if (control.first != nullptr) {
+        entry.developer = control.first->GetDeveloperName();
+        entry.version = control.first->GetVersionString();
+    } else {
+        FileSys::NACP nacp;
+        if (loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
+            entry.developer = nacp.GetDeveloperName();
         } else {
-            FileSys::NACP nacp{};
-            entry.developer = loader->ReadControlData(nacp) == Loader::ResultStatus::Success
-                ? nacp.GetDeveloperName()
-                : "";
-            entry.version = "1.0.0";
+            entry.developer = "";
         }
-        if (loader->GetFileType() == Loader::FileType::NRO) {
-            auto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
-            entry.isHomebrew = loader_nro->IsHomebrew();
-        } else {
-            entry.isHomebrew = false;
-        }
-        m_rom_metadata_cache[path] = entry;
-        return entry;
+
+        entry.version = "1.0.0";
     }
-    return {};
+
+    if (loader->GetFileType() == Loader::FileType::NRO) {
+        auto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
+        entry.isHomebrew = loader_nro->IsHomebrew();
+    } else {
+        entry.isHomebrew = false;
+    }
+
+    m_rom_metadata_cache[path] = entry;
+
+    return entry;
 }
 
-static RomMetadata GetRomMetadata(const std::string& path, bool reload = false) {
-    if (reload)
+RomMetadata GetRomMetadata(const std::string& path, bool reload = false) {
+    if (reload) {
         return CacheRomMetadata(path);
-    if (auto it = m_rom_metadata_cache.find(path); it != m_rom_metadata_cache.end())
-        return it->second;
+    }
+
+    if (auto search = m_rom_metadata_cache.find(path); search != m_rom_metadata_cache.end()) {
+        return search->second;
+    }
+
     return CacheRomMetadata(path);
 }
 
 extern "C" {
 
-jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsValid(JNIEnv* env, jobject obj, jstring jpath) {
-    if (auto const file = EmulationSession::GetInstance().System().GetFilesystem()->OpenFile(Common::Android::GetJString(env, jpath), FileSys::OpenMode::Read); file) {
-        if (auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file); loader) {
-            auto const file_type = loader->GetFileType();
-            if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error)
-                return false;
-            if ((file_type == Loader::FileType::NSP || file_type == Loader::FileType::XCI) && !Loader::IsBootableGameContainer(file, file_type))
-                return false;
-            u64 program_id = 0;
-            return loader->ReadProgramId(program_id) == Loader::ResultStatus::Success;
-        }
+jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsValid(JNIEnv* env, jobject obj,
+                                                               jstring jpath) {
+    const auto file = EmulationSession::GetInstance().System().GetFilesystem()->OpenFile(
+        Common::Android::GetJString(env, jpath), FileSys::OpenMode::Read);
+    if (!file) {
+        return false;
     }
-    return false;
+
+    auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file);
+    if (!loader) {
+        return false;
+    }
+
+    const auto file_type = loader->GetFileType();
+    if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
+        return false;
+    }
+
+    if ((file_type == Loader::FileType::NSP || file_type == Loader::FileType::XCI) &&
+        !Loader::IsBootableGameContainer(file, file_type)) {
+        return false;
+    }
+
+    u64 program_id = 0;
+    Loader::ResultStatus res = loader->ReadProgramId(program_id);
+    if (res != Loader::ResultStatus::Success) {
+        return false;
+    }
+    return true;
 }
 
-jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getTitle(JNIEnv* env, jobject obj, jstring jpath) {
-    return Common::Android::ToJString(env, GetRomMetadata(Common::Android::GetJString(env, jpath)).title);
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getTitle(JNIEnv* env, jobject obj,
+                                                            jstring jpath) {
+    return Common::Android::ToJString(
+        env, GetRomMetadata(Common::Android::GetJString(env, jpath)).title);
 }
 
-jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getProgramId(JNIEnv* env, jobject obj, jstring jpath) {
-    return Common::Android::ToJString(env, std::to_string(GetRomMetadata(Common::Android::GetJString(env, jpath)).programId));
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getProgramId(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return Common::Android::ToJString(
+        env, std::to_string(GetRomMetadata(Common::Android::GetJString(env, jpath)).programId));
 }
 
-jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getDeveloper(JNIEnv* env, jobject obj, jstring jpath) {
-    return Common::Android::ToJString(env, GetRomMetadata(Common::Android::GetJString(env, jpath)).developer);
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getDeveloper(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return Common::Android::ToJString(
+        env, GetRomMetadata(Common::Android::GetJString(env, jpath)).developer);
 }
 
-jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getVersion(JNIEnv* env, jobject obj, jstring jpath, jboolean jreload) {
-    return Common::Android::ToJString(env, GetRomMetadata(Common::Android::GetJString(env, jpath), jreload).version);
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getVersion(JNIEnv* env, jobject obj,
+                                                              jstring jpath, jboolean jreload) {
+    return Common::Android::ToJString(
+        env, GetRomMetadata(Common::Android::GetJString(env, jpath), jreload).version);
 }
 
-jbyteArray Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIcon(JNIEnv* env, jobject obj, jstring jpath) {
+jbyteArray Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIcon(JNIEnv* env, jobject obj,
+                                                              jstring jpath) {
     auto icon_data = GetRomMetadata(Common::Android::GetJString(env, jpath)).icon;
-    jbyteArray icon = env->NewByteArray(jsize(icon_data.size()));
-    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon), reinterpret_cast<jbyte*>(icon_data.data()));
+    jbyteArray icon = env->NewByteArray(static_cast<jsize>(icon_data.size()));
+    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon),
+                            reinterpret_cast<jbyte*>(icon_data.data()));
     return icon;
 }
 
-jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsHomebrew(JNIEnv* env, jobject obj, jstring jpath) {
-    return jboolean(GetRomMetadata(Common::Android::GetJString(env, jpath)).isHomebrew);
+jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsHomebrew(JNIEnv* env, jobject obj,
+                                                                  jstring jpath) {
+    return static_cast<jboolean>(
+        GetRomMetadata(Common::Android::GetJString(env, jpath)).isHomebrew);
 }
 
 void Java_org_yuzu_yuzu_1emu_utils_GameMetadata_resetMetadata(JNIEnv* env, jobject obj) {

src/android/app/src/main/jni/native.cpp

@@ -50,7 +50,6 @@ 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"
@@ -1183,10 +1182,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_logSettings(JNIEnv* env, jobject jobj
     Settings::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)));
 }

src/android/app/src/main/res/values-ar/strings.xml

@@ -958,6 +958,7 @@
     <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>
 

src/android/app/src/main/res/values-de/strings.xml

@@ -884,6 +884,7 @@ 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>
 

src/android/app/src/main/res/values-es/strings.xml

@@ -950,6 +950,7 @@
     <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>
 

src/android/app/src/main/res/values-fr/strings.xml

@@ -897,6 +897,7 @@
     <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>
 

src/android/app/src/main/res/values-pl/strings.xml

@@ -871,6 +871,7 @@
     <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>
 

src/android/app/src/main/res/values-ru/strings.xml

@@ -954,6 +954,7 @@
     <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>
 

src/android/app/src/main/res/values-uk/strings.xml

@@ -943,6 +943,7 @@
     <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>
 

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -948,6 +948,7 @@
     <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>
 

src/android/app/src/main/res/values/arrays.xml

@@ -34,7 +34,7 @@
     </integer-array>
 
     <string-array name="clockNames">
-        <item>@string/clock_normal</item>
+        <item>@string/off</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/fast_gpu_normal</item>
+        <item>@string/off</item>
         <item>@string/fast_gpu_medium</item>
         <item>@string/fast_gpu_high</item>
     </string-array>

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 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="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="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">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="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="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>
@@ -524,8 +524,6 @@
     <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
-    <string name="renderer_unified_memory">Unified memory access</string>
-    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
     <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
     <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
     <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
@@ -562,7 +560,6 @@
 
     <!-- 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>
 
@@ -971,15 +968,14 @@
     <string name="memory_6gb">6GB (Unsafe)</string>
     <string name="memory_8gb">8GB (Unsafe)</string>
 
-    <!-- CPU clock levels -->
-    <string name="clock_normal">Normal</string>
-    <string name="clock_boost">Boost</string>
-    <string name="clock_fast">Overclock</string>
+    <!--CPU clock speeds-->
+    <string name="clock_boost">Boost (1700MHz)</string>
+    <string name="clock_fast">Fast (2000MHz)</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 overclock factors -->
+    <string name="off">Off</string>
+    <string name="fast_gpu_medium">Medium (256)</string>
+    <string name="fast_gpu_high">High (512)</string>
 
     <!-- GPU swizzle texture size -->
     <string name="gpu_texturesizeswizzle_verysmall">Very Small (16 MB)</string>

src/android/app/src/main/res/xml/game_mode_config.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <game-mode-config
     xmlns:android="http://schemas.android.com/apk/res/android"
-    android:supportsBatteryGameMode="false"
+    android:supportsBatteryGameMode="true"
     android:supportsPerformanceGameMode="true"
     android:allowGameDownscaling="false"
     android:allowGameFpsOverride="false"/>

src/audio_core/renderer/command/data_source/decode.cpp

@@ -18,15 +18,20 @@
 namespace AudioCore::Renderer {
 
 constexpr u32 TempBufferSize = 0x3F00;
+constexpr std::array<u8, 3> PitchBySrcQuality = {4, 8, 4};
 
-/// @brief Decode PCM data. Only s16 or f32 is supported.
-/// @tparam T         - Type to decode. Only s16 and f32 are supported.
-/// @param memory     - Core memory for reading samples.
-/// @param out_buffer - Output mix buffer to receive the samples.
-/// @param req        - Information for how to decode.
-/// @return Number of samples decoded.
+/**
+ * Decode PCM data. Only s16 or f32 is supported.
+ *
+ * @tparam T         - Type to decode. Only s16 and f32 are supported.
+ * @param memory     - Core memory for reading samples.
+ * @param out_buffer - Output mix buffer to receive the samples.
+ * @param req        - Information for how to decode.
+ * @return Number of samples decoded.
+ */
 template <typename T>
-static u32 DecodePcm(Core::Memory::Memory& memory, std::span<s16> out_buffer, const DecodeArg& req) {
+static u32 DecodePcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
+                     const DecodeArg& req) {
     constexpr s32 min{(std::numeric_limits<s16>::min)()};
     constexpr s32 max{(std::numeric_limits<s16>::max)()};
 
@@ -89,12 +94,16 @@ static u32 DecodePcm(Core::Memory::Memory& memory, std::span<s16> out_buffer, co
     return samples_to_decode;
 }
 
-/// @brief Decode ADPCM data.
-/// @param memory     - Core memory for reading samples.
-/// @param out_buffer - Output mix buffer to receive the samples.
-/// @param req        - Information for how to decode.
-/// @return Number of samples decoded.
-static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer, const DecodeArg& req) {
+/**
+ * Decode ADPCM data.
+ *
+ * @param memory     - Core memory for reading samples.
+ * @param out_buffer - Output mix buffer to receive the samples.
+ * @param req        - Information for how to decode.
+ * @return Number of samples decoded.
+ */
+static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
+                       const DecodeArg& req) {
     constexpr u32 SamplesPerFrame{14};
     constexpr u32 NibblesPerFrame{16};
 
@@ -106,7 +115,8 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
         return 0;
     }
 
-    auto end{(req.end_offset % SamplesPerFrame) + NibblesPerFrame * (req.end_offset / SamplesPerFrame)};
+    auto end{(req.end_offset % SamplesPerFrame) +
+             NibblesPerFrame * (req.end_offset / SamplesPerFrame)};
     if (req.end_offset % SamplesPerFrame) {
         end += 3;
     } else {
@@ -123,49 +133,52 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
         return 0;
     }
 
-    auto samples_to_read = samples_to_process;
-    auto samples_remaining_in_frame = start_pos % SamplesPerFrame;
-    auto position_in_frame = (start_pos / SamplesPerFrame) * NibblesPerFrame + samples_remaining_in_frame;
+    auto samples_to_read{samples_to_process};
+    auto samples_remaining_in_frame{start_pos % SamplesPerFrame};
+    auto position_in_frame{(start_pos / SamplesPerFrame) * NibblesPerFrame +
+                           samples_remaining_in_frame};
+
     if (samples_remaining_in_frame) {
         position_in_frame += 2;
     }
 
     const auto size{(std::max)((samples_to_process / 8U) * SamplesPerFrame, 8U)};
-    Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::UnsafeRead> wavebuffer(memory, req.buffer + position_in_frame / 2, size);
+    Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::UnsafeRead> wavebuffer(
+        memory, req.buffer + position_in_frame / 2, size);
 
-    auto context = req.adpcm_context;
-    auto header = context->header;
-    u8 scale = u8(header & 0xfU);
-    u8 coeff_index = u8((header >> 4U) & 0x7u);
-    s32 coeff0 = req.coefficients[coeff_index * 2 + 0];
-    s32 coeff1 = req.coefficients[coeff_index * 2 + 1];
+    auto context{req.adpcm_context};
+    auto header{context->header};
+    u8 coeff_index{static_cast<u8>((header >> 4U) & 0xFU)};
+    u8 scale{static_cast<u8>(header & 0xFU)};
+    s32 coeff0{req.coefficients[coeff_index * 2 + 0]};
+    s32 coeff1{req.coefficients[coeff_index * 2 + 1]};
 
-    auto yn0 = context->yn0;
-    auto yn1 = context->yn1;
-    auto const get_step = [](u32 index) {
-        // Emulates the following table
-        // 0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
-        constexpr u64 steps_table = 0x1234567876543210ull;
-        constexpr u64 steps_sign = 0b1111111100000000ull;
-        auto const r = s32((steps_table >> (index * 4)) & 0xf);
-        return ((steps_sign >> index) & 1) == 0 ? -r : r;
+    auto yn0{context->yn0};
+    auto yn1{context->yn1};
+
+    static constexpr std::array<s32, 16> Steps{
+        0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
     };
-    auto const decode_sample = [&](const s32 code) -> s16 {
+
+    const auto decode_sample = [&](const s32 code) -> s16 {
         const auto xn = code * (1 << scale);
         const auto prediction = coeff0 * yn0 + coeff1 * yn1;
         const auto sample = ((xn << 11) + 0x400 + prediction) >> 11;
         const auto saturated = std::clamp<s32>(sample, -0x8000, 0x7FFF);
         yn1 = yn0;
-        return yn0 = s16(saturated);
+        yn0 = static_cast<s16>(saturated);
+        return yn0;
     };
 
-    u32 read_index = 0;
-    for (u32 write_index = 0; samples_to_read > 0 && write_index < out_buffer.size(); ) {
+    u32 read_index{0};
+    u32 write_index{0};
+
+    while (samples_to_read > 0) {
         // Are we at a new frame?
         if ((position_in_frame % NibblesPerFrame) == 0) {
             header = wavebuffer[read_index++];
-            scale = header & 0xFu;
-            coeff_index = (header >> 4) & 0x7u;
+            coeff_index = (header >> 4) & 0xF;
+            scale = header & 0xF;
             coeff0 = req.coefficients[coeff_index * 2 + 0];
             coeff1 = req.coefficients[coeff_index * 2 + 1];
             position_in_frame += 2;
@@ -174,12 +187,14 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
             if (samples_to_read >= SamplesPerFrame) {
                 // Can grab all samples until the next header
                 for (u32 i = 0; i < SamplesPerFrame / 2; i++) {
-                    auto code0 = get_step((wavebuffer[read_index + i] >> 4) & 0xF);
-                    auto code1 = get_step(wavebuffer[read_index + i] & 0xF);
+                    auto code0{Steps[(wavebuffer[read_index] >> 4) & 0xF]};
+                    auto code1{Steps[wavebuffer[read_index] & 0xF]};
+                    read_index++;
+
                     out_buffer[write_index++] = decode_sample(code0);
                     out_buffer[write_index++] = decode_sample(code1);
                 }
-                read_index += SamplesPerFrame / 2;
+
                 position_in_frame += SamplesPerFrame;
                 samples_to_read -= SamplesPerFrame;
                 continue;
@@ -187,14 +202,15 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
         }
 
         // Decode a single sample
-        auto code = wavebuffer[read_index];
+        auto code{wavebuffer[read_index]};
         if (position_in_frame & 1) {
             code &= 0xF;
             read_index++;
         } else {
             code >>= 4;
         }
-        out_buffer[write_index++] = decode_sample(get_step(code));
+
+        out_buffer[write_index++] = decode_sample(Steps[code]);
 
         position_in_frame++;
         samples_to_read--;
@@ -203,21 +219,27 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
     context->header = header;
     context->yn0 = yn0;
     context->yn1 = yn1;
+
     return samples_to_process;
 }
 
-/// @brief Decode implementation.
-/// Decode wavebuffers according to the given args.
-///
-/// @param memory - Core memory to read data from.
-/// @param args   - The wavebuffer data, and information for how to decode it.
+/**
+ * Decode implementation.
+ * Decode wavebuffers according to the given args.
+ *
+ * @param memory - Core memory to read data from.
+ * @param args   - The wavebuffer data, and information for how to decode it.
+ */
 void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuffersArgs& args) {
-    constexpr auto EndWaveBuffer = [](auto& voice_state, auto& wavebuffer, auto& index, auto& played_samples, auto& consumed) -> void {
+    static constexpr auto EndWaveBuffer = [](auto& voice_state, auto& wavebuffer, auto& index,
+                                             auto& played_samples, auto& consumed) -> void {
         voice_state.wave_buffer_valid[index] = false;
         voice_state.loop_count = 0;
+
         if (wavebuffer.stream_ended) {
             played_samples = 0;
         }
+
         index = (index + 1) % MaxWaveBuffers;
         consumed++;
     };
@@ -233,9 +255,8 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
         return;
     }
 
-    // 0 -> 4, 1 -> 8, 2 -> 4
-    auto pitch = u32((0x040804ul >> (u32(args.src_quality) * 8)) & 0xfful);
-    if (u32(pitch + size_required.to_int_floor()) > TempBufferSize) {
+    auto pitch{PitchBySrcQuality[static_cast<u32>(args.src_quality)]};
+    if (static_cast<u32>(pitch + size_required.to_int_floor()) > TempBufferSize) {
         return;
     }
 
@@ -251,7 +272,7 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
     bool is_buffer_starved{false};
     u32 offset{voice_state.offset};
 
-    auto output_buffer = args.output;
+    auto output_buffer{args.output};
     std::array<s16, TempBufferSize> temp_buffer{};
 
     while (remaining_sample_count > 0) {
@@ -273,8 +294,8 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
             if (wavebuffer_index >= MaxWaveBuffers) {
                 LOG_ERROR(Service_Audio, "Invalid wavebuffer index! {}", wavebuffer_index);
                 wavebuffer_index = 0;
-                wavebuffers_consumed = MaxWaveBuffers;
                 voice_state.wave_buffer_valid.fill(false);
+                wavebuffers_consumed = MaxWaveBuffers;
             }
 
             if (!voice_state.wave_buffer_valid[wavebuffer_index]) {
@@ -282,9 +303,12 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
                 break;
             }
 
-            auto& wavebuffer = args.wave_buffers[wavebuffer_index];
-            if (offset == 0 && args.sample_format == SampleFormat::Adpcm && wavebuffer.context != 0) {
-                memory.ReadBlockUnsafe(wavebuffer.context, &voice_state.adpcm_context, wavebuffer.context_size);
+            auto& wavebuffer{args.wave_buffers[wavebuffer_index]};
+
+            if (offset == 0 && args.sample_format == SampleFormat::Adpcm &&
+                wavebuffer.context != 0) {
+                memory.ReadBlockUnsafe(wavebuffer.context, &voice_state.adpcm_context,
+                                       wavebuffer.context_size);
             }
 
             auto start_offset{wavebuffer.start_offset};
@@ -327,7 +351,9 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
             case SampleFormat::Adpcm: {
                 decode_arg.adpcm_context = &voice_state.adpcm_context;
                 memory.ReadBlockUnsafe(args.data_address, &decode_arg.coefficients, args.data_size);
-                samples_decoded = DecodeAdpcm( memory, {&temp_buffer[temp_buffer_pos], TempBufferSize - temp_buffer_pos}, decode_arg);
+                samples_decoded = DecodeAdpcm(
+                    memory, {&temp_buffer[temp_buffer_pos], TempBufferSize - temp_buffer_pos},
+                    decode_arg);
             } break;
 
             default:

src/audio_core/renderer/command/resample/resample.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,13 +5,21 @@
 
 namespace AudioCore::Renderer {
 
-static void ResampleLowQuality(std::span<s32> output, std::span<const s16> input, const Common::FixedPoint<49, 15>& sample_rate_ratio, Common::FixedPoint<49, 15>& fraction, const u32 samples_to_write) {
-    u32 read_index{0};
-    for (u32 i = 0; i < samples_to_write; i++) {
-        output[i] = input[read_index + (fraction >= 0.5f)];
-        fraction += sample_rate_ratio;
-        read_index += u32(fraction.to_int_floor());
-        fraction.clear_int();
+static void ResampleLowQuality(std::span<s32> output, std::span<const s16> input,
+                               const Common::FixedPoint<49, 15>& sample_rate_ratio,
+                               Common::FixedPoint<49, 15>& fraction, const u32 samples_to_write) {
+    if (sample_rate_ratio == 1.0f) {
+        for (u32 i = 0; i < samples_to_write; i++) {
+            output[i] = input[i];
+        }
+    } else {
+        u32 read_index{0};
+        for (u32 i = 0; i < samples_to_write; i++) {
+            output[i] = input[read_index + (fraction >= 0.5f)];
+            fraction += sample_rate_ratio;
+            read_index += static_cast<u32>(fraction.to_int_floor());
+            fraction.clear_int();
+        }
     }
 }
 
@@ -290,7 +295,7 @@ static void ResampleNormalQuality(std::span<s32> output, std::span<const s16> in
     auto lut{get_lut()};
     u32 read_index{0};
     for (u32 i = 0; i < samples_to_write; i++) {
-        const auto lut_index = ((fraction.get_frac() >> 8) << 2) & 511;
+        const auto lut_index{(fraction.get_frac() >> 8) * 4};
         const Common::FixedPoint<56, 8> sample0{input[read_index + 0] * lut[lut_index + 0]};
         const Common::FixedPoint<56, 8> sample1{input[read_index + 1] * lut[lut_index + 1]};
         const Common::FixedPoint<56, 8> sample2{input[read_index + 2] * lut[lut_index + 2]};
@@ -840,7 +845,7 @@ static void ResampleHighQuality(std::span<s32> output, std::span<const s16> inpu
     auto lut{get_lut()};
     u32 read_index{0};
     for (u32 i = 0; i < samples_to_write; i++) {
-        const auto lut_index = ((fraction.get_frac() >> 8) << 3) & 1023;
+        const auto lut_index{(fraction.get_frac() >> 8) * 8};
         const Common::FixedPoint<56, 8> sample0{input[read_index + 0] * lut[lut_index + 0]};
         const Common::FixedPoint<56, 8> sample1{input[read_index + 1] * lut[lut_index + 1]};
         const Common::FixedPoint<56, 8> sample2{input[read_index + 2] * lut[lut_index + 2]};

src/common/CMakeLists.txt

@@ -121,8 +121,6 @@ add_library(
     swap.h
     thread.cpp
     thread.h
-    adpf.cpp
-    adpf.h
     thread_queue_list.h
     thread_worker.h
     threadsafe_queue.h

src/common/adpf.cpp

@@ -1,317 +0,0 @@
-// 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
-
-#endif

src/common/adpf.h

@@ -1,26 +0,0 @@
-// 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::ADPF

src/common/heap_tracker.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/common/host_memory.cpp

@@ -51,45 +51,14 @@
 
 #endif // ^^^ POSIX ^^^
 
-#include <atomic>
 #include <mutex>
 #include <random>
-#include <vector>
 
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
-#include "common/memory_detect.h"
-#include "common/settings.h"
-
-#ifdef __ANDROID__
-#include <dlfcn.h>
-#include <android/hardware_buffer.h>
-
-namespace {
-
-struct NativeHandle {
-    int version;
-    int numFds;
-    int numInts;
-    int data[1];
-};
-
-using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
-
-PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
-    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
-    if (lib == nullptr) {
-        return nullptr;
-    }
-    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
-        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
-}
-
-} // namespace
-#endif
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -106,12 +75,6 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;
 
-static std::atomic<u64> committed_backing_size{};
-
-u64 GetCommittedBackingSize() noexcept {
-    return committed_backing_size.load(std::memory_order_relaxed);
-}
-
 #ifdef _WIN32
 
 // Manually imported for MinGW compatibility
@@ -160,7 +123,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
         , process{GetCurrentProcess()}
@@ -266,10 +229,6 @@ public:
         UNREACHABLE();
     }
 
-    bool IsBackingShared() const noexcept {
-        return true;
-    }
-
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
 
@@ -542,10 +501,9 @@ static int shm_open_anon(int flags, mode_t mode) {
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
-        , preferred_offset{preferred_offset_}
     {}
 
     bool Init() {
@@ -585,15 +543,10 @@ public:
             LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
             if (fd > 0) {
+                fd = -1;
                 close(fd);
             }
-            fd = -1;
         } else {
-#ifdef __ANDROID__
-            if (InitAhbBacking()) {
-                return InitVirtual();
-            }
-#endif
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
@@ -601,10 +554,7 @@ public:
             return false;
         }
 
-        return InitVirtual();
-    }
-
-    bool InitVirtual() {
+        // Virtual memory initialization
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
         if (virtual_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -617,222 +567,6 @@ public:
         return true;
     }
 
-#ifdef __ANDROID__
-    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
-        return AHardwareBuffer_Desc{
-            .width = static_cast<u32>(len),
-            .height = 1,
-            .layers = 1,
-            .format = AHARDWAREBUFFER_FORMAT_BLOB,
-            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
-            .stride = 0,
-            .rfu0 = 0,
-            .rfu1 = 0,
-        };
-    }
-
-    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
-        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
-        AHardwareBuffer* buffer{};
-        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-            return false;
-        }
-        const NativeHandle* const handle = get_native_handle(buffer);
-        if (handle == nullptr || handle->numFds < 1) {
-            AHardwareBuffer_release(buffer);
-            return false;
-        }
-        const int probe_fd = handle->data[0];
-        bool ok = true;
-        const auto try_map = [&](int prot, off_t offset, const char* what) {
-            if (!ok) {
-                return;
-            }
-            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
-            if (ptr == MAP_FAILED) {
-                ok = false;
-                return;
-            }
-            munmap(ptr, PageAlignment);
-        };
-        try_map(PROT_READ | PROT_WRITE, 0, "shared mappings");
-        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment), "mappings at an offset");
-#ifdef ARCHITECTURE_arm64
-        try_map(PROT_READ | PROT_EXEC, 0, "executable mappings");
-#endif
-        AHardwareBuffer_release(buffer);
-        return ok;
-    }
-
-    size_t ComputeAhbBudget(size_t window_size) const {
-        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
-        if (total_physical == 0) {
-            return 0;
-        }
-        constexpr u64 MinimumTotalPhysical = 7ULL << 30;
-        if (total_physical < MinimumTotalPhysical) {
-            return 0;
-        }
-        const u64 max_map_count = Common::GetMaxMapCount();
-        constexpr u64 ReservedMaps = 24576;
-        if (max_map_count == 0 || max_map_count <= ReservedMaps) {
-            return 0;
-        }
-        u64 budget = total_physical / 6;
-        budget = (std::min)(budget, (max_map_count - ReservedMaps) * PageAlignment);
-        const u64 available = Common::GetAvailablePhysicalMemory();
-        if (available != 0) {
-            constexpr u64 Headroom = 2ULL << 30;
-            budget = (std::min)(budget, available > Headroom ? available - Headroom : 0);
-        }
-        budget = (std::min)(budget, static_cast<u64>(backing_size));
-        budget = Common::AlignDown(budget, window_size);
-        constexpr u64 MinimumBudget = 256ULL << 20;
-        if (budget < MinimumBudget) {
-            return 0;
-        }
-        return static_cast<size_t>(budget);
-    }
-
-    bool InitAhbBacking() {
-        if (!Settings::values.use_unified_memory.GetValue()) {
-            return false;
-        }
-        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
-            ResolveGetNativeHandle();
-        if (get_native_handle == nullptr) {
-            return false;
-        }
-        constexpr size_t window_size = 512ULL << 20;
-        const AHardwareBuffer_Desc window_desc = MakeBlobDesc(window_size);
-        if (AHardwareBuffer_isSupported(&window_desc) == 0) {
-            return false;
-        }
-        const size_t budget = ComputeAhbBudget(window_size);
-        if (budget == 0) {
-            return false;
-        }
-        if (!ProbeAhbBacking(get_native_handle)) {
-            return false;
-        }
-        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
-        const size_t region_size = (std::min)(budget, aligned_backing);
-        const size_t region_base = Common::AlignDown(
-            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
-        const size_t num_windows = region_size / window_size;
-
-        std::vector<AHardwareBuffer*> buffers;
-        std::vector<int> buffer_fds;
-        const auto cleanup = [&] {
-            for (AHardwareBuffer* buffer : buffers) {
-                AHardwareBuffer_release(buffer);
-            }
-            buffers.clear();
-            buffer_fds.clear();
-        };
-        for (size_t i = 0; i < num_windows; ++i) {
-            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
-            AHardwareBuffer* buffer{};
-            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-                cleanup();
-                return false;
-            }
-            buffers.push_back(buffer);
-            const NativeHandle* const handle = get_native_handle(buffer);
-            if (handle == nullptr || handle->numFds < 1) {
-                cleanup();
-                return false;
-            }
-            const int buffer_fd = handle->data[0];
-            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
-            if (buffer_len < static_cast<off_t>(window_size)) {
-                cleanup();
-                return false;
-            }
-            buffer_fds.push_back(buffer_fd);
-        }
-        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
-                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
-        if (base == MAP_FAILED) {
-            cleanup();
-            return false;
-        }
-        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
-                                              off_t map_offset) {
-            if (len == 0) {
-                return true;
-            }
-            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
-                     map_offset) == MAP_FAILED) {
-                munmap(base, backing_size);
-                cleanup();
-                return false;
-            }
-            return true;
-        };
-        if (!map_over_reservation(0, region_base, fd, 0)) {
-            return false;
-        }
-        for (size_t i = 0; i < num_windows; ++i) {
-            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
-                                      0)) {
-                return false;
-            }
-        }
-        const size_t tail_offset = region_base + region_size;
-        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
-                                  static_cast<off_t>(tail_offset))) {
-            return false;
-        }
-        backing_base = base;
-        ahb_windows = std::move(buffers);
-        ahb_fds = std::move(buffer_fds);
-        ahb_window_size = window_size;
-        ahb_base = region_base;
-        ahb_bytes = region_size;
-        committed_backing_size.store(region_size, std::memory_order_relaxed);
-        return true;
-    }
-
-    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
-        while (length > 0) {
-            int map_fd = fd;
-            off_t map_offset = static_cast<off_t>(host_offset);
-            size_t chunk = length;
-            if (host_offset < ahb_base) {
-                chunk = (std::min)(chunk, ahb_base - host_offset);
-            } else if (host_offset < ahb_base + ahb_bytes) {
-                const size_t relative = host_offset - ahb_base;
-                const size_t window = relative / ahb_window_size;
-                const size_t local = relative % ahb_window_size;
-                map_fd = ahb_fds[window];
-                map_offset = static_cast<off_t>(local);
-                chunk = (std::min)(chunk, ahb_window_size - local);
-            }
-            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
-                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
-            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
-            virtual_offset += chunk;
-            host_offset += chunk;
-            length -= chunk;
-        }
-    }
-
-    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t AhbWindowSize() const noexcept {
-        return ahb_bytes != 0 ? ahb_window_size : 0;
-    }
-
-    size_t AhbBase() const noexcept {
-        return ahb_base;
-    }
-#endif
-
     ~Impl() {
         Release();
     }
@@ -853,12 +587,6 @@ public:
 #ifdef ARCHITECTURE_arm64
         if (True(perms & MemoryPermission::Execute))
             prot_flags |= PROT_EXEC;
-#endif
-#ifdef __ANDROID__
-        if (ahb_bytes != 0) {
-            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
-            return;
-        }
 #endif
         int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
         void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -904,18 +632,8 @@ public:
         virtual_base = nullptr;
     }
 
-    bool IsBackingShared() const noexcept {
-#ifdef __ANDROID__
-        if (ahb_bytes != 0) {
-            return true;
-        }
-#endif
-        return fd >= 0;
-    }
-
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
-    const size_t preferred_offset;
 
     u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
     u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -938,18 +656,6 @@ private:
             int ret = close(fd);
             ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
         }
-
-#ifdef __ANDROID__
-        for (AHardwareBuffer* buffer : ahb_windows) {
-            AHardwareBuffer_release(buffer);
-        }
-        ahb_windows.clear();
-        ahb_fds.clear();
-        if (ahb_bytes != 0) {
-            committed_backing_size.store(0, std::memory_order_relaxed);
-            ahb_bytes = 0;
-        }
-#endif
     }
 
     void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -975,19 +681,11 @@ private:
 
     int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
     FreeRegionManager free_manager{};
-
-#ifdef __ANDROID__
-    std::vector<AHardwareBuffer*> ahb_windows;
-    std::vector<int> ahb_fds;
-    size_t ahb_window_size{};
-    size_t ahb_base{};
-    size_t ahb_bytes{};
-#endif
 };
 
 #endif // ^^^ POSIX ^^^
 
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
     : backing_size(backing_size_)
     , virtual_size(virtual_size_)
 {
@@ -999,7 +697,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t prefer
 #else
     // Try to allocate a fastmem arena.
     // The implementation will fail with std::bad_alloc on errors.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
     if (impl->Init()) {
         backing_base = impl->backing_base;
         virtual_base = impl->virtual_base;
@@ -1069,38 +767,6 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
     std::memset(backing_base + physical_offset, fill_value, length);
 }
 
-std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
-#else
-    return {};
-#endif
-}
-
-size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbWindowSize() : 0;
-#else
-    return 0;
-#endif
-}
-
-bool HostMemory::IsBackingShared() const noexcept {
-#if defined(__OPENORBIS__) || defined(__managarm__)
-    return false;
-#else
-    return impl && impl->IsBackingShared();
-#endif
-}
-
-size_t HostMemory::BackingHardwareBufferBase() const noexcept {
-#ifdef __ANDROID__
-    return impl ? impl->AhbBase() : 0;
-#else
-    return 0;
-#endif
-}
-
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
     if (impl) {

src/common/host_memory.h

@@ -8,17 +8,12 @@
 
 #include <memory>
 #include <optional>
-#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"
 
-struct AHardwareBuffer;
-
 namespace Common {
 
-[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
-
 enum class MemoryPermission : u32 {
     Read = 1 << 0,
     Write = 1 << 1,
@@ -33,7 +28,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
  */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
     ~HostMemory();
 
     /**
@@ -67,18 +62,6 @@ public:
         return backing_base;
     }
 
-    [[nodiscard]] size_t BackingSize() const noexcept {
-        return backing_size;
-    }
-
-    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
-
-    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
-
-    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
-
-    [[nodiscard]] bool IsBackingShared() const noexcept;
-
     [[nodiscard]] u8* VirtualBasePointer() noexcept {
         return virtual_base;
     }

src/common/memory_detect.cpp

@@ -17,10 +17,6 @@
 #endif
 #endif
 
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
 #include "common/memory_detect.h"
 
 namespace Common {
@@ -73,55 +69,4 @@ const MemoryInfo& GetMemInfo() {
     return mem_info;
 }
 
-u64 GetAvailablePhysicalMemory() {
-#ifdef _WIN32
-    MEMORYSTATUSEX memorystatus;
-    memorystatus.dwLength = sizeof(memorystatus);
-    if (GlobalMemoryStatusEx(&memorystatus)) {
-        return memorystatus.ullAvailPhys;
-    }
-    return 0;
-#elif defined(__linux__)
-    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
-        char line[256];
-        u64 available = 0;
-        while (std::fgets(line, sizeof(line), file) != nullptr) {
-            if (std::strncmp(line, "MemAvailable:", 13) == 0) {
-                available = std::strtoull(line + 13, nullptr, 10) * 1024ULL;
-                break;
-            }
-        }
-        std::fclose(file);
-        if (available != 0) {
-            return available;
-        }
-    }
-    struct sysinfo info;
-    if (sysinfo(&info) == 0) {
-        const u64 unit = info.mem_unit != 0 ? info.mem_unit : 1ULL;
-        return (static_cast<u64>(info.freeram) + static_cast<u64>(info.bufferram)) * unit;
-    }
-    return 0;
-#else
-    return 0;
-#endif
-}
-
-u64 GetMaxMapCount() {
-#ifdef __linux__
-    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
-        char line[32];
-        u64 count = 0;
-        if (std::fgets(line, sizeof(line), file) != nullptr) {
-            count = std::strtoull(line, nullptr, 10);
-        }
-        std::fclose(file);
-        return count;
-    }
-    return 0;
-#else
-    return 0;
-#endif
-}
-
 } // namespace Common

src/common/memory_detect.h

@@ -18,8 +18,4 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
-[[nodiscard]] u64 GetAvailablePhysicalMemory();
-
-[[nodiscard]] u64 GetMaxMapCount();
-
 } // namespace Common

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> cpu_clock{linkage,
-                                              CpuClock::Normal,
+    SwitchableSetting<CpuClock> fast_cpu_time{linkage,
+                                              CpuClock::Off,
                                               "fast_cpu_time",
-                                              Category::System,
+                                              Category::Cpu,
                                               Specialization::Default,
                                               true,
                                               true};
@@ -540,13 +540,13 @@ struct Values {
 #endif
 
     // Renderer Hacks //
-    SwitchableSetting<GpuClock> gpu_clock{linkage,
-                                          GpuClock::Boost,
-                                          "fast_gpu_time",
-                                          Category::System,
-                                          Specialization::Default,
-                                          true,
-                                          true};
+    SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,
+                                                  GpuOverclock::Medium,
+                                                  "fast_gpu_time",
+                                                  Category::RendererHacks,
+                                                  Specialization::Default,
+                                                        true,
+                                                        true};
 
     SwitchableSetting<bool> skip_cpu_inner_invalidation{linkage,
                                                         false,
@@ -587,9 +587,6 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
-    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
-                                               Category::RendererHacks};
-
     SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                   GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",

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, Normal, Boost, Overclock)
+ENUM(CpuClock, Off, Boost, Fast)
 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(GpuClock, Normal, Boost, Overclock)
+ENUM(GpuOverclock, Normal, Medium, High)
 ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)
 ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High)
 ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High)

src/common/thread.cpp

@@ -1,6 +1,5 @@
 // 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
@@ -10,7 +9,6 @@
 #include <string>
 #include <thread>
 
-#include "common/adpf.h"
 #include "common/error.h"
 #include "common/logging.h"
 #include "common/assert.h"
@@ -41,402 +39,6 @@
 #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(&current);
-    if (sched_getaffinity(getpid(), sizeof(current), &current) != 0) {
-        return;
-    }
-    if (std::memcmp(&current, &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
@@ -446,6 +48,7 @@ void RememberCurrentThreadNice(pid_t tid, s32 nice_value) {
 #endif
 #include "common/x64/rdtsc.h"
 #endif
+#include "core/core_timing.h"
 
 namespace Common {
 
@@ -475,31 +78,21 @@ 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
-    const s32 max_prio = sched_get_priority_max(SCHED_OTHER);
-    const s32 min_prio = sched_get_priority_min(SCHED_OTHER);
+    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;
     if (max_prio > min_prio) {
-        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, &params);
+        params.sched_priority = min_prio + ((max_prio - min_prio) * level) / 4;
+    } else {
+        params.sched_priority = min_prio - ((min_prio - max_prio) * level) / 4;
     }
+
+    pthread_setschedparam(this_thread, scheduling_type, &params);
 #endif
 }
 
@@ -539,94 +132,29 @@ void SetCurrentThreadName(const char* name) {
 #endif
 }
 
-void SetCurrentThreadToPerformanceCores() {
+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) {
 #if defined(__ANDROID__)
-    if (ADPF::AddCurrentThread(ADPF::Session::Render)) {
-        SetCurrentThreadCoreGroup(CoreGroup::Unrestricted);
-        return;
-    }
-    SetCurrentThreadCoreGroup(CoreGroup::Performance);
+        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
 #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(&current);
-    if (sched_getaffinity(tid, sizeof(current), &current) == 0 &&
-        std::memcmp(&current, &expected, sizeof(current)) == 0) {
-        return;
-    }
-    RefreshThreadPolicies();
-#endif
 }
 
 #ifdef ARCHITECTURE_x86_64

src/common/thread.h

@@ -99,20 +99,8 @@ 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 SetCurrentThreadToPerformanceCores();
-void SetCurrentThreadToEfficiencyCores();
-void SetCurrentThreadToBackgroundWork();
-void SetCurrentThreadToAllCores();
-
-void RefreshThreadPolicies();
-void PollThreadPolicies();
+void PinCurrentThreadToPerformanceCore(size_t core_id);
 
 } // namespace Common

src/common/thread_worker.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -37,25 +37,10 @@ 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 = {},
-                                  ThreadPlacement placement = ThreadPlacement::Default)
+    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})
         : workers_queued{num_workers}, thread_name{std::move(name)} {
-        const auto lambda = [this, func, placement](std::stop_token stop_token) {
+        const auto lambda = [this, func](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()) {

src/common/uuid.cpp

@@ -208,12 +208,4 @@ UUID UUID::MakeRandomRFC4122V4() {
     return uuid;
 }
 
-UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
-    UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
-    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
-    uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
-    return uuid;
-}
-
 } // namespace Common

src/common/uuid.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,7 +5,6 @@
 
 #include <array>
 #include <functional>
-#include <span>
 #include <string>
 
 #include "common/common_types.h"
@@ -90,20 +86,28 @@ struct UUID {
         };
     }
 
-    /// @brief Creates a random UUID.
-    /// @returns A random UUID.
-    [[nodiscard]] static UUID MakeRandom();
+    /**
+     * Creates a random UUID.
+     *
+     * @returns A random UUID.
+     */
+    static UUID MakeRandom();
 
-    /// @brief Creates a random UUID with a seed.
-    /// @param seed A seed to initialize the Mersenne-Twister RNG
-    /// @returns A random UUID.
-    [[nodiscard]] static UUID MakeRandomWithSeed(u32 seed);
+    /**
+     * Creates a random UUID with a seed.
+     *
+     * @param seed A seed to initialize the Mersenne-Twister RNG
+     *
+     * @returns A random UUID.
+     */
+    static UUID MakeRandomWithSeed(u32 seed);
 
-    /// @brief Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
-    /// @returns A random UUID that is RFC 4122 Version 4 compliant.
-    [[nodiscard]] static UUID MakeRandomRFC4122V4();
-
-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);
+    /**
+     * Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
+     *
+     * @returns A random UUID that is RFC 4122 Version 4 compliant.
+     */
+    static UUID MakeRandomRFC4122V4();
 
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };

src/core/core.cpp

@@ -10,7 +10,6 @@
 #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"
@@ -119,7 +118,6 @@ struct System::Impl {
 
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -147,8 +145,7 @@ struct System::Impl {
             !device_memory.has_value() ||
             is_multicore != Settings::values.use_multi_core.GetValue() ||
             extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb) ||
-            unified_memory != Settings::values.use_unified_memory.GetValue();
+                                       Settings::MemoryLayout::Memory_4Gb);
 
         if (!must_reinitialize) {
             return;
@@ -159,7 +156,6 @@ struct System::Impl {
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout =
             Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
-        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         Initialize(system);
     }
@@ -389,7 +385,6 @@ struct System::Impl {
 
     void ShutdownMainProcess() {
         SetShuttingDown(true);
-        Common::ADPF::Shutdown();
 
         // Reset per-game flags
         Settings::values.use_squashed_iterated_blend = false;
@@ -506,7 +501,6 @@ struct System::Impl {
     std::atomic_bool is_powered_on{};
     bool is_multicore : 1 = false;
     bool extended_memory_layout : 1 = false;
-    bool unified_memory : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
     bool nvdec_active : 1 = false;

src/core/core_timing.cpp

@@ -23,21 +23,6 @@ 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));
 }
@@ -73,8 +58,7 @@ 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::VeryHigh);
-            Common::SetCurrentThreadToPerformanceCores();
+            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
             on_thread_init();
             has_started = true;
 
@@ -225,9 +209,8 @@ void CoreTiming::ResetTicks() {
 
 u64 CoreTiming::GetClockTicks() const {
     u64 fres = is_multicore ? Common::g_wall_clock.GetCNTPCT() : Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
-    if (const u32 target = CpuClockTargetMhz(Settings::values.cpu_clock.GetValue());
-        target != CPU_CLOCK_BASE_MHZ) {
-        fres = fres * target / CPU_CLOCK_BASE_MHZ;
+    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 (::Settings::values.sync_core_speed.GetValue()) {
         auto const ticks = f64(fres);

src/core/cpu_manager.cpp

@@ -174,7 +174,12 @@ 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);
-    Common::SetCurrentThreadToPerformanceCores();
+#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
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
 

src/core/device_memory.cpp

@@ -12,18 +12,9 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif
 
-namespace {
-size_t ApplicationPoolOffset() {
-    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
-    const size_t dram_size = Init::GetIntendedMemorySize();
-    const size_t application_pool_size = Init::GetApplicationPoolSize();
-    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
-}
-}
-
 DeviceMemory::DeviceMemory()
     : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize, ApplicationPoolOffset()} {}
+             VirtualReserveSize} {}
 
 DeviceMemory::~DeviceMemory() = default;
 

src/core/device_memory_manager.h

@@ -20,8 +20,6 @@
 #include "common/scratch_buffer.h"
 #include "common/virtual_buffer.h"
 
-struct AHardwareBuffer;
-
 namespace Core {
 
 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -97,34 +95,6 @@ public:
         ApplyOpOnPAddr(address, buffer, operation);
     }
 
-    u8* GetPhysicalBase() noexcept {
-        return reinterpret_cast<u8*>(physical_base);
-    }
-
-    const u8* GetPhysicalBase() const noexcept {
-        return reinterpret_cast<const u8*>(physical_base);
-    }
-
-    size_t GetPhysicalSize() const noexcept {
-        return physical_size;
-    }
-
-    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
-        return ahb_windows;
-    }
-
-    size_t GetBackingHardwareBufferWindowSize() const noexcept {
-        return ahb_window_size;
-    }
-
-    size_t GetBackingHardwareBufferBase() const noexcept {
-        return ahb_base;
-    }
-
-    bool IsBackingShared() const noexcept {
-        return backing_is_shared;
-    }
-
     PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
         PAddr subbits = PAddr(address & page_mask);
         auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -201,11 +171,6 @@ private:
     std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;
 
     const uintptr_t physical_base;
-    const size_t physical_size;
-    const std::span<AHardwareBuffer* const> ahb_windows;
-    const size_t ahb_window_size;
-    const size_t ahb_base;
-    const bool backing_is_shared;
     DeviceInterface* device_inter;
 
     struct TrackedEntry {

src/core/device_memory_manager.inc

@@ -171,11 +171,6 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
     : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
-    , physical_size{device_memory_.buffer.BackingSize()}
-    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
-    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
-    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
-    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
     , device_inter{nullptr}
     , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
     , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)

src/core/file_sys/control_metadata.h

@@ -274,22 +274,23 @@ public:
     explicit NACP(VirtualFile file);
     ~NACP();
 
-    [[nodiscard]] const LanguageEntry& GetLanguageEntry() const;
-    [[nodiscard]] std::string GetApplicationName() const;
-    [[nodiscard]] std::string GetDeveloperName() const;
-    [[nodiscard]] u64 GetTitleId() const;
-    [[nodiscard]] u64 GetDLCBaseTitleId() const;
-    [[nodiscard]] std::string GetVersionString() const;
-    [[nodiscard]] u64 GetDefaultNormalSaveSize() const;
-    [[nodiscard]] u64 GetDefaultJournalSaveSize() const;
-    [[nodiscard]] u32 GetSupportedLanguages() const;
-    [[nodiscard]] std::vector<std::string> GetApplicationNames() const;
-    [[nodiscard]] std::vector<u8> GetRawBytes() const;
-    [[nodiscard]] bool GetUserAccountSwitchLock() const;
-    [[nodiscard]] u64 GetDeviceSaveDataSize() const;
-    [[nodiscard]] u32 GetParentalControlFlag() const;
-    [[nodiscard]] const std::array<u8, 0x20>& GetRatingAge() const;
+    const LanguageEntry& GetLanguageEntry() const;
+    std::string GetApplicationName() const;
+    std::string GetDeveloperName() const;
+    u64 GetTitleId() const;
+    u64 GetDLCBaseTitleId() const;
+    std::string GetVersionString() const;
+    u64 GetDefaultNormalSaveSize() const;
+    u64 GetDefaultJournalSaveSize() const;
+    u32 GetSupportedLanguages() const;
+    std::vector<std::string> GetApplicationNames() const;
+    std::vector<u8> GetRawBytes() const;
+    bool GetUserAccountSwitchLock() const;
+    u64 GetDeviceSaveDataSize() const;
+    u32 GetParentalControlFlag() const;
+    const std::array<u8, 0x20>& GetRatingAge() const;
 
+private:
     RawNACP raw{};
     std::vector<LanguageEntry> language_entries;
 };

src/core/file_sys/patch_manager.cpp

@@ -1156,14 +1156,4 @@ PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
 
     return {std::move(nacp), icon_file};
 }
-
-[[nodiscard]] PatchManager::Metadata PatchManager::GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept {
-    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(), system.GetContentProvider()};
-    auto metadata = pm.GetControlMetadata();
-    if (metadata.first != nullptr)
-        return metadata;
-    const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(application_id), system.GetFileSystemController(), system.GetContentProvider()};
-    return pm_update.GetControlMetadata();
-}
-
 } // namespace FileSys

src/core/file_sys/patch_manager.h

@@ -105,9 +105,6 @@ public:
     // Version of GetControlMetadata that takes an arbitrary NCA
     [[nodiscard]] Metadata ParseControlNCA(const NCA& nca) const;
 
-    /// @brief Gets NACP metadata (accounting for any patches or updates)
-    [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;
-
 private:
     [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                           const std::string& build_id) const;

src/core/hle/service/am/service/application_functions.cpp

@@ -4,8 +4,6 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <openssl/evp.h>
-
 #include "common/settings.h"
 #include "common/uuid.h"
 #include "core/file_sys/control_metadata.h"
@@ -156,7 +154,20 @@ Result IApplicationFunctions::GetDesiredLanguage(Out<u64> out_language_code) {
     // Default to 0 (all languages supported)
     u32 supported_languages = 0;
 
-    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
+    const auto res = [this] {
+        const FileSys::PatchManager pm{m_applet->program_id, system.GetFileSystemController(),
+                                       system.GetContentProvider()};
+        auto metadata = pm.GetControlMetadata();
+        if (metadata.first != nullptr) {
+            return metadata;
+        }
+
+        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(m_applet->program_id),
+                                              system.GetFileSystemController(),
+                                              system.GetContentProvider()};
+        return pm_update.GetControlMetadata();
+    }();
+
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();
     }
@@ -194,7 +205,20 @@ Result IApplicationFunctions::SetTerminateResult(Result terminate_result) {
 Result IApplicationFunctions::GetDisplayVersion(Out<DisplayVersion> out_display_version) {
     LOG_DEBUG(Service_AM, "called");
 
-    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
+    const auto res = [this] {
+        const FileSys::PatchManager pm{m_applet->program_id, system.GetFileSystemController(),
+                                       system.GetContentProvider()};
+        auto metadata = pm.GetControlMetadata();
+        if (metadata.first != nullptr) {
+            return metadata;
+        }
+
+        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(m_applet->program_id),
+                                              system.GetFileSystemController(),
+                                              system.GetContentProvider()};
+        return pm_update.GetControlMetadata();
+    }();
+
     if (res.first != nullptr) {
         const auto& version = res.first->GetVersionString();
         std::memcpy(out_display_version->string.data(), version.data(),
@@ -323,21 +347,8 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {
 }
 
 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
-    LOG_WARNING(Service_AM, "(stubbed)");
-
-    // This should be hashed with the device specific hash
-    // for now this will do
-    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    u8 hash[EVP_MAX_MD_SIZE];
-    unsigned int hash_len = 0;
-    auto const seed = res.first->raw.seed_for_pseudo_device_id;
-    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
-    auto const algorithm = EVP_sha1();
-    EVP_DigestInit_ex(ctx, algorithm, nullptr);
-    EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash, &hash_len);
-    EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+    *out_pseudo_device_id = {};
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/library_applet_self_accessor.cpp

@@ -252,7 +252,19 @@ Result ILibraryAppletSelfAccessor::GetMainAppletApplicationDesiredLanguage(
     // Default to 0 (all languages supported)
     u32 supported_languages = 0;
 
-    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, identity.application_id);
+    const auto res = [this, identity] {
+        const FileSys::PatchManager pm{identity.application_id, system.GetFileSystemController(),
+                                       system.GetContentProvider()};
+        auto metadata = pm.GetControlMetadata();
+        if (metadata.first != nullptr) {
+            return metadata;
+        }
+
+        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(identity.application_id),
+                                              system.GetFileSystemController(),
+                                              system.GetContentProvider()};
+        return pm_update.GetControlMetadata();
+    }();
 
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -6,7 +6,6 @@
 
 #include <boost/container/small_vector.hpp>
 
-#include "common/adpf.h"
 #include "common/assert.h"
 #include "common/logging.h"
 #include "core/core.h"
@@ -87,16 +86,11 @@ 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;

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -1,6 +1,3 @@
-// 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
 
@@ -40,8 +37,6 @@ 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:

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -57,8 +57,18 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
     // Set default speed limit to 100%.
     *out_speed_scale = 1.0f;
 
-    nvdisp.WaitForComposite();
-    this->ReleaseFramebuffersLocked(display);
+    // 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;
+    }
 
     // Determine the number of vsync periods to wait before composing again.
     std::optional<s32> swap_interval{};
@@ -148,30 +158,55 @@ 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;
 
-    return 1;
-}
-
-void HardwareComposer::ReleaseFramebuffersLocked(Display& display) {
+    // Release any necessary framebuffers (non-overlay layers only, as overlays are already released above).
     for (auto& [layer_id, framebuffer] : m_framebuffers) {
         if (!framebuffer.is_acquired) {
+            // Already released.
             continue;
         }
 
-        const auto layer = display.stack.FindLayer(layer_id);
-        if (!layer) {
+        if (framebuffer.release_frame_number > m_frame_number) {
             continue;
         }
 
-        if (!layer->is_overlay && framebuffer.release_frame_number > m_frame_number) {
-            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;
+            }
 
-        layer->buffer_item_consumer->ReleaseBuffer(framebuffer.item, android::Fence::NoFence());
-        framebuffer.is_acquired = false;
+            // 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;
+        }
     }
+
+    return 1;
 }
 
 void HardwareComposer::RemoveLayerLocked(Display& display, ConsumerId consumer_id) {

src/core/hle/service/nvnflinger/hardware_composer.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -52,7 +52,6 @@ private:
 private:
     bool TryAcquireFramebufferLocked(Layer& layer, Framebuffer& framebuffer);
     CacheStatus CacheFramebufferLocked(Layer& layer, ConsumerId consumer_id);
-    void ReleaseFramebuffersLocked(Display& display);
 };
 
 } // namespace Service::Nvnflinger

src/core/hle/service/vi/conductor.cpp

@@ -4,11 +4,7 @@
 // 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"
@@ -18,8 +14,6 @@
 
 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)
@@ -74,9 +68,6 @@ 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());
@@ -85,8 +76,6 @@ 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();
@@ -125,25 +114,4 @@ 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::VI

src/core/hle/service/vi/conductor.h

@@ -44,7 +44,6 @@ private:
     void ProcessVsync();
     void VsyncThread(std::stop_token token);
     s64 GetNextTicks() const;
-    s64 GetFramePeriodNs() const;
 
 private:
     Core::System& m_system;

src/hid_core/frontend/emulated_console.cpp

@@ -100,7 +100,6 @@ void EmulatedConsole::ReloadInput() {
     motion.gyro = emulated_motion.GetGyroscope();
     motion.rotation = emulated_motion.GetRotations();
     motion.orientation = emulated_motion.GetOrientation();
-    motion.quaternion = emulated_motion.GetQuaternion();
     motion.is_at_rest = !emulated_motion.IsMoving(motion_sensitivity);
 
     // Unique index for identifying touch device source

src/hid_core/resources/npad/npad.cpp

@@ -504,12 +504,9 @@ void NPad::OnUpdate(Kernel::KernelCore& kernel, const Core::Timing::CoreTiming&
 
         for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
             auto& controller = controller_data[aruid_index][i];
-            controller.shared_memory = &data->shared_memory_format->npad.npad_entry[i].internal_state;
+            controller.shared_memory =
+                &data->shared_memory_format->npad.npad_entry[i].internal_state;
             auto* npad = controller.shared_memory;
-            if (!npad || !controller.device) {
-                LOG_WARNING(Service_HID, "No device for {}", i);
-                continue;
-            }
 
             const auto& controller_type = controller.device->GetNpadStyleIndex();
 

src/qt_common/config/shared_translation.cpp

@@ -92,9 +92,12 @@ 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, 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, 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, use_custom_cpu_ticks, QString(), QString());
     INSERT(Settings, cpu_ticks, tr("Custom CPU Ticks"),
@@ -227,11 +230,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, use_unified_memory, tr("Enable unified memory access"),
-           tr("Lets the GPU write buffer readbacks directly into guest memory."));
-    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, 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_unswizzle_enabled, tr("GPU Unswizzle"),
            tr("Accelerates BCn 3D texture decoding using GPU compute.\n"
               "Disable if experiencing crashes or graphical glitches."));
@@ -638,9 +639,9 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                           }});
     translations->insert({Settings::EnumMetadata<Settings::CpuClock>::Index(),
                           {
-                              PAIR(CpuClock, Normal, tr("Normal")),
-                              PAIR(CpuClock, Boost, tr("Boost")),
-                              PAIR(CpuClock, Overclock, tr("Overclock")),
+                              PAIR(CpuClock, Off, tr("Off")),
+                              PAIR(CpuClock, Boost, tr("Boost (1700MHz)")),
+                              PAIR(CpuClock, Fast, tr("Fast (2000MHz)")),
                           }});
     translations->insert(
         {Settings::EnumMetadata<Settings::ConfirmStop>::Index(),
@@ -649,11 +650,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::GpuClock>::Index(),
+    translations->insert({Settings::EnumMetadata<Settings::GpuOverclock>::Index(),
                           {
-                              PAIR(GpuClock, Normal, tr("Normal")),
-                              PAIR(GpuClock, Boost, tr("Boost")),
-                              PAIR(GpuClock, Overclock, tr("Overclock")),
+                              PAIR(GpuOverclock, Normal, tr("Off")),
+                              PAIR(GpuOverclock, Medium, tr("Medium (256)")),
+                              PAIR(GpuOverclock, High, tr("High (512)")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzleSize>::Index(),
                           {

src/video_core/CMakeLists.txt

@@ -158,8 +158,6 @@ add_library(video_core STATIC
     renderer_vulkan/vk_compute_pass.h
     renderer_vulkan/vk_compute_pipeline.cpp
     renderer_vulkan/vk_compute_pipeline.h
-    renderer_vulkan/vk_descriptor_buffer.cpp
-    renderer_vulkan/vk_descriptor_buffer.h
     renderer_vulkan/vk_descriptor_pool.cpp
     renderer_vulkan/vk_descriptor_pool.h
     renderer_vulkan/vk_fence_manager.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -571,11 +571,7 @@ void BufferCache<P>::AccumulateFlushes() {
 
 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    if (async_buffers.empty()) {
-        return false;
-    }
-    return async_buffers.front().has_value() ||
-           !pending_downloads.front().unified_copies.empty();
+    return (!async_buffers.empty() && async_buffers.front().has_value());
 }
 
 template <class P>
@@ -583,7 +579,6 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     AccumulateFlushes();
 
     if (committed_gpu_modified_ranges.empty()) {
-        pending_downloads.emplace_back();
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
@@ -643,83 +638,27 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     }
     committed_gpu_modified_ranges.clear();
     if (downloads.empty()) {
-        pending_downloads.emplace_back();
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
-
-    struct QueuedUnifiedCopy {
-        u64 window;
-        BufferId buffer_id;
-        boost::container::small_vector<BufferCopy, 16> copies;
-    };
-
-    AsyncDownloadBatch batch;
-    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
-    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
-    boost::container::small_vector<u64, 4> window_ids;
-    UnifiedWindowGroups groups;
-    u64 staging_size_bytes = 0;
-    for (auto& [copy, buffer_id] : downloads) {
-        Buffer& buffer = slot_buffers[buffer_id];
-        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
-        bool unified = false;
-        if constexpr (USE_UNIFIED_MEMORY) {
-            if (runtime.HasUnifiedMemory()) {
-                window_ids.clear();
-                groups.clear();
-                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
-                                                window_ids, groups);
-            }
-        }
-        BufferCopy record{copy};
-        record.src_offset = static_cast<size_t>(orig_device_addr);
-        if (unified) {
-            async_downloads.Add(orig_device_addr, copy.size);
-            buffer.MarkUsage(copy.src_offset, copy.size);
-            for (size_t i = 0; i < window_ids.size(); ++i) {
-                unified_copy_queue.push_back(
-                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
-            }
-            batch.unified_copies.push_back(record);
-            continue;
-        }
-        copy.dst_offset = staging_size_bytes;
-        constexpr u64 align = 64ULL;
-        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
-        staging_downloads.push_back({copy, buffer_id});
-    }
-
-    std::optional<Async_Buffer> download_staging;
-    if (!staging_downloads.empty()) {
-        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
-    }
+    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
+    boost::container::small_vector<BufferCopy, 4> normalized_copies;
     runtime.PreCopyBarrier();
-    for (auto& [copy, buffer_id] : staging_downloads) {
-        copy.dst_offset += download_staging->offset;
+    for (auto& [copy, buffer_id] : downloads) {
+        copy.dst_offset += download_staging.offset;
         const std::array copies{copy};
+        BufferCopy second_copy{copy};
         Buffer& buffer = slot_buffers[buffer_id];
-        BufferCopy record{copy};
-        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
+        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
         async_downloads.Add(orig_device_addr, copy.size);
         buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
-        batch.staging_copies.push_back(record);
-    }
-    if constexpr (USE_UNIFIED_MEMORY) {
-        for (const auto& queued : unified_copy_queue) {
-            const std::span<const BufferCopy> group_span(queued.copies.data(),
-                                                         queued.copies.size());
-            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
-        }
-        if (!unified_copy_queue.empty()) {
-            runtime.UnifiedMemoryHostBarrier();
-        }
+        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
+        normalized_copies.push_back(second_copy);
     }
     runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(batch));
-    async_buffers.emplace_back(std::move(download_staging));
+    pending_downloads.emplace_back(std::move(normalized_copies));
+    async_buffers.emplace_back(download_staging);
 }
 
 template <class P>
@@ -734,49 +673,32 @@ void BufferCache<P>::PopAsyncFlushes() {
 
 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
-    struct Writeback {
-        DAddr addr;
-        const u8* src;
-        u64 size;
-    };
-    boost::container::small_vector<Writeback, 8> writebacks;
-    {
-        std::scoped_lock lock{mutex};
-        if (async_buffers.empty()) {
-            return;
-        }
-        auto& batch = pending_downloads.front();
-        auto& async_buffer = async_buffers.front();
-        if (async_buffer.has_value()) {
-            const u8* base = async_buffer->mapped_span.data();
-            const size_t base_offset = async_buffer->offset;
-            for (const auto& copy : batch.staging_copies) {
-                const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-                const u64 dst_offset = copy.dst_offset - base_offset;
-                const u8* read_mapped_memory = base + dst_offset;
-                async_downloads.ForEachInRange(
-                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-                        writebacks.push_back(
-                            {start, &read_mapped_memory[start - device_addr], end - start});
-                    });
-                async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-                    gpu_modified_ranges.Subtract(start, end - start);
-                });
-            }
-            async_buffers_death_ring.emplace_back(*async_buffer);
-        }
-        for (const auto& copy : batch.unified_copies) {
-            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-                gpu_modified_ranges.Subtract(start, end - start);
-            });
-        }
+    if (async_buffers.empty()) {
+        return;
+    }
+    if (!async_buffers.front().has_value()) {
         async_buffers.pop_front();
-        pending_downloads.pop_front();
+        return;
     }
-    for (const auto& wb : writebacks) {
-        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
+    auto& downloads = pending_downloads.front();
+    auto& async_buffer = async_buffers.front();
+    u8* base = async_buffer->mapped_span.data();
+    const size_t base_offset = async_buffer->offset;
+    for (const auto& copy : downloads) {
+        const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+        const u64 dst_offset = copy.dst_offset - base_offset;
+        const u8* read_mapped_memory = base + dst_offset;
+        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
+                                           end - start);
+        });
+        async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+            gpu_modified_ranges.Subtract(start, end - start);
+        });
     }
+    async_buffers_death_ring.emplace_back(*async_buffer);
+    async_buffers.pop_front();
+    pending_downloads.pop_front();
 }
 
 template <class P>
@@ -1777,98 +1699,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
     }
 }
 
-template <class P>
-bool BufferCache<P>::ResolveUnifiedWindows(
-    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
-    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
-    [[maybe_unused]] UnifiedWindowGroups& groups) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        const u8* const physical_base = device_memory.GetPhysicalBase();
-        const u64 unified_base = runtime.UnifiedMemoryBase();
-        const u64 unified_size = runtime.UnifiedMemorySize();
-        const u64 window_size = runtime.UnifiedMemoryWindowSize();
-        if (window_size == 0) {
-            return false;
-        }
-        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
-            for (size_t i = 0; i < window_ids.size(); ++i) {
-                if (window_ids[i] == window) {
-                    return groups[i];
-                }
-            }
-            window_ids.push_back(window);
-            groups.emplace_back();
-            return groups.back();
-        };
-        u64 downloaded = 0;
-        while (downloaded < size) {
-            const DAddr page_addr = device_addr + downloaded;
-            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
-            if (ptr == nullptr) {
-                return false;
-            }
-            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
-            u64 chunk = (std::min)(size - downloaded,
-                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
-            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
-            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
-                return false;
-            }
-            const u64 relative = phys_offset - unified_base;
-            const u64 window = relative / window_size;
-            const u64 local_offset = relative % window_size;
-            chunk = (std::min)(chunk, window_size - local_offset);
-            auto& group = group_for(window);
-            if (!group.empty()) {
-                BufferCopy& last = group.back();
-                if (last.src_offset + last.size == buffer_offset + downloaded &&
-                    last.dst_offset + last.size == local_offset) {
-                    last.size += chunk;
-                    downloaded += chunk;
-                    continue;
-                }
-            }
-            group.push_back(BufferCopy{
-                .src_offset = buffer_offset + downloaded,
-                .dst_offset = local_offset,
-                .size = chunk,
-            });
-            downloaded += chunk;
-        }
-        return true;
-    } else {
-        return false;
-    }
-}
-
-template <class P>
-bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
-                                              [[maybe_unused]] std::span<BufferCopy> copies) {
-    if constexpr (USE_UNIFIED_MEMORY) {
-        boost::container::small_vector<u64, 4> window_ids;
-        UnifiedWindowGroups groups;
-        for (const BufferCopy& copy : copies) {
-            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
-                                       copy.size, window_ids, groups)) {
-                return false;
-            }
-        }
-        for (const BufferCopy& copy : copies) {
-            buffer.MarkUsage(copy.src_offset, copy.size);
-        }
-        runtime.PreCopyBarrier();
-        for (size_t i = 0; i < window_ids.size(); ++i) {
-            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
-            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
-        }
-        runtime.UnifiedMemoryHostBarrier();
-        runtime.Finish();
-        return true;
-    } else {
-        return false;
-    }
-}
-
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                         [[maybe_unused]] u64 total_size_bytes,
@@ -1972,12 +1802,6 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
     }
 
     if constexpr (USE_MEMORY_MAPS) {
-        if constexpr (USE_UNIFIED_MEMORY) {
-            if (runtime.HasUnifiedMemory() &&
-                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
-                return;
-            }
-        }
         auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
         const u8* const mapped_memory = download_staging.mapped_span.data();
         const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());

src/video_core/buffer_cache/buffer_cache_base.h

@@ -180,7 +180,6 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
     static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
     static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
-    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;
 
 #ifdef YUZU_LEGACY
     static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -444,15 +443,6 @@ private:
 
     void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);
 
-    bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
-
-    using UnifiedWindowGroups =
-        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
-
-    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
-                               boost::container::small_vector<u64, 4>& window_ids,
-                               UnifiedWindowGroups& groups);
-
     void DownloadBufferMemory(Buffer& buffer_id);
 
     void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -508,14 +498,9 @@ private:
     std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;
 
     // Async Buffers
-    struct AsyncDownloadBatch {
-        boost::container::small_vector<BufferCopy, 4> staging_copies;
-        boost::container::small_vector<BufferCopy, 4> unified_copies;
-    };
-
     Common::OverlapRangeSet<DAddr> async_downloads;
     std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<AsyncDownloadBatch> pending_downloads;
+    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
     std::optional<Async_Buffer> current_buffer;
 
     std::deque<Async_Buffer> async_buffers_death_ring;

src/video_core/fence_manager.h

@@ -195,7 +195,6 @@ 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;

src/video_core/gpu.cpp

@@ -10,7 +10,6 @@
 #include <condition_variable>
 #include <list>
 #include <memory>
-#include <utility>
 
 #include "common/assert.h"
 #include "common/settings.h"
@@ -40,19 +39,6 @@
 
 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_}
@@ -130,7 +116,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(std::forward<Func>(action));
+        sync_requests.emplace_back(action);
         return fence;
     }
 
@@ -159,8 +145,14 @@ struct GPU::Impl {
     }
 
     [[nodiscard]] u64 GetTicks() const {
-        const u64 gpu_tick = system.CoreTiming().GetGPUTicks();
-        return gpu_tick / GpuClockMultiplier(Settings::values.gpu_clock.GetValue());
+        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;
     }
 
     void RendererFrameEndNotify() {
@@ -233,9 +225,9 @@ struct GPU::Impl {
     }
 
     void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers, std::vector<Service::Nvidia::NvFence>&& fences) {
-        const size_t num_fences{fences.size()};
+        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();
@@ -246,42 +238,27 @@ struct GPU::Impl {
                 free_swap_counters.pop_front();
             }
         }
-        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);
+        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;
                     }
-                    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);
+                    free_swap_counters.push_back(current_request_counter);
                 }
-            });
+                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);
-    }
-
-    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);
+        WaitForSyncOperation(wait_fence);
     }
 
     std::vector<u8> GetAppletCaptureBuffer() {
@@ -334,7 +311,6 @@ 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)
@@ -452,10 +428,6 @@ 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();
 }

src/video_core/gpu.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -218,8 +218,6 @@ 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.

src/video_core/gpu_thread.cpp

@@ -30,7 +30,6 @@ void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Core::Fronten
     thread = std::jthread([&](std::stop_token stop_token) {
         Common::SetCurrentThreadName("GPU");
         Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
-        Common::SetCurrentThreadToPerformanceCores();
         system.RegisterHostThread();
 
         auto current_context = context.Acquire();

src/video_core/host_shaders/astc_decoder.comp

@@ -77,8 +77,14 @@ uvec4 local_buff;
 uvec4 color_endpoint_data;
 int color_bitsread = 0;
 
-#define MAX_WEIGHT_VALUES 64
-uint result_vector[MAX_WEIGHT_VALUES];
+// Global "vector" to be pushed into when decoding
+// At most will require BLOCK_WIDTH x BLOCK_HEIGHT in single plane mode
+// At most will require BLOCK_WIDTH x BLOCK_HEIGHT x 2 in dual plane mode
+// So the maximum would be 144 (12 x 12) elements, x 2 for two planes
+#define DIVCEIL(number, divisor) (number + divisor - 1) / divisor
+#define ARRAY_NUM_ELEMENTS 144
+#define VECTOR_ARRAY_SIZE DIVCEIL(ARRAY_NUM_ELEMENTS * 2, 4)
+uint result_vector[ARRAY_NUM_ELEMENTS * 2];
 
 int result_index = 0;
 uint result_vector_max_index;
@@ -486,7 +492,7 @@ void DecodeColorValues(uvec4 modes, uint num_partitions, uint color_data_bits, o
         A = ReplicateBitTo9((bitval & 1));
         switch (encoding) {
         case JUST_BITS:
-            color_values[out_index++] = FastReplicateTo8(bitval, bitlen);
+            color_values[++out_index] = FastReplicateTo8(bitval, bitlen);
             break;
         case TRIT: {
             D = QuintTritValue(val);
@@ -565,7 +571,7 @@ void DecodeColorValues(uvec4 modes, uint num_partitions, uint color_data_bits, o
             uint T = (D * C) + B;
             T ^= A;
             T = (A & 0x80) | (T >> 2);
-            color_values[out_index++] = T;
+            color_values[++out_index] = T;
         }
     }
 }
@@ -747,12 +753,12 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, uint color_endpoint_mode, ui
 #define READ_UINT_VALUES(N)                                                                        \
     uvec4 V[2];                                                                                    \
     for (uint i = 0; i < N; i++) {                                                                 \
-        V[i / 4][i % 4] = color_values[colvals_index++];                      \
+        V[i / 4][i % 4] = color_values[++colvals_index];                      \
     }
 #define READ_INT_VALUES(N)                                                                         \
     ivec4 V[2];                                                                                    \
     for (uint i = 0; i < N; i++) {                                                                 \
-        V[i / 4][i % 4] = int(color_values[colvals_index++]);                      \
+        V[i / 4][i % 4] = int(color_values[++colvals_index]);                      \
     }
 
     switch (color_endpoint_mode) {
@@ -1219,10 +1225,6 @@ void DecompressBlock(ivec3 coord) {
         FillError(coord);
         return;
     }
-    if (GetNumWeightValues(size_params, dual_plane) > MAX_WEIGHT_VALUES) {
-        FillError(coord);
-        return;
-    }
     uint partition_index = 1;
     uvec4 color_endpoint_mode = uvec4(0);
     uint ced_pointer = 0;
@@ -1237,10 +1239,6 @@ void DecompressBlock(ivec3 coord) {
     const uint base_mode = base_cem & 3;
     const uint max_weight = DecodeMaxWeight(mode);
     const uint weight_bits = GetPackedBitSize(size_params, dual_plane, max_weight);
-    if (weight_bits < 24 || weight_bits > 96) {
-        FillError(coord);
-        return;
-    }
     uint remaining_bits = 128 - weight_bits - total_bitsread;
     uint extra_cem_bits = 0;
     if (base_mode > 0) {
@@ -1255,7 +1253,6 @@ void DecompressBlock(ivec3 coord) {
             extra_cem_bits += 8;
             break;
         default:
-            FillError(coord);
             return;
         }
     }
@@ -1265,7 +1262,6 @@ void DecompressBlock(ivec3 coord) {
     if (remaining_bits > 128) {
         // Bad data, more remaining bits than 4 bytes
         // return early
-        FillError(coord);
         return;
     }
     // Read color data...
@@ -1388,7 +1384,11 @@ void DecompressBlock(ivec3 coord) {
                 p = Cf / 65535.0f;
             }
 
+#ifdef VULKAN
+            imageStore(dest_image, coord + ivec3(i, j, 0), p.gbar);
+#else
             imageStore(dest_image, coord + ivec3(i, j, 0), clamp(p, 0.0f, 1.0f).gbar);
+#endif
         }
     }
 }

src/video_core/macro.cpp

@@ -417,6 +417,14 @@ void HLE_TransformFeedbackSetup::Execute(Core::System& system, Engines::Maxwell3
     default: return std::monostate{};
     }
 }
+[[nodiscard]] inline bool CanBeHLEProgram(u64 hash) noexcept {
+    switch (hash) {
+#define HLE_MACRO_ELEM(HASH, TY, VAL) case HASH: return true;
+    HLE_MACRO_LIST
+#undef HLE_MACRO_ELEM
+    default: return false;
+    }
+}
 
 void MacroInterpreterImpl::Execute(Core::System& system, Engines::Maxwell3D& maxwell3d, std::span<const u32> params, u32 method) {
     Reset();
@@ -1337,92 +1345,80 @@ static void Dump(u64 hash, std::span<const u32> code, bool decompiled = false) {
     macro_file.write(reinterpret_cast<const char*>(code.data()), code.size_bytes());
 }
 
-void MacroEngine::Execute(Core::System& system, Engines::Maxwell3D& maxwell3d, u32 method,
-                          std::span<const u32> parameters) {
-    const auto execute_variant = [&system, &maxwell3d, &parameters,
-                                  method](AnyCachedMacro& cached) {
-        if (std::holds_alternative<MacroInterpreterImpl>(cached) ||
-            std::holds_alternative<std::unique_ptr<DynamicCachedMacro>>(cached) ||
-            Settings::values.disable_macro_hle) {
-            maxwell3d.RefreshParameters();
-        }
-
-        if (auto program = std::get_if<HLE_DrawArraysIndirect>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_DrawIndexedIndirect>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_MultiDrawIndexedIndirectCount>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_MultiLayerClear>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_C713C83D8F63CCF3>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_D7333D26E0A93EDE>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_BindShader>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_SetRasterBoundingBox>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_ClearConstBuffer>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_ClearMemory>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_TransformFeedbackSetup>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<HLE_DrawIndirectByteCount>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<MacroInterpreterImpl>(&cached))
-            return program->Execute(system, maxwell3d, parameters, method);
-        if (auto program = std::get_if<std::unique_ptr<DynamicCachedMacro>>(&cached))
-            return program->get()->Execute(system, maxwell3d, parameters, method);
-
-        UNREACHABLE();
+void MacroEngine::Execute(Core::System& system, Engines::Maxwell3D& maxwell3d, u32 method, std::span<const u32> parameters) {
+    auto const execute_variant = [&system, &maxwell3d, &parameters, method](AnyCachedMacro& acm) {
+        if (auto a = std::get_if<HLE_DrawArraysIndirect>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_DrawIndexedIndirect>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_MultiDrawIndexedIndirectCount>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_MultiLayerClear>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_C713C83D8F63CCF3>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_D7333D26E0A93EDE>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_BindShader>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_SetRasterBoundingBox>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_ClearConstBuffer>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_ClearMemory>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_TransformFeedbackSetup>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<HLE_DrawIndirectByteCount>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<MacroInterpreterImpl>(&acm))
+            return a->Execute(system, maxwell3d, parameters, method);
+        if (auto a = std::get_if<std::unique_ptr<DynamicCachedMacro>>(&acm))
+            return a->get()->Execute(system, maxwell3d, parameters, method);
     };
     if (auto const it = macro_cache.find(method); it != macro_cache.end()) {
-        execute_variant(it->second.program);
-        return;
-    }
-
-    // Macro not compiled, check if it's uploaded and if so, compile it
-    std::span<const u32> code;
-    auto macro_code = uploaded_macro_code.find(method);
-    if (macro_code == uploaded_macro_code.end()) {
+        auto& ci = it->second;
+        if (!CanBeHLEProgram(ci.hash) || Settings::values.disable_macro_hle)
+            maxwell3d.RefreshParameters(); //LLE must reload parameters
+        execute_variant(ci.program);
+    } else {
+        // Macro not compiled, check if it's uploaded and if so, compile it
         std::optional<u32> mid_method;
-        for (const auto& [method_base, uploaded_code] : uploaded_macro_code) {
-            if (method >= method_base && (method - method_base) < uploaded_code.size()) {
-                mid_method = method_base;
-                break;
+        const auto macro_code = uploaded_macro_code.find(method);
+        if (macro_code == uploaded_macro_code.end()) {
+            for (const auto& [method_base, code] : uploaded_macro_code) {
+                if (method >= method_base && (method - method_base) < code.size()) {
+                    mid_method = method_base;
+                    break;
+                }
+            }
+            if (!mid_method.has_value()) {
+                ASSERT_MSG(false, "Macro 0x{0:x} was not uploaded", method);
+                return;
             }
         }
-        if (!mid_method) {
-            ASSERT_MSG(false, "Macro 0x{0:x} was not uploaded", method);
-            return;
+        auto& ci = macro_cache[method];
+        if (mid_method) {
+            const auto& macro_cached = uploaded_macro_code[mid_method.value()];
+            const auto rebased_method = method - mid_method.value();
+            auto& code = uploaded_macro_code[method];
+            code.resize(macro_cached.size() - rebased_method);
+            std::memcpy(code.data(), macro_cached.data() + rebased_method, code.size() * sizeof(u32));
+            ci.hash = Common::HashValue(code);
+            ci.program = Compile(system, maxwell3d, code);
+        } else {
+            ci.program = Compile(system, maxwell3d, macro_code->second);
+            ci.hash = Common::HashValue(macro_code->second);
+        }
+        if (CanBeHLEProgram(ci.hash) && !Settings::values.disable_macro_hle) {
+            ci.program = GetHLEProgram(ci.hash);
+        } else {
+            maxwell3d.RefreshParameters();
+        }
+        execute_variant(ci.program);
+        if (Settings::values.dump_macros) {
+            Dump(ci.hash, macro_code->second, !std::holds_alternative<std::monostate>(ci.program));
         }
-
-        const auto source = uploaded_macro_code.find(*mid_method);
-        ASSERT(source != uploaded_macro_code.end());
-        const auto rebased_method = method - *mid_method;
-        std::vector<u32> rebased_code(source->second.begin() + rebased_method,
-                                      source->second.end());
-        const auto [it, inserted] = uploaded_macro_code.emplace(method, std::move(rebased_code));
-        ASSERT(inserted);
-        code = it->second;
-    } else {
-        code = macro_code->second;
-    }
-
-    auto& ci = macro_cache[method];
-    ci.hash = Common::HashRange(code.begin(), code.end());
-    if (!Settings::values.disable_macro_hle) {
-        ci.program = GetHLEProgram(ci.hash);
-    }
-    if (std::holds_alternative<std::monostate>(ci.program)) {
-        ci.program = Compile(system, maxwell3d, code);
-    }
-
-    execute_variant(ci.program);
-    if (Settings::values.dump_macros) {
-        Dump(ci.hash, code, !std::holds_alternative<std::monostate>(ci.program));
     }
 }
 

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -261,7 +261,6 @@ struct BufferCacheParams {
 
     // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
-    static constexpr bool USE_UNIFIED_MEMORY = false;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -47,93 +47,6 @@ using Shader::Backend::SPIRV::NUM_TEXTURE_AND_IMAGE_SCALING_WORDS;
     return std::nullopt;
 }
 
-[[nodiscard]] inline VkDeviceSize DescriptorSizeForType(const Device& device,
-                                                        VkDescriptorType type) {
-    const auto& props = device.DescriptorBufferProperties();
-    const bool robust = device.IsRobustBufferAccessEnabled();
-    switch (type) {
-    case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-        return robust ? props.robustUniformBufferDescriptorSize : props.uniformBufferDescriptorSize;
-    case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-        return robust ? props.robustStorageBufferDescriptorSize : props.storageBufferDescriptorSize;
-    case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-        return robust ? props.robustUniformTexelBufferDescriptorSize
-                      : props.uniformTexelBufferDescriptorSize;
-    case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-        return robust ? props.robustStorageTexelBufferDescriptorSize
-                      : props.storageTexelBufferDescriptorSize;
-    case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-        return props.combinedImageSamplerDescriptorSize;
-    case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-        return props.storageImageDescriptorSize;
-    default:
-        return 0;
-    }
-}
-
-struct DescriptorBufferBinding {
-    VkDescriptorType type;
-    u32 count;
-    VkDeviceSize offset;
-    VkDeviceSize stride;
-};
-
-struct DescriptorBufferLayout {
-    VkDeviceSize size{};
-    boost::container::small_vector<DescriptorBufferBinding, 32> bindings;
-
-    [[nodiscard]] bool Empty() const noexcept {
-        return bindings.empty();
-    }
-};
-
-inline void WriteDescriptorBuffer(const Device& device, const DescriptorBufferLayout& layout,
-                                  const DescriptorUpdateEntry* payload, u8* host) {
-    const vk::Device& dev = device.GetLogical();
-    for (const DescriptorBufferBinding& binding : layout.bindings) {
-        for (u32 index = 0; index < binding.count; ++index) {
-            const DescriptorUpdateEntry& entry = *(payload++);
-            const VkDescriptorAddressInfoEXT address_info{
-                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
-                .pNext = nullptr,
-                .address = entry.address.address,
-                .range = entry.address.range,
-                .format = entry.address.format,
-            };
-            VkDescriptorGetInfoEXT get_info{
-                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
-                .pNext = nullptr,
-                .type = binding.type,
-                .data{},
-            };
-            switch (binding.type) {
-            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-                get_info.data.pUniformBuffer = &address_info;
-                break;
-            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-                get_info.data.pStorageBuffer = &address_info;
-                break;
-            case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-                get_info.data.pUniformTexelBuffer = &address_info;
-                break;
-            case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-                get_info.data.pStorageTexelBuffer = &address_info;
-                break;
-            case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-                get_info.data.pCombinedImageSampler = &entry.image;
-                break;
-            case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-                get_info.data.pStorageImage = &entry.image;
-                break;
-            default:
-                continue;
-            }
-            dev.GetDescriptorEXT(get_info, binding.stride,
-                                 host + binding.offset + index * binding.stride);
-        }
-    }
-}
-
 [[nodiscard]] inline u32 NumDescriptorEntries(const Shader::Info& info) {
     return Shader::NumDescriptors(info.constant_buffer_descriptors) +
            Shader::NumDescriptors(info.storage_buffers_descriptors) +
@@ -148,70 +61,20 @@ public:
     DescriptorLayoutBuilder(const Device& device_) : device{&device_} {}
 
     bool CanUsePushDescriptor() const noexcept {
-        if (!device->IsKhrPushDescriptorSupported() ||
-            num_descriptors > device->MaxPushDescriptors()) {
-            return false;
-        }
-        return !device->IsExtDescriptorBufferSupported() ||
-               device->DescriptorBufferProperties().bufferlessPushDescriptors;
+        return device->IsKhrPushDescriptorSupported() &&
+               num_descriptors <= device->MaxPushDescriptors();
     }
 
-    bool CanUseDescriptorBuffer() const noexcept {
-        const auto& props = device->DescriptorBufferProperties();
-        if (!device->IsExtDescriptorBufferSupported() || bindings.empty() ||
-            !props.combinedImageSamplerDescriptorSingleArray) {
-            return false;
-        }
-        return !props.bufferlessPushDescriptors || !CanUsePushDescriptor();
-    }
-
-    DescriptorBufferLayout MakeDescriptorBufferLayout(VkDescriptorSetLayout layout) const {
-        DescriptorBufferLayout result;
-        if (!layout) {
-            return result;
-        }
-        const vk::Device& dev = device->GetLogical();
-        result.size = dev.GetDescriptorSetLayoutSizeEXT(layout);
-        result.bindings.reserve(bindings.size());
-        for (const VkDescriptorSetLayoutBinding& entry : bindings) {
-            result.bindings.push_back(DescriptorBufferBinding{
-                .type = entry.descriptorType,
-                .count = entry.descriptorCount,
-                .offset = dev.GetDescriptorSetLayoutBindingOffsetEXT(layout, entry.binding),
-                .stride = DescriptorSizeForType(*device, entry.descriptorType),
-            });
-        }
-        return result;
-    }
-
-    vk::DescriptorSetLayout CreateDescriptorSetLayout(bool use_push_descriptor,
-                                                      bool use_descriptor_buffer = false) const {
+    // TODO(crueter): utilize layout binding flags
+    vk::DescriptorSetLayout CreateDescriptorSetLayout(bool use_push_descriptor) const {
         if (bindings.empty()) {
             return nullptr;
         }
-        VkDescriptorSetLayoutCreateFlags flags = 0;
-        if (use_push_descriptor) {
-            flags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
-        }
-        if (use_descriptor_buffer) {
-            flags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT;
-        }
-        boost::container::small_vector<VkDescriptorBindingFlags, 32> binding_flags;
-        VkDescriptorSetLayoutBindingFlagsCreateInfo binding_flags_ci{};
-        const void* pnext = nullptr;
-        if (!use_push_descriptor && device->IsDescriptorBindingPartiallyBoundSupported()) {
-            binding_flags.assign(bindings.size(), VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT);
-            binding_flags_ci = {
-                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
-                .pNext = nullptr,
-                .bindingCount = static_cast<u32>(binding_flags.size()),
-                .pBindingFlags = binding_flags.data(),
-            };
-            pnext = &binding_flags_ci;
-        }
+        const VkDescriptorSetLayoutCreateFlags flags =
+            use_push_descriptor ? VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR : 0;
         return device->GetLogical().CreateDescriptorSetLayout({
             .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .pNext = pnext,
+            .pNext = nullptr,
             .flags = flags,
             .bindingCount = static_cast<u32>(bindings.size()),
             .pBindings = bindings.data(),

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -69,9 +69,6 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo
     if (device.IsExtConditionalRendering()) {
         flags |= VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT;
     }
-    if (device.IsBufferDeviceAddressSupported()) {
-        flags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
     const VkBufferCreateInfo buffer_ci = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -94,9 +91,6 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_p
     device = &runtime.device;
     buffer = runtime.CreateNullBuffer();
     is_null = true;
-    if (device->IsBufferDeviceAddressSupported()) {
-        device_address = device->GetLogical().GetBufferDeviceAddress(*buffer);
-    }
 }
 
 Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
@@ -106,9 +100,6 @@ Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
     if (runtime.device.HasDebuggingToolAttached()) {
         buffer.SetObjectNameEXT(fmt::format("Buffer {:#x}", CpuAddr()).c_str());
     }
-    if (device->IsBufferDeviceAddressSupported()) {
-        device_address = device->GetLogical().GetBufferDeviceAddress(*buffer);
-    }
 }
 
 void Buffer::MarkUsage(u64 offset, u64 size) noexcept {
@@ -365,93 +356,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
                                                                      scheduler_, staging_pool_);
 }
 
-void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
-                                                std::span<AHardwareBuffer* const> hardware_buffers,
-                                                size_t hardware_buffer_window,
-                                                size_t hardware_buffer_base) {
-    unified_memory = std::make_unique<HostMemoryImport>(
-        device, base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
-    if (!unified_memory->IsValid()) {
-        unified_memory.reset();
-    }
-}
-
-void BufferCacheRuntime::CopyToUnifiedMemory(
-    size_t window_index, VkBuffer src_buffer,
-    std::span<const VideoCommon::BufferCopy> copies) {
-    if (!unified_memory || src_buffer == VK_NULL_HANDLE || copies.empty() ||
-        window_index >= unified_memory->GetWindowCount()) {
-        return;
-    }
-    const VkBuffer dst_buffer = unified_memory->GetWindowBuffer(window_index);
-    if (dst_buffer == VK_NULL_HANDLE) {
-        return;
-    }
-    VkDeviceSize covered_begin = std::numeric_limits<VkDeviceSize>::max();
-    VkDeviceSize covered_end = 0;
-    for (const VideoCommon::BufferCopy& copy : copies) {
-        covered_begin = (std::min)(covered_begin, static_cast<VkDeviceSize>(copy.dst_offset));
-        covered_end = (std::max)(covered_end,
-                                 static_cast<VkDeviceSize>(copy.dst_offset + copy.size));
-    }
-
-    boost::container::small_vector<VkBufferCopy, 8> vk_copies(copies.size());
-    std::ranges::transform(copies, vk_copies.begin(), MakeBufferCopy);
-
-    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
-    const u32 queue_family = device.GetGraphicsFamily();
-
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([src_buffer, dst_buffer, vk_copies, foreign, queue_family, covered_begin,
-                      covered_end](vk::CommandBuffer cmdbuf) {
-        if (foreign) {
-            const VkBufferMemoryBarrier acquire{
-                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                .pNext = nullptr,
-                .srcAccessMask = 0,
-                .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
-                .dstQueueFamilyIndex = queue_family,
-                .buffer = dst_buffer,
-                .offset = covered_begin,
-                .size = covered_end - covered_begin,
-            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, acquire);
-        }
-        cmdbuf.CopyBuffer(src_buffer, dst_buffer, VideoCommon::FixSmallVectorADL(vk_copies));
-        if (foreign) {
-            const VkBufferMemoryBarrier release{
-                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                .pNext = nullptr,
-                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-                .dstAccessMask = 0,
-                .srcQueueFamilyIndex = queue_family,
-                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
-                .buffer = dst_buffer,
-                .offset = covered_begin,
-                .size = covered_end - covered_begin,
-            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, release);
-        }
-    });
-}
-
-void BufferCacheRuntime::UnifiedMemoryHostBarrier() {
-    static constexpr VkMemoryBarrier HOST_BARRIER{
-        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-        .pNext = nullptr,
-        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-        .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
-    };
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0,
-                               HOST_BARRIER);
-    });
-}
-
 StagingBufferRef BufferCacheRuntime::UploadStagingBuffer(size_t size) {
     return staging_pool.Request(size, MemoryUsage::Upload);
 }
@@ -460,10 +364,6 @@ StagingBufferRef BufferCacheRuntime::DownloadStagingBuffer(size_t size, bool def
     return staging_pool.Request(size, MemoryUsage::Download, deferred);
 }
 
-VkFormat BufferCacheRuntime::TexelBufferFormat(VideoCore::Surface::PixelFormat format) const {
-    return MaxwellToVK::SurfaceFormat(device, FormatType::Buffer, false, format).format;
-}
-
 void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
     staging_pool.FreeDeferred(ref);
 }
@@ -790,9 +690,6 @@ vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
     if (device.IsExtTransformFeedbackSupported()) {
         create_info.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     }
-    if (device.IsBufferDeviceAddressSupported()) {
-        create_info.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
     vk::Buffer ret = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
     if (device.HasDebuggingToolAttached()) {
         ret.SetObjectNameEXT("Null buffer");

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -7,8 +7,6 @@
 #pragma once
 
 #include <limits>
-#include <memory>
-#include <span>
 
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
@@ -41,10 +39,6 @@ public:
         return *buffer;
     }
 
-    [[nodiscard]] VkDeviceAddress DeviceAddress() const noexcept {
-        return device_address;
-    }
-
     [[nodiscard]] bool IsRegionUsed(u64 offset, u64 size) const noexcept {
         return tracker.IsUsed(offset, size);
     }
@@ -76,7 +70,6 @@ private:
     vk::Buffer buffer;
     std::vector<BufferView> views;
     VideoCommon::UsageTracker tracker;
-    VkDeviceAddress device_address{};
     u64 last_usage_tick{};
     bool is_null{};
 };
@@ -99,31 +92,6 @@ public:
 
     void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept;
 
-    void TryEnableUnifiedMemory(void* base, size_t size,
-                                std::span<AHardwareBuffer* const> hardware_buffers,
-                                size_t hardware_buffer_window, size_t hardware_buffer_base);
-
-    [[nodiscard]] bool HasUnifiedMemory() const noexcept {
-        return unified_memory != nullptr && unified_memory->IsValid();
-    }
-
-    [[nodiscard]] u64 UnifiedMemorySize() const noexcept {
-        return unified_memory ? unified_memory->GetSize() : 0;
-    }
-
-    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept {
-        return unified_memory ? unified_memory->GetBaseOffset() : 0;
-    }
-
-    [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept {
-        return unified_memory ? unified_memory->GetWindowSize() : 0;
-    }
-
-    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
-                             std::span<const VideoCommon::BufferCopy> copies);
-
-    void UnifiedMemoryHostBarrier();
-
     u64 CurrentTick();
 
     u64 KnownGpuTick();
@@ -177,25 +145,22 @@ public:
                                           [[maybe_unused]] u32 binding_index,
                                           u32 size) {
         const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
-        guest_descriptor_queue.AddBuffer(ref.buffer, ref.device_address,
-                                         static_cast<u32>(ref.offset), size);
+        BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
         return ref.mapped_span;
     }
 
-    void BindUniformBuffer(const Buffer& buffer, u32 offset, u32 size) {
+    void BindUniformBuffer(VkBuffer buffer, u32 offset, u32 size) {
         BindBuffer(buffer, offset, size);
     }
 
-    void BindStorageBuffer(const Buffer& buffer, u32 offset, u32 size,
+    void BindStorageBuffer(VkBuffer buffer, u32 offset, u32 size,
                            [[maybe_unused]] bool is_written) {
         BindBuffer(buffer, offset, size);
     }
 
     void BindTextureBuffer(Buffer& buffer, u32 offset, u32 size,
                            VideoCore::Surface::PixelFormat format) {
-        guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format),
-                                              buffer.DeviceAddress(), offset, size,
-                                              TexelBufferFormat(format));
+        guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format));
     }
 
     bool ShouldLimitDynamicStorageBuffers() const {
@@ -207,17 +172,14 @@ public:
     }
 
 private:
-    void BindBuffer(const Buffer& buffer, u32 offset, u32 size) {
-        const VkBuffer handle = buffer.Handle();
-        if (handle == VK_NULL_HANDLE) {
-            guest_descriptor_queue.AddBuffer(handle, 0, 0, VK_WHOLE_SIZE);
+    void BindBuffer(VkBuffer buffer, u32 offset, u32 size) {
+        if (buffer == VK_NULL_HANDLE) {
+            guest_descriptor_queue.AddBuffer(buffer, 0, VK_WHOLE_SIZE);
         } else {
-            guest_descriptor_queue.AddBuffer(handle, buffer.DeviceAddress(), offset, size);
+            guest_descriptor_queue.AddBuffer(buffer, offset, size);
         }
     }
 
-    VkFormat TexelBufferFormat(VideoCore::Surface::PixelFormat format) const;
-
     void ReserveNullBuffer();
     vk::Buffer CreateNullBuffer();
 
@@ -231,7 +193,6 @@ private:
     std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;
 
     vk::Buffer null_buffer;
-    std::unique_ptr<HostMemoryImport> unified_memory;
 
     std::unique_ptr<Uint8Pass> uint8_pass;
     QuadIndexedPass quad_index_pass;
@@ -254,7 +215,6 @@ struct BufferCacheParams {
     static constexpr bool USE_MEMORY_MAPS = true;
     static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true;
-    static constexpr bool USE_UNIFIED_MEMORY = true;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -34,14 +34,12 @@ using Tegra::Texture::TexturePair;
 ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk::PipelineCache& pipeline_cache_,
                                  DescriptorPool& descriptor_pool,
                                  GuestDescriptorQueue& guest_descriptor_queue_,
-                                 DescriptorBufferRing& descriptor_buffer_ring_,
                                  Common::ThreadWorker* thread_worker,
                                  PipelineStatistics* pipeline_statistics,
                                  VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
                                  vk::ShaderModule spv_module_, u64 shader_hash_)
     : device{device_},
-      pipeline_cache(pipeline_cache_), guest_descriptor_queue{guest_descriptor_queue_},
-      descriptor_buffer_ring{descriptor_buffer_ring_}, info{info_},
+      pipeline_cache(pipeline_cache_), guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
       shader_hash{shader_hash_}, spv_module(std::move(spv_module_)) {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
@@ -50,36 +48,18 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
                 uniform_buffer_sizes.begin());
     num_descriptor_entries = NumDescriptorEntries(info);
 
-    DescriptorLayoutBuilder builder{device};
-    builder.Add(info, VK_SHADER_STAGE_COMPUTE_BIT);
+    auto func{[this, &scheduler, &descriptor_pool, shader_notify, pipeline_statistics] {
+        DescriptorLayoutBuilder builder{device};
+        builder.Add(info, VK_SHADER_STAGE_COMPUTE_BIT);
 
-    uses_push_descriptor = builder.CanUsePushDescriptor();
-    uses_descriptor_buffer = builder.CanUseDescriptorBuffer() && descriptor_buffer_ring.IsValid();
-    descriptor_set_layout =
-        builder.CreateDescriptorSetLayout(uses_push_descriptor, uses_descriptor_buffer);
-    if (uses_descriptor_buffer) {
-        descriptor_buffer_layout = builder.MakeDescriptorBufferLayout(*descriptor_set_layout);
-        if (!descriptor_buffer_ring.CanAllocate(descriptor_buffer_layout.size)) {
-            LOG_DEBUG(Render_Vulkan,
-                        "Compute shader {:016X} needs {} descriptor bytes per dispatch, falling "
-                        "back to sets",
-                        shader_hash, descriptor_buffer_layout.size);
-            uses_descriptor_buffer = false;
-            descriptor_buffer_layout = {};
-            descriptor_set_layout = builder.CreateDescriptorSetLayout(false);
-        }
-    }
-    pipeline_layout = builder.CreatePipelineLayout(*descriptor_set_layout);
-    if (!uses_descriptor_buffer) {
+        uses_push_descriptor = builder.CanUsePushDescriptor();
+        descriptor_set_layout = builder.CreateDescriptorSetLayout(uses_push_descriptor);
+        pipeline_layout = builder.CreatePipelineLayout(*descriptor_set_layout);
         descriptor_update_template =
             builder.CreateTemplate(*descriptor_set_layout, *pipeline_layout, uses_push_descriptor);
         if (!uses_push_descriptor) {
-            descriptor_allocator =
-                descriptor_pool.Allocator(device, scheduler, *descriptor_set_layout, info);
+            descriptor_allocator = descriptor_pool.Allocator(device, scheduler, *descriptor_set_layout, info);
         }
-    }
-
-    auto func{[this, shader_notify, pipeline_statistics] {
         const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_ci{
             .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
             .pNext = nullptr,
@@ -89,9 +69,6 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
         if (device.IsKhrPipelineExecutablePropertiesEnabled() && Settings::values.renderer_debug.GetValue()) {
             flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
         }
-        if (uses_descriptor_buffer) {
-            flags |= VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT;
-        }
         const VkComputePipelineCreateInfo compute_ci{
             .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
             .pNext = nullptr,
@@ -148,10 +125,10 @@ ComputePipeline::ComputePipeline(const Device& device_, Scheduler& scheduler, vk
     }
 }
 
-bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
+void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                 Tegra::MemoryManager& gpu_memory, Scheduler& scheduler,
                                 BufferCache& buffer_cache, TextureCache& texture_cache) {
-    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries, uses_descriptor_buffer);
+    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);
 
     buffer_cache.SetComputeUniformBufferState(info.constant_buffer_mask, &uniform_buffer_sizes);
     buffer_cache.UnbindComputeStorageBuffers();
@@ -272,33 +249,10 @@ bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(true, "compute pipeline");
     }
 
-    const DescriptorUpdateEntry* const descriptor_data{guest_descriptor_queue.UpdateData()};
-    VkDeviceSize descriptor_buffer_offset{};
-    u32 descriptor_buffer_chunk{};
-    if (uses_descriptor_buffer) {
-        const DescriptorBufferRing::Allocation alloc{
-            descriptor_buffer_ring.Allocate(scheduler, descriptor_buffer_layout.size)};
-        if (!alloc.host) {
-            LOG_DEBUG(Render_Vulkan, "Failed to reserve descriptor memory, skipping dispatch");
-            return false;
-        }
-        WriteDescriptorBuffer(device, descriptor_buffer_layout, descriptor_data, alloc.host);
-        descriptor_buffer_offset = alloc.offset;
-        descriptor_buffer_chunk = alloc.chunk;
-    }
-
-    const bool bind_descriptor_buffer{
-        uses_descriptor_buffer && scheduler.UpdateDescriptorBufferChunk(descriptor_buffer_chunk)};
-
+    const void* const descriptor_data{guest_descriptor_queue.UpdateData()};
     const bool is_rescaling = !info.texture_descriptors.empty() || !info.image_descriptors.empty();
-    scheduler.Record([this, descriptor_data, is_rescaling, descriptor_buffer_offset,
-                      descriptor_buffer_chunk, bind_descriptor_buffer,
+    scheduler.Record([this, descriptor_data, is_rescaling,
                       rescaling_data = rescaling.Data()](vk::CommandBuffer cmdbuf) {
-        if (bind_descriptor_buffer) {
-            const VkDescriptorBufferBindingInfoEXT binding_info{
-                descriptor_buffer_ring.BindingInfo(descriptor_buffer_chunk)};
-            cmdbuf.BindDescriptorBuffersEXT(binding_info);
-        }
         if (!pipeline) {
             return;
         }
@@ -311,11 +265,7 @@ bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                  RESCALING_LAYOUT_WORDS_OFFSET, sizeof(rescaling_data),
                                  rescaling_data.data());
         }
-        if (uses_descriptor_buffer) {
-            const u32 buffer_index{};
-            cmdbuf.SetDescriptorBufferOffsetsEXT(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline_layout,
-                                                 0, buffer_index, descriptor_buffer_offset);
-        } else if (uses_push_descriptor) {
+        if (uses_push_descriptor) {
             cmdbuf.PushDescriptorSetWithTemplateKHR(*descriptor_update_template, *pipeline_layout,
                                                     0, descriptor_data);
         } else {
@@ -326,7 +276,6 @@ bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                                       descriptor_set, nullptr);
         }
     });
-    return true;
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -13,9 +13,7 @@
 #include "common/common_types.h"
 #include "common/thread_worker.h"
 #include "shader_recompiler/shader_info.h"
-#include "video_core/renderer_vulkan/pipeline_helper.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
-#include "video_core/renderer_vulkan/vk_descriptor_buffer.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
@@ -36,7 +34,6 @@ public:
     explicit ComputePipeline(const Device& device, Scheduler& scheduler, vk::PipelineCache& pipeline_cache,
                              DescriptorPool& descriptor_pool,
                              GuestDescriptorQueue& guest_descriptor_queue,
-                             DescriptorBufferRing& descriptor_buffer_ring,
                              Common::ThreadWorker* thread_worker,
                              PipelineStatistics* pipeline_statistics,
                              VideoCore::ShaderNotify* shader_notify, const Shader::Info& info,
@@ -48,9 +45,8 @@ public:
     ComputePipeline& operator=(const ComputePipeline&) = delete;
     ComputePipeline(const ComputePipeline&) = delete;
 
-    [[nodiscard]] bool Configure(Tegra::Engines::KeplerCompute& kepler_compute,
-                                 Tegra::MemoryManager& gpu_memory, Scheduler& scheduler,
-                                 BufferCache& buffer_cache, TextureCache& texture_cache);
+    void Configure(Tegra::Engines::KeplerCompute& kepler_compute, Tegra::MemoryManager& gpu_memory,
+                   Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache);
 
     bool IsBound() const noexcept {
         return static_cast<bool>(pipeline);
@@ -60,7 +56,6 @@ private:
     const Device& device;
     vk::PipelineCache& pipeline_cache;
     GuestDescriptorQueue& guest_descriptor_queue;
-    DescriptorBufferRing& descriptor_buffer_ring;
     Shader::Info info;
     u64 shader_hash{};
     u32 num_descriptor_entries{};
@@ -70,8 +65,6 @@ private:
     vk::ShaderModule spv_module;
     vk::DescriptorSetLayout descriptor_set_layout;
     bool uses_push_descriptor{false};
-    bool uses_descriptor_buffer{false};
-    DescriptorBufferLayout descriptor_buffer_layout;
     DescriptorAllocator descriptor_allocator;
     vk::PipelineLayout pipeline_layout;
     vk::DescriptorUpdateTemplate descriptor_update_template;

src/video_core/renderer_vulkan/vk_descriptor_buffer.cpp

@@ -1,141 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <algorithm>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/logging.h"
-#include "video_core/renderer_vulkan/vk_descriptor_buffer.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-
-namespace Vulkan {
-
-DescriptorBufferRing::DescriptorBufferRing(const Device& device_,
-                                           MemoryAllocator& memory_allocator)
-    : device{device_} {
-    if (!device.IsExtDescriptorBufferSupported() || !device.IsBufferDeviceAddressSupported()) {
-        return;
-    }
-    const VkPhysicalDeviceDescriptorBufferPropertiesEXT& props{device.DescriptorBufferProperties()};
-    alignment = std::max<VkDeviceSize>(props.descriptorBufferOffsetAlignment, 1);
-
-    const VkDeviceSize max_bound{(std::min)({props.maxSamplerDescriptorBufferRange,
-                                             props.maxResourceDescriptorBufferRange,
-                                             props.samplerDescriptorBufferAddressSpaceSize,
-                                             props.resourceDescriptorBufferAddressSpaceSize,
-                                             props.descriptorBufferAddressSpaceSize})};
-    const VkDeviceSize frame_size{device.IsTiler() ? TILER_FRAME_SIZE : DESKTOP_FRAME_SIZE};
-    const VkDeviceSize chunk_size{
-        Common::AlignDown((std::min)(frame_size, max_bound), alignment)};
-    if (chunk_size <= alignment) {
-        LOG_DEBUG(Render_Vulkan, "Descriptor buffer binding limit of {} is unusable, disabling",
-                  max_bound);
-        return;
-    }
-    chunk_capacity = chunk_size - alignment;
-    chunks_per_frame = static_cast<size_t>(frame_size / chunk_size);
-
-    const VkBufferCreateInfo buffer_ci{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .size = chunk_size,
-        .usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
-                 VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT |
-                 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    const size_t total_chunks{chunks_per_frame * FRAMES_IN_FLIGHT};
-    chunks.reserve(total_chunks);
-    chunk_addresses.reserve(total_chunks);
-    chunk_hosts.reserve(total_chunks);
-    for (size_t index = 0; index < total_chunks; ++index) {
-        vk::Buffer buffer{memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::Upload)};
-        if (!buffer.IsHostVisible()) {
-            LOG_DEBUG(Render_Vulkan, "Descriptor buffer is not host visible, disabling");
-            chunks.clear();
-            return;
-        }
-        if (!buffer.IsHostCoherent()) {
-            LOG_DEBUG(Render_Vulkan, "Descriptor buffer is not host coherent, disabling");
-            chunks.clear();
-            return;
-        }
-        if (device.HasDebuggingToolAttached()) {
-            buffer.SetObjectNameEXT("Descriptor buffer");
-        }
-        const VkDeviceAddress raw_address{device.GetLogical().GetBufferDeviceAddress(*buffer)};
-        const VkDeviceAddress address{Common::AlignUp(raw_address, alignment)};
-        chunk_addresses.push_back(address);
-        chunk_hosts.push_back(buffer.Mapped().data() + (address - raw_address));
-        chunks.push_back(std::move(buffer));
-    }
-}
-
-DescriptorBufferRing::~DescriptorBufferRing() = default;
-
-void DescriptorBufferRing::TickFrame() {
-    if (++frame_index >= FRAMES_IN_FLIGHT) {
-        frame_index = 0;
-    }
-    chunk_cursor = 0;
-    cursor = 0;
-    ++generation;
-    frame_reused = true;
-}
-
-void DescriptorBufferRing::TouchFrame(Scheduler& scheduler) {
-    frame_ticks[frame_index] = scheduler.CurrentTick();
-}
-
-DescriptorBufferRing::Allocation DescriptorBufferRing::Allocate(Scheduler& scheduler,
-                                                                VkDeviceSize size) {
-    ASSERT(!chunks.empty());
-    if (!CanAllocate(size)) {
-        LOG_DEBUG(Render_Vulkan, "Descriptor set of {} bytes exceeds chunk capacity {}", size,
-                  chunk_capacity);
-        return Allocation{};
-    }
-    const VkDeviceSize needed{Common::AlignUp(size, alignment)};
-    if (frame_reused) {
-        frame_reused = false;
-        scheduler.Wait(frame_ticks[frame_index]);
-    }
-    if (cursor + needed > chunk_capacity) {
-        if (chunk_cursor + 1 < chunks_per_frame) {
-            ++chunk_cursor;
-        } else {
-            LOG_DEBUG(Render_Vulkan, "Descriptor buffer frame exhausted, stalling on the GPU");
-            scheduler.Finish();
-            chunk_cursor = 0;
-            ++generation;
-        }
-        cursor = 0;
-    }
-    const size_t chunk{frame_index * chunks_per_frame + chunk_cursor};
-    const VkDeviceSize offset{cursor};
-    cursor += needed;
-    frame_ticks[frame_index] = scheduler.CurrentTick();
-    return Allocation{
-        .host = chunk_hosts[chunk] + offset,
-        .offset = offset,
-        .chunk = static_cast<u32>(chunk),
-        .generation = generation,
-    };
-}
-
-VkDescriptorBufferBindingInfoEXT DescriptorBufferRing::BindingInfo(u32 chunk) const noexcept {
-    return VkDescriptorBufferBindingInfoEXT{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
-        .pNext = nullptr,
-        .address = chunk_addresses[chunk],
-        .usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT |
-                 VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT,
-    };
-}
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_descriptor_buffer.h

@@ -1,71 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <array>
-#include <vector>
-
-#include "common/alignment.h"
-#include "common/common_types.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-class Device;
-class Scheduler;
-
-class DescriptorBufferRing final {
-    static constexpr size_t FRAMES_IN_FLIGHT = 8;
-    static constexpr VkDeviceSize TILER_FRAME_SIZE = 2 * 1024 * 1024;
-    static constexpr VkDeviceSize DESKTOP_FRAME_SIZE = 4 * 1024 * 1024;
-
-public:
-    explicit DescriptorBufferRing(const Device& device_, MemoryAllocator& memory_allocator);
-    ~DescriptorBufferRing();
-
-    struct Allocation {
-        u8* host{};
-        VkDeviceSize offset{};
-        u32 chunk{};
-        u64 generation{};
-    };
-
-    [[nodiscard]] u64 CurrentGeneration() const noexcept {
-        return generation;
-    }
-
-    void TouchFrame(Scheduler& scheduler);
-
-    [[nodiscard]] bool CanAllocate(VkDeviceSize size) const noexcept {
-        return Common::AlignUp(size, alignment) <= chunk_capacity;
-    }
-
-    void TickFrame();
-
-    [[nodiscard]] Allocation Allocate(Scheduler& scheduler, VkDeviceSize size);
-
-    [[nodiscard]] VkDescriptorBufferBindingInfoEXT BindingInfo(u32 chunk) const noexcept;
-
-    [[nodiscard]] bool IsValid() const noexcept {
-        return !chunks.empty();
-    }
-
-private:
-    const Device& device;
-    std::vector<vk::Buffer> chunks;
-    std::vector<VkDeviceAddress> chunk_addresses;
-    std::vector<u8*> chunk_hosts;
-    VkDeviceSize alignment{1};
-    VkDeviceSize chunk_capacity{};
-    size_t chunks_per_frame{};
-    size_t frame_index{};
-    size_t chunk_cursor{};
-    VkDeviceSize cursor{};
-    u64 generation{1};
-    std::array<u64, FRAMES_IN_FLIGHT> frame_ticks{};
-    bool frame_reused{};
-};
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <cstring>
 #include <iostream>
 #include <span>
 
@@ -251,15 +250,13 @@ GraphicsPipeline::GraphicsPipeline(
     Scheduler& scheduler_, BufferCache& buffer_cache_, TextureCache& texture_cache_,
     vk::PipelineCache& pipeline_cache_, VideoCore::ShaderNotify* shader_notify,
     const Device& device_, DescriptorPool& descriptor_pool,
-    GuestDescriptorQueue& guest_descriptor_queue_, DescriptorBufferRing& descriptor_buffer_ring_,
-    Common::ThreadWorker* worker_thread,
+    GuestDescriptorQueue& guest_descriptor_queue_, Common::ThreadWorker* worker_thread,
     PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
     const GraphicsPipelineCacheKey& key_, std::array<vk::ShaderModule, NUM_STAGES> stages,
     const std::array<const Shader::Info*, NUM_STAGES>& infos)
     : key{key_}, device{device_}, texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
       pipeline_cache(pipeline_cache_), scheduler{scheduler_},
-      guest_descriptor_queue{guest_descriptor_queue_},
-      descriptor_buffer_ring{descriptor_buffer_ring_}, spv_modules{std::move(stages)} {
+      guest_descriptor_queue{guest_descriptor_queue_}, spv_modules{std::move(stages)} {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
     }
@@ -279,37 +276,20 @@ GraphicsPipeline::GraphicsPipeline(
         num_descriptor_entries += NumDescriptorEntries(*info);
     }
     fragment_has_color0_output = stage_infos[NUM_STAGES - 1].stores_frag_color[0];
+    auto func{[this, shader_notify, &render_pass_cache, &descriptor_pool, pipeline_statistics] {
+        DescriptorLayoutBuilder builder{MakeBuilder(device, stage_infos)};
+        uses_push_descriptor = builder.CanUsePushDescriptor();
+        descriptor_set_layout = builder.CreateDescriptorSetLayout(uses_push_descriptor);
 
-    DescriptorLayoutBuilder builder{MakeBuilder(device, stage_infos)};
-    uses_push_descriptor = builder.CanUsePushDescriptor();
-    uses_descriptor_buffer = builder.CanUseDescriptorBuffer() && descriptor_buffer_ring.IsValid();
-    descriptor_set_layout =
-        builder.CreateDescriptorSetLayout(uses_push_descriptor, uses_descriptor_buffer);
-    if (uses_descriptor_buffer) {
-        descriptor_buffer_layout = builder.MakeDescriptorBufferLayout(*descriptor_set_layout);
-        if (!descriptor_buffer_ring.CanAllocate(descriptor_buffer_layout.size)) {
-            LOG_WARNING(Render_Vulkan,
-                        "Graphics pipeline {:016X} needs {} descriptor bytes per draw, falling back "
-                        "to sets",
-                        key.Hash(), descriptor_buffer_layout.size);
-            uses_descriptor_buffer = false;
-            descriptor_buffer_layout = {};
-            descriptor_set_layout = builder.CreateDescriptorSetLayout(uses_push_descriptor);
+        if (!uses_push_descriptor) {
+            descriptor_allocator = descriptor_pool.Allocator(device, scheduler, *descriptor_set_layout, stage_infos);
         }
-    }
 
-    const VkDescriptorSetLayout set_layout{*descriptor_set_layout};
-    pipeline_layout = builder.CreatePipelineLayout(set_layout);
-    if (!uses_descriptor_buffer) {
+        const VkDescriptorSetLayout set_layout{*descriptor_set_layout};
+        pipeline_layout = builder.CreatePipelineLayout(set_layout);
         descriptor_update_template =
             builder.CreateTemplate(set_layout, *pipeline_layout, uses_push_descriptor);
-        if (!uses_push_descriptor) {
-            descriptor_allocator =
-                descriptor_pool.Allocator(device, scheduler, set_layout, stage_infos);
-        }
-    }
 
-    auto func{[this, shader_notify, &render_pass_cache, pipeline_statistics] {
         const VkRenderPass render_pass{render_pass_cache.Get(MakeRenderPassKey(key.state, device))};
         Validate();
         try {
@@ -516,7 +496,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     buffer_cache.UpdateGraphicsBuffers(is_indexed);
     buffer_cache.BindHostGeometryBuffers(is_indexed);
 
-    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries, uses_descriptor_buffer);
+    guest_descriptor_queue.Acquire(scheduler, num_descriptor_entries);
 
     RescalingPushConstant rescaling;
     RenderAreaPushConstant render_area;
@@ -558,43 +538,13 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     if (IsBuilt() && !pipeline) {
         return false;
     }
-    return ConfigureDraw(rescaling, render_area);
+    ConfigureDraw(rescaling, render_area);
+
+    return true;
 }
 
-bool GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
+void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
                                      const RenderAreaPushConstant& render_area) {
-    const void* const descriptor_data{guest_descriptor_queue.UpdateData()};
-
-    VkDeviceSize descriptor_buffer_offset{};
-    u32 descriptor_buffer_chunk{};
-    if (descriptor_set_layout && uses_descriptor_buffer) {
-        const auto* const entries = static_cast<const DescriptorUpdateEntry*>(descriptor_data);
-        const bool reuse_allocation =
-            last_descriptor_buffer_generation == descriptor_buffer_ring.CurrentGeneration() &&
-            last_descriptor_payload.size() == num_descriptor_entries &&
-            std::memcmp(last_descriptor_payload.data(), entries,
-                        num_descriptor_entries * sizeof(DescriptorUpdateEntry)) == 0;
-        if (reuse_allocation) {
-            descriptor_buffer_offset = last_descriptor_buffer_offset;
-            descriptor_buffer_chunk = last_descriptor_buffer_chunk;
-            descriptor_buffer_ring.TouchFrame(scheduler);
-        } else {
-            const DescriptorBufferRing::Allocation alloc{
-                descriptor_buffer_ring.Allocate(scheduler, descriptor_buffer_layout.size)};
-            if (!alloc.host) {
-                LOG_DEBUG(Render_Vulkan, "Failed to reserve descriptor memory, skipping draw");
-                return false;
-            }
-            WriteDescriptorBuffer(device, descriptor_buffer_layout, entries, alloc.host);
-            descriptor_buffer_offset = alloc.offset;
-            descriptor_buffer_chunk = alloc.chunk;
-            last_descriptor_buffer_offset = alloc.offset;
-            last_descriptor_buffer_chunk = alloc.chunk;
-            last_descriptor_buffer_generation = alloc.generation;
-            last_descriptor_payload.assign(entries, entries + num_descriptor_entries);
-        }
-    }
-
     scheduler.RequestRenderpass(texture_cache.GetFramebuffer());
     if (!is_built.load(std::memory_order::relaxed)) {
         // Wait for the pipeline to be built
@@ -606,9 +556,6 @@ bool GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
     const bool is_rescaling{texture_cache.IsRescaling()};
     const bool update_rescaling{scheduler.UpdateRescaling(is_rescaling)};
     const bool bind_pipeline{scheduler.UpdateGraphicsPipeline(this)};
-    const bool bind_descriptor_buffer{
-        descriptor_set_layout && uses_descriptor_buffer &&
-        scheduler.UpdateDescriptorBufferChunk(descriptor_buffer_chunk)};
 
     // Log graphics pipeline binding
     if (bind_pipeline && GPU::Logging::IsActive() &&
@@ -617,27 +564,11 @@ bool GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
         GPU::Logging::GPULogger::GetInstance().LogPipelineBind(false, pipeline_info);
     }
 
-    bool update_descriptors = true;
-    if (descriptor_set_layout && !uses_push_descriptor && !uses_descriptor_buffer) {
-        const auto* const entries = static_cast<const DescriptorUpdateEntry*>(descriptor_data);
-        update_descriptors =
-            bind_pipeline || last_descriptor_payload.size() != num_descriptor_entries ||
-            std::memcmp(last_descriptor_payload.data(), entries,
-                        num_descriptor_entries * sizeof(DescriptorUpdateEntry)) != 0;
-        if (update_descriptors) {
-            last_descriptor_payload.assign(entries, entries + num_descriptor_entries);
-        }
-    }
-    scheduler.Record([this, descriptor_data, bind_pipeline, update_descriptors,
-                      descriptor_buffer_offset, descriptor_buffer_chunk, bind_descriptor_buffer,
-                      rescaling_data = rescaling.Data(), is_rescaling, update_rescaling,
+    const void* const descriptor_data{guest_descriptor_queue.UpdateData()};
+    scheduler.Record([this, descriptor_data, bind_pipeline, rescaling_data = rescaling.Data(),
+                      is_rescaling, update_rescaling,
                       uses_render_area = render_area.uses_render_area,
                       render_area_data = render_area.words](vk::CommandBuffer cmdbuf) {
-        if (bind_descriptor_buffer) {
-            const VkDescriptorBufferBindingInfoEXT binding_info{
-                descriptor_buffer_ring.BindingInfo(descriptor_buffer_chunk)};
-            cmdbuf.BindDescriptorBuffersEXT(binding_info);
-        }
         if (bind_pipeline) {
             if (!pipeline) {
                 return;
@@ -662,14 +593,10 @@ bool GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
         if (!descriptor_set_layout) {
             return;
         }
-        if (uses_descriptor_buffer) {
-            const u32 buffer_index{};
-            cmdbuf.SetDescriptorBufferOffsetsEXT(VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline_layout,
-                                                 0, buffer_index, descriptor_buffer_offset);
-        } else if (uses_push_descriptor) {
+        if (uses_push_descriptor) {
             cmdbuf.PushDescriptorSetWithTemplateKHR(*descriptor_update_template, *pipeline_layout,
                                                     0, descriptor_data);
-        } else if (update_descriptors) {
+        } else {
             const VkDescriptorSet descriptor_set{descriptor_allocator.Commit()};
             const vk::Device& dev{device.GetLogical()};
             dev.UpdateDescriptorSet(descriptor_set, *descriptor_update_template, descriptor_data);
@@ -677,7 +604,6 @@ bool GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
                                       descriptor_set, nullptr);
         }
     });
-    return true;
 }
 
 void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
@@ -1069,9 +995,6 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     if (device.IsKhrPipelineExecutablePropertiesEnabled() && Settings::values.renderer_debug.GetValue()) {
         flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
     }
-    if (uses_descriptor_buffer) {
-        flags |= VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT;
-    }
 
     pipeline = device.GetLogical().CreateGraphicsPipeline({
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -12,18 +12,14 @@
 #include <condition_variable>
 #include <mutex>
 #include <type_traits>
-#include <vector>
 
 #include "common/thread_worker.h"
 #include "shader_recompiler/shader_info.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
-#include "video_core/renderer_vulkan/pipeline_helper.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
-#include "video_core/renderer_vulkan/vk_descriptor_buffer.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
-#include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace VideoCore {
@@ -80,8 +76,7 @@ public:
         Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache,
         vk::PipelineCache& pipeline_cache, VideoCore::ShaderNotify* shader_notify,
         const Device& device, DescriptorPool& descriptor_pool,
-        GuestDescriptorQueue& guest_descriptor_queue,
-        DescriptorBufferRing& descriptor_buffer_ring, Common::ThreadWorker* worker_thread,
+        GuestDescriptorQueue& guest_descriptor_queue, Common::ThreadWorker* worker_thread,
         PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
         const GraphicsPipelineCacheKey& key, std::array<vk::ShaderModule, NUM_STAGES> stages,
         const std::array<const Shader::Info*, NUM_STAGES>& infos);
@@ -137,7 +132,7 @@ private:
     template <typename Spec>
     bool ConfigureImpl(bool is_indexed);
 
-    bool ConfigureDraw(const RescalingPushConstant& rescaling,
+    void ConfigureDraw(const RescalingPushConstant& rescaling,
                        const RenderAreaPushConstant& render_are);
 
     void MakePipeline(VkRenderPass render_pass);
@@ -153,7 +148,6 @@ private:
     vk::PipelineCache& pipeline_cache;
     Scheduler& scheduler;
     GuestDescriptorQueue& guest_descriptor_queue;
-    DescriptorBufferRing& descriptor_buffer_ring;
 
     bool (*configure_func)(GraphicsPipeline*, bool){};
 
@@ -176,17 +170,10 @@ private:
     vk::DescriptorUpdateTemplate descriptor_update_template;
     vk::Pipeline pipeline;
 
-    DescriptorBufferLayout descriptor_buffer_layout;
-    std::vector<DescriptorUpdateEntry> last_descriptor_payload;
-    VkDeviceSize last_descriptor_buffer_offset{};
-    u32 last_descriptor_buffer_chunk{};
-    u64 last_descriptor_buffer_generation{};
-
     std::condition_variable build_condvar;
     std::mutex build_mutex;
     std::atomic_bool is_built{false};
     bool uses_push_descriptor{false};
-    bool uses_descriptor_buffer{false};
 };
 
 } // namespace Vulkan

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, 2, 8);
+    const int clamped = std::clamp(configured, 4, 8);
     const size_t desired = static_cast<size_t>(clamped);
     if (desired == 0) {
         return 1ULL;
@@ -340,20 +340,17 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                              const Device& device_, Scheduler& scheduler_,
                              DescriptorPool& descriptor_pool_,
                              GuestDescriptorQueue& guest_descriptor_queue_,
-                             DescriptorBufferRing& descriptor_buffer_ring_,
                              RenderPassCache& render_pass_cache_, BufferCache& buffer_cache_,
                              TextureCache& texture_cache_, VideoCore::ShaderNotify& shader_notify_)
     : VideoCommon::ShaderCache{device_memory_}, device{device_}, scheduler{scheduler_},
       descriptor_pool{descriptor_pool_}, guest_descriptor_queue{guest_descriptor_queue_},
-      descriptor_buffer_ring{descriptor_buffer_ring_},
       render_pass_cache{render_pass_cache_}, buffer_cache{buffer_cache_},
       texture_cache{texture_cache_}, shader_notify{shader_notify_},
       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", {}, Common::ThreadPlacement::Background),
-      serialization_thread(1, "VkPipelineSerialization", {},
-                           Common::ThreadPlacement::Background) {
+              "VkPipelineBuilder"),
+      serialization_thread(1, "VkPipelineSerialization") {
     const auto& float_control{device.FloatControlProperties()};
     const VkDriverId driver_id{device.GetDriverID()};
     const VkShaderStageFlags subgroup_stages{device.GetSubgroupSupportedStages()};
@@ -839,8 +836,8 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
     return std::make_unique<GraphicsPipeline>(
         scheduler, buffer_cache, texture_cache, vulkan_pipeline_cache, &shader_notify, device,
-        descriptor_pool, guest_descriptor_queue, descriptor_buffer_ring, thread_worker, statistics,
-        render_pass_cache, key, std::move(modules), infos);
+        descriptor_pool, guest_descriptor_queue, thread_worker, statistics, render_pass_cache, key,
+        std::move(modules), infos);
 
 } catch (const Shader::Exception& exception) {
     auto hash = key.Hash();
@@ -960,8 +957,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     }
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
     return std::make_unique<ComputePipeline>(device, scheduler, vulkan_pipeline_cache, descriptor_pool,
-                                             guest_descriptor_queue, descriptor_buffer_ring,
-                                             thread_worker, statistics,
+                                             guest_descriptor_queue, thread_worker, statistics,
                                              &shader_notify, program.info, std::move(spv_module),
                                              key.unique_hash);
 

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -105,7 +105,6 @@ public:
     explicit PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device,
                            Scheduler& scheduler, DescriptorPool& descriptor_pool,
                            GuestDescriptorQueue& guest_descriptor_queue,
-                           DescriptorBufferRing& descriptor_buffer_ring,
                            RenderPassCache& render_pass_cache, BufferCache& buffer_cache,
                            TextureCache& texture_cache, VideoCore::ShaderNotify& shader_notify_);
     ~PipelineCache();
@@ -148,7 +147,6 @@ private:
     Scheduler& scheduler;
     DescriptorPool& descriptor_pool;
     GuestDescriptorQueue& guest_descriptor_queue;
-    DescriptorBufferRing& descriptor_buffer_ring;
     RenderPassCache& render_pass_cache;
     BufferCache& buffer_cache;
     TextureCache& texture_cache;

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -266,8 +266,6 @@ 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 frames

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -203,10 +203,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
     : gpu{gpu_}, device_memory{device_memory_}, device{device_},
       memory_allocator{memory_allocator_}, state_tracker{state_tracker_}, scheduler{scheduler_},
       staging_pool(device, memory_allocator, scheduler), descriptor_pool(device, scheduler),
-      guest_descriptor_queue(device, UpdateDescriptorQueue::GUEST_FRAME_PAYLOAD_SIZE,
-                             device.IsExtDescriptorBufferSupported()),
-      compute_pass_descriptor_queue(device, UpdateDescriptorQueue::COMPUTE_FRAME_PAYLOAD_SIZE),
-      descriptor_buffer_ring(device, memory_allocator),
+      guest_descriptor_queue(device), compute_pass_descriptor_queue(device),
       blit_image(device, scheduler, state_tracker, descriptor_pool), render_pass_cache(device),
       texture_cache_runtime{
           device,     scheduler,         memory_allocator, staging_pool,
@@ -219,19 +216,11 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
                           staging_pool, compute_pass_descriptor_queue, descriptor_pool, texture_cache),
       query_cache(gpu, *this, device_memory, query_cache_runtime),
       pipeline_cache(device_memory, device, scheduler, descriptor_pool, guest_descriptor_queue,
-                     descriptor_buffer_ring, render_pass_cache, buffer_cache, texture_cache,
-                     gpu.ShaderNotify()),
+                     render_pass_cache, buffer_cache, texture_cache, gpu.ShaderNotify()),
       accelerate_dma(buffer_cache, texture_cache, scheduler),
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
-    if (Settings::values.use_unified_memory.GetValue() && device_memory.IsBackingShared()) {
-        buffer_cache_runtime.TryEnableUnifiedMemory(
-            device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
-            device_memory.GetBackingHardwareBuffers(),
-            device_memory.GetBackingHardwareBufferWindowSize(),
-            device_memory.GetBackingHardwareBufferBase());
-    }
 }
 
 RasterizerVulkan::~RasterizerVulkan() {
@@ -594,10 +583,7 @@ void RasterizerVulkan::DispatchCompute() {
         return;
     }
     std::scoped_lock lock{texture_cache.mutex, buffer_cache.mutex};
-    if (!pipeline->Configure(*kepler_compute, *gpu_memory, scheduler, buffer_cache,
-                             texture_cache)) {
-        return;
-    }
+    pipeline->Configure(*kepler_compute, *gpu_memory, scheduler, buffer_cache, texture_cache);
 
     const auto& qmd{kepler_compute->launch_description};
     auto indirect_address = kepler_compute->GetIndirectComputeAddress();
@@ -896,7 +882,6 @@ void RasterizerVulkan::TickFrame() {
     draw_counter = 0;
     guest_descriptor_queue.TickFrame();
     compute_pass_descriptor_queue.TickFrame();
-    descriptor_buffer_ring.TickFrame();
     fence_manager.TickFrame();
     staging_pool.TickFrame();
     {

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -17,7 +17,6 @@
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
-#include "video_core/renderer_vulkan/vk_descriptor_buffer.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
@@ -208,7 +207,6 @@ private:
     DescriptorPool descriptor_pool;
     GuestDescriptorQueue guest_descriptor_queue;
     ComputePassDescriptorQueue compute_pass_descriptor_queue;
-    DescriptorBufferRing descriptor_buffer_ring;
     BlitImageHelper blit_image;
     RenderPassCache render_pass_cache;
 

src/video_core/renderer_vulkan/vk_resource_pool.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,7 +12,10 @@ ResourcePool::ResourcePool(MasterSemaphore& master_semaphore_, size_t grow_step_
     : master_semaphore{&master_semaphore_}, grow_step{grow_step_} {}
 
 size_t ResourcePool::CommitResource() {
-    const auto search = [this](size_t begin, size_t end, u64 gpu_tick) -> std::optional<size_t> {
+    // Refresh semaphore to query updated results
+    master_semaphore->Refresh();
+    const u64 gpu_tick = master_semaphore->KnownGpuTick();
+    const auto search = [this, gpu_tick](size_t begin, size_t end) -> std::optional<size_t> {
         for (size_t iterator = begin; iterator < end; ++iterator) {
             if (gpu_tick >= ticks[iterator]) {
                 ticks[iterator] = master_semaphore->CurrentTick();
@@ -24,17 +24,11 @@ size_t ResourcePool::CommitResource() {
         }
         return std::nullopt;
     };
-    const auto find_free = [&](u64 gpu_tick) -> std::optional<size_t> {
-        std::optional<size_t> result = search(hint_iterator, ticks.size(), gpu_tick);
-        if (!result) {
-            result = search(0, hint_iterator, gpu_tick);
-        }
-        return result;
-    };
-    std::optional<size_t> found = find_free(master_semaphore->KnownGpuTick());
+    // Try to find a free resource from the hinted position to the end.
+    std::optional<size_t> found = search(hint_iterator, ticks.size());
     if (!found) {
-        master_semaphore->Refresh();
-        found = find_free(master_semaphore->KnownGpuTick());
+        // Search from beginning to the hinted position.
+        found = search(0, hint_iterator);
         if (!found) {
             // Both searches failed, the pool is full; handle it.
             const size_t free_resource = ManageOverflow();

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -247,19 +247,8 @@ bool Scheduler::UpdateRescaling(bool is_rescaling) {
     return true;
 }
 
-bool Scheduler::UpdateDescriptorBufferChunk(u32 descriptor_chunk) {
-    if (state.descriptor_buffer_bound && descriptor_chunk == state.descriptor_buffer_chunk) {
-        return false;
-    }
-    state.descriptor_buffer_bound = true;
-    state.descriptor_buffer_chunk = descriptor_chunk;
-    return true;
-}
-
 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()) {
@@ -380,7 +369,6 @@ void Scheduler::AllocateNewContext() {
 void Scheduler::InvalidateState() {
     state.graphics_pipeline = nullptr;
     state.rescaling_defined = false;
-    state.descriptor_buffer_bound = false;
     state_tracker.InvalidateCommandBufferState();
 }
 

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -80,9 +80,6 @@ public:
     /// Update the rescaling state. Returns true if the state has to be updated.
     bool UpdateRescaling(bool is_rescaling);
 
-    /// Returns true when the descriptor buffer chunk has to be bound into the command buffer.
-    bool UpdateDescriptorBufferChunk(u32 descriptor_chunk);
-
     /// Invalidates current command buffer state except for render passes
     void InvalidateState();
 
@@ -258,8 +255,6 @@ private:
         bool is_rescaling = false;
         bool rescaling_defined = false;
         bool needs_state_enable_refresh = false;
-        u32 descriptor_buffer_chunk = 0;
-        bool descriptor_buffer_bound = false;
     };
 
     struct DeferredClear {

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -84,16 +84,10 @@ StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& mem
     if (device.IsExtTransformFeedbackSupported()) {
         stream_ci.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     }
-    if (device.IsBufferDeviceAddressSupported()) {
-        stream_ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
     stream_buffer = memory_allocator.CreateBuffer(stream_ci, MemoryUsage::Stream);
     if (device.HasDebuggingToolAttached()) {
         stream_buffer.SetObjectNameEXT("Stream Buffer");
     }
-    if (device.IsBufferDeviceAddressSupported()) {
-        stream_buffer_address = device.GetLogical().GetBufferDeviceAddress(*stream_buffer);
-    }
     stream_pointer = stream_buffer.Mapped();
     ASSERT_MSG(!stream_pointer.empty(), "Stream buffer must be host visible!");
 }
@@ -155,7 +149,6 @@ StagingBufferRef StagingBufferPool::GetStreamBuffer(size_t size) {
     iterator = Common::AlignUp(iterator + size, MAX_ALIGNMENT);
     return StagingBufferRef{
         .buffer = *stream_buffer,
-        .device_address = stream_buffer_address,
         .offset = static_cast<VkDeviceSize>(offset),
         .mapped_span = stream_pointer.subspan(offset, size),
         .usage{},
@@ -219,22 +212,14 @@ StagingBufferRef StagingBufferPool::CreateStagingBuffer(size_t size, MemoryUsage
     if (device.IsExtTransformFeedbackSupported()) {
         buffer_ci.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     }
-    if (device.IsBufferDeviceAddressSupported()) {
-        buffer_ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
-    }
     vk::Buffer buffer = memory_allocator.CreateBuffer(buffer_ci, usage);
     if (device.HasDebuggingToolAttached()) {
         ++buffer_index;
         buffer.SetObjectNameEXT(fmt::format("Staging Buffer {}", buffer_index).c_str());
     }
     const std::span<u8> mapped_span = buffer.Mapped();
-    const VkDeviceAddress buffer_address =
-        device.IsBufferDeviceAddressSupported()
-            ? device.GetLogical().GetBufferDeviceAddress(*buffer)
-            : VkDeviceAddress{};
     StagingBuffer& entry = GetCache(usage)[log2_size].entries.emplace_back(StagingBuffer{
         .buffer = std::move(buffer),
-        .device_address = buffer_address,
         .mapped_span = mapped_span,
         .usage = usage,
         .log2_level = log2_size,

src/video_core/renderer_vulkan/vk_staging_buffer_pool.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -21,7 +18,6 @@ class Scheduler;
 
 struct StagingBufferRef {
     VkBuffer buffer;
-    VkDeviceAddress device_address;
     VkDeviceSize offset;
     std::span<u8> mapped_span;
     MemoryUsage usage;
@@ -54,7 +50,6 @@ private:
 
     struct StagingBuffer {
         vk::Buffer buffer;
-        VkDeviceAddress device_address;
         std::span<u8> mapped_span;
         MemoryUsage usage;
         u32 log2_level;
@@ -65,7 +60,6 @@ private:
         StagingBufferRef Ref() const noexcept {
             return {
                 .buffer = *buffer,
-                .device_address = device_address,
                 .offset = 0,
                 .mapped_span = mapped_span,
                 .usage = usage,
@@ -109,7 +103,6 @@ private:
     Scheduler& scheduler;
 
     vk::Buffer stream_buffer;
-    VkDeviceAddress stream_buffer_address{};
     std::span<u8> stream_pointer;
     VkDeviceSize stream_buffer_size;
     VkDeviceSize region_size;

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -144,6 +144,11 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
           info.size.depth == 1;
 }
 
+[[nodiscard]] bool WillUseWidenedAstcFormat(const Device& device, const ImageInfo& info) {
+    return WillUseAcceleratedAstcDecode(device, info) &&
+           !VideoCore::Surface::IsPixelFormatSRGB(info.format);
+}
+
 [[nodiscard]] VkImageCreateInfo MakeImageCreateInfo(const Device& device, const ImageInfo& info,
                                                     std::optional<VkFormat> format_override = {}) {
     auto format_info =
@@ -264,10 +269,6 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
     }
 }
 
-[[nodiscard]] bool IsLdrAstcFormat(VkFormat format) {
-    return format >= VK_FORMAT_ASTC_4x4_UNORM_BLOCK && format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
-}
-
 [[nodiscard]] VkImageAspectFlags ImageViewAspectMask(const VideoCommon::ImageViewInfo& info) {
     if (info.IsRenderTarget()) {
         return ImageAspectMask(info.format);
@@ -1779,7 +1780,12 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
     : VideoCommon::ImageBase(info_, gpu_addr_, cpu_addr_), scheduler{&runtime_.scheduler},
       runtime{&runtime_},
       original_image(MakeImage(runtime_.device, runtime_.memory_allocator, info,
-                               runtime->ViewFormats(info.format))),
+                               WillUseWidenedAstcFormat(runtime_.device, info)
+                                   ? std::span<const VkFormat>{}
+                                   : runtime->ViewFormats(info.format),
+                               WillUseWidenedAstcFormat(runtime_.device, info)
+                                   ? std::make_optional(VK_FORMAT_R32G32B32A32_SFLOAT)
+                                   : std::nullopt)),
       aspect_mask(ImageAspectMask(info.format)) {
     if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) {
         switch (Settings::values.accelerate_astc.GetValue()) {
@@ -1806,9 +1812,13 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
     }
     current_image = &Image::original_image;
     storage_image_views.resize(info.resources.levels);
-    if (WillUseAcceleratedAstcDecode(runtime->device, info)) {
+    if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported() &&
+        Settings::values.astc_recompression.GetValue() ==
+            Settings::AstcRecompression::Uncompressed) {
         const auto& device = runtime->device.GetLogical();
-        const VkFormat storage_format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+        const VkFormat storage_format = WillUseWidenedAstcFormat(runtime->device, info)
+                                            ? VK_FORMAT_R32G32B32A32_SFLOAT
+                                            : VK_FORMAT_A8B8G8R8_UNORM_PACK32;
         for (s32 level = 0; level < info.resources.levels; ++level) {
             storage_image_views[level] =
                 MakeStorageView(device, level, *original_image, storage_format);
@@ -2194,7 +2204,9 @@ VkImageView Image::StorageImageView(s32 level) noexcept {
         auto format_info =
             MaxwellToVK::SurfaceFormat(runtime->device, FormatType::Optimal, true, info.format);
         if (WillUseAcceleratedAstcDecode(runtime->device, info)) {
-            format_info.format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+            format_info.format = WillUseWidenedAstcFormat(runtime->device, info)
+                                     ? VK_FORMAT_R32G32B32A32_SFLOAT
+                                     : VK_FORMAT_A8B8G8R8_UNORM_PACK32;
         }
         view = MakeStorageView(runtime->device.GetLogical(), level, *(this->*current_image),
                                format_info.format);
@@ -2370,7 +2382,11 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
             SanitizeDepthStencilSwizzle(swizzle, device->SupportsDepthStencilSwizzleOne());
         }
     }
+    uses_widened_astc_format = WillUseWidenedAstcFormat(*device, image.info);
     auto format_info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+    if (uses_widened_astc_format) {
+        format_info.format = VK_FORMAT_R32G32B32A32_SFLOAT;
+    }
     if (device->ApiVersion() >= VK_API_VERSION_1_3) {
         const VkFormatProperties3 properties3 =
             device->GetPhysical().GetFormatProperties3(format_info.format);
@@ -2388,18 +2404,9 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
         .pNext = nullptr,
         .usage = clamped_view_usage,
     };
-    const VkImageViewASTCDecodeModeEXT astc_decode_mode{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
-        .pNext = &image_view_usage,
-        .decodeMode = VK_FORMAT_R8G8B8A8_UNORM,
-    };
-    const void* view_next = &image_view_usage;
-    if (device->IsExtAstcDecodeModeSupported() && IsLdrAstcFormat(format_info.format)) {
-        view_next = &astc_decode_mode;
-    }
     const VkImageViewCreateInfo create_info{
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .pNext = view_next,
+        .pNext = &image_view_usage,
         .flags = 0,
         .image = image.Handle(),
         .viewType = VkImageViewType{},
@@ -2524,6 +2531,9 @@ VkImageView ImageView::StorageView(Shader::TextureType texture_type,
         if (image_format == Shader::ImageFormat::Typeless) {
             if (!typeless_storage_view) {
                 auto info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+                if (uses_widened_astc_format) {
+                    info.format = VK_FORMAT_R32G32B32A32_SFLOAT;
+                }
                 typeless_storage_view = MakeView(info.format, VK_IMAGE_ASPECT_COLOR_BIT, texture_type);
             }
             return *typeless_storage_view;

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -436,6 +436,7 @@ private:
     VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
     u32 buffer_size = 0;
 
+    bool uses_widened_astc_format = false;
     bool supports_depth_comparison = false;
 };
 

src/video_core/renderer_vulkan/vk_update_descriptor.cpp

@@ -16,11 +16,8 @@
 
 namespace Vulkan {
 
-UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_, size_t frame_payload_size_,
-                                             bool supports_descriptor_buffer_)
-    : device{device_}, frame_payload_size{frame_payload_size_},
-      supports_descriptor_buffer{supports_descriptor_buffer_},
-      payload(frame_payload_size_ * FRAMES_IN_FLIGHT)
+UpdateDescriptorQueue::UpdateDescriptorQueue(const Device& device_)
+    : device{device_}
 {
     payload_start = payload.data();
     payload_cursor = payload.data();
@@ -32,21 +29,19 @@ void UpdateDescriptorQueue::TickFrame() {
     if (++frame_index >= FRAMES_IN_FLIGHT) {
         frame_index = 0;
     }
-    payload_start = payload.data() + frame_index * frame_payload_size;
+    payload_start = payload.data() + frame_index * FRAME_PAYLOAD_SIZE;
     payload_cursor = payload_start;
 }
 
-void UpdateDescriptorQueue::Acquire(Scheduler& scheduler, size_t required_entries,
-                                    bool use_descriptor_buffer_) {
-    use_descriptor_buffer = supports_descriptor_buffer && use_descriptor_buffer_;
+void UpdateDescriptorQueue::Acquire(Scheduler& scheduler, size_t required_entries) {
     static constexpr size_t DEFAULT_REQUIRED_ENTRIES = 0x400;
     const size_t reserve = required_entries > 0 ? required_entries : DEFAULT_REQUIRED_ENTRIES;
-    ASSERT_MSG(reserve < frame_payload_size, "Descriptor reservation {} >= frame capacity {}",
-               reserve, frame_payload_size);
+    ASSERT_MSG(reserve < FRAME_PAYLOAD_SIZE, "Descriptor reservation {} >= frame capacity {}",
+               reserve, FRAME_PAYLOAD_SIZE);
     const size_t used = static_cast<size_t>(std::distance(payload_start, payload_cursor));
-    if (used + reserve >= frame_payload_size) {
+    if (used + reserve >= FRAME_PAYLOAD_SIZE) {
         LOG_WARNING(Render_Vulkan, "Payload overflow (used={}, reserve={}, capacity={})",
-                    used, reserve, frame_payload_size);
+                    used, reserve, FRAME_PAYLOAD_SIZE);
         scheduler.WaitWorker();
         payload_cursor = payload_start;
     }

src/video_core/renderer_vulkan/vk_update_descriptor.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <array>
 #include <variant>
-#include <vector>
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
@@ -15,45 +15,30 @@ namespace Vulkan {
 class Device;
 class Scheduler;
 
-struct DescriptorAddress {
-    VkDeviceAddress address;
-    VkDeviceSize range;
-    VkFormat format;
-};
-
 union DescriptorUpdateEntry {
     DescriptorUpdateEntry() = default;
     DescriptorUpdateEntry(VkDescriptorImageInfo image_) : image{image_} {}
     DescriptorUpdateEntry(VkDescriptorBufferInfo buffer_) : buffer{buffer_} {}
     DescriptorUpdateEntry(VkBufferView texel_buffer_) : texel_buffer{texel_buffer_} {}
-    DescriptorUpdateEntry(DescriptorAddress address_) : address{address_} {}
     std::monostate empty{};
     VkDescriptorImageInfo image;
     VkDescriptorBufferInfo buffer;
     VkBufferView texel_buffer;
-    DescriptorAddress address;
 };
 
 class UpdateDescriptorQueue final {
     // This should be plenty for the vast majority of cases. Most desktop platforms only
     // provide up to 3 swapchain images.
     static constexpr size_t FRAMES_IN_FLIGHT = 8;
+    static constexpr size_t FRAME_PAYLOAD_SIZE = 0x20000;
+    static constexpr size_t PAYLOAD_SIZE = FRAME_PAYLOAD_SIZE * FRAMES_IN_FLIGHT;
 
 public:
-    static constexpr size_t GUEST_FRAME_PAYLOAD_SIZE = 0x80000;
-    static constexpr size_t COMPUTE_FRAME_PAYLOAD_SIZE = 0x20000;
-
-    explicit UpdateDescriptorQueue(const Device& device_, size_t frame_payload_size_,
-                                   bool supports_descriptor_buffer_ = false);
+    explicit UpdateDescriptorQueue(const Device& device_);
     ~UpdateDescriptorQueue();
 
-    [[nodiscard]] bool UsesDescriptorBuffer() const noexcept {
-        return use_descriptor_buffer;
-    }
-
     void TickFrame();
-    void Acquire(Scheduler& scheduler, size_t required_entries = 0,
-                 bool use_descriptor_buffer_ = false);
+    void Acquire(Scheduler& scheduler, size_t required_entries = 0);
 
     const DescriptorUpdateEntry* UpdateData() const noexcept {
         return upload_start;
@@ -83,46 +68,17 @@ public:
         };
     }
 
-    void AddBuffer(VkBuffer buffer, VkDeviceAddress base_address, VkDeviceSize offset,
-                   VkDeviceSize size) {
-        if (!use_descriptor_buffer) {
-            AddBuffer(buffer, offset, size);
-            return;
-        }
-        *(payload_cursor++) = DescriptorAddress{
-            .address = base_address == 0 ? 0 : base_address + offset,
-            .range = base_address == 0 ? VK_WHOLE_SIZE : size,
-            .format = VK_FORMAT_UNDEFINED,
-        };
-    }
-
     void AddTexelBuffer(VkBufferView texel_buffer) {
         *(payload_cursor++) = texel_buffer;
     }
 
-    void AddTexelBuffer(VkBufferView texel_buffer, VkDeviceAddress base_address,
-                        VkDeviceSize offset, VkDeviceSize size, VkFormat format) {
-        if (!use_descriptor_buffer) {
-            AddTexelBuffer(texel_buffer);
-            return;
-        }
-        *(payload_cursor++) = DescriptorAddress{
-            .address = base_address == 0 ? 0 : base_address + offset,
-            .range = base_address == 0 ? VK_WHOLE_SIZE : size,
-            .format = format,
-        };
-    }
-
 private:
     const Device& device;
-    const size_t frame_payload_size;
-    const bool supports_descriptor_buffer;
-    bool use_descriptor_buffer{false};
     size_t frame_index{0};
     DescriptorUpdateEntry* payload_cursor = nullptr;
     DescriptorUpdateEntry* payload_start = nullptr;
     const DescriptorUpdateEntry* upload_start = nullptr;
-    std::vector<DescriptorUpdateEntry> payload;
+    std::array<DescriptorUpdateEntry, PAYLOAD_SIZE> payload;
 };
 
 // TODO: should these be separate classes instead?

src/video_core/texture_cache/texture_cache_base.h

@@ -509,8 +509,7 @@ private:
     u64 frame_tick = 0;
     u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();
 
-    Common::ThreadWorker texture_decode_worker{1, "TextureDecoder", {},
-                                               Common::ThreadPlacement::Efficiency};
+    Common::ThreadWorker texture_decode_worker{1, "TextureDecoder"};
     std::vector<std::unique_ptr<AsyncDecodeContext>> async_decodes;
 
     std::deque<PendingUnswizzle> unswizzle_queue;

src/video_core/textures/astc.cpp

@@ -1769,12 +1769,6 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
         return;
     }
 
-    if (weightParams.GetNumWeightValues() > 64) {
-        assert(false && "Too many weights in the weight grid");
-        FillError(outBuf, blockWidth, blockHeight);
-        return;
-    }
-
     // Read num partitions
     u32 nPartitions = strm.ReadBits<2>() + 1;
     assert(nPartitions <= 4);
@@ -1811,11 +1805,6 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
 
     // Remaining bits are color endpoint data...
     u32 nWeightBits = weightParams.GetPackedBitSize();
-    if (nWeightBits < 24 || nWeightBits > 96) {
-        assert(false && "Invalid weight bit count");
-        FillError(outBuf, blockWidth, blockHeight);
-        return;
-    }
     s32 remainingBits = 128 - nWeightBits - static_cast<int>(strm.GetBitsRead());
 
     // Consider extra bits prior to texel data...

src/video_core/textures/workers.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -11,6 +11,7 @@ namespace Tegra::Texture {
 Common::ThreadWorker& GetThreadWorkers() {
     static Common::ThreadWorker workers{(std::max)(std::thread::hardware_concurrency(), 2U) / 2,
                                         "ImageTranscode"};
+
     return workers;
 }
 

src/video_core/vulkan_common/vulkan_device.cpp

@@ -16,7 +16,6 @@
 #include <fmt/format.h>
 
 #include "common/assert.h"
-#include "common/host_memory.h"
 #include "common/literals.h"
 #include <ranges>
 #include "common/settings.h"
@@ -507,8 +506,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     if (is_qualcomm) {
         must_emulate_scaled_formats = true;
         LOG_WARNING(Render_Vulkan, "Qualcomm drivers require scaled vertex format emulation.");
-        has_broken_descriptor_aliasing = true;
-        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken descriptor aliasing.");
         LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken custom border color.");
         RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
                                VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
@@ -716,37 +713,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         RemoveExtensionFeature(extensions.vertex_input_dynamic_state, features.vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
     }
 
-    // Descriptors feature list
-    {
-        auto& descriptor_indexing = features.descriptor_indexing;
-        descriptor_indexing.shaderInputAttachmentArrayDynamicIndexing = false;
-        descriptor_indexing.shaderUniformTexelBufferArrayDynamicIndexing = false;
-        descriptor_indexing.shaderStorageTexelBufferArrayDynamicIndexing = false;
-        descriptor_indexing.shaderUniformBufferArrayNonUniformIndexing = false;
-        descriptor_indexing.shaderStorageBufferArrayNonUniformIndexing = false;
-        descriptor_indexing.shaderInputAttachmentArrayNonUniformIndexing = false;
-        descriptor_indexing.descriptorBindingUniformBufferUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingSampledImageUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingStorageImageUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingStorageBufferUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingUniformTexelBufferUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingStorageTexelBufferUpdateAfterBind = false;
-        descriptor_indexing.descriptorBindingUpdateUnusedWhilePending = false;
-        descriptor_indexing.descriptorBindingVariableDescriptorCount = false;
-        descriptor_indexing.runtimeDescriptorArray = false;
-    }
-
-    // VK_EXT_descriptor_buffer requires VK_KHR_buffer_device_address
-    if (extensions.descriptor_buffer && !features.buffer_device_address.bufferDeviceAddress) {
-        LOG_WARNING(Render_Vulkan, "Descriptor buffer needs buffer device address, disabling.");
-        RemoveExtensionFeature(extensions.descriptor_buffer, features.descriptor_buffer,
-                               VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME);
-    }
-    if (!extensions.descriptor_buffer) {
-        RemoveExtensionFeature(extensions.buffer_device_address, features.buffer_device_address,
-                               VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME);
-    }
-
     logical = vk::Device::Create(physical, queue_cis, ExtensionListForVulkan(loaded_extensions), first_next, dld);
 
     graphics_queue = logical.GetQueue(graphics_family);
@@ -760,9 +726,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     if (extensions.memory_budget) {
         flags |= VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT;
     }
-    if (extensions.buffer_device_address) {
-        flags |= VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;
-    }
     const VmaAllocatorCreateInfo allocator_info{
             .flags = flags,
             .physicalDevice = physical,
@@ -857,13 +820,14 @@ bool Device::ComputeIsOptimalAstcSupported() const {
     if (!features.features.textureCompressionASTC_LDR) {
         return false;
     }
-    const VkFormatFeatureFlags format_feature_usage{
-        VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
-        VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
+    const auto format_feature_usage{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_DST_BIT |
+                                    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+                                    VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
     for (const auto format : astc_formats) {
         const auto physical_format_properties{physical.GetFormatProperties(format)};
-        if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) !=
-            format_feature_usage) {
+        if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) == 0) {
             return false;
         }
     }
@@ -975,7 +939,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
     FOR_EACH_VK_EXTENSION(EXTENSION);
-    FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
     if (supported_extensions.contains(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)) {
         loaded_extensions.erase(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
@@ -988,13 +951,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
         extensions.robustness_2 = false;
     }
 
-#ifdef __ANDROID__
-    if (extensions.external_memory_ahb && !extensions.queue_family_foreign) {
-        loaded_extensions.erase(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
-        extensions.external_memory_ahb = false;
-    }
-#endif
-
 #undef FEATURE_EXTENSION
 #undef EXTENSION
 
@@ -1017,10 +973,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
         CHECK_EXTENSION(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
 
-    if (instance_version < VK_API_VERSION_1_2) {
-        CHECK_EXTENSION(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME);
-    }
-
 #undef LOG_EXTENSION
 #undef CHECK_EXTENSION
 
@@ -1131,11 +1083,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
         SetNext(next, properties.push_descriptor);
     }
-    if (extensions.descriptor_buffer) {
-        properties.descriptor_buffer.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
-        SetNext(next, properties.descriptor_buffer);
-    }
     if (extensions.subgroup_size_control || features.subgroup_size_control.subgroupSizeControl) {
         properties.subgroup_size_control.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
@@ -1151,21 +1098,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
         SetNext(next, properties.maintenance5);
     }
-    if (extensions.external_memory_host) {
-        properties.external_memory_host.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
-        SetNext(next, properties.external_memory_host);
-    }
-    if (extensions.maintenance3 || instance_version >= VK_API_VERSION_1_1) {
-        properties.maintenance3.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
-        SetNext(next, properties.maintenance3);
-    }
-    if (extensions.maintenance4 || features.maintenance4.maintenance4) {
-        properties.maintenance4.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
-        SetNext(next, properties.maintenance4);
-    }
 
     // Perform the property fetch.
     physical.GetProperties2(properties2);
@@ -1282,11 +1214,6 @@ void Device::RemoveUnsuitableExtensions() {
     RemoveExtensionFeatureIfUnsuitable(extensions.depth_clip_control, features.depth_clip_control,
                                        VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME);
 
-    // VK_EXT_descriptor_buffer
-    extensions.descriptor_buffer = features.descriptor_buffer.descriptorBuffer;
-    RemoveExtensionFeatureIfUnsuitable(extensions.descriptor_buffer, features.descriptor_buffer,
-                                       VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME);
-
     // VK_EXT_extended_dynamic_state
     extensions.extended_dynamic_state = features.extended_dynamic_state.extendedDynamicState;
     RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state,
@@ -1540,27 +1467,12 @@ void Device::CollectPhysicalMemoryInfo() {
     device_access_memory = 0;
     u64 device_initial_usage = 0;
     u64 local_memory = 0;
-    const auto heap_has_usable_type = [&mem_properties](size_t heap) {
-        for (u32 index = 0; index < mem_properties.memoryTypeCount; ++index) {
-            if (mem_properties.memoryTypes[index].heapIndex != heap) {
-                continue;
-            }
-            if ((mem_properties.memoryTypes[index].propertyFlags &
-                 VK_MEMORY_PROPERTY_PROTECTED_BIT) == 0) {
-                return true;
-            }
-        }
-        return false;
-    };
     for (size_t element = 0; element < num_properties; ++element) {
         const bool is_heap_local =
             (mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0;
         if (!is_integrated && !is_heap_local) {
             continue;
         }
-        if (!heap_has_usable_type(element)) {
-            continue;
-        }
         valid_heap_memory.push_back(element);
         if (is_heap_local) {
             local_memory += mem_properties.memoryHeaps[element].size;
@@ -1572,13 +1484,6 @@ void Device::CollectPhysicalMemoryInfo() {
         }
         device_access_memory += mem_properties.memoryHeaps[element].size;
     }
-    const u64 committed_backing = Common::GetCommittedBackingSize();
-    if (committed_backing != 0) {
-        LOG_INFO(Render_Vulkan, "Discounting {} MiB of guest memory committed by the host",
-                 committed_backing >> 20);
-        local_memory -= std::min(local_memory, committed_backing);
-        device_access_memory -= std::min(device_access_memory, committed_backing);
-    }
     if (is_integrated) {
         const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);
         const u64 memory_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Aggressive ? 6_GiB : 4_GiB;

src/video_core/vulkan_common/vulkan_device.h

@@ -36,7 +36,6 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(EXT, DescriptorIndexing, DESCRIPTOR_INDEXING, descriptor_indexing)                     \
     FEATURE(EXT, HostQueryReset, HOST_QUERY_RESET, host_query_reset)                               \
     FEATURE(KHR, 8BitStorage, 8BIT_STORAGE, bit8_storage)                                          \
-    FEATURE(KHR, BufferDeviceAddress, BUFFER_DEVICE_ADDRESS, buffer_device_address)                \
     FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
 
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
@@ -56,7 +55,6 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
     FEATURE(EXT, DepthBiasControl, DEPTH_BIAS_CONTROL, depth_bias_control)                         \
     FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
-    FEATURE(EXT, DescriptorBuffer, DESCRIPTOR_BUFFER, descriptor_buffer)                           \
     FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
     FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
     FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
@@ -74,16 +72,16 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
             pipeline_executable_properties)                                                        \
     FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)
+            workgroup_memory_explicit_layout)                                                      \
+    FEATURE(EXT, TextureCompressionASTCHDR, TEXTURE_COMPRESSION_ASTC_HDR,                          \
+            texture_compression_astc_hdr)
 
 
 // Define miscellaneous extensions which may be used by the implementation here.
 #define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
-    EXTENSION(EXT, ASTC_DECODE_MODE, astc_decode_mode)                                             \
     EXTENSION(EXT, CONDITIONAL_RENDERING, conditional_rendering)                                   \
     EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
     EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
-    EXTENSION(EXT, EXTERNAL_MEMORY_HOST, external_memory_host)                                     \
     EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
     EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
     EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
@@ -113,14 +111,6 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(IMG, FILTER_CUBIC, filter_cubic_img)                                                 \
     EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
 
-#ifdef __ANDROID__
-#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)                                                  \
-    EXTENSION(EXT, QUEUE_FAMILY_FOREIGN, queue_family_foreign)                                     \
-    EXTENSION(ANDROID, EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER, external_memory_ahb)
-#else
-#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)
-#endif
-
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
     EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
@@ -186,8 +176,6 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE_NAME(depth_bias_control, depthBiasControl)                                             \
     FEATURE_NAME(depth_bias_control, leastRepresentableValueForceUnormRepresentation)              \
     FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
-    FEATURE_NAME(descriptor_indexing, descriptorBindingPartiallyBound)                             \
-    FEATURE_NAME(descriptor_indexing, shaderSampledImageArrayNonUniformIndexing)                   \
     FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
     FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
     FEATURE_NAME(robust_image_access, robustImageAccess)                                           \
@@ -381,7 +369,8 @@ FN_MAX_LIMIT_LIST
     }
 
     bool IsOptimalAstcSupported() const {
-        return is_optimal_astc_supported;
+        return features.features.textureCompressionASTC_LDR &&
+               features.texture_compression_astc_hdr.textureCompressionASTC_HDR;
     }
 
     /// Returns true if BCn is natively supported.
@@ -396,7 +385,7 @@ FN_MAX_LIMIT_LIST
 
     /// Returns true if descriptor aliasing is natively supported.
     bool IsDescriptorAliasingSupported() const {
-        return !has_broken_descriptor_aliasing;
+        return GetDriverID() != VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
     }
 
     bool IsSampledImageArrayNonUniformIndexingSupported() const {
@@ -479,26 +468,6 @@ FN_MAX_LIMIT_LIST
         return properties.push_descriptor.maxPushDescriptors;
     }
 
-    /// Returns true if robust buffer access is enabled on the device.
-    bool IsRobustBufferAccessEnabled() const {
-        return features.features.robustBufferAccess == VK_TRUE;
-    }
-
-    /// Returns true if the device supports descriptor buffers.
-    bool IsExtDescriptorBufferSupported() const {
-        return extensions.descriptor_buffer;
-    }
-
-    /// Returns the descriptor buffer properties of the device.
-    const VkPhysicalDeviceDescriptorBufferPropertiesEXT& DescriptorBufferProperties() const {
-        return properties.descriptor_buffer;
-    }
-
-    /// Returns true if the device supports buffer device address.
-    bool IsBufferDeviceAddressSupported() const {
-        return extensions.buffer_device_address;
-    }
-
     /// Returns true if formatless image load is supported.
     bool IsFormatlessImageLoadSupported() const {
         return features.features.shaderStorageImageReadWithoutFormat;
@@ -847,39 +816,6 @@ FN_MAX_LIMIT_LIST
         return extensions.conditional_rendering;
     }
 
-    bool IsExtExternalMemoryHostSupported() const {
-        return extensions.external_memory_host;
-    }
-
-    bool IsExtExternalMemoryAhbSupported() const {
-#ifdef __ANDROID__
-        return extensions.external_memory_ahb && extensions.queue_family_foreign;
-#else
-        return false;
-#endif
-    }
-
-    u64 GetMinImportedHostPointerAlignment() const {
-        return properties.external_memory_host.minImportedHostPointerAlignment;
-    }
-
-    u64 GetMaxBufferSize() const {
-        return properties.maintenance4.maxBufferSize;
-    }
-
-    u64 GetMaxMemoryAllocationSize() const {
-        return properties.maintenance3.maxMemoryAllocationSize;
-    }
-
-    bool IsExtAstcDecodeModeSupported() const {
-        return extensions.astc_decode_mode;
-    }
-
-    /// Returns true if descriptor bindings is partially bound.
-    bool IsDescriptorBindingPartiallyBoundSupported() const {
-        return features.descriptor_indexing.descriptorBindingPartiallyBound;
-    }
-
     bool HasTimelineSemaphore() const;
 
     /// Returns true if the device supports VK_KHR_synchronization2.
@@ -1143,7 +1079,6 @@ private:
         FOR_EACH_VK_FEATURE_1_4(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
-        FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
 #undef EXTENSION
 #undef FEATURE
@@ -1172,13 +1107,9 @@ private:
         VkPhysicalDeviceSubgroupProperties subgroup_properties{};
         VkPhysicalDeviceFloatControlsProperties float_controls{};
         VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
-        VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
-        VkPhysicalDeviceMaintenance3Properties maintenance3{};
-        VkPhysicalDeviceMaintenance4Properties maintenance4{};
         VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
-        VkPhysicalDeviceExternalMemoryHostPropertiesEXT external_memory_host{};
 
         VkPhysicalDeviceProperties properties{};
     };
@@ -1200,7 +1131,6 @@ private:
     bool is_non_gpu{};                         ///< Is SoftwareRasterizer, FPGA, non-GPU device.
     bool has_broken_compute{};                 ///< Compute shaders can cause crashes
     bool has_broken_cube_compatibility{};      ///< Has broken cube compatibility bit
-    bool has_broken_descriptor_aliasing{};     ///< Miscompiles descriptors aliased on one binding
     bool has_broken_parallel_compiling{};      ///< Has broken parallel shader compiling.
     bool has_renderdoc{};                      ///< Has RenderDoc attached
     bool has_nsight_graphics{};                ///< Has Nsight Graphics attached

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -25,34 +25,9 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 #include "common/settings.h"
 
-#ifdef __ANDROID__
-#include <android/hardware_buffer.h>
-#endif
-
 namespace Vulkan {
     namespace {
 
-        [[nodiscard]] std::optional<u32> FindImportMemoryType(
-                const VkPhysicalDeviceMemoryProperties &props, u32 type_mask) {
-            const auto find = [&](VkMemoryPropertyFlags wanted) -> std::optional<u32> {
-                for (u32 i = 0; i < props.memoryTypeCount; ++i) {
-                    if (((type_mask >> i) & 1u) != 0 &&
-                        (props.memoryTypes[i].propertyFlags & wanted) == wanted) {
-                        return i;
-                    }
-                }
-                return std::nullopt;
-            };
-            auto type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
-                                   VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
-            if (!type_index) {
-                type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                                  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
-            }
-            return type_index;
-        }
-
 // Helpers translating MemoryUsage to flags/usage
 
         [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
@@ -225,263 +200,6 @@ namespace Vulkan {
         size = 0;
     }
 
-    HostMemoryImport::HostMemoryImport(const Device &device_, void *base, size_t size,
-                                       std::span<AHardwareBuffer *const> hardware_buffers,
-                                       size_t hardware_buffer_window, size_t hardware_buffer_base)
-            : device{device_} {
-        if (ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, hardware_buffer_base,
-                                  size)) {
-            return;
-        }
-        if (device.IsTiler()) {
-            return;
-        }
-        if (!hardware_buffers.empty()) {
-            return;
-        }
-        if (ImportHostPointer(base, size)) {
-            return;
-        }
-        LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
-    }
-
-    bool HostMemoryImport::ImportHostPointer(void *base, size_t size) {
-        if (!device.IsExtExternalMemoryHostSupported()) {
-            return false;
-        }
-        const u64 alignment = device.GetMinImportedHostPointerAlignment();
-        if (alignment == 0 || !Common::IsAligned(reinterpret_cast<uintptr_t>(base), alignment) ||
-            !Common::IsAligned(size, alignment)) {
-            return false;
-        }
-        using namespace Common::Literals;
-        constexpr VkDeviceSize DesktopWindowSize = 4_GiB;
-        VkDeviceSize candidate_window = DesktopWindowSize;
-        const u64 max_buffer_size = device.GetMaxBufferSize();
-        if (max_buffer_size != 0 && max_buffer_size < candidate_window) {
-            candidate_window = max_buffer_size;
-        }
-        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
-        if (max_allocation_size != 0 && max_allocation_size < candidate_window) {
-            candidate_window = max_allocation_size;
-        }
-        candidate_window = Common::AlignDown(candidate_window, alignment);
-        if (candidate_window == 0) {
-            return false;
-        }
-        window_size = candidate_window;
-
-        const auto &logical = device.GetLogical();
-        const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
-
-        for (size_t offset = 0; offset < size; offset += window_size) {
-            u8 *const window_base = static_cast<u8 *>(base) + offset;
-            const VkDeviceSize window_len =
-                    (std::min)(static_cast<VkDeviceSize>(size - offset), window_size);
-            VkMemoryHostPointerPropertiesEXT host_props{
-                    .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
-                    .pNext = nullptr,
-                    .memoryTypeBits = 0,
-            };
-            if (logical.GetMemoryHostPointerPropertiesEXT(
-                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, window_base,
-                        &host_props) != VK_SUCCESS ||
-                host_props.memoryTypeBits == 0) {
-                break;
-            }
-            const VkExternalMemoryBufferCreateInfo external_info{
-                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
-                    .pNext = nullptr,
-                    .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
-            };
-            const VkBufferCreateInfo buffer_ci{
-                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-                    .pNext = &external_info,
-                    .flags = 0,
-                    .size = window_len,
-                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-                    .queueFamilyIndexCount = 0,
-                    .pQueueFamilyIndices = nullptr,
-            };
-            VkBuffer new_buffer{};
-            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
-                break;
-            }
-            const VkMemoryRequirements requirements =
-                    logical.GetBufferMemoryRequirements(new_buffer);
-            const u32 type_mask = requirements.memoryTypeBits & host_props.memoryTypeBits;
-            if (type_mask == 0 || requirements.size > window_len) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            const auto type_index = FindImportMemoryType(memory_props, type_mask);
-            if (!type_index) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            const u32 heap_index = memory_props.memoryTypes[*type_index].heapIndex;
-            const VkDeviceSize heap_size = memory_props.memoryHeaps[heap_index].size;
-            if (imported_size + window_len > heap_size / 2) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            const VkImportMemoryHostPointerInfoEXT import_info{
-                    .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
-                    .pNext = nullptr,
-                    .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
-                    .pHostPointer = window_base,
-            };
-            const VkMemoryAllocateInfo alloc_info{
-                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-                    .pNext = &import_info,
-                    .allocationSize = window_len,
-                    .memoryTypeIndex = *type_index,
-            };
-            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
-            if (!memory) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            windows.push_back(Window{
-                    .memory = std::move(memory),
-                    .buffer = new_buffer,
-            });
-            imported_size += static_cast<size_t>(window_len);
-        }
-        if (windows.empty()) {
-            return false;
-        }
-        return true;
-    }
-
-    bool HostMemoryImport::ImportHardwareBuffers(
-            [[maybe_unused]] std::span<AHardwareBuffer *const> hardware_buffers,
-            [[maybe_unused]] size_t hardware_buffer_window,
-            [[maybe_unused]] size_t hardware_buffer_base, [[maybe_unused]] size_t size) {
-#ifdef __ANDROID__
-        if (hardware_buffers.empty() || hardware_buffer_window == 0 ||
-            !device.IsExtExternalMemoryAhbSupported()) {
-            return false;
-        }
-        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
-        if (max_allocation_size != 0 && hardware_buffer_window > max_allocation_size) {
-            return false;
-        }
-        if (hardware_buffer_base >= size) {
-            return false;
-        }
-        const auto &logical = device.GetLogical();
-        const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
-        window_size = hardware_buffer_window;
-        base_offset = hardware_buffer_base;
-        for (size_t i = 0; i < hardware_buffers.size(); ++i) {
-            const size_t offset = hardware_buffer_base + i * hardware_buffer_window;
-            if (offset >= size) {
-                break;
-            }
-            const VkDeviceSize window_len = (std::min)(
-                    static_cast<VkDeviceSize>(size - offset),
-                    static_cast<VkDeviceSize>(hardware_buffer_window));
-            VkAndroidHardwareBufferPropertiesANDROID ahb_props{
-                    .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
-                    .pNext = nullptr,
-                    .allocationSize = 0,
-                    .memoryTypeBits = 0,
-            };
-            if (logical.GetAndroidHardwareBufferPropertiesANDROID(hardware_buffers[i],
-                                                                  &ahb_props) != VK_SUCCESS ||
-                ahb_props.memoryTypeBits == 0 || ahb_props.allocationSize < window_len) {
-                break;
-            }
-            const VkExternalMemoryBufferCreateInfo external_info{
-                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
-                    .pNext = nullptr,
-                    .handleTypes =
-                            VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
-            };
-            const VkBufferCreateInfo buffer_ci{
-                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-                    .pNext = &external_info,
-                    .flags = 0,
-                    .size = window_len,
-                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-                    .queueFamilyIndexCount = 0,
-                    .pQueueFamilyIndices = nullptr,
-            };
-            VkBuffer new_buffer{};
-            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
-                break;
-            }
-            const VkMemoryRequirements requirements =
-                    logical.GetBufferMemoryRequirements(new_buffer);
-            const u32 type_mask = requirements.memoryTypeBits & ahb_props.memoryTypeBits;
-            if (type_mask == 0 || requirements.size > ahb_props.allocationSize) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            const auto type_index = FindImportMemoryType(memory_props, type_mask);
-            if (!type_index) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            const VkImportAndroidHardwareBufferInfoANDROID import_info{
-                    .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
-                    .pNext = nullptr,
-                    .buffer = hardware_buffers[i],
-            };
-            const VkMemoryDedicatedAllocateInfo dedicated_info{
-                    .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
-                    .pNext = &import_info,
-                    .image = VK_NULL_HANDLE,
-                    .buffer = new_buffer,
-            };
-            const VkMemoryAllocateInfo alloc_info{
-                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-                    .pNext = &dedicated_info,
-                    .allocationSize = ahb_props.allocationSize,
-                    .memoryTypeIndex = *type_index,
-            };
-            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
-            if (!memory) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
-                logical.DestroyBufferRaw(new_buffer);
-                break;
-            }
-            windows.push_back(Window{
-                    .memory = std::move(memory),
-                    .buffer = new_buffer,
-            });
-            imported_size += static_cast<size_t>(window_len);
-        }
-        if (windows.empty()) {
-            window_size = 0;
-            base_offset = 0;
-            return false;
-        }
-        foreign_ownership = true;
-        return true;
-#else
-        return false;
-#endif
-    }
-
-    HostMemoryImport::~HostMemoryImport() {
-        for (Window &window : windows) {
-            if (window.buffer != VK_NULL_HANDLE) {
-                device.GetLogical().DestroyBufferRaw(window.buffer);
-            }
-        }
-    }
-
     MemoryAllocator::MemoryAllocator(const Device &device_)
             : device{device_}, allocator{device.GetAllocator()},
               properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},

src/video_core/vulkan_common/vulkan_memory_allocator.h

@@ -15,8 +15,6 @@
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 #include "video_core/vulkan_common/vma.h"
 
-struct AHardwareBuffer;
-
 namespace Vulkan {
 
     class Device;
@@ -86,66 +84,6 @@ namespace Vulkan {
         void *mapped_ptr{};  ///< Optional persistent mapped pointer
     };
 
-    class HostMemoryImport {
-    public:
-        explicit HostMemoryImport(const Device &device_, void *base, size_t size,
-                                  std::span<AHardwareBuffer *const> hardware_buffers,
-                                  size_t hardware_buffer_window, size_t hardware_buffer_base);
-
-        ~HostMemoryImport();
-
-        HostMemoryImport(const HostMemoryImport &) = delete;
-
-        HostMemoryImport &operator=(const HostMemoryImport &) = delete;
-
-        [[nodiscard]] bool IsValid() const noexcept {
-            return !windows.empty();
-        }
-
-        [[nodiscard]] size_t GetSize() const noexcept {
-            return imported_size;
-        }
-
-        [[nodiscard]] size_t GetBaseOffset() const noexcept {
-            return base_offset;
-        }
-
-        [[nodiscard]] bool NeedsForeignOwnershipTransfer() const noexcept {
-            return foreign_ownership;
-        }
-
-        [[nodiscard]] VkDeviceSize GetWindowSize() const noexcept {
-            return window_size;
-        }
-
-        [[nodiscard]] VkBuffer GetWindowBuffer(size_t index) const noexcept {
-            return windows[index].buffer;
-        }
-
-        [[nodiscard]] size_t GetWindowCount() const noexcept {
-            return windows.size();
-        }
-
-    private:
-        struct Window {
-            vk::DeviceMemory memory;
-            VkBuffer buffer{};
-        };
-
-        bool ImportHostPointer(void *base, size_t size);
-
-        bool ImportHardwareBuffers(std::span<AHardwareBuffer *const> hardware_buffers,
-                                   size_t hardware_buffer_window, size_t hardware_buffer_base,
-                                   size_t size);
-
-        const Device &device;
-        std::vector<Window> windows;
-        VkDeviceSize window_size{};
-        size_t imported_size{};
-        size_t base_offset{};
-        bool foreign_ownership{};
-    };
-
 /// Memory allocator container.
 /// Allocates and releases memory allocations on demand.
     class MemoryAllocator {

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -216,16 +216,12 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetBufferMemoryRequirements2);
     X(vkGetDeviceQueue);
     X(vkGetEventStatus);
-    X(vkGetMemoryHostPointerPropertiesEXT);
     X(vkGetFenceStatus);
     X(vkGetImageMemoryRequirements);
     X(vkGetPipelineCacheData);
     X(vkGetMemoryFdKHR);
 #ifdef _WIN32
     X(vkGetMemoryWin32HandleKHR);
-#endif
-#ifdef __ANDROID__
-    X(vkGetAndroidHardwareBufferPropertiesANDROID);
 #endif
     X(vkGetQueryPoolResults);
     X(vkGetPipelineExecutablePropertiesKHR);
@@ -241,12 +237,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkUnmapMemory);
     X(vkUpdateDescriptorSetWithTemplate);
     X(vkUpdateDescriptorSets);
-    X(vkGetBufferDeviceAddress);
-    X(vkGetDescriptorSetLayoutSizeEXT);
-    X(vkGetDescriptorSetLayoutBindingOffsetEXT);
-    X(vkGetDescriptorEXT);
-    X(vkCmdBindDescriptorBuffersEXT);
-    X(vkCmdSetDescriptorBufferOffsetsEXT);
     X(vkWaitForFences);
     X(vkWaitSemaphores);
 

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -332,16 +332,12 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2{};
     PFN_vkGetDeviceQueue vkGetDeviceQueue{};
     PFN_vkGetEventStatus vkGetEventStatus{};
-    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT{};
     PFN_vkGetFenceStatus vkGetFenceStatus{};
     PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
     PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
     PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
     PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
-#endif
-#ifdef __ANDROID__
-    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID{};
 #endif
     PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR{};
     PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR{};
@@ -356,12 +352,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT{};
     PFN_vkUnmapMemory vkUnmapMemory{};
     PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate{};
-    PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress{};
-    PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT{};
-    PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT{};
-    PFN_vkGetDescriptorEXT vkGetDescriptorEXT{};
-    PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT{};
-    PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT{};
     PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets{};
     PFN_vkWaitForFences vkWaitForFences{};
     PFN_vkWaitSemaphores vkWaitSemaphores{};
@@ -803,11 +793,6 @@ public:
         return !mapped.empty();
     }
 
-    /// Returns true if host writes are visible to the device.
-    bool IsHostCoherent() const noexcept {
-        return is_coherent;
-    }
-
     void Flush() const;
 
     void Invalidate() const;
@@ -1086,34 +1071,6 @@ public:
     VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer buffer,
                                                      void* pnext = nullptr) const noexcept;
 
-    VkResult GetMemoryHostPointerPropertiesEXT(
-        VkExternalMemoryHandleTypeFlagBits handle_type, const void* host_pointer,
-        VkMemoryHostPointerPropertiesEXT* out_properties) const noexcept {
-        return dld->vkGetMemoryHostPointerPropertiesEXT(handle, handle_type, host_pointer,
-                                                        out_properties);
-    }
-
-#ifdef __ANDROID__
-    VkResult GetAndroidHardwareBufferPropertiesANDROID(
-        const struct AHardwareBuffer* buffer,
-        VkAndroidHardwareBufferPropertiesANDROID* out_properties) const noexcept {
-        return dld->vkGetAndroidHardwareBufferPropertiesANDROID(handle, buffer, out_properties);
-    }
-#endif
-
-    VkResult CreateBufferRaw(const VkBufferCreateInfo& ci, VkBuffer* out_buffer) const noexcept {
-        return dld->vkCreateBuffer(handle, &ci, nullptr, out_buffer);
-    }
-
-    void DestroyBufferRaw(VkBuffer buffer) const noexcept {
-        dld->vkDestroyBuffer(handle, buffer, nullptr);
-    }
-
-    VkResult BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory,
-                              VkDeviceSize offset) const noexcept {
-        return dld->vkBindBufferMemory(handle, buffer, memory, offset);
-    }
-
     VkMemoryRequirements GetImageMemoryRequirements(VkImage image) const noexcept;
 
     std::vector<VkPipelineExecutablePropertiesKHR> GetPipelineExecutablePropertiesKHR(
@@ -1130,34 +1087,6 @@ public:
         dld->vkUpdateDescriptorSetWithTemplate(handle, set, update_template, data);
     }
 
-    [[nodiscard]] VkDeviceAddress GetBufferDeviceAddress(VkBuffer buffer) const noexcept {
-        const VkBufferDeviceAddressInfo info{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
-            .pNext = nullptr,
-            .buffer = buffer,
-        };
-        return dld->vkGetBufferDeviceAddress(handle, &info);
-    }
-
-    [[nodiscard]] VkDeviceSize GetDescriptorSetLayoutSizeEXT(
-        VkDescriptorSetLayout layout) const noexcept {
-        VkDeviceSize size{};
-        dld->vkGetDescriptorSetLayoutSizeEXT(handle, layout, &size);
-        return size;
-    }
-
-    [[nodiscard]] VkDeviceSize GetDescriptorSetLayoutBindingOffsetEXT(
-        VkDescriptorSetLayout layout, u32 binding) const noexcept {
-        VkDeviceSize offset{};
-        dld->vkGetDescriptorSetLayoutBindingOffsetEXT(handle, layout, binding, &offset);
-        return offset;
-    }
-
-    void GetDescriptorEXT(const VkDescriptorGetInfoEXT& info, size_t size,
-                          void* descriptor) const noexcept {
-        dld->vkGetDescriptorEXT(handle, &info, size, descriptor);
-    }
-
     VkResult AcquireNextImageKHR(VkSwapchainKHR swapchain, u64 timeout, VkSemaphore semaphore,
                                  VkFence fence, u32* image_index) const noexcept {
         return dld->vkAcquireNextImageKHR(handle, swapchain, timeout, semaphore, fence,
@@ -1471,18 +1400,6 @@ public:
         PipelineBarrier(src_stage_mask, dst_stage_mask, dependency_flags, {}, {}, image_barrier);
     }
 
-    void BindDescriptorBuffersEXT(Span<VkDescriptorBufferBindingInfoEXT> bindings) const noexcept {
-        dld->vkCmdBindDescriptorBuffersEXT(handle, bindings.size(), bindings.data());
-    }
-
-    void SetDescriptorBufferOffsetsEXT(VkPipelineBindPoint bind_point, VkPipelineLayout layout,
-                                       u32 first_set, Span<u32> buffer_indices,
-                                       Span<VkDeviceSize> offsets) const noexcept {
-        dld->vkCmdSetDescriptorBufferOffsetsEXT(handle, bind_point, layout, first_set,
-                                                buffer_indices.size(), buffer_indices.data(),
-                                                offsets.data());
-    }
-
     void CopyBufferToImage(VkBuffer src_buffer, VkImage dst_image, VkImageLayout dst_image_layout,
                            Span<VkBufferImageCopy> regions) const noexcept {
         dld->vkCmdCopyBufferToImage(handle, src_buffer, dst_image, dst_image_layout, regions.size(),

src/yuzu/configuration/configure_cpu.cpp

@@ -76,7 +76,8 @@ 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.cpu_ticks.Id()) {
+        } else if (setting->Id() == Settings::values.fast_cpu_time.Id() ||
+                   setting->Id() == Settings::values.cpu_ticks.Id()) {
             ui->general_layout->addWidget(widget);
         } else {
             // Presently, all other settings here are unsafe checkboxes