From 05e31d1e76c40408593eba57d6b7952271193ce9 Mon Sep 17 00:00:00 2001 From: weakboson Date: Sat, 26 Jul 2025 23:20:28 +0800 Subject: [PATCH] Use coherent names for source and destination. --- src/video_core/buffer_cache/buffer_cache.h | 73 +++++++++++----------- 1 file changed, 36 insertions(+), 37 deletions(-) diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h index a6e87a3583..fd7764b2f8 100644 --- a/src/video_core/buffer_cache/buffer_cache.h +++ b/src/video_core/buffer_cache/buffer_cache.h @@ -187,34 +187,34 @@ void BufferCache

::ClearDownload(DAddr device_addr, u64 size) { } template -bool BufferCache

::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) { +bool BufferCache

::DMACopy(GPUVAddr src_address, GPUVAddr dst_address, u64 amount) { const std::optional cpu_src_address = gpu_memory->GpuToCpuAddress(src_address); - const std::optional cpu_dest_address = gpu_memory->GpuToCpuAddress(dest_address); - if (!cpu_src_address || !cpu_dest_address) { + const std::optional cpu_dst_address = gpu_memory->GpuToCpuAddress(dst_address); + if (!cpu_src_address || !cpu_dst_address) { return false; } - const bool source_dirty = IsRegionRegistered(*cpu_src_address, amount); - const bool dest_dirty = IsRegionRegistered(*cpu_dest_address, amount); - if (!source_dirty && !dest_dirty) { + const bool src_dirty = IsRegionRegistered(*cpu_src_address, amount); + const bool dst_dirty = IsRegionRegistered(*cpu_dst_address, amount); + if (!src_dirty && !dst_dirty) { return false; } - ClearDownload(*cpu_dest_address, amount); + ClearDownload(*cpu_dst_address, amount); BufferId buffer_a; BufferId buffer_b; do { channel_state->has_deleted_buffers = false; buffer_a = FindBuffer(*cpu_src_address, static_cast(amount)); - buffer_b = FindBuffer(*cpu_dest_address, static_cast(amount)); + buffer_b = FindBuffer(*cpu_dst_address, static_cast(amount)); } while (channel_state->has_deleted_buffers); auto& src_buffer = slot_buffers[buffer_a]; - auto& dest_buffer = slot_buffers[buffer_b]; + auto& dst_buffer = slot_buffers[buffer_b]; SynchronizeBuffer(src_buffer, *cpu_src_address, static_cast(amount)); - SynchronizeBuffer(dest_buffer, *cpu_dest_address, static_cast(amount)); + SynchronizeBuffer(dst_buffer, *cpu_dst_address, static_cast(amount)); std::array copies{BufferCopy{ .src_offset = src_buffer.Offset(*cpu_src_address), - .dst_offset = dest_buffer.Offset(*cpu_dest_address), + .dst_offset = dst_buffer.Offset(*cpu_dst_address), .size = amount, }}; @@ -222,28 +222,28 @@ bool BufferCache

::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am auto mirror = [&](DAddr base_address, DAddr base_address_end) { const u64 size = base_address_end - base_address; const DAddr diff = base_address - *cpu_src_address; - const DAddr new_base_address = *cpu_dest_address + diff; + const DAddr new_base_address = *cpu_dst_address + diff; tmp_intervals.push_back({new_base_address, size}); uncommitted_gpu_modified_ranges.Add(new_base_address, size); }; gpu_modified_ranges.ForEachInRange(*cpu_src_address, amount, mirror); // This subtraction in this order is important for overlapping copies. - gpu_modified_ranges.Subtract(*cpu_dest_address, amount); + gpu_modified_ranges.Subtract(*cpu_dst_address, amount); const bool has_new_downloads = tmp_intervals.size() != 0; for (const auto& pair : tmp_intervals) { gpu_modified_ranges.Add(pair.first, pair.second); } const auto& copy = copies[0]; src_buffer.MarkUsage(copy.src_offset, copy.size); - dest_buffer.MarkUsage(copy.dst_offset, copy.size); - runtime.CopyBuffer(dest_buffer, src_buffer, copies, true); + dst_buffer.MarkUsage(copy.dst_offset, copy.size); + runtime.CopyBuffer(dst_buffer, src_buffer, copies, true); if (has_new_downloads) { - memory_tracker.MarkRegionAsGpuModified(*cpu_dest_address, amount); + memory_tracker.MarkRegionAsGpuModified(*cpu_dst_address, amount); } Tegra::Memory::DeviceGuestMemoryScoped tmp(device_memory, *cpu_src_address, amount, &tmp_buffer); - tmp.SetAddressAndSize(*cpu_dest_address, amount); + tmp.SetAddressAndSize(*cpu_dst_address, amount); return true; } @@ -253,8 +253,8 @@ bool BufferCache

::DMAClear(GPUVAddr dst_address, u64 amount, u32 value) { if (!cpu_dst_address) { return false; } - const bool dest_dirty = IsRegionRegistered(*cpu_dst_address, amount); - if (!dest_dirty) { + const bool dst_dirty = IsRegionRegistered(*cpu_dst_address, amount); + if (!dst_dirty) { return false; } @@ -263,10 +263,10 @@ bool BufferCache

::DMAClear(GPUVAddr dst_address, u64 amount, u32 value) { gpu_modified_ranges.Subtract(*cpu_dst_address, size); const BufferId buffer = FindBuffer(*cpu_dst_address, static_cast(size)); - Buffer& dest_buffer = slot_buffers[buffer]; - const u32 offset = dest_buffer.Offset(*cpu_dst_address); - runtime.ClearBuffer(dest_buffer, offset, size, value); - dest_buffer.MarkUsage(offset, size); + Buffer& dst_buffer = slot_buffers[buffer]; + const u32 offset = dst_buffer.Offset(*cpu_dst_address); + runtime.ClearBuffer(dst_buffer, offset, size, value); + dst_buffer.MarkUsage(offset, size); return true; } @@ -1074,8 +1074,7 @@ void BufferCache

::UpdateIndexBuffer() { u32 buffer_size = Common::AlignUp(inline_index_size, CACHING_PAGESIZE); if (inline_buffer_id == NULL_BUFFER_ID) [[unlikely]] { inline_buffer_id = CreateBuffer(0, buffer_size); - } - if (slot_buffers[inline_buffer_id].SizeBytes() < buffer_size) [[unlikely]] { + } else if (slot_buffers[inline_buffer_id].SizeBytes() < buffer_size) [[unlikely]] { slot_buffers.erase(inline_buffer_id); inline_buffer_id = CreateBuffer(0, buffer_size); } @@ -1529,38 +1528,38 @@ void BufferCache

::MappedUploadMemory([[maybe_unused]] Buffer& buffer, } template -bool BufferCache

::InlineMemory(DAddr dest_address, size_t copy_size, +bool BufferCache

::InlineMemory(DAddr dst_address, size_t copy_size, std::span inlined_buffer) { - const bool is_dirty = IsRegionRegistered(dest_address, copy_size); + const bool is_dirty = IsRegionRegistered(dst_address, copy_size); if (!is_dirty) { return false; } - DAddr aligned_start = Common::AlignDown(dest_address, DEVICE_PAGESIZE); - DAddr aligned_end = Common::AlignUp(dest_address + copy_size, DEVICE_PAGESIZE); + DAddr aligned_start = Common::AlignDown(dst_address, DEVICE_PAGESIZE); + DAddr aligned_end = Common::AlignUp(dst_address + copy_size, DEVICE_PAGESIZE); if (!IsRegionGpuModified(aligned_start, aligned_end - aligned_start)) { return false; } - InlineMemoryImplementation(dest_address, copy_size, inlined_buffer); + InlineMemoryImplementation(dst_address, copy_size, inlined_buffer); return true; } template -void BufferCache

::InlineMemoryImplementation(DAddr dest_address, size_t copy_size, +void BufferCache

::InlineMemoryImplementation(DAddr dst_address, size_t copy_size, std::span inlined_buffer) { - ClearDownload(dest_address, copy_size); - gpu_modified_ranges.Subtract(dest_address, copy_size); + ClearDownload(dst_address, copy_size); + gpu_modified_ranges.Subtract(dst_address, copy_size); - BufferId buffer_id = FindBuffer(dest_address, static_cast(copy_size)); + BufferId buffer_id = FindBuffer(dst_address, static_cast(copy_size)); auto& buffer = slot_buffers[buffer_id]; - SynchronizeBuffer(buffer, dest_address, static_cast(copy_size)); + SynchronizeBuffer(buffer, dst_address, static_cast(copy_size)); if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) { auto upload_staging = runtime.UploadStagingBuffer(copy_size); std::array copies{BufferCopy{ .src_offset = upload_staging.offset, - .dst_offset = buffer.Offset(dest_address), + .dst_offset = buffer.Offset(dst_address), .size = copy_size, }}; u8* const src_pointer = upload_staging.mapped_span.data(); @@ -1568,7 +1567,7 @@ void BufferCache

::InlineMemoryImplementation(DAddr dest_address, size_t copy_ const bool can_reorder = runtime.CanReorderUpload(buffer, copies); runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true, can_reorder); } else { - buffer.ImmediateUpload(buffer.Offset(dest_address), inlined_buffer.first(copy_size)); + buffer.ImmediateUpload(buffer.Offset(dst_address), inlined_buffer.first(copy_size)); } }