mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-27 12:34:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Better sync

Browse Source
This commit is contained in:
Lander Gallastegi 2025-05-01 13:19:13 +02:00
parent b6001e47d6
commit ef51446b36
7 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
View File

@ -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:
Name(id, "fault_readback");
case Shader::BufferType::FaultBuffer:
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) {
fault_readback_index = buffers.size();
} else if (desc.buffer_type == BufferType::FaultBuffer) {
fault_buffer_index = buffers.size();
}
// Define aliases depending on the shader usage.

6
src/shader_recompiler/backend/spirv/spirv_emit_context.h
View File

@ -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{};

2
src/shader_recompiler/info.h
View File

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

4
src/shader_recompiler/ir/passes/shader_info_collection_pass.cpp
View File

@ -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),
.buffer_type = BufferType::FaultReadback,
.inline_cbuf = AmdGpu::Buffer::Placeholder(VideoCore::BufferCache::FAULT_BUFFER_SIZE),
.buffer_type = BufferType::FaultBuffer,
.is_written = true,
});
}

24
src/video_core/buffer_cache/buffer_cache.cpp
View File

@ -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};
vk::DescriptorBufferInfo fault_readback_info{
std::array<vk::BufferMemoryBarrier2, 2> barriers{fault_buffer_barrier, download_barrier};
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 VAddr page_end = Common::DivCeil(end, CACHING_PAGESIZE);
const u64 page_start = start >> CACHING_PAGEBITS;
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;

6
src/video_core/buffer_cache/buffer_cache.h
View File

@ -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.
[[nodiscard]] Buffer* GetFaultReadbackBuffer() noexcept {
/// Retrieves the fault buffer.
[[nodiscard]] Buffer* GetFaultBuffer() noexcept {
return &fault_buffer;
}

4
src/video_core/renderer_vulkan/vk_rasterizer.cpp
View File

@ -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) {
const auto* fault_buffer = buffer_cache.GetFaultReadbackBuffer();
} else if (desc.buffer_type == Shader::BufferType::FaultBuffer) {
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();