debuggerx/eden
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden.git synced 2026-10-06 22:10:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

[TEST] Setting up writeable regions

Browse Source
This commit is contained in:
CamilleLaVey
2026-08-08 22:18:38 -04:00
parent e46dd1bd5f
commit fe939bb14d
2 changed files with 78 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/video_core/buffer_cache/buffer_cache.h
+71 -24
View File
@@ -115,7 +115,8 @@ void BufferCache<P>::TickFrame() {
template <class P> template <class P>
void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) { void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
if (memory_tracker.IsRegionGpuModified(device_addr, size)) { if (memory_tracker.IsRegionGpuModified(device_addr, size) ||
IntersectsInPlaceWrites(device_addr, size)) {
ClearDownload(device_addr, size); ClearDownload(device_addr, size);
ForgetGpuModifiedRange(device_addr, size); ForgetGpuModifiedRange(device_addr, size);
} }
@@ -605,16 +606,24 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
struct QueuedDownload { struct QueuedDownload {
BufferCopy copy; BufferCopy copy;
BufferId buffer_id; BufferId buffer_id;
bool written_in_place;
}; };
boost::container::small_vector<QueuedDownload, 16> downloads; boost::container::small_vector<QueuedDownload, 16> downloads;
boost::container::small_vector<BufferCopy, 16> in_place_downloads;
u64 total_size_bytes = 0; u64 total_size_bytes = 0;
u64 largest_copy = 0; u64 largest_copy = 0;
for (const Common::RangeSet<DAddr>& range_set : committed_gpu_modified_ranges) { for (const Common::RangeSet<DAddr>& range_set : committed_gpu_modified_ranges) {
range_set.ForEach([&](DAddr interval_lower, DAddr interval_upper) { range_set.ForEach([&](DAddr interval_lower, DAddr interval_upper) {
const std::size_t size = interval_upper - interval_lower; const std::size_t size = interval_upper - interval_lower;
const DAddr device_addr = interval_lower; const DAddr device_addr = interval_lower;
in_place_gpu_written_ranges.ForEachInRange(
device_addr, size, [&](DAddr start, DAddr end) {
in_place_downloads.push_back(BufferCopy{
.src_offset = static_cast<size_t>(start),
.dst_offset = 0,
.size = end - start,
});
});
ForEachBufferInRange(device_addr, size, [&](BufferId buffer_id, Buffer& buffer) { ForEachBufferInRange(device_addr, size, [&](BufferId buffer_id, Buffer& buffer) {
const DAddr buffer_start = buffer.CpuAddr(); const DAddr buffer_start = buffer.CpuAddr();
const DAddr buffer_end = buffer_start + buffer.SizeBytes(); const DAddr buffer_end = buffer_start + buffer.SizeBytes();
@@ -624,8 +633,7 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
new_start, new_end - new_start, false, new_start, new_end - new_start, false,
[&](u64 device_addr_out, u64 range_size) { [&](u64 device_addr_out, u64 range_size) {
const DAddr buffer_addr = buffer.CpuAddr(); const DAddr buffer_addr = buffer.CpuAddr();
const auto add_download = [&](DAddr start, DAddr end, const auto add_download = [&](DAddr start, DAddr end) {
bool written_in_place) {
const u64 new_offset = start - buffer_addr; const u64 new_offset = start - buffer_addr;
const u64 new_size = end - start; const u64 new_size = end - start;
downloads.push_back({ downloads.push_back({
@@ -635,7 +643,6 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
.size = new_size, .size = new_size,
}, },
buffer_id, buffer_id,
written_in_place,
}); });
// Align up to avoid cache conflicts // Align up to avoid cache conflicts
constexpr u64 align = 64ULL; constexpr u64 align = 64ULL;
@@ -643,29 +650,28 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
total_size_bytes += (new_size + align - 1) & mask; total_size_bytes += (new_size + align - 1) & mask;
largest_copy = (std::max)(largest_copy, new_size); largest_copy = (std::max)(largest_copy, new_size);
}; };
const auto split_by_in_place = [&](DAddr start, DAddr end) { const auto skip_in_place = [&](DAddr start, DAddr end) {
DAddr cursor = start; DAddr cursor = start;
in_place_gpu_written_ranges.ForEachInRange( in_place_gpu_written_ranges.ForEachInRange(
start, end - start, [&](DAddr in_start, DAddr in_end) { start, end - start, [&](DAddr in_start, DAddr in_end) {
if (cursor < in_start) { if (cursor < in_start) {
add_download(cursor, in_start, false); add_download(cursor, in_start);
} }
add_download(in_start, in_end, true);
cursor = in_end; cursor = in_end;
}); });
if (cursor < end) { if (cursor < end) {
add_download(cursor, end, false); add_download(cursor, end);
} }
}; };
gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, gpu_modified_ranges.ForEachInRange(device_addr_out, range_size,
split_by_in_place); skip_in_place);
}); });
}); });
}); });
} }
committed_gpu_modified_ranges.clear(); committed_gpu_modified_ranges.clear();
if (downloads.empty()) { if (downloads.empty() && in_place_downloads.empty()) {
pending_downloads.emplace_back(); pending_downloads.emplace_back();
async_buffers.emplace_back(std::optional<Async_Buffer>{}); async_buffers.emplace_back(std::optional<Async_Buffer>{});
return; return;
@@ -683,18 +689,13 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
boost::container::small_vector<u64, 4> window_ids; boost::container::small_vector<u64, 4> window_ids;
UnifiedWindowGroups groups; UnifiedWindowGroups groups;
u64 staging_size_bytes = 0; u64 staging_size_bytes = 0;
bool has_in_place_writes = false; for (const BufferCopy& copy : in_place_downloads) {
for (auto& [copy, buffer_id, written_in_place] : downloads) { async_downloads.Add(static_cast<DAddr>(copy.src_offset), copy.size);
batch.unified_copies.push_back(copy);
}
for (auto& [copy, buffer_id] : downloads) {
Buffer& buffer = slot_buffers[buffer_id]; Buffer& buffer = slot_buffers[buffer_id];
const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset; const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
if (written_in_place) {
BufferCopy record{copy};
record.src_offset = static_cast<size_t>(orig_device_addr);
async_downloads.Add(orig_device_addr, copy.size);
batch.unified_copies.push_back(record);
has_in_place_writes = true;
continue;
}
bool unified = false; bool unified = false;
if constexpr (USE_UNIFIED_MEMORY) { if constexpr (USE_UNIFIED_MEMORY) {
if (runtime.HasUnifiedMemory()) { if (runtime.HasUnifiedMemory()) {
@@ -750,7 +751,7 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
} }
} }
if constexpr (USE_UNIFIED_DIRECT_BINDING) { if constexpr (USE_UNIFIED_DIRECT_BINDING) {
if (has_in_place_writes) { if (!in_place_downloads.empty()) {
runtime.UnifiedMemoryShaderWriteBarrier(); runtime.UnifiedMemoryShaderWriteBarrier();
} }
} }
@@ -1608,6 +1609,12 @@ void BufferCache<P>::UpdateComputeTextureBuffers() {
template <class P> template <class P>
void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) { void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) {
if constexpr (USE_UNIFIED_DIRECT_BINDING) {
if (!in_place_gpu_written_ranges.Empty() && IntersectsInPlaceWrites(device_addr, size)) {
SynchronizeBuffer(slot_buffers[buffer_id], device_addr, size);
in_place_gpu_written_ranges.Subtract(device_addr, size);
}
}
if constexpr (!IS_OPENGL) { if constexpr (!IS_OPENGL) {
Buffer& buffer = slot_buffers[buffer_id]; Buffer& buffer = slot_buffers[buffer_id];
buffer.setWriteTick(runtime.CurrentTick()); buffer.setWriteTick(runtime.CurrentTick());
@@ -1619,10 +1626,13 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u3
template <class P> template <class P>
void BufferCache<P>::MarkWrittenBufferInPlace(DAddr device_addr, u32 size) { void BufferCache<P>::MarkWrittenBufferInPlace(DAddr device_addr, u32 size) {
memory_tracker.MarkRegionAsGpuModified(device_addr, size); memory_tracker.MarkRegionAsCpuModified(device_addr, size);
gpu_modified_ranges.Add(device_addr, size); gpu_modified_ranges.Add(device_addr, size);
uncommitted_gpu_modified_ranges.Add(device_addr, size); uncommitted_gpu_modified_ranges.Add(device_addr, size);
in_place_gpu_written_ranges.Add(device_addr, size); in_place_gpu_written_ranges.Add(device_addr, size);
if constexpr (!IS_OPENGL) {
in_place_write_tick = runtime.CurrentTick();
}
} }
template <class P> template <class P>
@@ -1631,6 +1641,31 @@ void BufferCache<P>::ForgetGpuModifiedRange(DAddr device_addr, u64 size) {
in_place_gpu_written_ranges.Subtract(device_addr, size); in_place_gpu_written_ranges.Subtract(device_addr, size);
} }
template <class P>
bool BufferCache<P>::IsRegionWrittenInPlace(DAddr device_addr, u64 size) {
u64 covered = 0;
in_place_gpu_written_ranges.ForEachInRange(
device_addr, size, [&](DAddr start, DAddr end) { covered += end - start; });
return covered == size;
}
template <class P>
bool BufferCache<P>::IntersectsInPlaceWrites(DAddr device_addr, u64 size) {
bool intersects = false;
in_place_gpu_written_ranges.ForEachInRange(device_addr, size,
[&](DAddr, DAddr) { intersects = true; });
return intersects;
}
template <class P>
void BufferCache<P>::WaitForInPlaceWrites() {
if constexpr (!IS_OPENGL) {
if (in_place_write_tick > runtime.KnownGpuTick()) {
runtime.Wait(in_place_write_tick);
}
}
}
template <class P> template <class P>
BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size) { BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size) {
if (device_addr == 0) { if (device_addr == 0) {
@@ -1858,6 +1893,17 @@ void BufferCache<P>::UploadMemory(Buffer& buffer, u64 total_size_bytes, u64 larg
if (TryUnifiedUploadMemory(buffer, copies)) { if (TryUnifiedUploadMemory(buffer, copies)) {
return; return;
} }
if constexpr (USE_UNIFIED_DIRECT_BINDING) {
if (!in_place_gpu_written_ranges.Empty()) {
const DAddr buffer_start = buffer.CpuAddr();
for (const BufferCopy& copy : copies) {
if (IntersectsInPlaceWrites(buffer_start + copy.dst_offset, copy.size)) {
WaitForInPlaceWrites();
break;
}
}
}
}
if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) { if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
MappedUploadMemory(buffer, total_size_bytes, copies); MappedUploadMemory(buffer, total_size_bytes, copies);
} else { } else {
@@ -1939,7 +1985,8 @@ bool BufferCache<P>::ResolveUnifiedDirectBinding([[maybe_unused]] DAddr device_a
} }
contiguous += Core::DEVICE_PAGESIZE; contiguous += Core::DEVICE_PAGESIZE;
} }
if (IsRegionGpuModified(device_addr, size)) { if (IsRegionGpuModified(device_addr, size) &&
!IsRegionWrittenInPlace(device_addr, size)) {
return false; return false;
} }
window_index = relative / window_size; window_index = relative / window_size;
src/video_core/buffer_cache/buffer_cache_base.h
+7
View File
@@ -422,6 +422,12 @@ private:
void ForgetGpuModifiedRange(DAddr device_addr, u64 size); void ForgetGpuModifiedRange(DAddr device_addr, u64 size);
[[nodiscard]] bool IsRegionWrittenInPlace(DAddr device_addr, u64 size);
[[nodiscard]] bool IntersectsInPlaceWrites(DAddr device_addr, u64 size);
void WaitForInPlaceWrites();
[[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size); [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size);
void WaitForGpuFenceIfNeeded(Buffer& buffer); void WaitForGpuFenceIfNeeded(Buffer& buffer);
@@ -518,6 +524,7 @@ private:
Common::RangeSet<DAddr> uncommitted_gpu_modified_ranges; Common::RangeSet<DAddr> uncommitted_gpu_modified_ranges;
Common::RangeSet<DAddr> gpu_modified_ranges; Common::RangeSet<DAddr> gpu_modified_ranges;
Common::RangeSet<DAddr> in_place_gpu_written_ranges; Common::RangeSet<DAddr> in_place_gpu_written_ranges;
u64 in_place_write_tick = 0;
std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges; std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;
// Async Buffers // Async Buffers