Better sync

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -201,7 +201,7 @@ void EmitContext::DefineArithmeticTypes() {
             Constant(U64, static_cast<u64>(VideoCore::BufferCache::CACHING_PAGEBITS));
         caching_pagemask_value = Constant(U64, VideoCore::BufferCache::CACHING_PAGESIZE - 1);
 
-        // Used to calculate fault readback buffer position and mask
+        // Used to calculate fault buffer position and mask
         u32_three_value = ConstU32(3U);
         u32_seven_value = ConstU32(7U);
         bda_first_time_mask = Constant(U64, 0x1ULL);
@@ -747,8 +747,8 @@ EmitContext::BufferSpv EmitContext::DefineBuffer(bool is_storage, bool is_writte
     case Shader::BufferType::BdaPagetable:
         Name(id, "bda_pagetable");
         break;
-    case Shader::BufferType::FaultReadback:
+    case Shader::BufferType::FaultBuffer:
-        Name(id, "fault_readback");
+        Name(id, "fault_buffer");
         break;
     case Shader::BufferType::SharedMemory:
         Name(id, "ssbo_shmem");
@@ -782,8 +782,8 @@ void EmitContext::DefineBuffers() {
             flatbuf_index = buffers.size();
         } else if (desc.buffer_type == BufferType::BdaPagetable) {
             bda_pagetable_index = buffers.size();
-        } else if (desc.buffer_type == BufferType::FaultReadback) {
+        } else if (desc.buffer_type == BufferType::FaultBuffer) {
-            fault_readback_index = buffers.size();
+            fault_buffer_index = buffers.size();
         }
 
         // Define aliases depending on the shader usage.

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -199,7 +199,7 @@ public:
 
         // First time access
         AddLabel(first_time_label);
-        const auto& fault_buffer = buffers[fault_readback_index];
+        const auto& fault_buffer = buffers[fault_buffer_index];
         const auto [fault_buffer_id, fault_pointer_type] = fault_buffer[PointerType::U8];
         const Id page_div8 = OpShiftRightLogical(U32[1], page32, u32_three_value);
         const Id page_mod8 = OpBitwiseAnd(U32[1], page32, u32_seven_value);
@@ -248,7 +248,7 @@ public:
         // Merge
         AddLabel(merge_label);
         const Id final_result =
-            OpPhi(type, fallback_result, fallback_label, result, available_label);
+            OpPhi(type, fallback_result, fallback_label, result, after_save_masked_label);
         return final_result;
     }
 
@@ -407,7 +407,7 @@ public:
 
     size_t flatbuf_index{};
     size_t bda_pagetable_index{};
-    size_t fault_readback_index{};
+    size_t fault_buffer_index{};
 
     Id sampler_type{};
     Id sampler_pointer_type{};

src/shader_recompiler/info.h

@@ -43,7 +43,7 @@ enum class BufferType : u32 {
     Guest,
     Flatbuf,
     BdaPagetable,
-    FaultReadback,
+    FaultBuffer,
     GdsBuffer,
     SharedMemory,
 };

src/shader_recompiler/ir/passes/shader_info_collection_pass.cpp

@@ -119,8 +119,8 @@ void CollectShaderInfoPass(IR::Program& program) {
         });
         program.info.buffers.push_back({
             .used_types = IR::Type::U8,
-            .inline_cbuf = AmdGpu::Buffer::Placeholder(VideoCore::BufferCache::FAULT_READBACK_SIZE),
+            .inline_cbuf = AmdGpu::Buffer::Placeholder(VideoCore::BufferCache::FAULT_BUFFER_SIZE),
-            .buffer_type = BufferType::FaultReadback,
+            .buffer_type = BufferType::FaultBuffer,
             .is_written = true,
         });
     }

src/video_core/buffer_cache/buffer_cache.cpp

@@ -35,7 +35,7 @@ BufferCache::BufferCache(const Vulkan::Instance& instance_, Vulkan::Scheduler& s
       bda_pagetable_buffer{instance, scheduler, MemoryUsage::DeviceLocal,
                            0,        AllFlags,  BDA_PAGETABLE_SIZE},
       fault_buffer(instance, scheduler, MemoryUsage::DeviceLocal, 0, AllFlags,
-                            FAULT_READBACK_SIZE),
+                            FAULT_BUFFER_SIZE),
       memory_tracker{&tracker} {
     Vulkan::SetObjectName(instance.GetDevice(), gds_buffer.Handle(), "GDS Buffer");
     Vulkan::SetObjectName(instance.GetDevice(), bda_pagetable_buffer.Handle(),
@@ -628,14 +628,14 @@ BufferId BufferCache::CreateBuffer(VAddr device_addr, u32 wanted_size) {
 void BufferCache::ProcessFaultBuffer() {
     // Run fault processing shader
     const auto [mapped, offset] = download_buffer.Map(MaxPageFaults * sizeof(u64));
-    vk::BufferMemoryBarrier2 fault_readback_barrier{
+    vk::BufferMemoryBarrier2 fault_buffer_barrier{
         .srcStageMask = vk::PipelineStageFlagBits2::eAllCommands,
         .srcAccessMask = vk::AccessFlagBits2::eShaderWrite,
         .dstStageMask = vk::PipelineStageFlagBits2::eComputeShader,
         .dstAccessMask = vk::AccessFlagBits2::eShaderRead,
         .buffer = fault_buffer.Handle(),
         .offset = 0,
-        .size = FAULT_READBACK_SIZE,
+        .size = FAULT_BUFFER_SIZE,
     };
     vk::BufferMemoryBarrier2 download_barrier{
         .srcStageMask = vk::PipelineStageFlagBits2::eTransfer,
@@ -646,11 +646,11 @@ void BufferCache::ProcessFaultBuffer() {
         .offset = offset,
         .size = MaxPageFaults * sizeof(u64),
     };
-    std::array<vk::BufferMemoryBarrier2, 2> barriers{fault_readback_barrier, download_barrier};
+    std::array<vk::BufferMemoryBarrier2, 2> barriers{fault_buffer_barrier, download_barrier};
-    vk::DescriptorBufferInfo fault_readback_info{
+    vk::DescriptorBufferInfo fault_buffer_info{
         .buffer = fault_buffer.Handle(),
         .offset = 0,
-        .range = FAULT_READBACK_SIZE,
+        .range = FAULT_BUFFER_SIZE,
     };
     vk::DescriptorBufferInfo download_info{
         .buffer = download_buffer.Handle(),
@@ -664,7 +664,7 @@ void BufferCache::ProcessFaultBuffer() {
             .dstArrayElement = 0,
             .descriptorCount = 1,
             .descriptorType = vk::DescriptorType::eStorageBuffer,
-            .pBufferInfo = &fault_readback_info,
+            .pBufferInfo = &fault_buffer_info,
         },
         {
             .dstSet = VK_NULL_HANDLE,
@@ -698,7 +698,7 @@ void BufferCache::ProcessFaultBuffer() {
         .dstAccessMask = vk::AccessFlagBits2::eTransferWrite,
         .buffer = fault_buffer.Handle(),
         .offset = 0,
-        .size = FAULT_READBACK_SIZE,
+        .size = FAULT_BUFFER_SIZE,
     };
     const vk::BufferMemoryBarrier2 reset_post_barrier = {
         .srcStageMask = vk::PipelineStageFlagBits2::eTransfer,
@@ -707,14 +707,14 @@ void BufferCache::ProcessFaultBuffer() {
         .dstAccessMask = vk::AccessFlagBits2::eMemoryRead | vk::AccessFlagBits2::eMemoryWrite,
         .buffer = fault_buffer.Handle(),
         .offset = 0,
-        .size = FAULT_READBACK_SIZE,
+        .size = FAULT_BUFFER_SIZE,
     };
     cmdbuf.pipelineBarrier2(vk::DependencyInfo{
         .dependencyFlags = vk::DependencyFlagBits::eByRegion,
         .bufferMemoryBarrierCount = 1,
         .pBufferMemoryBarriers = &reset_pre_barrier,
     });
-    cmdbuf.fillBuffer(fault_buffer.buffer, 0, FAULT_READBACK_SIZE, 0);
+    cmdbuf.fillBuffer(fault_buffer.buffer, 0, FAULT_BUFFER_SIZE, 0);
     cmdbuf.pipelineBarrier2(vk::DependencyInfo{
         .dependencyFlags = vk::DependencyFlagBits::eByRegion,
         .bufferMemoryBarrierCount = 1,
@@ -737,8 +737,8 @@ void BufferCache::ProcessFaultBuffer() {
         for (const auto& range : fault_ranges) {
             const VAddr start = range.lower();
             const VAddr end = range.upper();
-            const VAddr page_start = start >> CACHING_PAGEBITS;
+            const u64 page_start = start >> CACHING_PAGEBITS;
-            const VAddr page_end = Common::DivCeil(end, CACHING_PAGESIZE);
+            const u64 page_end = Common::DivCeil(end, CACHING_PAGESIZE);
             // Mark the pages as synced
             for (u64 page = page_start; page < page_end; ++page) {
                 page_table[page].is_dma_synced = true;

src/video_core/buffer_cache/buffer_cache.h

@@ -44,7 +44,7 @@ public:
     static constexpr u64 CACHING_NUMPAGES = u64{1} << (40 - CACHING_PAGEBITS);
 
     static constexpr u64 BDA_PAGETABLE_SIZE = CACHING_NUMPAGES * sizeof(vk::DeviceAddress);
-    static constexpr u64 FAULT_READBACK_SIZE = CACHING_NUMPAGES / 8; // Bit per page
+    static constexpr u64 FAULT_BUFFER_SIZE = CACHING_NUMPAGES / 8; // Bit per page
 
     struct PageData {
         BufferId buffer_id{};
@@ -87,8 +87,8 @@ public:
         return &bda_pagetable_buffer;
     }
 
-    /// Retrieves the fault readback buffer.
+    /// Retrieves the fault buffer.
-    [[nodiscard]] Buffer* GetFaultReadbackBuffer() noexcept {
+    [[nodiscard]] Buffer* GetFaultBuffer() noexcept {
         return &fault_buffer;
     }
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -558,8 +558,8 @@ void Rasterizer::BindBuffers(const Shader::Info& stage, Shader::Backend::Binding
             } else if (desc.buffer_type == Shader::BufferType::BdaPagetable) {
                 const auto* bda_buffer = buffer_cache.GetBdaPageTableBuffer();
                 buffer_infos.emplace_back(bda_buffer->Handle(), 0, bda_buffer->SizeBytes());
-            } else if (desc.buffer_type == Shader::BufferType::FaultReadback) {
+            } else if (desc.buffer_type == Shader::BufferType::FaultBuffer) {
-                const auto* fault_buffer = buffer_cache.GetFaultReadbackBuffer();
+                const auto* fault_buffer = buffer_cache.GetFaultBuffer();
                 buffer_infos.emplace_back(fault_buffer->Handle(), 0, fault_buffer->SizeBytes());
             } else if (desc.buffer_type == Shader::BufferType::SharedMemory) {
                 auto& lds_buffer = buffer_cache.GetStreamBuffer();