return release early fences

Thanks, Debian.

Signed-off-by: crueter <crueter@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3539

CMakeModules/CPMUtil.cmake

@@ -84,7 +84,11 @@ function(SystemPackageViable JSON_NAME)
     parse_object(${object})
 
     string(REPLACE " " ";" find_args "${find_args}")
-    find_package(${package} ${version} ${find_args} QUIET NO_POLICY_SCOPE)
+    if (${package}_FORCE_BUNDLED)
+        set(${package}_FOUND OFF)
+    else()
+        find_package(${package} ${version} ${find_args} QUIET NO_POLICY_SCOPE)
+    endif()
 
     set(${pkg}_VIABLE ${${package}_FOUND} PARENT_SCOPE)
     set(${pkg}_PACKAGE ${package} PARENT_SCOPE)

externals/cpmfile.json

@@ -150,7 +150,7 @@
         "package": "SDL2",
         "name": "SDL2",
         "repo": "crueter-ci/SDL2",
-        "version": "2.32.10-a65111bd2d",
+        "version": "2.32.10-cf5dabd6ea",
         "min_version": "2.26.4"
     },
     "catch2": {
@@ -184,7 +184,6 @@
         "repo": "libsdl-org/SDL",
         "tag": "release-%VERSION%",
         "hash": "d5622d6bb7266f7942a7b8ad43e8a22524893bf0c2ea1af91204838d9b78d32768843f6faa248757427b8404b8c6443776d4afa6b672cd8571a4e0c03a829383",
-        "key": "generic",
         "bundled": true,
         "git_version": "2.32.10",
         "skip_updates": true
@@ -194,7 +193,6 @@
         "repo": "libsdl-org/SDL",
         "sha": "cc016b0046",
         "hash": "b8d9873446cdb922387471df9968e078714683046674ef0d0edddf8e25da65a539a3bae83d635496b970237f90b07b36a69f8d7855d450de59311d6d6e8c3dbc",
-        "key": "steamdeck",
         "bundled": true,
         "skip_updates": "true"
     },

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

@@ -23,6 +23,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_USE_DISK_SHADER_CACHE("use_disk_shader_cache"),
     RENDERER_FORCE_MAX_CLOCK("force_max_clock"),
     RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_EARLY_RELEASE_FENCES("early_release_fences"),
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),

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

@@ -679,6 +679,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.renderer_asynchronous_shaders_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_EARLY_RELEASE_FENCES,
+                    titleId = R.string.renderer_early_release_fences,
+                    descriptionId = R.string.renderer_early_release_fences_description
+                )
+            )
             put(
                 SingleChoiceSetting(
                     IntSetting.FAST_GPU_TIME,

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

@@ -285,6 +285,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_EARLY_RELEASE_FENCES.key)
             add(SettingsItem.GPU_UNSWIZZLE_COMBINED)
 
             add(HeaderSetting(R.string.extensions))

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

@@ -510,6 +510,8 @@
     <string name="fix_bloom_effects_description">Reduces bloom blur in LA/EOW (Adreno 700), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</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_early_release_fences">Release Fences Early</string>
+    <string name="renderer_early_release_fences_description">Fixes crashes and freezes in some games, may cause issues with Unreal Engine games.</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>

src/common/settings.h

@@ -546,6 +546,16 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
+#ifdef ANDROID
+    SwitchableSetting<bool> early_release_fences{linkage,
+                                                     false,
+                                                     "early_release_fences",
+                                                     Category::RendererAdvanced,
+                                                     Specialization::Default,
+                                                     true,
+                                                     true};
+#endif
+
     SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                   GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",
@@ -568,13 +578,7 @@ struct Values {
                                                   Category::RendererHacks};
 
     SwitchableSetting<ExtendedDynamicState> dyna_state{linkage,
-#if defined (_WIN32)
-                                           ExtendedDynamicState::EDS3,
-#elif defined (__FreeBSD__)
-                                           ExtendedDynamicState::EDS3,
-#elif defined (ANDROID)
-                                           ExtendedDynamicState::Disabled,
-#elif defined (__APPLE__)
+#if defined (ANDROID) || defined (__APPLE__)
                                            ExtendedDynamicState::Disabled,
 #else
                                            ExtendedDynamicState::EDS2,

src/dynarmic/src/dynarmic/backend/x64/a32_interface.cpp

@@ -65,11 +65,10 @@ static Optimization::PolyfillOptions GenPolyfillOptions(const BlockOfCode& code)
 
 struct Jit::Impl {
     Impl(Jit* jit, A32::UserConfig conf) noexcept
-        : ir_block{LocationDescriptor(0, PSR(0), FPSCR(0), false)}
-        , conf(std::move(conf))
-        , block_of_code(GenRunCodeCallbacks(conf.callbacks, &GetCurrentBlockThunk, this, conf), JitStateInfo{jit_state}, conf.code_cache_size, GenRCP(conf))
+        : block_of_code(GenRunCodeCallbacks(conf.callbacks, &GetCurrentBlockThunk, this, conf), JitStateInfo{jit_state}, conf.code_cache_size, GenRCP(conf))
         , emitter(block_of_code, conf, jit)
         , polyfill_options(GenPolyfillOptions(block_of_code))
+        , conf(std::move(conf))
         , jit_interface(jit)
     {}
 
@@ -204,8 +203,7 @@ private:
     }
 
     A32EmitX64::BlockDescriptor GetBasicBlock(IR::LocationDescriptor descriptor) {
-        auto block = emitter.GetBasicBlock(descriptor);
-        if (block)
+        if (auto block = emitter.GetBasicBlock(descriptor))
             return *block;
 
         constexpr size_t MINIMUM_REMAINING_CODESIZE = 1 * 1024 * 1024;
@@ -215,8 +213,10 @@ private:
         }
         block_of_code.EnsureMemoryCommitted(MINIMUM_REMAINING_CODESIZE);
 
-        ir_block.Reset(descriptor);
-        A32::Translate(ir_block, A32::LocationDescriptor{descriptor}, conf.callbacks, {conf.arch_version, conf.define_unpredictable_behaviour, conf.hook_hint_instructions});
+        // LocationDescriptor ctor() does important ops (like tflags) do not skip
+        auto const arch_descriptor = A32::LocationDescriptor{descriptor};
+        ir_block.Reset(arch_descriptor);
+        A32::Translate(ir_block, arch_descriptor, conf.callbacks, {conf.arch_version, conf.define_unpredictable_behaviour, conf.hook_hint_instructions});
         Optimization::Optimize(ir_block, conf, polyfill_options);
         return emitter.Emit(ir_block);
     }
@@ -243,12 +243,13 @@ private:
         }
     }
 
-    IR::Block ir_block;
-    const A32::UserConfig conf;
+    IR::Block ir_block = {LocationDescriptor(0, PSR(0), FPSCR(0), false)};
     A32JitState jit_state;
     BlockOfCode block_of_code;
     A32EmitX64 emitter;
     Optimization::PolyfillOptions polyfill_options;
+    // Keep it here, you don't wanna mess with the fuckery that's initializer lists
+    const A32::UserConfig conf;
     Jit* jit_interface;
 
     // Requests made during execution to invalidate the cache are queued up here.

src/dynarmic/src/dynarmic/backend/x64/a64_interface.cpp

@@ -62,8 +62,7 @@ static Optimization::PolyfillOptions GenPolyfillOptions(const BlockOfCode& code)
 struct Jit::Impl final {
 public:
     Impl(Jit* jit, UserConfig conf)
-        : ir_block{LocationDescriptor(0, FP::FPCR(0), false)}
-        , conf(conf)
+        : conf(conf)
         , block_of_code(GenRunCodeCallbacks(conf.callbacks, &GetCurrentBlockThunk, this, conf), JitStateInfo{jit_state}, conf.code_cache_size, GenRCP(conf))
         , emitter(block_of_code, conf, jit)
         , polyfill_options(GenPolyfillOptions(block_of_code))
@@ -257,8 +256,8 @@ private:
         return GetBlock(A64::LocationDescriptor{GetCurrentLocation()}.SetSingleStepping(true));
     }
 
-    CodePtr GetBlock(IR::LocationDescriptor current_location) {
-        if (auto block = emitter.GetBasicBlock(current_location))
+    CodePtr GetBlock(IR::LocationDescriptor descriptor) {
+        if (auto block = emitter.GetBasicBlock(descriptor))
             return block->entrypoint;
 
         constexpr size_t MINIMUM_REMAINING_CODESIZE = 1 * 1024 * 1024;
@@ -271,8 +270,10 @@ private:
 
         // JIT Compile
         const auto get_code = [this](u64 vaddr) { return conf.callbacks->MemoryReadCode(vaddr); };
-        ir_block.Reset(current_location);
-        A64::Translate(ir_block, A64::LocationDescriptor{current_location}, get_code, {conf.define_unpredictable_behaviour, conf.wall_clock_cntpct});
+        // LocationDescriptor ctor() does important ops (like tflags) do not skip
+        auto const arch_descriptor = A64::LocationDescriptor{descriptor};
+        ir_block.Reset(arch_descriptor);
+        A64::Translate(ir_block, arch_descriptor, get_code, {conf.define_unpredictable_behaviour, conf.wall_clock_cntpct});
         Optimization::Optimize(ir_block, conf, polyfill_options);
         return emitter.Emit(ir_block).entrypoint;
     }
@@ -299,7 +300,7 @@ private:
         }
     }
 
-    IR::Block ir_block;
+    IR::Block ir_block = {LocationDescriptor(0, FP::FPCR(0), false)};
     const UserConfig conf;
     A64JitState jit_state;
     BlockOfCode block_of_code;

src/dynarmic/src/dynarmic/ir/basic_block.cpp

@@ -22,13 +22,10 @@
 
 namespace Dynarmic::IR {
 
-Block::Block(const LocationDescriptor& location)
-    : location{location},
-    end_location{location},
-    cond{Cond::AL}
-{
-
-}
+Block::Block(LocationDescriptor location) noexcept
+    : location{location}
+    , end_location{location}
+{}
 
 /// Prepends a new instruction to this basic block before the insertion point,
 /// handling any allocations necessary to do so.
@@ -60,6 +57,21 @@ Block::iterator Block::PrependNewInst(iterator insertion_point, Opcode opcode, s
     return instructions.insert_before(insertion_point, inst);
 }
 
+void Block::Reset(LocationDescriptor location_) noexcept {
+    mcl::intrusive_list<IR::Inst> tmp = {};
+    instructions.swap(tmp);
+    inlined_inst.clear();
+    pooled_inst.clear();
+    cond_failed.reset();
+    location = location_;
+    end_location = location_;
+    cond = Cond::AL;
+    terminal = Term::Invalid{};
+    cond_failed_cycle_count = 0;
+    cycle_count = 0;
+    ASSERT(instructions.size() == 0);
+}
+
 static std::string TerminalToString(const Terminal& terminal_variant) noexcept {
     struct : boost::static_visitor<std::string> {
         std::string operator()(const Term::Invalid&) const {
@@ -123,11 +135,11 @@ std::string DumpBlock(const IR::Block& block) noexcept {
         case Type::A32ExtReg: return A32::ExtRegToString(arg.GetA32ExtRegRef());
         case Type::A64Reg: return A64::RegToString(arg.GetA64RegRef());
         case Type::A64Vec: return A64::VecToString(arg.GetA64VecRef());
-        case Type::CoprocInfo: return fmt::format("#<coproc>");
-        case Type::NZCVFlags: return fmt::format("#<NZCV flags>");
-        case Type::Cond: return fmt::format("#<cond={}>", A32::CondToString(arg.GetCond()));
-        case Type::Table: return fmt::format("#<table>");
-        case Type::AccType: return fmt::format("#<acc-type={}>", u32(arg.GetAccType()));
+        case Type::CoprocInfo: return fmt::format("$coproc{}", arg.GetCoprocInfo()[0]);
+        case Type::NZCVFlags: return fmt::format("$nzcv");
+        case Type::Cond: return fmt::format("$cond={}", A32::CondToString(arg.GetCond()));
+        case Type::Table: return fmt::format("$table");
+        case Type::AccType: return fmt::format("$acc-type={}", u32(arg.GetAccType()));
         default: return fmt::format("<unknown immediate type {}>", arg.GetType());
         }
     };

src/dynarmic/src/dynarmic/ir/basic_block.h

@@ -43,7 +43,7 @@ public:
     using reverse_iterator = instruction_list_type::reverse_iterator;
     using const_reverse_iterator = instruction_list_type::const_reverse_iterator;
 
-    explicit Block(const LocationDescriptor& location);
+    Block(LocationDescriptor location) noexcept;
     ~Block() = default;
     Block(const Block&) = delete;
     Block& operator=(const Block&) = delete;
@@ -58,6 +58,7 @@ public:
         return PrependNewInst(instructions.end(), opcode, args);
     }
     iterator PrependNewInst(iterator insertion_point, Opcode op, std::initializer_list<Value> args) noexcept;
+    void Reset(LocationDescriptor location_) noexcept;
 
     /// Gets a mutable reference to the instruction list for this basic block.
     inline instruction_list_type& Instructions() noexcept {
@@ -140,18 +141,6 @@ public:
         return cycle_count;
     }
 
-    inline void Reset(LocationDescriptor location_) noexcept {
-        inlined_inst.clear();
-        pooled_inst.clear();
-        cond_failed.reset();
-        location = location_;
-        terminal = Term::Invalid{};
-        cond_failed_cycle_count = 0;
-        cycle_count = 0;
-        instruction_list_type tmp{};
-        instructions.swap(tmp);
-    }
-
     /// "Hot cache" for small blocks so we don't call global allocator
     boost::container::static_vector<Inst, 30> inlined_inst;
     /// List of instructions in this block.
@@ -165,7 +154,7 @@ public:
     /// Description of the end location of this block
     LocationDescriptor end_location;
     /// Conditional to pass in order to execute this block
-    Cond cond;
+    Cond cond = Cond::AL;
     /// Terminal instruction of this block.
     Terminal terminal = Term::Invalid{};
     /// Number of cycles this block takes to execute if the conditional fails.

src/dynarmic/src/dynarmic/ir/opt_passes.cpp

@@ -1042,6 +1042,11 @@ static void FoldZeroExtendXToLong(IR::Inst& inst) {
 static void ConstantPropagation(IR::Block& block) {
     for (auto& inst : block.instructions) {
         auto const opcode = inst.GetOpcode();
+        // skip NZCV so we dont end up discarding side effects :)
+        // TODO(lizzie): hey stupid maybe fix the A64 codegen for folded constants AND
+        // redirect the mfer properly?!??! just saying :)
+        if (IR::MayGetNZCVFromOp(opcode) && inst.GetAssociatedPseudoOperation(IR::Opcode::GetNZCVFromOp))
+            continue;
         switch (opcode) {
         case Op::LeastSignificantWord:
             FoldLeastSignificantWord(inst);

src/video_core/fence_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -72,15 +72,26 @@ public:
     }
 
     void SignalFence(std::function<void()>&& func) {
-        if constexpr (!can_async_check) {
-            TryReleasePendingFences<false>();
-        }
+#ifdef ANDROID
+        const bool early_release_fences = Settings::values.early_release_fences.GetValue();
+#else
+        constexpr bool early_release_fences = false;
+#endif
         const bool should_flush = ShouldFlush();
         const bool delay_fence = Settings::IsGPULevelHigh() || (Settings::IsGPULevelMedium() && should_flush);
+        if (!can_async_check || (!delay_fence && early_release_fences)) {
+            TryReleasePendingFences<false>();
+        }
         CommitAsyncFlushes();
         TFence new_fence = CreateFence(!should_flush);
-        if constexpr (can_async_check) {
-            guard.lock();
+        if (!early_release_fences){
+            if constexpr (can_async_check) {
+                guard.lock();
+            }
+        } else {
+            if (delay_fence) {
+                guard.lock();
+            }
         }
         if (delay_fence) {
             uncommitted_operations.emplace_back(std::move(func));
@@ -94,9 +105,16 @@ public:
         if (should_flush) {
             rasterizer.FlushCommands();
         }
-        if constexpr (can_async_check) {
-            guard.unlock();
-            cv.notify_all();
+        if (!early_release_fences){
+            if constexpr (can_async_check) {
+                guard.unlock();
+                cv.notify_all();
+            }
+        } else {
+            if (delay_fence) {
+                guard.unlock();
+                cv.notify_all();
+            }
         }
         rasterizer.InvalidateGPUCache();
     }

src/video_core/renderer_vulkan/vk_master_semaphore.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -243,7 +243,11 @@ void MasterSemaphore::WaitThread(std::stop_token token) {
             free_queue.push_front(std::move(fence));
             gpu_tick.store(host_tick, std::memory_order_release);
         }
+#ifdef ANDROID
         free_cv.notify_all();
+#else
+        free_cv.notify_one();
+#endif
     }
 }