[vk_texture_cashe] improve MSAA copy fallback when specialized pass unavailable

Fix the mouse panning issues

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3181
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Co-authored-by: John <john@eden-emu.dev>
Co-committed-by: John <john@eden-emu.dev>

src/core/memory.cpp

@@ -10,6 +10,7 @@
 #include <mutex>
 #include <span>
 #include <thread>
+#include <type_traits>
 #include <vector>
 
 #include "common/assert.h"
@@ -681,22 +682,17 @@ struct Memory::Impl {
         }
     }
 
-    [[nodiscard]] u8* GetPointerImpl(u64 vaddr, auto on_unmapped, auto on_rasterizer) const {
+    template<typename F, typename G>
+    [[nodiscard]] u8* GetPointerImpl(u64 vaddr, F&& on_unmapped, G&& on_rasterizer) const {
         // AARCH64 masks the upper 16 bit of all memory accesses
-        vaddr = vaddr & 0xffffffffffffULL;
-        if (!AddressSpaceContains(*current_page_table, vaddr, 1)) [[unlikely]] {
-            on_unmapped();
-            return nullptr;
-        } else {
+        vaddr &= 0xffffffffffffULL;
+        if (AddressSpaceContains(*current_page_table, vaddr, 1)) [[likely]] {
             // Avoid adding any extra logic to this fast-path block
             const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Raw();
-            if (const uintptr_t pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            if (const uintptr_t pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) [[likely]] {
                 return reinterpret_cast<u8*>(pointer + vaddr);
             } else {
                 switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
-                case Common::PageType::Unmapped:
-                    on_unmapped();
-                    return nullptr;
                 case Common::PageType::Memory:
                     ASSERT_MSG(false, "Mapped memory page without a pointer @ 0x{:016X}", vaddr);
                     return nullptr;
@@ -707,11 +703,18 @@ struct Memory::Impl {
                     on_rasterizer();
                     return host_ptr;
                 }
+                case Common::PageType::Unmapped: [[unlikely]] {
+                    on_unmapped();
+                    return nullptr;
+                }
                 default:
                     UNREACHABLE();
                 }
                 return nullptr;
             }
+        } else {
+            on_unmapped();
+            return nullptr;
         }
     }
 
@@ -729,172 +732,38 @@ struct Memory::Impl {
             GetInteger(vaddr), []() {}, []() {});
     }
 
-    /**
-     * Reads a particular data type out of memory at the given virtual address.
-     *
-     * @param vaddr The virtual address to read the data type from.
-     *
-     * @tparam T The data type to read out of memory. This type *must* be
-     *           trivially copyable, otherwise the behavior of this function
-     *           is undefined.
-     *
-     * @returns The instance of T read from the specified virtual address.
-     */
+    /// @brief Reads a particular data type out of memory at the given virtual address.
+    /// @param vaddr The virtual address to read the data type from.
+    /// @tparam T The data type to read out of memory.
+    /// @returns The instance of T read from the specified virtual address.
     template <typename T>
-    T Read(Common::ProcessAddress vaddr) {
-        // Fast path for aligned reads of common sizes
+    inline T Read(Common::ProcessAddress vaddr) noexcept requires(std::is_trivially_copyable_v<T>) {
         const u64 addr = GetInteger(vaddr);
-        if constexpr (std::is_same_v<T, u8> || std::is_same_v<T, s8>) {
-            // 8-bit reads are always aligned
-            const u8* const ptr = GetPointerImpl(
-                addr,
-                [addr]() {
-                    LOG_ERROR(HW_Memory, "Unmapped Read8 @ 0x{:016X}", addr);
-                },
-                [&]() { HandleRasterizerDownload(addr, sizeof(T)); });
-            if (ptr) {
-                return static_cast<T>(*ptr);
-            }
-            return 0;
-        } else if constexpr (std::is_same_v<T, u16_le> || std::is_same_v<T, s16_le>) {
-            // Check alignment for 16-bit reads
-            if ((addr & 1) == 0) {
-                const u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Read16 @ 0x{:016X}", addr);
-                    },
-                    [&]() { HandleRasterizerDownload(addr, sizeof(T)); });
-                if (ptr) {
-                    return static_cast<T>(*reinterpret_cast<const u16*>(ptr));
-                }
-            }
-        } else if constexpr (std::is_same_v<T, u32_le> || std::is_same_v<T, s32_le>) {
-            // Check alignment for 32-bit reads
-            if ((addr & 3) == 0) {
-                const u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Read32 @ 0x{:016X}", addr);
-                    },
-                    [&]() { HandleRasterizerDownload(addr, sizeof(T)); });
-                if (ptr) {
-                    return static_cast<T>(*reinterpret_cast<const u32*>(ptr));
-                }
-            }
-        } else if constexpr (std::is_same_v<T, u64_le> || std::is_same_v<T, s64_le>) {
-            // Check alignment for 64-bit reads
-            if ((addr & 7) == 0) {
-                const u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Read64 @ 0x{:016X}", addr);
-                    },
-                    [&]() { HandleRasterizerDownload(addr, sizeof(T)); });
-                if (ptr) {
-                    return static_cast<T>(*reinterpret_cast<const u64*>(ptr));
-                }
-            }
-        }
-
-        // Fall back to the general case for other types or unaligned access
-        T result = 0;
-        const u8* const ptr = GetPointerImpl(
-            addr,
-            [addr]() {
-                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr);
-            },
-            [&]() { HandleRasterizerDownload(addr, sizeof(T)); });
-        if (ptr) {
+        if (auto const ptr = GetPointerImpl(addr, [addr]() {
+            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr);
+        }, [&]() {
+            HandleRasterizerDownload(addr, sizeof(T));
+        }); ptr) [[likely]] {
+            // It may be tempting to rewrite this particular section to use "reinterpret_cast";
+            // afterall, it's trivially copyable so surely it can be copied ov- Alignment.
+            // Remember, alignment. memcpy() will deal with all the alignment extremely fast.
+            T result{};
             std::memcpy(&result, ptr, sizeof(T));
+            return result;
         }
-        return result;
+        return T{};
     }
 
-    /**
-     * Writes a particular data type to memory at the given virtual address.
-     *
-     * @param vaddr The virtual address to write the data type to.
-     *
-     * @tparam T The data type to write to memory. This type *must* be
-     *           trivially copyable, otherwise the behavior of this function
-     *           is undefined.
-     */
+    /// @brief Writes a particular data type to memory at the given virtual address.
+    /// @param vaddr The virtual address to write the data type to.
+    /// @tparam T The data type to write to memory.
     template <typename T>
-    void Write(Common::ProcessAddress vaddr, const T data) {
-        // Fast path for aligned writes of common sizes
+    inline void Write(Common::ProcessAddress vaddr, const T data) noexcept requires(std::is_trivially_copyable_v<T>) {
         const u64 addr = GetInteger(vaddr);
-        if constexpr (std::is_same_v<T, u8> || std::is_same_v<T, s8>) {
-            // 8-bit writes are always aligned
-            u8* const ptr = GetPointerImpl(
-                addr,
-                [addr, data]() {
-                    LOG_ERROR(HW_Memory, "Unmapped Write8 @ 0x{:016X} = 0x{:02X}", addr,
-                              static_cast<u8>(data));
-                },
-                [&]() { HandleRasterizerWrite(addr, sizeof(T)); });
-            if (ptr) {
-                *ptr = static_cast<u8>(data);
-            }
-            return;
-        } else if constexpr (std::is_same_v<T, u16_le> || std::is_same_v<T, s16_le>) {
-            // Check alignment for 16-bit writes
-            if ((addr & 1) == 0) {
-                u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr, data]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Write16 @ 0x{:016X} = 0x{:04X}", addr,
-                                  static_cast<u16>(data));
-                    },
-                    [&]() { HandleRasterizerWrite(addr, sizeof(T)); });
-                if (ptr) {
-                    *reinterpret_cast<u16*>(ptr) = static_cast<u16>(data);
-                    return;
-                }
-            }
-        } else if constexpr (std::is_same_v<T, u32_le> || std::is_same_v<T, s32_le>) {
-            // Check alignment for 32-bit writes
-            if ((addr & 3) == 0) {
-                u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr, data]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Write32 @ 0x{:016X} = 0x{:08X}", addr,
-                                  static_cast<u32>(data));
-                    },
-                    [&]() { HandleRasterizerWrite(addr, sizeof(T)); });
-                if (ptr) {
-                    *reinterpret_cast<u32*>(ptr) = static_cast<u32>(data);
-                    return;
-                }
-            }
-        } else if constexpr (std::is_same_v<T, u64_le> || std::is_same_v<T, s64_le>) {
-            // Check alignment for 64-bit writes
-            if ((addr & 7) == 0) {
-                u8* const ptr = GetPointerImpl(
-                    addr,
-                    [addr, data]() {
-                        LOG_ERROR(HW_Memory, "Unmapped Write64 @ 0x{:016X} = 0x{:016X}", addr,
-                                  static_cast<u64>(data));
-                    },
-                    [&]() { HandleRasterizerWrite(addr, sizeof(T)); });
-                if (ptr) {
-                    *reinterpret_cast<u64*>(ptr) = static_cast<u64>(data);
-                    return;
-                }
-            }
-        }
-
-        // Fall back to the general case for other types or unaligned access
-        u8* const ptr = GetPointerImpl(
-            addr,
-            [addr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8,
-                          addr, static_cast<u64>(data));
-            },
-            [&]() { HandleRasterizerWrite(addr, sizeof(T)); });
-        if (ptr) {
+        if (auto const ptr = GetPointerImpl(addr, [addr, data]() {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8, addr, u64(data));
+        }, [&]() { HandleRasterizerWrite(addr, sizeof(T)); }); ptr) [[likely]]
             std::memcpy(ptr, &data, sizeof(T));
-        }
     }
 
     template <typename T>

src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp

@@ -57,7 +57,7 @@ class SigHandler {
 public:
     SigHandler() noexcept {
         signal_stack_size = std::max<size_t>(SIGSTKSZ, 2 * 1024 * 1024);
-        signal_stack_memory = std::malloc(signal_stack_size);
+        signal_stack_memory = mmap(nullptr, signal_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
         stack_t signal_stack{};
         signal_stack.ss_sp = signal_stack_memory;
@@ -89,7 +89,7 @@ public:
     }
 
     ~SigHandler() noexcept {
-        std::free(signal_stack_memory);
+        munmap(signal_stack_memory, signal_stack_size);
     }
 
     void AddCodeBlock(u64 offset, CodeBlockInfo cbi) noexcept {

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.cpp

@@ -82,8 +82,7 @@ FP::FPCR A32EmitContext::FPCR(bool fpcr_controlled) const {
 
 A32EmitX64::A32EmitX64(BlockOfCode& code, A32::UserConfig conf, A32::Jit* jit_interface)
         : EmitX64(code), conf(std::move(conf)), jit_interface(jit_interface) {
-    if (conf.fastmem_pointer.has_value())
-        GenFastmemFallbacks();
+    GenFastmemFallbacks();
     GenTerminalHandlers();
     code.PreludeComplete();
     ClearFastDispatchTable();

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.cpp

@@ -56,8 +56,7 @@ FP::FPCR A64EmitContext::FPCR(bool fpcr_controlled) const {
 A64EmitX64::A64EmitX64(BlockOfCode& code, A64::UserConfig conf, A64::Jit* jit_interface)
         : EmitX64(code), conf(conf), jit_interface{jit_interface} {
     GenMemory128Accessors();
-    if (conf.fastmem_pointer.has_value())
-        GenFastmemFallbacks();
+    GenFastmemFallbacks();
     GenTerminalHandlers();
     code.PreludeComplete();
     ClearFastDispatchTable();

src/input_common/drivers/mouse.cpp

@@ -14,7 +14,7 @@
 #include "input_common/drivers/mouse.h"
 
 namespace InputCommon {
-constexpr int update_time = 250; // 4 TPS
+constexpr int update_time = 10;
 constexpr float default_panning_sensitivity = 0.0010f;
 constexpr float default_stick_sensitivity = 0.0006f;
 constexpr float default_deadzone_counterweight = 0.01f;

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1497,11 +1497,13 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
 
 void TextureCacheRuntime::CopyImageMSAA(Image& dst, Image& src,
                                         std::span<const VideoCommon::ImageCopy> copies) {
-    const bool msaa_to_non_msaa = src.info.num_samples > 1 && dst.info.num_samples == 1;
     if (msaa_copy_pass) {
-        return msaa_copy_pass->CopyImage(dst, src, copies, msaa_to_non_msaa);
+        msaa_copy_pass->CopyImage(dst, src, copies,
+                                 src.info.num_samples > 1 && dst.info.num_samples == 1);
+        return;
     }
-    UNIMPLEMENTED_MSG("Copying images with different samples is not supported.");
+
+    CopyImage(dst, src, copies);
 }
 
 u64 TextureCacheRuntime::GetDeviceLocalMemory() const {