diff --git a/qrenderdoc/Code/QRDUtils.cpp b/qrenderdoc/Code/QRDUtils.cpp index 15cc6a1459a..9e4e60f0168 100644 --- a/qrenderdoc/Code/QRDUtils.cpp +++ b/qrenderdoc/Code/QRDUtils.cpp @@ -1620,6 +1620,39 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype) case ResourceUsage::Barrier: return lit("Barrier"); case ResourceUsage::CPUWrite: return lit("CPU Write"); + + case ResourceUsage::Pipeline: return lit("PSO"); + case ResourceUsage::PipelineLayout: return lit("PSO Layout"); + case ResourceUsage::VS_Shader: return lit("VS - Shader"); + case ResourceUsage::HS_Shader: return lit("HS - Shader"); + case ResourceUsage::DS_Shader: return lit("DS - Shader"); + case ResourceUsage::GS_Shader: return lit("GS - Shader"); + case ResourceUsage::PS_Shader: return lit("PS - Shader"); + case ResourceUsage::CS_Shader: return lit("CS - Shader"); + case ResourceUsage::TS_Shader: return lit("AS - Shader"); + case ResourceUsage::MS_Shader: return lit("MS - Shader"); + case ResourceUsage::DescriptorSet: return lit("Descriptor Set"); + case ResourceUsage::DescriptorSetLayout: return lit("Descriptor Set Layout"); + case ResourceUsage::RenderPass: return lit("Render Pass"); + case ResourceUsage::Framebuffer: return lit("Framebuffer"); + case ResourceUsage::Sampler: return lit("Sampler"); + case ResourceUsage::ImageView: return lit("ImageView"); + case ResourceUsage::BufferView: return lit("BufferView"); + case ResourceUsage::Bind: return lit("Bind"); + case ResourceUsage::UnBind: return lit("UnBind"); + case ResourceUsage::GetStatus: return lit("Get Status"); + case ResourceUsage::ReadCounter: return lit("Read Counter"); + case ResourceUsage::DescriptorSetWrite: return lit("Descriptor Set Write"); + case ResourceUsage::SparseBindingUpdate: return lit("Sparse Binding Update"); + case ResourceUsage::Reset: return lit("Reset"); + case ResourceUsage::Signal: return lit("Signal"); + case ResourceUsage::Wait: return lit("Wait"); + case ResourceUsage::Submit: return lit("Submit"); + case ResourceUsage::Begin: return lit("Begin"); + case ResourceUsage::End: return lit("End"); + case ResourceUsage::Recorded: return lit("Recorded"); + case ResourceUsage::Marker: return lit("Marker"); + case ResourceUsage::Present: return lit("Present"); } } else if(apitype == GraphicsAPI::OpenGL || apitype == GraphicsAPI::Vulkan) @@ -1687,6 +1720,39 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype) case ResourceUsage::Barrier: return lit("Barrier"); case ResourceUsage::CPUWrite: return lit("CPU Write"); + + case ResourceUsage::Pipeline: return lit("PSO"); + case ResourceUsage::PipelineLayout: return lit("PSO Layout"); + case ResourceUsage::VS_Shader: return lit("VS - Shader"); + case ResourceUsage::HS_Shader: return lit("HS - Shader"); + case ResourceUsage::DS_Shader: return lit("TCS - Shader"); + case ResourceUsage::GS_Shader: return lit("TES - Shader"); + case ResourceUsage::PS_Shader: return lit("FS - Shader"); + case ResourceUsage::CS_Shader: return lit("CS - Shader"); + case ResourceUsage::TS_Shader: return lit("TS - Shader"); + case ResourceUsage::MS_Shader: return lit("MS - Shader"); + case ResourceUsage::DescriptorSet: return lit("Descriptor Set"); + case ResourceUsage::DescriptorSetLayout: return lit("Descriptor Set Layout"); + case ResourceUsage::RenderPass: return lit("Render Pass"); + case ResourceUsage::Framebuffer: return lit("Framebuffer"); + case ResourceUsage::Sampler: return lit("Sampler"); + case ResourceUsage::ImageView: return lit("ImageView"); + case ResourceUsage::BufferView: return lit("BufferView"); + case ResourceUsage::Bind: return lit("Bind"); + case ResourceUsage::UnBind: return lit("UnBind"); + case ResourceUsage::GetStatus: return lit("Get Status"); + case ResourceUsage::ReadCounter: return lit("Read Counter"); + case ResourceUsage::DescriptorSetWrite: return lit("Descriptor Set Write"); + case ResourceUsage::SparseBindingUpdate: return lit("Sparse Binding Update"); + case ResourceUsage::Reset: return lit("Reset"); + case ResourceUsage::Signal: return lit("Signal"); + case ResourceUsage::Wait: return lit("Wait"); + case ResourceUsage::Submit: return lit("Submit"); + case ResourceUsage::Begin: return lit("Begin"); + case ResourceUsage::End: return lit("End"); + case ResourceUsage::Recorded: return lit("Recorded"); + case ResourceUsage::Marker: return lit("Marker"); + case ResourceUsage::Present: return lit("Present"); } } diff --git a/renderdoc/api/replay/renderdoc_tostr.inl b/renderdoc/api/replay/renderdoc_tostr.inl index 5720f968085..5ac7de86c07 100644 --- a/renderdoc/api/replay/renderdoc_tostr.inl +++ b/renderdoc/api/replay/renderdoc_tostr.inl @@ -851,6 +851,8 @@ rdcstr DoStringise(const ResourceUsage &el) STRINGISE_ENUM_CLASS_NAMED(GS_Constants, "GS - Constants"); STRINGISE_ENUM_CLASS_NAMED(PS_Constants, "PS - Constants"); STRINGISE_ENUM_CLASS_NAMED(CS_Constants, "CS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(TS_Constants, "TS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(MS_Constants, "MS - Constants"); STRINGISE_ENUM_CLASS_NAMED(All_Constants, "All Stages - Constants"); @@ -862,6 +864,8 @@ rdcstr DoStringise(const ResourceUsage &el) STRINGISE_ENUM_CLASS_NAMED(GS_Resource, "GS - Read-only Resource"); STRINGISE_ENUM_CLASS_NAMED(PS_Resource, "PS - Read-only Resource"); STRINGISE_ENUM_CLASS_NAMED(CS_Resource, "CS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(TS_Resource, "TS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(MS_Resource, "MS - Read-only Resource"); STRINGISE_ENUM_CLASS_NAMED(All_Resource, "All Stages - Read-only Resource"); @@ -871,9 +875,20 @@ rdcstr DoStringise(const ResourceUsage &el) STRINGISE_ENUM_CLASS_NAMED(GS_RWResource, "GS - Read-write Resource"); STRINGISE_ENUM_CLASS_NAMED(PS_RWResource, "PS - Read-write Resource"); STRINGISE_ENUM_CLASS_NAMED(CS_RWResource, "CS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(TS_RWResource, "TS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(MS_RWResource, "MS - Read-write Resource"); STRINGISE_ENUM_CLASS_NAMED(All_RWResource, "All Stages - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(VS_Shader, "Vertex Shader"); + STRINGISE_ENUM_CLASS_NAMED(HS_Shader, "Hull Shader"); + STRINGISE_ENUM_CLASS_NAMED(DS_Shader, "Domain Shader"); + STRINGISE_ENUM_CLASS_NAMED(GS_Shader, "Geometry Shader"); + STRINGISE_ENUM_CLASS_NAMED(PS_Shader, "Pixel Shader"); + STRINGISE_ENUM_CLASS_NAMED(CS_Shader, "Compute Shader"); + STRINGISE_ENUM_CLASS_NAMED(TS_Shader, "Task Shader"); + STRINGISE_ENUM_CLASS_NAMED(MS_Shader, "Mesh Shader"); + STRINGISE_ENUM_CLASS_NAMED(InputTarget, "Input target"); STRINGISE_ENUM_CLASS_NAMED(ColorTarget, "Color target"); STRINGISE_ENUM_CLASS_NAMED(DepthStencilTarget, "Depth/stencil target"); @@ -894,6 +909,36 @@ rdcstr DoStringise(const ResourceUsage &el) STRINGISE_ENUM_CLASS_NAMED(Barrier, "Barrier"); STRINGISE_ENUM_CLASS_NAMED(CPUWrite, "CPU Write"); + + STRINGISE_ENUM_CLASS_NAMED(Pipeline, "Pipeline"); + STRINGISE_ENUM_CLASS_NAMED(PipelineLayout, "Pipeline Layout"); + STRINGISE_ENUM_CLASS_NAMED(DescriptorSet, "Descriptor Set"); + STRINGISE_ENUM_CLASS_NAMED(DescriptorSetLayout, "Descriptor Set Layout"); + STRINGISE_ENUM_CLASS_NAMED(RenderPass, "Render Pass"); + STRINGISE_ENUM_CLASS_NAMED(Framebuffer, "Framebuffer"); + STRINGISE_ENUM_CLASS_NAMED(Sampler, "Sampler"); + STRINGISE_ENUM_CLASS_NAMED(ImageView, "Image View"); + STRINGISE_ENUM_CLASS_NAMED(BufferView, "Buffer View"); + + STRINGISE_ENUM_CLASS_NAMED(Bind, "Bind"); + STRINGISE_ENUM_CLASS_NAMED(UnBind, "UnBind"); + + STRINGISE_ENUM_CLASS_NAMED(GetStatus, "Get Status"); + STRINGISE_ENUM_CLASS_NAMED(ReadCounter, "Read Counter"); + STRINGISE_ENUM_CLASS_NAMED(DescriptorSetWrite, "Descriptor Set Write"); + STRINGISE_ENUM_CLASS_NAMED(SparseBindingUpdate, "Sparse Binding Update"); + STRINGISE_ENUM_CLASS_NAMED(Recorded, "Recorded"); + + STRINGISE_ENUM_CLASS_NAMED(Reset, "Reset"); + STRINGISE_ENUM_CLASS_NAMED(Signal, "Signal"); + STRINGISE_ENUM_CLASS_NAMED(Wait, "Wait"); + + STRINGISE_ENUM_CLASS_NAMED(Submit, "Submit"); + STRINGISE_ENUM_CLASS_NAMED(Marker, "Marker"); + STRINGISE_ENUM_CLASS_NAMED(Present, "Present"); + + STRINGISE_ENUM_CLASS_NAMED(Begin, "Begin"); + STRINGISE_ENUM_CLASS_NAMED(End, "End"); } END_ENUM_STRINGISE(); } diff --git a/renderdoc/api/replay/replay_enums.h b/renderdoc/api/replay/replay_enums.h index 0216ae05fa8..82087ea567c 100644 --- a/renderdoc/api/replay/replay_enums.h +++ b/renderdoc/api/replay/replay_enums.h @@ -2972,6 +2972,38 @@ Note that a resource may be used for more than one thing in one event, see :clas The resource is being used as a read-write resource in all shader stages. +.. data:: VS_Shader + + The :data:`vertex shader `. + +.. data:: HS_Shader + + The :data:`hull shader `. + +.. data:: DS_Shader + + The :data:`domain shader `. + +.. data:: GS_Shader + + The :data:`geometry shader `. + +.. data:: PS_Shader + + The :data:`pixel shader `. + +.. data:: CS_Shader + + The :data:`compute shader `. + +.. data:: TS_Shader + + The amplification or :data:`task shader `. + +.. data:: MS_Shader + + The :data:`mesh shader `. + .. data:: InputTarget The resource is being read as an input target for reading from the target currently being written. @@ -3032,6 +3064,103 @@ Note that a resource may be used for more than one thing in one event, see :clas The resource is written from the CPU, either directly as mapped memory or indirectly via a synchronous update. + +.. data:: Pipeline + + The Pipeline Object in Vulkan :data:`VKPipeline `. + +.. data:: PipelineLayout + + The PipelineLayout used when creating a Pipeline Object + +.. data:: DescriptorSet + + The DescriptorSet in Vulkan :data:`VKDescriptorSet `. + +.. data:: DescriptorSetLayout + + The DescriptorSetLayout used when creating a DescriptorSet + +.. data:: RenderPass + + The RenderPass Object in Vulkan :data: 'VKRenderPass '. + +.. data:: Framebuffer + + The FrameBuffer Object in Vulkan :data: 'VKFrameBuffer '. + +.. data:: Sampler + + The Sampler Object + +.. data:: ImageView + + An ImageView Object in Vulkan or D3D12. + +.. data:: BufferView + + A BufferView Object in Vulkan or D3D12. + +.. data:: Bind + + The resource is bound i.e. as a resource to the render state or memory bound to a resource. + +.. data:: UnBind + + The resource is unbound i.e. it was replaced in the render state. + +.. data:: GetStatus + + Getting the status of a synchronisation resource i.e. Vulkan Fence. + +.. data:: ReadCounter + + Reading the value of a synchronisation resource i.e. Vulkan Semaphore. + +.. data:: DescriptorSetWrite + + Updating a Descriptor Set resource. + +.. data:: SparseBindingUpdate + + Updating the Sparse Binding for a resource. + +.. data:: Marker + + The resource is associated with a marker or label. + +.. data:: Present + + The resource is associated with a present i.e. Command Queue + +.. data:: Recorded + + The resource is recorded into i.e. Command Buffer, Command List + +.. data:: Reset + + The resource is reset i.e. Fence, Event, Semaphore, Command Buffer. + +.. data:: Signal + + The synchronisation resource is signalled/set i.e. Fence, Event, Semaphore. + +.. data:: Wait + + The synchronisation resource is waited on i.e. Fence, Event, Semaphore. + +.. data:: Submit + + The resource is submitted i.e. Command Buffer, Command List. + +.. data:: Begin + + The resource starts recording i.e. Query, Command Buffer, Command List. + +.. data:: End + + The resource stops recording i.e. Query, Command Buffer, Command List. + )"); enum class ResourceUsage : uint32_t { @@ -3075,6 +3204,15 @@ enum class ResourceUsage : uint32_t All_RWResource, + VS_Shader, + HS_Shader, + DS_Shader, + GS_Shader, + PS_Shader, + CS_Shader, + TS_Shader, + MS_Shader, + InputTarget, ColorTarget, DepthStencilTarget, @@ -3095,6 +3233,37 @@ enum class ResourceUsage : uint32_t Barrier, CPUWrite, + + Pipeline, + PipelineLayout, + DescriptorSet, + DescriptorSetLayout, + RenderPass, + Framebuffer, + Sampler, + ImageView, + BufferView, + + Bind, + UnBind, + + GetStatus, + ReadCounter, + DescriptorSetWrite, + SparseBindingUpdate, + Marker, + Recorded, + + Reset, + Signal, + Wait, + + Submit, + Present, + + Begin, + End, + }; DECLARE_REFLECTION_ENUM(ResourceUsage); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 7a47390c7d0..5c43dfc15cc 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -5184,6 +5184,8 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) action.copyDestination = m_LastPresentedImage; AddAction(action); + if(m_LastPresentedImage != ResourceId()) + GetLastEventNode().AddResourceUsage(m_LastPresentedImage, ResourceUsage::CopyDst); } return true; @@ -6391,9 +6393,45 @@ void WrappedVulkan::AddUsage(VulkanEventNode &eventNode) const VulkanStatePipeline &pipeState = (compute ? state.compute : state.graphics); + VulkanCreationInfo &c = m_CreationInfo; + + ////////////////////////////// + // Pipeline + bool shaderObject = pipeState.shaderObject; + + ResourceId pipe = pipeState.pipeline; + if(!shaderObject) + { + eventNode.AddResourceUsage(pipe, ResourceUsage::Pipeline); + + const VulkanCreationInfo::Pipeline &p = c.m_Pipeline[pipe]; + if(compute) + { + eventNode.AddResourceUsage(p.compLayout, ResourceUsage::PipelineLayout); + } + else + { + eventNode.AddUniqueResourceUsage(p.vertLayout, ResourceUsage::PipelineLayout); + eventNode.AddUniqueResourceUsage(p.fragLayout, ResourceUsage::PipelineLayout); + } + } + ////////////////////////////// // Shaders + rdcarray shaderStages = ShaderStagesForAction(action.flags); + + for(int shad : shaderStages) + { + VulkanCreationInfo::ShaderEntry &sh = shaderObject + ? c.m_ShaderObject[state.shaderObjects[shad]].shad + : c.m_Pipeline[pipe].shaders[shad]; + if(sh.module == ResourceId()) + continue; + + eventNode.AddResourceUsage(sh.module, ResourceUsage(uint32_t(ResourceUsage::VS_Shader) + shad)); + } + if(pipeState.UsingDescBufs()) { eventNode.deferredResourceUsage.push_back({}); @@ -6530,7 +6568,10 @@ void WrappedVulkan::AddUsageForDescriptorBufferBind(VulkanEventNode &eventNode, const VulkanCreationInfo::PipelineLayout &pipeLayout = c.m_PipelineLayout[descSets[bindset].pipeLayout]; - const DescSetLayout &layout = c.m_DescSetLayout[pipeLayout.descSetLayouts[bindset]]; + ResourceId descSetLayoutId = pipeLayout.descSetLayouts[bindset]; + const DescSetLayout &layout = c.m_DescSetLayout[descSetLayoutId]; + + eventNode.AddUniqueResourceUsage(descSetLayoutId, ResourceUsage::DescriptorSetLayout); if(layout.bindings.empty()) { @@ -6650,8 +6691,13 @@ void WrappedVulkan::AddUsageForDescriptorSetBind(VulkanEventNode &eventNode, uin if(descSets[bindset].descBufferIdx != ~0U) return; - const DescriptorSetInfo &descset = m_DescriptorSetState[descSets[bindset].descSet]; - const DescSetLayout &layout = c.m_DescSetLayout[descset.layout]; + ResourceId descSetId = descSets[bindset].descSet; + const DescriptorSetInfo &descset = m_DescriptorSetState[descSetId]; + ResourceId descSetLayoutId = descset.layout; + const DescSetLayout &layout = c.m_DescSetLayout[descSetLayoutId]; + + eventNode.AddUniqueResourceUsage(descSetId, ResourceUsage::DescriptorSet); + eventNode.AddUniqueResourceUsage(descSetLayoutId, ResourceUsage::DescriptorSetLayout); if(layout.bindings.empty()) { @@ -6719,10 +6765,6 @@ void WrappedVulkan::AddUsageForDescriptor(VulkanEventNode &eventNode, const Desc if(slot.type == DescriptorSlotType::Unwritten) return; - // we don't mark samplers with usage - if(slot.type == DescriptorSlotType::Sampler) - return; - ResourceId id; switch(slot.type) @@ -6731,21 +6773,29 @@ void WrappedVulkan::AddUsageForDescriptor(VulkanEventNode &eventNode, const Desc case DescriptorSlotType::SampledImage: case DescriptorSlotType::StorageImage: if(slot.resource != ResourceId()) + { + eventNode.AddResourceUsage(slot.resource, ResourceUsage::ImageView); id = c.m_ImageView[slot.resource].image; + } + if(slot.sampler != ResourceId()) + eventNode.AddResourceUsage(slot.sampler, ResourceUsage::Sampler); break; case DescriptorSlotType::UniformTexelBuffer: case DescriptorSlotType::StorageTexelBuffer: - id = slot.resource; if(c.m_BufferView.find(slot.resource) != c.m_BufferView.end()) + { + eventNode.AddResourceUsage(slot.resource, ResourceUsage::BufferView); id = c.m_BufferView[slot.resource].buffer; + } break; case DescriptorSlotType::UniformBuffer: case DescriptorSlotType::UniformBufferDynamic: case DescriptorSlotType::StorageBuffer: case DescriptorSlotType::StorageBufferDynamic: - case DescriptorSlotType::AccelerationStructure: - if(slot.resource != ResourceId()) - id = slot.resource; + case DescriptorSlotType::AccelerationStructure: id = slot.resource; break; + case DescriptorSlotType::Sampler: + if(slot.sampler != ResourceId()) + eventNode.AddResourceUsage(slot.sampler, ResourceUsage::Sampler); break; default: RDCERR("Unexpected type %d", slot.type); break; } @@ -6773,6 +6823,8 @@ void WrappedVulkan::AddFramebufferUsage(VulkanEventNode &eventNode, if(renderPass != ResourceId() && framebuffer != ResourceId()) { const VulkanCreationInfo::RenderPass &rp = c.m_RenderPass[renderPass]; + eventNode.AddResourceUsage(renderPass, ResourceUsage::RenderPass); + eventNode.AddResourceUsage(framebuffer, ResourceUsage::Framebuffer); if(subpass >= rp.subpasses.size()) { @@ -6872,6 +6924,11 @@ void WrappedVulkan::AddFramebufferUsage(VulkanEventNode &eventNode, } } } + for(const ResourceId &att : fbattachments) + { + if(att != ResourceId()) + eventNode.AddResourceUsage(att, ResourceUsage::ImageView); + } } void WrappedVulkan::AddEvent() @@ -6901,6 +6958,9 @@ void WrappedVulkan::AddEvent() apievent.annotations = m_RootAnnotation->Duplicate(); } + if(m_LastCmdBufferID != ResourceId()) + node.AddResourceUsage(m_LastCmdBufferID, ResourceUsage::Recorded); + m_AddedEventNode = true; } diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 08b61bb3e23..98ad7036e4e 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -136,8 +136,23 @@ struct VulkanEventNode ~VulkanEventNode() = default; void AddResourceUsage(ResourceId id, ResourceUsage usage) { + RDCASSERTNOTEQUAL(id, ResourceId()); resourceUsage.push_back(make_rdcpair(id, usage)); } + void AddUniqueResourceUsage(ResourceId id, ResourceUsage usage) + { + RDCASSERTNOTEQUAL(id, ResourceId()); + if(resourceUsage.contains(make_rdcpair(id, usage))) + return; + resourceUsage.push_back(make_rdcpair(id, usage)); + } + void AddResourceBind(ResourceId prev, ResourceId cur) + { + if(prev != ResourceId()) + AddUniqueResourceUsage(prev, ResourceUsage::UnBind); + if(cur != ResourceId()) + AddUniqueResourceUsage(cur, ResourceUsage::Bind); + } // eventId is not used APIEvent event; @@ -781,6 +796,9 @@ class WrappedVulkan : public IFrameCapturer rdcarray pendingAnnotations; rdcarray executedCmds; + // the serialised command buffer not the baked command buffer + ResourceId commandBuffer; + uint32_t beginChunk = 0; uint32_t endChunk = 0; @@ -1204,6 +1222,11 @@ class WrappedVulkan : public IFrameCapturer RDCASSERT(IsLoading(m_State)); m_LoadingEventNode.AddResourceUsage(id, usage); } + void AddEventResourceBind(ResourceId prev, ResourceId cur) + { + RDCASSERT(IsLoading(m_State)); + m_LoadingEventNode.AddResourceBind(prev, cur); + } rdcarray m_Events; VulkanEventNode m_LoadingEventNode; diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 9eb8098daef..299f9890a7a 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -4163,12 +4163,6 @@ bool VulkanReplay::GetHistogram(ResourceId texid, const Subresource &sub, CompTy rdcarray VulkanReplay::GetUsage(ResourceId id) { - if(m_pDriver->m_CreationInfo.m_Image.find(id) == m_pDriver->m_CreationInfo.m_Image.end() && - m_pDriver->m_CreationInfo.m_Buffer.find(id) == m_pDriver->m_CreationInfo.m_Buffer.end()) - { - return {EventUsage(0, ResourceUsage::Unused)}; - } - return m_pDriver->GetUsage(id); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index eb6eefecba2..947f394032b 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -1547,6 +1547,8 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(SerialiserType &ser, VkComman m_BakedCmdBufferInfo[BakedCommandBuffer].activeSubpass = 0; m_BakedCmdBufferInfo[CommandBuffer].endBarriers.clear(); m_BakedCmdBufferInfo[BakedCommandBuffer].endBarriers.clear(); + m_BakedCmdBufferInfo[CommandBuffer].commandBuffer = CommandBuffer; + m_BakedCmdBufferInfo[BakedCommandBuffer].commandBuffer = CommandBuffer; VkCommandBufferBeginInfo unwrappedBeginInfo = BeginInfo; VkCommandBufferInheritanceInfo unwrappedInheritInfo; @@ -2266,6 +2268,10 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(SerialiserType &ser, VkComman (uint32_t)imgBarriers.size(), imgBarriers.data()); if(loading) { + // EndRenderPass will add Unbind usage for the RenderPass, Framebuffer + AddEventResourceUsage(fb, ResourceUsage::Bind); + AddEventResourceUsage(rp, ResourceUsage::Bind); + // Record image usage for images cleared in the beginning of the render pass. for(size_t i = 0; i < rpinfo.attachments.size(); i++) { @@ -2541,6 +2547,10 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass(SerialiserType &ser, VkCommandB action.flags |= ActionFlags::PassBoundary | ActionFlags::EndPass; AddAction(action); + + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(renderstate.GetFramebuffer(), ResourceUsage::UnBind); + eventNode.AddResourceUsage(renderstate.GetRenderPass(), ResourceUsage::UnBind); } attachments = renderstate.GetFramebufferAttachments(); @@ -2818,8 +2828,13 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass2(SerialiserType &ser, m_ActionCallback->PostRemisc(eventId, drawFlags, commandBuffer); } + // JAKE TODO: CHECK THIS AGAINST vkCmdBeginRenderPass if(loading) { + // EndRenderPass will add Unbind usage for the RenderPass, Framebuffer + AddEventResourceUsage(fb, ResourceUsage::Bind); + AddEventResourceUsage(rp, ResourceUsage::Bind); + // Record image usage for images cleared in the beginning of the render pass. const rdcarray &fbattachments = m_BakedCmdBufferInfo[m_LastCmdBufferID].state.GetFramebufferAttachments(); @@ -3133,6 +3148,10 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand action.flags |= ActionFlags::PassBoundary | ActionFlags::EndPass; AddAction(action); + + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(renderstate.GetFramebuffer(), ResourceUsage::UnBind); + eventNode.AddResourceUsage(renderstate.GetRenderPass(), ResourceUsage::UnBind); } attachments = GetCmdRenderState().GetFramebufferAttachments(); @@ -3603,6 +3622,12 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline(SerialiserType &ser, VkCommandBu renderstate.domainOrigin = pipeInfo.tessellationDomainOrigin; } } + if(loading) + { + if(prevPipeline != ResourceId()) + AddEventResourceUsage(prevPipeline, ResourceUsage::UnBind); + AddEventResourceUsage(id, ResourceUsage::Bind); + } } ObjDisp(commandBuffer)->CmdBindPipeline(Unwrap(commandBuffer), pipelineBindPoint, Unwrap(pipeline)); @@ -3699,6 +3724,8 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( // consume the offsets linearly along the descriptor set layouts for(uint32_t i = 0; i < setCount; i++) { + if(loading) + AddEventResourceBind(descsets[firstSet + i].descSet, GetResID(pDescriptorSets[i])); descsets[firstSet + i] = VulkanStatePipeline::DescriptorAndOffsets(); descsets[firstSet + i].pipeLayout = GetResID(layout); descsets[firstSet + i].descSet = GetResID(pDescriptorSets[i]); @@ -3820,6 +3847,9 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets2( // consume the offsets linearly along the descriptor set layouts for(uint32_t i = 0; i < BindDescriptorSetsInfo.descriptorSetCount; i++) { + if(loading) + AddEventResourceBind(descsets[firstSet + i].descSet, + GetResID(BindDescriptorSetsInfo.pDescriptorSets[i])); descsets[firstSet + i] = VulkanStatePipeline::DescriptorAndOffsets(); descsets[firstSet + i].pipeLayout = GetResID(BindDescriptorSetsInfo.layout); descsets[firstSet + i].descSet = GetResID(BindDescriptorSetsInfo.pDescriptorSets[i]); @@ -3913,6 +3943,8 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(SerialiserType &ser, for(uint32_t i = 0; i < bindingCount; i++) { + if(loading) + AddEventResourceBind(renderstate.vbuffers[firstBinding + i].buf, GetResID(pBuffers[i])); renderstate.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); renderstate.vbuffers[firstBinding + i].offs = pOffsets[i]; renderstate.vbuffers[firstBinding + i].size = VK_WHOLE_SIZE; @@ -3994,6 +4026,9 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers2( for(uint32_t i = 0; i < bindingCount; i++) { + if(loading) + AddEventResourceBind(renderstate.vbuffers[firstBinding + i].buf, GetResID(pBuffers[i])); + renderstate.vbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); renderstate.vbuffers[firstBinding + i].offs = pOffsets[i]; renderstate.vbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE; @@ -4081,6 +4116,8 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(SerialiserType &ser, { VulkanRenderState &renderstate = GetCmdRenderState(); + if(loading) + AddEventResourceBind(renderstate.ibuffer.buf, GetResID(buffer)); renderstate.ibuffer.buf = GetResID(buffer); renderstate.ibuffer.offs = offset; renderstate.ibuffer.size = VK_WHOLE_SIZE; @@ -4793,6 +4830,12 @@ bool WrappedVulkan::Serialise_vkCmdCopyQueryPoolResults( if(!loading) commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + if(loading) + { + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::CopySrc); + AddEventResourceUsage(GetResID(destBuffer), ResourceUsage::CopyDst); + } + VulkanCreationInfo::QueryPool &qpInfo = m_CreationInfo.m_QueryPool[GetResID(queryPool)]; // skip AS queries as we do not serialise them @@ -4945,6 +4988,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginQuery(SerialiserType &ser, VkCommandBuff if(commandBuffer != VK_NULL_HANDLE) ObjDisp(commandBuffer)->CmdBeginQuery(Unwrap(commandBuffer), Unwrap(queryPool), query, flags); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::Begin); } return true; @@ -4998,6 +5044,9 @@ bool WrappedVulkan::Serialise_vkCmdEndQuery(SerialiserType &ser, VkCommandBuffer if(commandBuffer != VK_NULL_HANDLE) ObjDisp(commandBuffer)->CmdEndQuery(Unwrap(commandBuffer), Unwrap(queryPool), query); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::End); } return true; @@ -5057,6 +5106,8 @@ bool WrappedVulkan::Serialise_vkCmdResetQueryPool(SerialiserType &ser, VkCommand m_ResetQueries.push_back({queryPool, firstQuery, queryCount}); } + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::Reset); } return true; @@ -5206,6 +5257,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman beginNode.startChildExecute = true; beginNode.cmdBufId = m_LastCmdBufferID; beginNode.childCmdBufId = cmd; + beginNode.AddResourceUsage(cmd, ResourceUsage::Reset); + beginNode.AddResourceUsage(cmdBufInfo.commandBuffer, ResourceUsage::Reset); if(!parentActiveRenderPass && (cmdBufInfo.beginFlags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) @@ -5242,6 +5295,8 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(SerialiserType &ser, VkComman VulkanEventNode &endNode = GetLastEventNode(); endNode.endChildExecute = true; endNode.childCmdBufId = cmd; + endNode.AddResourceUsage(cmd, ResourceUsage::Submit); + endNode.AddResourceUsage(cmdBufInfo.commandBuffer, ResourceUsage::Submit); } // add an extra pop marker @@ -6244,6 +6299,8 @@ bool WrappedVulkan::Serialise_vkCmdWriteBufferMarkerAMD(SerialiserType &ser, ->CmdWriteBufferMarkerAMD(Unwrap(commandBuffer), pipelineStage, Unwrap(dstBuffer), dstOffset, marker); } + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(dstBuffer), ResourceUsage::CopyDst); } return true; @@ -6311,6 +6368,8 @@ bool WrappedVulkan::Serialise_vkCmdWriteBufferMarker2AMD(SerialiserType &ser, ->CmdWriteBufferMarker2AMD(Unwrap(commandBuffer), stage, Unwrap(dstBuffer), dstOffset, marker); } + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(dstBuffer), ResourceUsage::CopyDst); } return true; @@ -6638,6 +6697,8 @@ bool WrappedVulkan::Serialise_vkCmdBindTransformFeedbackBuffersEXT( for(uint32_t i = 0; i < bindingCount; i++) { + if(loading) + AddEventResourceBind(renderstate.xfbbuffers[firstBinding + i].buf, GetResID(pBuffers[i])); renderstate.xfbbuffers[firstBinding + i].buf = GetResID(pBuffers[i]); renderstate.xfbbuffers[firstBinding + i].offs = pOffsets[i]; renderstate.xfbbuffers[firstBinding + i].size = pSizes ? pSizes[i] : VK_WHOLE_SIZE; @@ -6719,6 +6780,8 @@ bool WrappedVulkan::Serialise_vkCmdBeginTransformFeedbackEXT( for(uint32_t i = 0; i < bufferCount; i++) { ResourceId buf = pCounterBuffers ? GetResID(pCounterBuffers[i]) : ResourceId(); + if(loading) + AddEventResourceBind(renderstate.xfbcounters[i].buf, buf); renderstate.xfbcounters[i].buf = buf; renderstate.xfbcounters[i].offs = pCounterBufferOffsets ? pCounterBufferOffsets[i] : 0; } @@ -6796,6 +6859,11 @@ bool WrappedVulkan::Serialise_vkCmdEndTransformFeedbackEXT( { VulkanRenderState &renderstate = GetCmdRenderState(); + if(loading && pCounterBuffers) + { + for(uint32_t i = 0; i < bufferCount; i++) + AddEventResourceUsage(GetResID(pCounterBuffers[i]), ResourceUsage::UnBind); + } renderstate.firstxfbcounter = 0; renderstate.xfbcounters.clear(); } @@ -6876,6 +6944,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginQueryIndexedEXT(SerialiserType &ser, if(commandBuffer != VK_NULL_HANDLE) ObjDisp(commandBuffer) ->CmdBeginQueryIndexedEXT(Unwrap(commandBuffer), Unwrap(queryPool), query, flags, index); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::Begin); } return true; @@ -6935,6 +7006,9 @@ bool WrappedVulkan::Serialise_vkCmdEndQueryIndexedEXT(SerialiserType &ser, if(commandBuffer != VK_NULL_HANDLE) ObjDisp(commandBuffer) ->CmdEndQueryIndexedEXT(Unwrap(commandBuffer), Unwrap(queryPool), query, index); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::End); } return true; @@ -8527,6 +8601,8 @@ bool WrappedVulkan::Serialise_vkCmdWriteAccelerationStructuresPropertiesKHR( { m_LastCmdBufferID = GetResID(commandBuffer); + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::CopyDst); // don't actually replay - this is purely for user information } @@ -8653,6 +8729,9 @@ bool WrappedVulkan::Serialise_vkCmdBindShadersEXT(SerialiserType &ser, ResourceId shader = pShaders && (pShaders[i] != VK_NULL_HANDLE) ? GetResID(pShaders[i]) : ResourceId(); + if(loading) + AddEventResourceBind(renderstate.shaderObjects[stageIndex], shader); + renderstate.shaderObjects[stageIndex] = shader; // calling vkCmdBindShadersEXT disturbs the corresponding pipeline bind points @@ -8743,6 +8822,9 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2(SerialiserType &ser, { VulkanRenderState &renderstate = GetCmdRenderState(); + if(loading) + AddEventResourceBind(renderstate.ibuffer.buf, GetResID(buffer)); + renderstate.ibuffer.buf = GetResID(buffer); renderstate.ibuffer.offs = offset; renderstate.ibuffer.size = size; @@ -9895,6 +9977,9 @@ bool WrappedVulkan::Serialise_vkCmdCopyQueryPoolResultsToMemoryKHR( if(!loading) commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::CopySrc); + VulkanCreationInfo::QueryPool &qpInfo = m_CreationInfo.m_QueryPool[GetResID(queryPool)]; // skip AS queries as we do not serialise them diff --git a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp index 8f4575b9ee5..dae00827b7c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp @@ -2458,6 +2458,8 @@ void WrappedVulkan::ReplayDescriptorSetWrite(VkDevice device, const VkWriteDescr } } } + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(writeDesc.dstSet), ResourceUsage::DescriptorSetWrite); } void WrappedVulkan::ReplayDescriptorSetCopy(VkDevice device, const VkCopyDescriptorSet ©Desc) @@ -2533,6 +2535,11 @@ void WrappedVulkan::ReplayDescriptorSetCopy(VkDevice device, const VkCopyDescrip (*dstbind)[curDstIdx] = (*srcbind)[curSrcIdx]; } } + if(IsLoading(m_State)) + { + AddEventResourceUsage(srcSetId, ResourceUsage::CopySrc); + AddEventResourceUsage(dstSetId, ResourceUsage::CopyDst); + } } template diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 4d216f4dd09..09f5c5909e2 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -5579,6 +5579,8 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(SerialiserType &ser, VkDevice dev if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(device), ResourceUsage::Wait); } return true; diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index 059a463ab78..d810f9e55af 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -2186,6 +2186,8 @@ bool WrappedVulkan::Serialise_vkResetQueryPool(SerialiserType &ser, VkDevice dev if(IsReplayingAndReading()) { ObjDisp(device)->ResetQueryPool(Unwrap(device), Unwrap(queryPool), firstQuery, queryCount); + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queryPool), ResourceUsage::Reset); } return true; diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index dad311e2337..400bb1238b0 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -298,6 +298,7 @@ void WrappedVulkan::ReplayQueueSubmit(VkQueue queue, VkSubmitInfo2 submitInfo, r VulkanEventNode &eventNode = GetLastEventNode(); eventNode.event.chunkIndex = APIEvent::NoChunk; eventNode.addActionUse = false; + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Submit); } // submit command buffers one by one @@ -335,6 +336,9 @@ void WrappedVulkan::ReplayQueueSubmit(VkQueue queue, VkSubmitInfo2 submitInfo, r eventNode.addActionUse = false; eventNode.addSubmit = true; eventNode.cmdBufId = cmd; + eventNode.AddResourceUsage(cmd, ResourceUsage::Reset); + eventNode.AddResourceUsage(cmdBufInfo.commandBuffer, ResourceUsage::Reset); + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Submit); } // insert the baked command buffer into the root events, resolving indirect and deferred actions @@ -352,6 +356,9 @@ void WrappedVulkan::ReplayQueueSubmit(VkQueue queue, VkSubmitInfo2 submitInfo, r VulkanEventNode &eventNode = GetLastEventNode(); eventNode.event.chunkIndex = cmdBufInfo.endChunk; eventNode.addActionUse = false; + eventNode.AddResourceUsage(cmd, ResourceUsage::Submit); + eventNode.AddResourceUsage(cmdBufInfo.commandBuffer, ResourceUsage::Submit); + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Submit); if(localAnnotations) { // Modify using the annotations stored in the event node @@ -1368,12 +1375,25 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(SerialiserType &ser, VkQueue queue, rdcstr basename = StringFormat::Fmt("vkQueueSubmit(%u)", submitInfo.commandBufferInfoCount); + if(IsLoading(m_State)) + { + AddEventResourceUsage(GetResID(queue), ResourceUsage::Submit); + if(fence != VK_NULL_HANDLE) + AddEventResourceUsage(GetResID(fence), ResourceUsage::Wait); + for(uint32_t s = 0; s < pSubmits[sub].waitSemaphoreCount; ++s) + AddEventResourceUsage(GetResID(pSubmits[sub].pWaitSemaphores[s]), ResourceUsage::Wait); + for(uint32_t s = 0; s < pSubmits[sub].signalSemaphoreCount; ++s) + AddEventResourceUsage(GetResID(pSubmits[sub].pSignalSemaphores[s]), ResourceUsage::Signal); + } ReplayQueueSubmit(queue, submitInfo, basename); } if(submitCount == 0) { if(IsLoading(m_State)) { + AddEventResourceUsage(GetResID(queue), ResourceUsage::Submit); + if(fence != VK_NULL_HANDLE) + AddEventResourceUsage(GetResID(fence), ResourceUsage::Wait); AddEvent(); ObjDisp(queue)->QueueSubmit(Unwrap(queue), 0, NULL, VK_NULL_HANDLE); @@ -1384,7 +1404,9 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(SerialiserType &ser, VkQueue queue, AddEvent(); AddAction(action); - GetLastEventNode().event.chunkIndex = APIEvent::NoChunk; + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.event.chunkIndex = APIEvent::NoChunk; + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Submit); } else { @@ -1559,6 +1581,19 @@ bool WrappedVulkan::Serialise_vkQueueSubmit2(SerialiserType &ser, VkQueue queue, { rdcstr basename = StringFormat::Fmt("vkQueueSubmit2(%u)", pSubmits[sub].commandBufferInfoCount); + if(IsLoading(m_State)) + { + AddEventResourceUsage(GetResID(queue), ResourceUsage::Submit); + if(fence != VK_NULL_HANDLE) + AddEventResourceUsage(GetResID(fence), ResourceUsage::Wait); + + for(uint32_t s = 0; s < pSubmits[sub].waitSemaphoreInfoCount; ++s) + AddEventResourceUsage(GetResID(pSubmits[sub].pWaitSemaphoreInfos[s].semaphore), + ResourceUsage::Wait); + for(uint32_t s = 0; s < pSubmits[sub].signalSemaphoreInfoCount; ++s) + AddEventResourceUsage(GetResID(pSubmits[sub].pSignalSemaphoreInfos[s].semaphore), + ResourceUsage::Signal); + } VkSubmitInfo2 submitInfo = pSubmits[sub]; submitInfo.waitSemaphoreInfoCount = 0; submitInfo.pWaitSemaphoreInfos = NULL; @@ -1570,6 +1605,9 @@ bool WrappedVulkan::Serialise_vkQueueSubmit2(SerialiserType &ser, VkQueue queue, { if(IsLoading(m_State)) { + AddEventResourceUsage(GetResID(queue), ResourceUsage::Submit); + if(fence != VK_NULL_HANDLE) + AddEventResourceUsage(GetResID(fence), ResourceUsage::Wait); AddEvent(); ObjDisp(queue)->QueueSubmit2(Unwrap(queue), 0, NULL, VK_NULL_HANDLE); @@ -1580,7 +1618,9 @@ bool WrappedVulkan::Serialise_vkQueueSubmit2(SerialiserType &ser, VkQueue queue, AddEvent(); AddAction(action); - GetLastEventNode().event.chunkIndex = APIEvent::NoChunk; + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.event.chunkIndex = APIEvent::NoChunk; + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Submit); } else { @@ -1725,6 +1765,21 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que if(IsReplayingAndReading()) { + if(IsLoading(m_State)) + { + AddEventResourceUsage(GetResID(queue), ResourceUsage::SparseBindingUpdate); + if(fence != VK_NULL_HANDLE) + AddEventResourceUsage(GetResID(fence), ResourceUsage::Signal); + + for(uint32_t i = 0; i < bindInfoCount; i++) + { + for(uint32_t s = 0; s < pBindInfo[i].waitSemaphoreCount; ++s) + AddEventResourceUsage(GetResID(pBindInfo[i].pWaitSemaphores[s]), ResourceUsage::Wait); + for(uint32_t s = 0; s < pBindInfo[i].signalSemaphoreCount; ++s) + AddEventResourceUsage(GetResID(pBindInfo[i].pSignalSemaphores[s]), ResourceUsage::Signal); + } + } + // similar to vkQueueSubmit we don't need semaphores at all, just whether we waited on any. // For waiting semaphores, since we don't track state we have to just conservatively // wait for queue idle. Since we do that, there's equally no point in signalling semaphores @@ -1759,7 +1814,10 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que else { if(IsLoading(m_State)) + { m_SparseBindResources.insert(GetResID(buf[i].buffer)); + AddEventResourceUsage(GetResID(buf[i].buffer), ResourceUsage::SparseBindingUpdate); + } buf[i].buffer = Unwrap(buf[i].buffer); @@ -1781,7 +1839,10 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que else { if(IsLoading(m_State)) + { m_SparseBindResources.insert(GetResID(imopaque[i].image)); + AddEventResourceUsage(GetResID(imopaque[i].image), ResourceUsage::SparseBindingUpdate); + } imopaque[i].image = Unwrap(imopaque[i].image); @@ -1802,7 +1863,10 @@ bool WrappedVulkan::Serialise_vkQueueBindSparse(SerialiserType &ser, VkQueue que else { if(IsLoading(m_State)) + { m_SparseBindResources.insert(GetResID(im[i].image)); + AddEventResourceUsage(GetResID(im[i].image), ResourceUsage::SparseBindingUpdate); + } im[i].image = Unwrap(im[i].image); @@ -2010,6 +2074,8 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(SerialiserType &ser, VkQueue queue if(IsReplayingAndReading()) { ObjDisp(queue)->QueueWaitIdle(Unwrap(queue)); + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(queue), ResourceUsage::Wait); } return true; @@ -2061,6 +2127,8 @@ bool WrappedVulkan::Serialise_vkQueueBeginDebugUtilsLabelEXT(SerialiserType &ser AddEvent(); AddAction(action); + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Marker); } } @@ -2106,6 +2174,8 @@ bool WrappedVulkan::Serialise_vkQueueEndDebugUtilsLabelEXT(SerialiserType &ser, AddEvent(); AddAction(action); + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Marker); } } @@ -2158,6 +2228,8 @@ bool WrappedVulkan::Serialise_vkQueueInsertDebugUtilsLabelEXT(SerialiserType &se AddEvent(); AddAction(action); + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Marker); } } diff --git a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp index 838fa538e37..3bfb5c2a0c6 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp @@ -189,6 +189,9 @@ bool WrappedVulkan::Serialise_vkGetFenceStatus(SerialiserType &ser, VkDevice dev if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(fence), ResourceUsage::GetStatus); } return true; @@ -248,6 +251,11 @@ bool WrappedVulkan::Serialise_vkResetFences(SerialiserType &ser, VkDevice device // since we don't have anything signalling or waiting on fences, don't bother to reset them // either. // ObjDisp(device)->ResetFences(Unwrap(device), fenceCount, pFences); + if(IsLoading(m_State)) + { + for(uint32_t i = 0; i < fenceCount; ++i) + AddEventResourceUsage(GetResID(pFences[i]), ResourceUsage::Reset); + } } return true; @@ -294,6 +302,12 @@ bool WrappedVulkan::Serialise_vkWaitForFences(SerialiserType &ser, VkDevice devi if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + + if(IsLoading(m_State)) + { + for(uint32_t i = 0; i < fenceCount; ++i) + AddEventResourceUsage(GetResID(pFences[i]), ResourceUsage::Wait); + } } return true; @@ -406,6 +420,8 @@ bool WrappedVulkan::Serialise_vkSetEvent(SerialiserType &ser, VkDevice device, V if(IsReplayingAndReading()) { // see top of this file for current event/fence handling + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(event), ResourceUsage::Signal); } return true; @@ -445,6 +461,8 @@ bool WrappedVulkan::Serialise_vkResetEvent(SerialiserType &ser, VkDevice device, if(IsReplayingAndReading()) { // see top of this file for current event/fence handling + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(event), ResourceUsage::Reset); } return true; @@ -484,6 +502,9 @@ bool WrappedVulkan::Serialise_vkGetEventStatus(SerialiserType &ser, VkDevice dev if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(event), ResourceUsage::Wait); } return true; @@ -684,6 +705,9 @@ bool WrappedVulkan::Serialise_vkCmdResetEvent(SerialiserType &ser, VkCommandBuff if(!loading) commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + if(loading) + AddEventResourceUsage(GetResID(event), ResourceUsage::Reset); + // ObjDisp(commandBuffer)->CmdResetEvent(Unwrap(commandBuffer), Unwrap(event), mask); } } @@ -804,6 +828,8 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents( if(b.image != VK_NULL_HANDLE && b.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) AddEventResourceUsage(GetResID(b.image), ResourceUsage::Discard); } + for(uint32_t i = 0; i < eventCount; i++) + AddEventResourceUsage(GetResID(pEvents[i]), ResourceUsage::Wait); } // don't wrap this event @@ -971,6 +997,9 @@ bool WrappedVulkan::Serialise_vkGetSemaphoreCounterValue(SerialiserType &ser, Vk if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(semaphore), ResourceUsage::ReadCounter); } return true; @@ -1027,6 +1056,11 @@ bool WrappedVulkan::Serialise_vkWaitSemaphores(SerialiserType &ser, VkDevice dev if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + if(IsLoading(m_State)) + { + for(uint32_t i = 0; i < WaitInfo.semaphoreCount; ++i) + AddEventResourceUsage(GetResID(WaitInfo.pSemaphores[i]), ResourceUsage::Wait); + } } return true; @@ -1077,6 +1111,9 @@ bool WrappedVulkan::Serialise_vkSignalSemaphore(SerialiserType &ser, VkDevice de if(IsReplayingAndReading()) { ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + + if(IsLoading(m_State)) + AddEventResourceUsage(GetResID(SignalInfo.semaphore), ResourceUsage::Signal); } return true; @@ -1130,6 +1167,9 @@ bool WrappedVulkan::Serialise_vkCmdSetEvent2(SerialiserType &ser, VkCommandBuffe if(!loading) commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + if(loading) + AddEventResourceUsage(GetResID(event), ResourceUsage::Signal); + // ObjDisp(commandBuffer)->CmdSetEvent2(Unwrap(commandBuffer), Unwrap(event), &DependencyInfo); } } @@ -1191,6 +1231,9 @@ bool WrappedVulkan::Serialise_vkCmdResetEvent2(SerialiserType &ser, VkCommandBuf if(!loading) commandBuffer = RerecordCmdBuf(m_LastCmdBufferID); + if(loading) + AddEventResourceUsage(GetResID(event), ResourceUsage::Reset); + // ObjDisp(commandBuffer)->CmdResetEvent2(Unwrap(commandBuffer), Unwrap(event), stageMask); } } @@ -1301,6 +1344,8 @@ bool WrappedVulkan::Serialise_vkCmdWaitEvents2(SerialiserType &ser, VkCommandBuf b.newLayout != VK_IMAGE_LAYOUT_UNDEFINED) AddEventResourceUsage(GetResID(b.image), ResourceUsage::Discard); } + for(uint32_t i = 0; i < eventCount; ++i) + AddEventResourceUsage(GetResID(pEvents[i]), ResourceUsage::Wait); } if(loading && evIdx == 0) diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index b4b6eff576c..d3a47f469fd 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -964,6 +964,15 @@ bool WrappedVulkan::Serialise_vkQueuePresentKHR(SerialiserType &ser, VkQueue que m_LastPresentedImage = action.copyDestination = PresentedImage; AddAction(action); + VulkanEventNode &eventNode = GetLastEventNode(); + eventNode.AddResourceUsage(PresentedImage, ResourceUsage::CopyDst); + for(uint32_t i = 0; i < PresentInfo.waitSemaphoreCount; i++) + { + VkSemaphore sema = PresentInfo.pWaitSemaphores[i]; + if(sema != VK_NULL_HANDLE) + eventNode.AddResourceUsage(GetResID(sema), ResourceUsage::Wait); + } + eventNode.AddResourceUsage(GetResID(queue), ResourceUsage::Present); } return true; diff --git a/renderdoc/replay/replay_controller.cpp b/renderdoc/replay/replay_controller.cpp index 3b5e2f69dee..7803c9c56d5 100644 --- a/renderdoc/replay/replay_controller.cpp +++ b/renderdoc/replay/replay_controller.cpp @@ -1526,9 +1526,44 @@ rdcarray ReplayController::PixelHistory(ResourceId target, ui case ResourceUsage::ResolveSrc: case ResourceUsage::Barrier: case ResourceUsage::Indirect: + case ResourceUsage::VS_Shader: + case ResourceUsage::HS_Shader: + case ResourceUsage::DS_Shader: + case ResourceUsage::GS_Shader: + case ResourceUsage::PS_Shader: + case ResourceUsage::CS_Shader: + case ResourceUsage::TS_Shader: + case ResourceUsage::MS_Shader: // read-only, not a valid pixel history event continue; + case ResourceUsage::RenderPass: + case ResourceUsage::Framebuffer: + case ResourceUsage::Sampler: + case ResourceUsage::ImageView: + case ResourceUsage::BufferView: + case ResourceUsage::Pipeline: + case ResourceUsage::PipelineLayout: + case ResourceUsage::DescriptorSet: + case ResourceUsage::DescriptorSetLayout: + case ResourceUsage::Bind: + case ResourceUsage::UnBind: + case ResourceUsage::GetStatus: + case ResourceUsage::ReadCounter: + case ResourceUsage::Reset: + case ResourceUsage::Signal: + case ResourceUsage::Wait: + case ResourceUsage::Submit: + case ResourceUsage::Marker: + case ResourceUsage::Recorded: + case ResourceUsage::Begin: + case ResourceUsage::End: + case ResourceUsage::DescriptorSetWrite: + case ResourceUsage::SparseBindingUpdate: + case ResourceUsage::Present: + // resource related usage, not valid pixel history event + continue; + case ResourceUsage::CPUWrite: // writing but CPU-only, don't include continue; diff --git a/util/test/tests/Vulkan/VK_Resource_Usage.py b/util/test/tests/Vulkan/VK_Resource_Usage.py index f1ca704d5cd..fb9c34ffe81 100644 --- a/util/test/tests/Vulkan/VK_Resource_Usage.py +++ b/util/test/tests/Vulkan/VK_Resource_Usage.py @@ -10,6 +10,9 @@ class VK_Resource_Usage(rdtest.TestCase): markerStart = 0 markerEnd = 0 + def prune_and_sort(self, eids: List[int]) -> List[int]: + return sorted([x for x in eids if x >= self.markerStart and x <= self.markerEnd]) + def add_action(self, action: rd.ActionDescription): self.eids.append(action.eventId) for c in action.children: @@ -72,15 +75,29 @@ def check_capture(self): multiEIDs: List[int] = [] indirectCountEIDs: List[int] = [] submitEIDs: List[int] = [] + setEventEIDs: List[int] = [] + resetEventEIDs: List[int] = [] + waitEventsEIDs: List[int] = [] + beginCmdBufEIDs: List[int] = [] + endCmdBufEIDs: List[int] = [] waitFencesEIDs: List[int] = [] resetFencesEIDs: List[int] = [] descSetDrawEIDs: List[int] = [] descBufferDrawEIDs: List[int] = [] cmdDrawIndirectEIDs: List[int] = [] cmdMeshDispatchIndirectEIDs: List[int] = [] + descBufferDispatchEIDs : List[int] = [] + beginRenderPassEIDs : List[int] = [] endRenderPassEIDs : List[int] = [] fillBufferEIDs: List[int] = [] + bindPipelineEIDs : List[int] = [] + bindVertexBufferEIDs : List[int] = [] + bindIndexBufferEIDs : List[int] = [] + bindDescriptorSetEIDs : List[int] = [] copyBufferEIDs: List[int] = [] + computeWriteDataEIDs : List[int] = [] + noDescriptorSetDrawEIDs : List[int] = [] + computeDescriptorSetDispatchEIDs : List[int] = [] markerGraphics = 0 markerGraphicsNoDescriptorSet = 0 @@ -92,17 +109,24 @@ def check_capture(self): markerIndirectIndirectDraws = 0 markerIndirectSecondaryCommandBuffer = 0 markerIndirectSecondaryCommandBufferDispatchIndirect = 0 + markerIndirectSecondaryCommandBufferDrawIndirectSingle = 0 + markerIndirectDraws = 0 markerIndirectEnd = 0 markerNestedSecondaryCommandBuffer = 0 markerNestedSecondaryCommandBufferDispatch = 0 markerDescriptorBuffer = 0 + markerDescriptorBufferDraw = 0 + markerDescriptorBufferDispatch = 0 markerBarrierCommandSubmitFence = 0 markerCompute = 0 markerComputeDescriptorSet = 0 markerComputeSecondaryCommandBuffer = 0 + markerMeshShader = 0 markerLooseEventsAfterIndirectDrawsDrawIndirectSingle = 0 markerMultipleCommandBufferSubmits = 0 markerMultipleSecondaryCommandBufferExecutes = 0 + markerDrawIndexedIndirectUnBind = 0 + markerDrawIndexedIndirectBind = 0 self.markerStart = self.find_action("Resource Usage: Start").eventId self.markerEnd = self.find_action("Resource Usage: End").eventId @@ -116,13 +140,23 @@ def check_capture(self): markerNestedSecondaryCommandBufferDispatch = self.find_action("Dispatch", markerNestedSecondaryCommandBuffer).eventId if descBuffer: markerDescriptorBuffer = self.find_action("Descriptor Buffer").eventId + markerDescriptorBufferDraw = self.find_action("Draw", markerDescriptorBuffer).eventId + markerDescriptorBufferDispatch = self.find_action("Dispatch", markerDescriptorBuffer).eventId + if meshShader: + markerMeshShader = self.find_action("Mesh Shader").eventId markerBarrierCommandSubmitFence = self.find_action("Barrier Command Submit Fence").eventId + markerIndirectDispatchWriteIndirectDrawData = self.find_action("Indirect Dispatch Write IndirectDraw Data").eventId + markerIndirectSecondaryCommandBuffer = self.find_action("Secondary Command Buffer", markerIndirectDispatchWriteIndirectDrawData).eventId + markerIndirectSecondaryCommandBufferDrawIndirectSingle = self.find_action("DrawIndirect: Single", markerIndirectSecondaryCommandBuffer).eventId + markerIndirectDraws = self.find_action("Indirect Draws", markerIndirectDispatchWriteIndirectDrawData).eventId markerCompute = self.find_action("Compute").eventId markerComputeSecondaryCommandBuffer = self.find_action("Secondary Command Buffer", markerCompute).eventId markerLooseEventsAfterIndirectDraws = self.find_action("Loose Events After Indirect Draws").eventId markerLooseEventsAfterIndirectDrawsDrawIndirectSingle = self.find_action("DrawIndirect: Single", markerLooseEventsAfterIndirectDraws).eventId markerMultipleCommandBufferSubmits = self.find_action("Multiple Command Buffer Submits").eventId markerMultipleSecondaryCommandBufferExecutes = self.find_action("Multiple Secondary Command Buffer Executes").eventId + markerDrawIndexedIndirectUnBind = self.find_action("DrawIndexedIndirect-UnBind").eventId + markerDrawIndexedIndirectBind = self.find_action("DrawIndexedIndirect-Bind").eventId while len(actions) > 0: action = actions.pop(0) @@ -153,6 +187,10 @@ def check_capture(self): if flags & rd.ActionFlags.PushMarker: parentName = action.parent.customName if action.parent is not None else None markerPath = parentName + "." + action.customName if parentName is not None else action.customName + if not markerGraphicsNoDescriptorSet and markerPath == "Graphics.No Descriptor Set": + markerGraphicsNoDescriptorSet = action.eventId + if not markerGraphicsDescriptorSet and markerPath == "Graphics.Descriptor Set": + markerGraphicsDescriptorSet = action.eventId if not markerIndirect and markerPath == "Indirect": markerIndirect = action.eventId markerIndirectEnd = action.children[-1].eventId @@ -164,10 +202,23 @@ def check_capture(self): cmdDrawIndirectEIDs.append(action.eventId) if "vkCmdDrawMeshTasksIndirectEXT(" in action.customName: cmdMeshDispatchIndirectEIDs.append(action.eventId) + if "vkQueueSubmit" in action.customName: + if "vkBeginCommandBuffer" in action.customName: + beginCmdBufEIDs.append(action.eventId) + if "vkEndCommandBuffer" in action.customName: + endCmdBufEIDs.append(action.eventId) for e in action.events: + if e.eventId > self.markerEnd: + continue eventName = sdfile.chunks[e.chunkIndex].name if "vkQueueSubmit" in eventName: submitEIDs.append(e.eventId) + if "vkSetEvent" in eventName: + setEventEIDs.append(e.eventId) + if "vkResetEvent" in eventName: + resetEventEIDs.append(e.eventId) + if "vkGetEventStatus" in eventName: + waitEventsEIDs.append(e.eventId) if "vkWaitForFences" in eventName: waitFencesEIDs.append(e.eventId) if "vkResetFences" in eventName: @@ -176,8 +227,18 @@ def check_capture(self): copyBufferEIDs.append(e.eventId) if "vkCmdFillBuffer" in eventName: fillBufferEIDs.append(e.eventId) + if "vkCmdBeginRenderPass" in eventName: + beginRenderPassEIDs.append(e.eventId) if "vkCmdEndRenderPass" in eventName: endRenderPassEIDs.append(e.eventId) + if "vkCmdBindPipeline" in eventName: + bindPipelineEIDs.append(e.eventId) + if "vkCmdBindVertexBuffers" in eventName: + bindVertexBufferEIDs.append(e.eventId) + if "vkCmdBindIndexBuffer" in eventName: + bindIndexBufferEIDs.append(e.eventId) + if "vkCmdBindDescriptorSet" in eventName: + bindDescriptorSetEIDs.append(e.eventId) markerIndirectDispatchWriteIndirectDrawData = self.find_action("Indirect Dispatch Write IndirectDraw Data", markerIndirect).eventId markerIndirectIndirectDraws = self.find_action("Indirect Draws", markerIndirectDispatchWriteIndirectDrawData).eventId @@ -189,24 +250,60 @@ def check_capture(self): (eid > markerIndirect and (not nestedSecondaries or eid < markerNestedSecondaryCommandBuffer))] descBufferDrawEIDs += [eid for eid in drawEIDs if descBuffer and eid > markerDescriptorBuffer] - drawEIDs.sort() - indexedEIDs.sort() - indexedSpecialEIDs.sort() - dispatchEIDs.sort() - multiEIDs.sort() - indirectEIDs.sort() - meshDispatchEIDs.sort() - indirectCountEIDs.sort() - submitEIDs.sort() - waitFencesEIDs.sort() - resetFencesEIDs.sort() - descSetDrawEIDs.sort() - descBufferDrawEIDs.sort() - fillBufferEIDs.sort() - copyBufferEIDs.sort() - endRenderPassEIDs.sort() - cmdDrawIndirectEIDs.sort() - cmdMeshDispatchIndirectEIDs.sort() + descBufferDispatchEIDs += [eid for eid in dispatchEIDs if descBuffer and eid > markerDescriptorBuffer] + + # Dispatch before Compute region + # All the dispatch and indirect + # Dipatch within "Indirect" region + computeWriteDataEIDs += [eid for eid in dispatchEIDs + if eid < markerCompute or eid in indirectEIDs or (eid > markerIndirect and eid < markerIndirectEnd)] + + # Graphics->No Descriptor Set : Graphics -> Desscriptor Set + # Graphics->Secondary Command Buffer -> Compute + # Nested Secondary Command Buffer : Descriptor Buffer + noDescriptorSetDrawEIDs += [eid for eid in drawEIDs + if (eid > markerGraphicsNoDescriptorSet and eid < markerGraphicsDescriptorSet) or + (eid > markerGraphicsSecondaryCommandBuffer and eid < markerCompute) or + (nestedSecondaries and eid > markerNestedSecondaryCommandBuffer and (not descBuffer or eid < markerDescriptorBuffer))] + + # Dispatches in Compute -> Indirect + # Dispatches in Nested Secondary Command Buffer -> Descriptor Buffer + computeDescriptorSetDispatchEIDs += [eid for eid in dispatchEIDs + if (eid > markerComputeDescriptorSet and eid < markerIndirect) or + (nestedSecondaries and eid > markerNestedSecondaryCommandBufferDispatch and (not descBuffer or eid < markerDescriptorBuffer))] + + drawEIDs = self.prune_and_sort(drawEIDs) + indexedEIDs = self.prune_and_sort(indexedEIDs) + indexedSpecialEIDs = self.prune_and_sort(indexedSpecialEIDs) + dispatchEIDs = self.prune_and_sort(dispatchEIDs) + multiEIDs = self.prune_and_sort(multiEIDs) + indirectEIDs = self.prune_and_sort(indirectEIDs) + meshDispatchEIDs = self.prune_and_sort(meshDispatchEIDs) + indirectCountEIDs = self.prune_and_sort(indirectCountEIDs) + submitEIDs = self.prune_and_sort(submitEIDs) + beginCmdBufEIDs = self.prune_and_sort(beginCmdBufEIDs) + endCmdBufEIDs = self.prune_and_sort(endCmdBufEIDs) + waitFencesEIDs = self.prune_and_sort(waitFencesEIDs) + resetFencesEIDs = self.prune_and_sort(resetFencesEIDs) + descSetDrawEIDs = self.prune_and_sort(descSetDrawEIDs) + descBufferDrawEIDs = self.prune_and_sort(descBufferDrawEIDs) + fillBufferEIDs = self.prune_and_sort(fillBufferEIDs) + copyBufferEIDs = self.prune_and_sort(copyBufferEIDs) + descBufferDispatchEIDs = self.prune_and_sort(descBufferDispatchEIDs) + beginRenderPassEIDs = self.prune_and_sort(beginRenderPassEIDs) + endRenderPassEIDs = self.prune_and_sort(endRenderPassEIDs) + bindPipelineEIDs = self.prune_and_sort(bindPipelineEIDs) + bindVertexBufferEIDs = self.prune_and_sort(bindVertexBufferEIDs) + bindIndexBufferEIDs = self.prune_and_sort(bindIndexBufferEIDs) + computeWriteDataEIDs = self.prune_and_sort(computeWriteDataEIDs) + cmdDrawIndirectEIDs = self.prune_and_sort(cmdDrawIndirectEIDs) + cmdMeshDispatchIndirectEIDs = self.prune_and_sort(cmdMeshDispatchIndirectEIDs) + bindDescriptorSetEIDs = self.prune_and_sort(bindDescriptorSetEIDs) + noDescriptorSetDrawEIDs = self.prune_and_sort(noDescriptorSetDrawEIDs) + computeDescriptorSetDispatchEIDs = self.prune_and_sort(computeDescriptorSetDispatchEIDs) + setEventEIDs = self.prune_and_sort(setEventEIDs) + resetEventEIDs = self.prune_and_sort(resetEventEIDs) + waitEventsEIDs = self.prune_and_sort(waitEventsEIDs) action = self.find_action("Draw") self.set_event(action.eventId, False) @@ -216,11 +313,13 @@ def check_capture(self): for res in resources: expectedUsage: List[Tuple[int,rd.ResourceUsage]] = [] if res.type == rd.ResourceType.Device: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage = [] elif res.type == rd.ResourceType.Queue: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage += [(eid,rd.ResourceUsage.Submit) for eid in submitEIDs if eid >= self.markerStart and eid <= self.markerEnd] + expectedUsage += [(eid,rd.ResourceUsage.Submit) for eid in beginCmdBufEIDs if eid >= self.markerStart and eid <= self.markerEnd] + expectedUsage += [(eid,rd.ResourceUsage.Submit) for eid in endCmdBufEIDs if eid >= self.markerStart and eid <= self.markerEnd] elif res.type == rd.ResourceType.Pool: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage = [] elif res.type == rd.ResourceType.SwapchainImage: # the swap chain image has usage, anything else does not if res.resourceId == swapImage: @@ -235,23 +334,184 @@ def check_capture(self): else: expectedUsage = [] elif res.type == rd.ResourceType.RenderPass: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + if res.name == "Main Framebuffer": + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in beginRenderPassEIDs] + expectedUsage += [(eid,rd.ResourceUsage.UnBind) for eid in endRenderPassEIDs] + expectedUsage += [(eid,rd.ResourceUsage.Framebuffer) for eid in drawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.Framebuffer) for eid in meshDispatchEIDs] + if res.name == "Main Render Pass": + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in beginRenderPassEIDs] + expectedUsage += [(eid,rd.ResourceUsage.UnBind) for eid in endRenderPassEIDs] + expectedUsage += [(eid,rd.ResourceUsage.RenderPass) for eid in drawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.RenderPass) for eid in meshDispatchEIDs] elif res.type == rd.ResourceType.Sync: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage = [] + if res.name.startswith("Autotesting renderEndSemaphore"): + expectedUsage = [] + elif res.name.startswith("VK_Resource_Usage renderEndSemaphore"): + expectedUsage = [(submitEIDs[0], rd.ResourceUsage.Signal)] + elif res.name.startswith("Autotesting fence"): + expectedUsage = [] + elif res.name == "Barrier Command Submit Fence": + expectedUsage += [(eid,rd.ResourceUsage.Wait) for eid in waitFencesEIDs if eid > markerBarrierCommandSubmitFence] + expectedUsage += [(eid,rd.ResourceUsage.Reset) for eid in resetFencesEIDs if eid > markerBarrierCommandSubmitFence] + expectedUsage += [(eid,rd.ResourceUsage.Wait) for eid in submitEIDs + if eid > markerBarrierCommandSubmitFence] + elif res.name.startswith("Fence "): + # Ignore anonymous fences + continue + elif res.name == "Test Event": + expectedUsage += [(eid, rd.ResourceUsage.Signal) for eid in setEventEIDs] + expectedUsage += [(eid, rd.ResourceUsage.Reset) for eid in resetEventEIDs] + expectedUsage += [(eid, rd.ResourceUsage.Wait) for eid in waitEventsEIDs] + else: + expectedUsage = [] elif res.type == rd.ResourceType.View: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + # Ignore swapchain image views + if res.name.startswith("Main Swapchain ImageView"): + continue + if res.name == "Offscreen Image RTV": + expectedUsage += [(eid,rd.ResourceUsage.ImageView) for eid in descSetDrawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.ImageView) for eid in descBufferDrawEIDs] elif res.type == rd.ResourceType.Memory: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage = [] elif res.type == rd.ResourceType.ShaderBinding: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + if res.name == "Descriptor Set Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in descSetDrawEIDs] + elif res.name == "Compute Descriptor Set Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in computeDescriptorSetDispatchEIDs] + elif res.name == "No Descriptor Set Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in noDescriptorSetDrawEIDs] + elif res.name == "Compute WriteData Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in computeWriteDataEIDs] + elif res.name == "Compute Descriptor Buffer Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in descBufferDispatchEIDs] + elif res.name == "Descriptor Buffer Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in descBufferDrawEIDs] + elif res.name == "Mesh Shader Pipeline Layout": + expectedUsage += [(eid,rd.ResourceUsage.PipelineLayout) for eid in meshDispatchEIDs] + elif res.name == "Descriptor Buffer Layout": + expectedUsage += [(eid,rd.ResourceUsage.DescriptorSetLayout) for eid in descBufferDrawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.DescriptorSetLayout) for eid in descBufferDispatchEIDs] + elif res.name == "Descriptor Set Layout": + expectedUsage += [(eid,rd.ResourceUsage.DescriptorSetLayout) for eid in descSetDrawEIDs] + elif res.name == "Compute Descriptor Set Layout": + expectedUsage += [(eid,rd.ResourceUsage.DescriptorSetLayout) for eid in computeDescriptorSetDispatchEIDs] + elif res.name == "Compute WriteData Descriptor Set Layout": + expectedUsage += [(eid,rd.ResourceUsage.DescriptorSetLayout) for eid in computeWriteDataEIDs] elif res.type == rd.ResourceType.Shader: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + if res.name == "Descriptor Vertex Shader": + expectedUsage += [(eid,rd.ResourceUsage.VS_Shader) for eid in descSetDrawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.VS_Shader) for eid in descBufferDrawEIDs] + elif res.name == "Descriptor Pixel Shader": + expectedUsage += [(eid,rd.ResourceUsage.PS_Shader) for eid in descSetDrawEIDs] + expectedUsage += [(eid,rd.ResourceUsage.PS_Shader) for eid in descBufferDrawEIDs] + elif res.name == "Descriptor Buffer Vertex Shader": + expectedUsage += [(eid,rd.ResourceUsage.VS_Shader) for eid in drawEIDs if descBuffer and eid > markerDescriptorBuffer] + elif res.name == "Descriptor Buffer Pixel Shader": + expectedUsage += [(eid,rd.ResourceUsage.PS_Shader) for eid in drawEIDs if descBuffer and eid > markerDescriptorBuffer] + elif res.name == "Mesh Mesh Shader": + expectedUsage += [(eid,rd.ResourceUsage.MS_Shader) for eid in meshDispatchEIDs] + elif res.name == "Mesh Pixel Shader": + expectedUsage += [(eid,rd.ResourceUsage.PS_Shader) for eid in meshDispatchEIDs] + elif res.name == "Descriptor Set Compute Shader": + expectedUsage += [(eid,rd.ResourceUsage.CS_Shader) for eid in computeDescriptorSetDispatchEIDs] + elif res.name == "Descriptor Buffer Compute Shader": + expectedUsage += [(eid,rd.ResourceUsage.CS_Shader) for eid in dispatchEIDs if descBuffer and eid > markerDescriptorBuffer] + elif res.name == "Default Vertex Shader": + expectedUsage += [(eid,rd.ResourceUsage.VS_Shader) for eid in noDescriptorSetDrawEIDs] + elif res.name == "Default Pixel Shader": + expectedUsage += [(eid,rd.ResourceUsage.PS_Shader) for eid in noDescriptorSetDrawEIDs] + elif res.name == "WriteData Compute Shader": + expectedUsage += [(eid,rd.ResourceUsage.CS_Shader) for eid in computeWriteDataEIDs] elif res.type == rd.ResourceType.PipelineState: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + if res.name == "Compute Descriptor Set Pipeline": + expectedUsage += [(eid,rd.ResourceUsage.Pipeline) for eid in computeDescriptorSetDispatchEIDs] + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindPipelineEIDs + if eid > markerComputeDescriptorSet and eid < markerIndirect] + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindPipelineEIDs + if nestedSecondaries and eid > markerNestedSecondaryCommandBufferDispatch and (not descBuffer or eid < markerDescriptorBuffer)] + elif res.name == "Compute Descriptor Buffer Pipeline": + if descBuffer: + expectedUsage += [(eid,rd.ResourceUsage.Pipeline) for eid in dispatchEIDs + if eid > markerDescriptorBuffer] + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindPipelineEIDs + if eid > markerDescriptorBufferDispatch and meshShader and eid < markerMeshShader] + elif res.name == "Descriptor Buffer Pipeline": + if descBuffer: + expectedUsage += [(eid,rd.ResourceUsage.Pipeline) for eid in drawEIDs if eid > markerDescriptorBuffer] + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindPipelineEIDs if eid > markerDescriptorBufferDraw and eid < markerDescriptorBufferDispatch] + expectedUsage += [(eid,rd.ResourceUsage.UnBind) for eid in bindPipelineEIDs if meshShader and eid > markerMeshShader] + elif res.name == "Mesh Shader Pipeline": + if meshShader: + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindPipelineEIDs if eid > markerMeshShader] + expectedUsage += [(eid, rd.ResourceUsage.Pipeline) for eid in meshDispatchEIDs] + elif res.name == "Descriptor Set Pipeline": + # Bind: First pipeline bind in Graphics -> Descriptor Set + for eid in bindPipelineEIDs: + if eid > markerGraphicsDescriptorSet: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + # Bind: First pipeline bind in Indirect -> Indirect Draws + for eid in bindPipelineEIDs: + if eid > markerIndirectDraws: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + # Bind : First pipeline bind in Indirect -> Secondary Command Buffer -> DrawIndirect: Single + for eid in bindPipelineEIDs: + if eid > markerIndirectSecondaryCommandBufferDrawIndirectSingle: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + # The RenderState is reset in the primary command buffer when the secondary finishes + # Bind : First pipeline bind in Loose Events After Indirect Draws -> DrawIndirect: Single + for eid in bindPipelineEIDs: + if eid > markerLooseEventsAfterIndirectDrawsDrawIndirectSingle: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + expectedUsage += [(eid, rd.ResourceUsage.Pipeline) for eid in descSetDrawEIDs] + elif res.name == "No Descriptor Set Pipeline": + # Bind: First pipeline bind in Graphics + for eid in bindPipelineEIDs: + if eid > markerGraphicsNoDescriptorSet: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + # UnBind: First pipeline bind in Graphics -> Descriptor Set + for eid in bindPipelineEIDs: + if eid > markerGraphicsDescriptorSet: + expectedUsage.append((eid,rd.ResourceUsage.UnBind)) + break + # Bind: all pipeline bind in Graphics -> Secondary Command Buffer : Compute + expectedUsage += [(eid, rd.ResourceUsage.Bind) for eid in bindPipelineEIDs + if eid > markerGraphicsSecondaryCommandBuffer and eid < markerCompute] + # Bind: First pipeline bind in Nested Secondary Command Buffer + for eid in bindPipelineEIDs: + if nestedSecondaries and eid > markerNestedSecondaryCommandBuffer: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + expectedUsage += [(eid, rd.ResourceUsage.Pipeline) for eid in noDescriptorSetDrawEIDs] + elif res.name == "Compute WriteData Pipeline": + # Bind: First pipeline bind + expectedUsage.append((bindPipelineEIDs[0],rd.ResourceUsage.Bind)) + # Bind : First bind after Indirect->Indirect Dispatch Write IndirectDraw Data + for eid in bindPipelineEIDs: + if eid > markerIndirectDispatchWriteIndirectDrawData: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + # Bind : First bind after Indirect->Secondary Command Buffer + for eid in bindPipelineEIDs: + if eid > markerIndirectSecondaryCommandBuffer: + expectedUsage.append((eid,rd.ResourceUsage.Bind)) + break + expectedUsage += [(eid, rd.ResourceUsage.Pipeline) for eid in computeWriteDataEIDs] elif res.type == rd.ResourceType.Buffer: if res.name == "Vertex Buffer": + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindVertexBufferEIDs] expectedUsage += [(eid,rd.ResourceUsage.VertexBuffer) for eid in drawEIDs] if res.name == "Index Buffer": + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindIndexBufferEIDs + if (eid < markerDrawIndexedIndirectUnBind or eid > markerDrawIndexedIndirectBind)] + expectedUsage += [(eid,rd.ResourceUsage.UnBind) for eid in bindIndexBufferEIDs + if (eid > markerDrawIndexedIndirectUnBind and eid < markerDrawIndexedIndirectBind)] expectedUsage += [(eid,rd.ResourceUsage.IndexBuffer) for eid in indexedEIDs] if res.name == "Compute Buffer In": # All dispatches within "Compute" region @@ -266,6 +526,10 @@ def check_capture(self): if (eid > markerComputeDescriptorSet and eid < markerIndirect) or (nestedSecondaries and eid > markerNestedSecondaryCommandBuffer)] if res.name == "Indirect Data": + expectedUsage += [(eid,rd.ResourceUsage.Bind) for eid in bindIndexBufferEIDs + if (eid > markerDrawIndexedIndirectUnBind and eid < markerDrawIndexedIndirectBind)] + expectedUsage += [(eid,rd.ResourceUsage.UnBind) for eid in bindIndexBufferEIDs + if (eid == markerDrawIndexedIndirectBind+1)] expectedUsage += [(markerIndirectWriteIndirectDispatchData + 1,rd.ResourceUsage.Barrier), (markerIndirectWriteIndirectDispatchData + 2,rd.ResourceUsage.Clear), (markerIndirectWriteIndirectDispatchData + 3,rd.ResourceUsage.Barrier)] @@ -369,10 +633,34 @@ def check_capture(self): expectedUsage += [(eid,rd.ResourceUsage.PS_Resource) for eid in descBufferDrawEIDs] elif res.type == rd.ResourceType.CommandBuffer: expectedUsage = [(0,rd.ResourceUsage.Unused)] + # TODO: need to pick carefully which command buffer to validate + # TODO: check Baked Command Buffer and Command Buffer + continue elif res.type == rd.ResourceType.DescriptorStore: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + if res.name == "Descriptor Set": + expectedUsage += [(eid, rd.ResourceUsage.Bind) for eid in bindDescriptorSetEIDs + if (eid > markerGraphics and eid < markerCompute) or + (eid > markerIndirectDraws and eid < markerIndirectSecondaryCommandBuffer) or + (eid > markerIndirectSecondaryCommandBufferDrawIndirectSingle and eid < markerNestedSecondaryCommandBuffer)] + expectedUsage += [(eid, rd.ResourceUsage.DescriptorSet) for eid in descSetDrawEIDs] + if res.name == "Compute Descriptor Set": + # All dispatches within "Compute" region + # All dispatches within "Nested Secondary Command Buffer" region + expectedUsage += [(eid, rd.ResourceUsage.Bind) for eid in bindDescriptorSetEIDs + if (eid > markerComputeDescriptorSet and eid < markerIndirect) or + (nestedSecondaries and eid > markerNestedSecondaryCommandBuffer and (not descBuffer or eid < markerDescriptorBuffer))] + expectedUsage += [(eid, rd.ResourceUsage.DescriptorSet) for eid in dispatchEIDs + if (eid > markerComputeDescriptorSet and eid < markerIndirect) or + (nestedSecondaries and eid > markerNestedSecondaryCommandBuffer and (not descBuffer or eid < markerDescriptorBuffer))] + if res.name == "Compute WriteData Descriptor Set": + expectedUsage += [(eid, rd.ResourceUsage.Bind) for eid in bindDescriptorSetEIDs + if (eid > markerIndirectWriteIndirectDispatchData and eid < markerGraphics) or + (eid > markerIndirectDispatchWriteIndirectDrawData and eid < markerIndirectDraws) or + (nestedSecondaries and (eid > markerIndirectSecondaryCommandBuffer and eid < markerIndirectSecondaryCommandBufferDrawIndirectSingle))] + expectedUsage += [(eid, rd.ResourceUsage.DescriptorSet) for eid in computeWriteDataEIDs] elif res.type == rd.ResourceType.Sampler: - expectedUsage = [(0,rd.ResourceUsage.Unused)] + expectedUsage += [(eid, rd.ResourceUsage.Sampler) for eid in descSetDrawEIDs] + expectedUsage += [(eid, rd.ResourceUsage.Sampler) for eid in descBufferDrawEIDs] else: raise rdtest.TestFailureException(f"'{res.name}' {res.resourceId} Unexpected resource type {res.type.name}") expectedUsage.sort(key=lambda x: x[0])