Implement void Core::Memory::HandleRasterizerWrite(VAddr v_address, size_t size)

Author: N3xoX1

src/nxemu-module-spec/base.h

@@ -17,9 +17,9 @@
 enum
 {
     MODULE_LOADER_SPECS_VERSION = 0x0106,
-    MODULE_VIDEO_SPECS_VERSION = 0x0103,
+    MODULE_VIDEO_SPECS_VERSION = 0x0104,
     MODULE_CPU_SPECS_VERSION = 0x0102,
-    MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0105,
+    MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0106,
 };
 
 enum MODULE_TYPE : uint16_t

src/nxemu-module-spec/operating_system.h

@@ -70,14 +70,15 @@ __interface ICacheInvalidator
 
 __interface IOperatingSystem
 {
-    bool Initialize(void) = 0;
+    bool Initialize() = 0;
     bool CreateApplicationProcess(uint64_t codeSize, const IProgramMetadata & metaData, uint64_t & baseAddress, uint64_t & processID, bool is_hbl) = 0;
     void StartApplicationProcess(int32_t priority, int64_t stackSize, uint32_t version, StorageId baseGameStorageId, StorageId updateStorageId, uint8_t * nacpData, uint32_t nacpDataLen) = 0;
     bool LoadModule(const IModuleInfo & module, uint64_t baseAddress) = 0;
-    IDeviceMemory & DeviceMemory(void) = 0;
+    IDeviceMemory & DeviceMemory() = 0;
     void KeyboardKeyPress(int modifier, int keyIndex, int keyCode) = 0;
     void KeyboardKeyRelease(int modifier, int keyIndex, int keyCode) = 0;
     void GatherGPUDirtyMemory(ICacheInvalidator * invalidator) = 0;
+    void GameFrameEnd() = 0;
 };
 
 EXPORT IOperatingSystem * CALL CreateOperatingSystem(ISwitchSystem & system);

src/nxemu-module-spec/video.h

@@ -35,6 +35,8 @@ __interface IChannelState
     void Release() = 0;
 };
 
+typedef void (*DeviceMemoryOperation)(uint64_t device_address, void* user_data);
+
 __interface IVideo
 {
     bool Initialize(void) = 0;
@@ -48,6 +50,8 @@ __interface IVideo
     void UpdateFramebufferLayout(uint32_t width, uint32_t height) = 0;
     IChannelState * AllocateChannel() = 0;
     void PushGPUEntries(int32_t bindId, const uint64_t * commandList, uint32_t commandListSize, const uint32_t * prefetchCommandlist, uint32_t prefetchCommandlistSize) = 0;
+    void ApplyOpOnDeviceMemoryPointer(const uint8_t * pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void * userData) = 0;
+    bool OnCPUWrite(uint64_t addr, uint64_t size) = 0;
 };
 
 EXPORT IVideo * CALL CreateVideo(IRenderWindow & RenderWindow, ISwitchSystem & System);

src/nxemu-os/core/core.cpp

@@ -274,6 +274,10 @@ bool System::IsPoweredOn() const {
     return impl->is_powered_on.load(std::memory_order::relaxed);
 }
 
+size_t System::GetCurrentHostThreadID() const {
+    return impl->kernel.GetCurrentHostThreadID();
+}
+
 std::span<GPUDirtyMemoryManager> System::GetGPUDirtyMemoryManager() {
     return impl->gpu_dirty_memory_managers;
 }

src/nxemu-os/core/hle/kernel/k_process.cpp

@@ -322,6 +322,7 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params, const KPa
 
     // Ensure our memory is initialized.
     m_memory.SetCurrentPageTable(*this);
+    m_memory.SetGPUDirtyManagers(m_kernel.System().GetGPUDirtyMemoryManager());
 
     // Ensure we can insert the code region.
     R_UNLESS(m_page_table.CanContain(params.code_address, params.code_num_pages * PageSize,
@@ -418,6 +419,7 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params,
 
     // Ensure our memory is initialized.
     m_memory.SetCurrentPageTable(*this);
+    m_memory.SetGPUDirtyManagers(m_kernel.System().GetGPUDirtyMemoryManager());
 
     // Ensure we can insert the code region.
     R_UNLESS(m_page_table.CanContain(params.code_address, code_size, KMemoryState::Code),

src/nxemu-os/core/memory.cpp

@@ -23,6 +23,7 @@
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/memory.h"
+#include <nxemu-module-spec/video.h>
 
 namespace Core::Memory {
 
@@ -800,8 +801,51 @@ struct Memory::Impl {
         UNIMPLEMENTED();
     }
 
+    struct RasterizerWriteContext {
+        Impl * impl;
+        size_t core;
+        size_t size;
+    };
+
+    static void HandleRasterizerWriteCallback(uint64_t address, void * user_data)
+    {
+        RasterizerWriteContext & context = *((RasterizerWriteContext*)user_data);
+        auto& current_area = context.impl->rasterizer_write_areas[context.core];
+        PAddr subaddress = address >> YUZU_PAGEBITS;
+        bool do_collection = current_area.last_address == subaddress;
+        if (!do_collection) [[unlikely]] {
+            do_collection = context.impl->system.GetVideo().OnCPUWrite(address, context.size);
+            if (!do_collection) {
+                return;
+            }
+            current_area.last_address = subaddress;
+        }
+        context.impl->gpu_dirty_managers[context.core].Collect(address, context.size);
+    }
+
     void HandleRasterizerWrite(VAddr v_address, size_t size) {
-        UNIMPLEMENTED();
+        const auto* p = GetPointerImpl(
+            v_address, []() {}, []() {});
+        constexpr size_t sys_core = Core::Hardware::NUM_CPU_CORES - 1;
+        const size_t core = std::min(system.GetCurrentHostThreadID(),
+                                     sys_core); // any other calls threads go to syscore.
+        
+        RasterizerWriteContext context;
+        context.impl = this;
+        context.core = core;
+        context.size = size;
+             
+        // Guard on sys_core;
+        if (core == sys_core) [[unlikely]] {
+            sys_core_guard.lock();
+        }
+        SCOPE_EXIT {
+            if (core == sys_core) [[unlikely]] {
+                sys_core_guard.unlock();
+            }
+        };
+
+        system.GetVideo().ApplyOpOnDeviceMemoryPointer(p, scratch_buffers[core].data(), scratch_buffers[core].size(), HandleRasterizerWriteCallback, &context);
     }
 
     struct GPUDirtyState {
@@ -816,6 +860,7 @@ struct Memory::Impl {
     Common::PageTable* current_page_table = nullptr;
     std::array<GPUDirtyState, Core::Hardware::NUM_CPU_CORES> rasterizer_write_areas{};
     std::array<Common::ScratchBuffer<u32>, Core::Hardware::NUM_CPU_CORES> scratch_buffers{};
+    std::span<Core::GPUDirtyMemoryManager> gpu_dirty_managers;
     std::mutex sys_core_guard;
 
     std::optional<Common::HeapTracker> heap_tracker;
@@ -985,6 +1030,10 @@ bool Memory::ZeroBlock(Common::ProcessAddress dest_addr, const std::size_t size)
     return impl->ZeroBlock(dest_addr, size);
 }
 
+void Memory::SetGPUDirtyManagers(std::span<Core::GPUDirtyMemoryManager> managers) {
+    impl->gpu_dirty_managers = managers;
+}
+
 Result Memory::InvalidateDataCache(Common::ProcessAddress dest_addr, const std::size_t size) {
     return impl->InvalidateDataCache(dest_addr, size);
 }

src/nxemu-os/core/memory.h

@@ -490,6 +490,8 @@ class Memory :
      */
     void MarkRegionDebug(Common::ProcessAddress vaddr, u64 size, bool debug);
 
+    void SetGPUDirtyManagers(std::span<Core::GPUDirtyMemoryManager> managers);
+
     bool InvalidateNCE(Common::ProcessAddress vaddr, size_t size);
 
     bool InvalidateSeparateHeap(void* fault_address);

src/nxemu-os/os_manager.cpp

@@ -3,6 +3,7 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "core/perf_stats.h"
 #include "yuzu_common/logging/backend.h"
 #include "yuzu_common/settings.h"
 #include "yuzu_common/settings_input.h"
@@ -149,4 +150,9 @@ void OSManager::KeyboardKeyRelease(int modifier, int keyIndex, int keyCode)
 void OSManager::GatherGPUDirtyMemory(ICacheInvalidator * invalidator)
 {
     m_coreSystem.GatherGPUDirtyMemory(invalidator);
-}
+}
+
+void OSManager::GameFrameEnd()
+{
+    m_coreSystem.GetPerfStats().EndGameFrame();
+}

src/nxemu-os/os_manager.h

@@ -12,14 +12,15 @@ class OSManager :
     void EmulationStarting();
 
     // IOperatingSystem
-    bool Initialize(void) override;
+    bool Initialize() override;
     bool CreateApplicationProcess(uint64_t codeSize, const IProgramMetadata & metaData, uint64_t & baseAddress, uint64_t & processID, bool is_hbl) override;
     void StartApplicationProcess(int32_t priority, int64_t stackSize, uint32_t version, StorageId baseGameStorageId, StorageId updateStorageId, uint8_t * nacpData, uint32_t nacpDataLen) override;
     bool LoadModule(const IModuleInfo & module, uint64_t baseAddress) override;
-    IDeviceMemory & DeviceMemory(void) override;
+    IDeviceMemory & DeviceMemory() override;
     void KeyboardKeyPress(int modifier, int keyIndex, int keyCode) override;
     void KeyboardKeyRelease(int modifier, int keyIndex, int keyCode) override;
     void GatherGPUDirtyMemory(ICacheInvalidator * invalidator) override;
+    void GameFrameEnd() override;
 
 private:
     OSManager() = delete;

src/nxemu-video/video_manager.cpp

@@ -136,3 +136,20 @@ void VideoManager::MemoryMap(uint64_t address, uint64_t virtualAddress, uint64_t
 {
     impl->m_host1x->MemoryManager().Map(address, virtualAddress, size, Core::Asid{asid}, track);
 }
+
+void VideoManager::ApplyOpOnDeviceMemoryPointer(const uint8_t* pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void* userData)
+{
+    Common::ScratchBuffer<u32> tempBuffer;
+    tempBuffer.resize(scratchBufferSize);
+    std::memcpy(tempBuffer.data(), scratchBuffer, scratchBufferSize * sizeof(uint32_t));
+
+    impl->m_host1x->MemoryManager().ApplyOpOnPointer(pointer, tempBuffer, [operation, userData](DAddr address) {
+        operation(address, userData);
+    });
+    std::memcpy(scratchBuffer, tempBuffer.data(), tempBuffer.size() * sizeof(uint32_t));
+}
+
+bool VideoManager::OnCPUWrite(uint64_t addr, uint64_t size)
+{
+    return impl->m_gpuCore->OnCPUWrite(addr, size);
+}