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/common/globalconfig.h b/renderdoc/common/globalconfig.h index acde74f9227..c4d397f25ae 100644 --- a/renderdoc/common/globalconfig.h +++ b/renderdoc/common/globalconfig.h @@ -172,7 +172,7 @@ enum #define FORCE_ASSERTS OPTION_ON // force debugbreaks regardless of debug/release mode -#define FORCE_DEBUGBREAK OPTION_OFF +#define FORCE_DEBUGBREAK OPTION_ON ///////////////////////////////////////////////// // Logging configuration diff --git a/renderdoc/data/hlsl/shaderdebug.hlsl b/renderdoc/data/hlsl/shaderdebug.hlsl index eae7d173d9f..f06be20db6d 100644 --- a/renderdoc/data/hlsl/shaderdebug.hlsl +++ b/renderdoc/data/hlsl/shaderdebug.hlsl @@ -80,6 +80,13 @@ void RENDERDOC_DebugSampleVS(uint id else uv = 0.0f.xxxx; + // 0, -4 : UV = uv + ddy * 2 + // 0, 0 : UV = uv + // 4, 0 : UV = uv + ddx * 2 + // pos = float4((id == 2) ? 4.0f : 0.0f, (id == 0) ? -4.0f : 0.0f, 0.5, 1.0); + // -1, -3 : UV = uv + ddy * 2 + // -1, 1 : UV = uv + // 3, 1 : UV = uv + ddx * 2 pos = float4((id == 2) ? 3.0f : -1.0f, (id == 0) ? -3.0f : 1.0f, 0.5, 1.0); } diff --git a/renderdoc/driver/shaders/dxil/dxil_debug.cpp b/renderdoc/driver/shaders/dxil/dxil_debug.cpp index dc382fd81f3..e1e6fb3353c 100644 --- a/renderdoc/driver/shaders/dxil/dxil_debug.cpp +++ b/renderdoc/driver/shaders/dxil/dxil_debug.cpp @@ -10260,6 +10260,11 @@ rdcarray Debugger::ContinueDebug() rdcarray ret; m_ShaderChangesReturn = NULL; + const int maxDeltaSteps = 100000; + // 100000 + if(m_Steps > maxDeltaSteps) + return ret; + // initialise the first ShaderDebugState if we haven't stepped yet if(m_Steps == 0) { @@ -10326,12 +10331,15 @@ rdcarray Debugger::ContinueDebug() m_ShaderChangesReturn = &ret; // continue stepping until we have 1000000 target steps completed in a chunk. - for(int stepEnd = m_Steps + 1000000; m_Steps < stepEnd;) + for(int stepEnd = m_Steps + maxDeltaSteps; m_Steps < stepEnd;) { allStepsCompleted = true; if(active.Finished() && !active.IsSimulationStepActive()) break; + if((m_Steps % 10000) == 0) + RDCLOG("m_Steps:%d", m_Steps); + // Execute the threads in each active tangle ThreadExecutionStates threadExecutionStates; TangleGroup &tangles = m_ControlFlow.GetTangles(); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 7a47390c7d0..3210638552b 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -4122,8 +4122,10 @@ RDResult WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEv uint64_t startOffset = ser.GetReader()->GetOffset(); + RDCASSERT(m_BakedCmdBufferInfo.find(ResourceId()) == m_BakedCmdBufferInfo.end()); for(;;) { + RDCASSERT(m_BakedCmdBufferInfo.find(ResourceId()) == m_BakedCmdBufferInfo.end()); if(IsActiveReplaying(m_State) && m_RootEventID > endEventID) { // we can just break out if we've done all the events desired. @@ -4215,6 +4217,7 @@ RDResult WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEv chunktype != VulkanChunk::SetCommandAnnotation) m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++; } + RDCASSERT(m_BakedCmdBufferInfo.find(ResourceId()) == m_BakedCmdBufferInfo.end()); } if(!partial && !IsStructuredExporting(m_State)) @@ -4264,6 +4267,7 @@ RDResult WrappedVulkan::ContextReplayLog(CaptureState readType, uint32_t startEv m_RerecordCmds.clear(); + RDCASSERT(m_BakedCmdBufferInfo.find(ResourceId()) == m_BakedCmdBufferInfo.end()); return ResultCode::Succeeded; } @@ -4483,6 +4487,14 @@ bool WrappedVulkan::ContextProcessChunk(ReadSerialiser &ser, VulkanChunk chunk) { if(!m_AddedEventNode) AddEvent(); + if(GetLastEventNode().resourceUsage.empty()) + { + if(chunk != VulkanChunk::vkUpdateDescriptorSets) + { + RDCASSERT(!GetLastEventNode().resourceUsage.empty()); + RDCFATAL("EMPTY RESOURCE USAGE"); + } + } } } @@ -5184,6 +5196,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 +6405,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 +6580,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 +6703,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 +6777,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 +6785,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 +6835,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 +6936,11 @@ void WrappedVulkan::AddFramebufferUsage(VulkanEventNode &eventNode, } } } + for(const ResourceId &att : fbattachments) + { + if(att != ResourceId()) + eventNode.AddResourceUsage(att, ResourceUsage::ImageView); + } } void WrappedVulkan::AddEvent() @@ -6901,6 +6970,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..92d1985d1e4 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -136,8 +136,27 @@ struct VulkanEventNode ~VulkanEventNode() = default; void AddResourceUsage(ResourceId id, ResourceUsage usage) { + RDCASSERTNOTEQUAL(id, ResourceId()); + if(id == ResourceId()) + RDCFATAL("NULL ID"); resourceUsage.push_back(make_rdcpair(id, usage)); } + void AddUniqueResourceUsage(ResourceId id, ResourceUsage usage) + { + RDCASSERTNOTEQUAL(id, ResourceId()); + if(id == ResourceId()) + RDCFATAL("NULL ID"); + 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 +800,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; @@ -1201,9 +1223,18 @@ class WrappedVulkan : public IFrameCapturer void AddEventResourceUsage(ResourceId id, ResourceUsage usage) { + if(!IsLoading(m_State)) + RDCFATAL("!IsLoading"); RDCASSERT(IsLoading(m_State)); m_LoadingEventNode.AddResourceUsage(id, usage); } + void AddEventResourceBind(ResourceId prev, ResourceId cur) + { + if(!IsLoading(m_State)) + RDCFATAL("!IsLoading"); + RDCASSERT(IsLoading(m_State)); + m_LoadingEventNode.AddResourceBind(prev, cur); + } rdcarray m_Events; VulkanEventNode m_LoadingEventNode; @@ -1268,6 +1299,8 @@ class WrappedVulkan : public IFrameCapturer VulkanEventNode &GetLastEventNode() { + if(!IsLoading(m_State)) + RDCFATAL("!IsLoading"); RDCASSERT(IsLoading(m_State)); rdcarray &eventNodes = (m_LastCmdBufferID != ResourceId() ? m_BakedCmdBufferInfo[m_LastCmdBufferID].eventNodes @@ -1276,6 +1309,8 @@ class WrappedVulkan : public IFrameCapturer } VulkanEventNode &GetLoadingEventNode() { + if(!IsLoading(m_State)) + RDCFATAL("!IsLoading"); RDCASSERT(IsLoading(m_State)); return 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/demos/d3d11/d3d11_helpers.h b/util/test/demos/d3d11/d3d11_helpers.h index 6b959d3cdea..212e83e1b6d 100644 --- a/util/test/demos/d3d11/d3d11_helpers.h +++ b/util/test/demos/d3d11/d3d11_helpers.h @@ -229,7 +229,7 @@ class D3D11SamplerCreator return *this; } - D3D11SamplerCreator &Aniso(D3D11_COMPARISON_FUNC comp) + D3D11SamplerCreator &Comparison(D3D11_COMPARISON_FUNC comp) { m_Desc.ComparisonFunc = comp; return *this; diff --git a/util/test/demos/d3d11/d3d11_shader_debug_zoo.cpp b/util/test/demos/d3d11/d3d11_shader_debug_zoo.cpp index 44e33a14d87..cdaa700f1a0 100644 --- a/util/test/demos/d3d11/d3d11_shader_debug_zoo.cpp +++ b/util/test/demos/d3d11/d3d11_shader_debug_zoo.cpp @@ -34,6 +34,7 @@ RD_TEST(D3D11_Shader_Debug_Zoo, D3D11GraphicsTest) float zero; float one; float negone; + float texDim; }; std::string common = R"EOSHADER( @@ -44,6 +45,7 @@ struct consts float zeroVal : ZERO; float oneVal : ONE; float negoneVal : NEGONE; + float texDim : TEXDIM; }; cbuffer packed_consts : register(b1) @@ -55,6 +57,7 @@ cbuffer packed_consts : register(b1) struct v2f { float4 pos : SV_POSITION; + float4 s : S; float2 zeroVal : ZERO; float tinyVal : TINY; float oneVal : ONE; @@ -73,6 +76,19 @@ v2f main(consts IN, uint tri : SV_InstanceID) OUT.pos = float4(IN.pos.x + IN.pos.z * float(tri), IN.pos.y, 0.0f, 1); + // OUT.s.xy : 0 -> 2 : across the triangle x & y, changes per pixel + OUT.s.x = IN.pos.x + 1.0; + OUT.s.x *= IN.texDim; + OUT.s.x -= 1.0; + OUT.s.x /= 2.0; + + OUT.s.y = IN.pos.y; + OUT.s.y *= 2.0; + OUT.s.y += 0.5; + OUT.s.y = 2.0 - OUT.s.y; + // OUT.s.zw : large variation in x & y + OUT.s.zw = (IN.pos.xy + float2(543.0, 213.0)) * (IN.pos.yx + float2(100.0, -113.0)); + OUT.zeroVal = IN.zeroVal.xx; OUT.oneVal = IN.oneVal; OUT.negoneVal = IN.negoneVal; @@ -115,6 +131,7 @@ Texture2DMS dimtexms : register(t4); Texture2D smiley : register(t5); Texture2D smileyint : register(t6); Texture2D smileyuint : register(t7); +Texture2D smileyr32 : register(t8); RWByteAddressBuffer byterwtest : register(u1); RWStructuredBuffer structrwtest : register(u2); @@ -131,6 +148,7 @@ RWTexture2D unbounduav2 : register(u5); SamplerState linearclamp : register(s0); SamplerState linearwrap : register(s1); SamplerState unboundsamp : register(s2); +SamplerComparisonState linearcompare : register(s3); float4 main(v2f IN) : SV_Target0 { @@ -830,11 +848,43 @@ float4 main(v2f IN) : SV_Target0 { float4 Color = float4(0,0,0,1); float2 uv = IN.pos.xy / float2(2.0, 2.0); - uv.y += 0.187; + uv.x += 0.6042; + uv.y += 0.4167; Color.x = smiley.CalculateLevelOfDetail(linearclamp, uv); Color.y = smiley.CalculateLevelOfDetailUnclamped(linearclamp, uv); return Color; } + if(IN.tri == 100) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.Sample(linearclamp, uv); + } + if(IN.tri == 101) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.SampleBias(linearclamp, uv, 4.0); + } + if(IN.tri == 102) + { + float4 Color = float4(0,0,0,0); + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + Color.x = smileyr32.SampleCmp(linearcompare, uv, 0.0); + Color.y = smileyr32.SampleCmp(linearcompare, uv, 0.1); + Color.z = smileyr32.SampleCmp(linearcompare, uv, 0.7); + Color.w = smileyr32.SampleCmp(linearcompare, uv, 1.0); + float4 derivs = float4(0,0,0,0); + derivs.x = ddx(uv.x); + derivs.y = ddx(uv.y); + derivs.z = ddy(uv.x); + derivs.w = ddy(uv.y); + return Color + derivs; + } return float4(0.4f, 0.4f, 0.4f, 0.4f); } @@ -1065,6 +1115,15 @@ float4 main(v2f IN, uint samp : SV_SampleIndex) : SV_Target0 D3D11_INPUT_PER_VERTEX_DATA, 0, }, + { + "TEXDIM", + 0, + DXGI_FORMAT_R32_FLOAT, + 0, + D3D11_APPEND_ALIGNED_ELEMENT, + D3D11_INPUT_PER_VERTEX_DATA, + 0, + }, }; ID3D11InputLayoutPtr layout; @@ -1085,9 +1144,9 @@ float4 main(v2f IN, uint samp : SV_SampleIndex) : SV_Target0 float triWidth = 8.0f / float(texDim); ConstsA2V triangle[] = { - {Vec3f(-1.0f, -1.0f, triWidth), 0.0f, 1.0f, -1.0f}, - {Vec3f(-1.0f, 1.0f, triWidth), 0.0f, 1.0f, -1.0f}, - {Vec3f(-1.0f + triWidth, 1.0f, triWidth), 0.0f, 1.0f, -1.0f}, + {Vec3f(-1.0f, -1.0f, triWidth), 0.0f, 1.0f, -1.0f, (float)texDim}, + {Vec3f(-1.0f, 1.0f, triWidth), 0.0f, 1.0f, -1.0f, (float)texDim}, + {Vec3f(-1.0f + triWidth, 1.0f, triWidth), 0.0f, 1.0f, -1.0f, (float)texDim}, }; ID3D11BufferPtr vb = MakeBuffer().Vertex().Data(triangle); @@ -1148,11 +1207,29 @@ float4 main(v2f IN, uint samp : SV_SampleIndex) : SV_Target0 ID3D11ShaderResourceViewPtr smileysrv = MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_UNORM); ID3D11ShaderResourceViewPtr smileyintsrv = MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_SINT); ID3D11ShaderResourceViewPtr smileyuintsrv = MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_UINT); + ID3D11Texture2DPtr smileyr32 = + MakeTexture(DXGI_FORMAT_R32_TYPELESS, rgba8.width, rgba8.height).SRV(); + ID3D11ShaderResourceViewPtr smileyr32srv = MakeSRV(smileyr32).Format(DXGI_FORMAT_R32_FLOAT); + + std::vector smileyR32Data; + uint32_t *srcptr = rgba8.data.data(); + for(UINT row = 0; row < rgba8.height; row++) + { + for(UINT col = 0; col < rgba8.width; col++) + { + uint32_t texValue = *srcptr; + uint32_t red = texValue & 0xFF; + smileyR32Data.push_back((float)red / 255.0f); + srcptr++; + } + } ctx->UpdateSubresource(smiley, 0, NULL, rgba8.data.data(), rgba8.width * sizeof(uint32_t), 0); + ctx->UpdateSubresource(smileyr32, 0, NULL, smileyR32Data.data(), rgba8.width * sizeof(float), 0); ID3D11ShaderResourceView *srvs[] = { - srv, rawsrv, structsrv, testSRV, msSRV, smileysrv, smileyintsrv, smileyuintsrv, + srv, rawsrv, structsrv, testSRV, msSRV, + smileysrv, smileyintsrv, smileyuintsrv, smileyr32srv, }; ctx->PSSetShaderResources(0, ARRAY_COUNT(srvs), srvs); @@ -1174,8 +1251,11 @@ float4 main(v2f IN, uint samp : SV_SampleIndex) : SV_Target0 ID3D11SamplerStatePtr linearclamp = MakeSampler(); ctx->PSSetSamplers(0, 1, &linearclamp.GetInterfacePtr()); - ID3D11SamplerStatePtr linearwrap = MakeSampler(); + ID3D11SamplerStatePtr linearwrap = MakeSampler().Address(D3D11_TEXTURE_ADDRESS_WRAP); ctx->PSSetSamplers(1, 1, &linearwrap.GetInterfacePtr()); + ID3D11SamplerStatePtr linearcompare = + MakeSampler().Filter(D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR).Comparison(D3D11_COMPARISON_LESS); + ctx->PSSetSamplers(3, 1, &linearcompare.GetInterfacePtr()); ID3D11VertexShaderPtr vsmsaa = CreateVS(vsmsaablob); ID3D11PixelShaderPtr psmsaa = CreatePS(psmsaablob); diff --git a/util/test/demos/d3d12/d3d12_shader_debug_zoo.cpp b/util/test/demos/d3d12/d3d12_shader_debug_zoo.cpp index 797f6dd79c3..9ca95b70dab 100644 --- a/util/test/demos/d3d12/d3d12_shader_debug_zoo.cpp +++ b/util/test/demos/d3d12/d3d12_shader_debug_zoo.cpp @@ -235,6 +235,7 @@ Texture2DMS dimtexms : register(t4); Texture2D smiley : register(t5); Texture2D smileyint : register(t6); Texture2D smileyuint : register(t7); +Texture2D smileyr32 : register(t8); RWByteAddressBuffer byterwtest : register(u1); RWStructuredBuffer structrwtest : register(u2); RWByteAddressBuffer byterwtest2 : register(u3); @@ -258,6 +259,7 @@ Buffer narrowtypedsrv : register(t102); Buffer rgb_srv : register(t103); SamplerState linearclamp : register(s0); +SamplerComparisonState linearcompare : register(s1); StructuredBuffer rootsrv : register(t20); ByteAddressBuffer rootbytesrv : register(t21); @@ -1122,9 +1124,10 @@ float4 main(v2f IN) : SV_Target0 { float4 Color = float4(0,0,0,1); float2 uv = IN.s.xy / float2(2.0, 2.0); - uv.y += 0.187; - Color.x = smiley.CalculateLevelOfDetail(linearclamp, uv); - Color.y = smiley.CalculateLevelOfDetailUnclamped(linearclamp, uv); + uv.x += 0.6042; + uv.y += 0.4167; + Color.x = smileyr32.CalculateLevelOfDetail(linearclamp, uv); + Color.y = smileyr32.CalculateLevelOfDetailUnclamped(linearclamp, uv); return Color; } #if (SM_6_0 || SM_6_2 || SM_6_6) @@ -1187,6 +1190,34 @@ float4 main(v2f IN) : SV_Target0 return float4(asfloat(rootbytesrv.Load(z+0).x), asfloat(rootbytesrv.Load(z+4).x), asfloat(rootbytesrv.Load(z+8).x), float(rootbytesrv.Load(z+12).x)); } +)EOSHADER" + R"EOSHADER( + if(IN.tri == 113) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.Sample(linearclamp, uv); + } + if(IN.tri == 114) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.SampleBias(linearclamp, uv, 4.0); + } + if(IN.tri == 115) + { + float4 Color = float4(0,0,0,0); + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + Color.x = smileyr32.SampleCmp(linearcompare, uv, 0.0); + Color.y = smileyr32.SampleCmp(linearcompare, uv, 0.1); + Color.z = smileyr32.SampleCmp(linearcompare, uv, 0.7); + Color.w = smileyr32.SampleCmp(linearcompare, uv, 1.0); + return Color; + } if(IN.tri == 113) { uint a = 0, b = 0, c = 0; @@ -1293,6 +1324,32 @@ float4 main(v2f IN) : SV_Target0 } #endif // #if UNBOUND_CBVS #endif + if(IN.tri == 122) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.Sample(linearclamp, uv); + } + if(IN.tri == 123) + { + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + return smiley.SampleBias(linearclamp, uv, 4.0); + } + if(IN.tri == 124) + { + float4 Color = float4(0,0,0,0); + float2 uv = IN.s.xy / float2(2.0, 2.0); + uv.x += 0.6042; + uv.y += 0.4167; + Color.x = smileyr32.SampleCmp(linearcompare, uv, 0.0); + Color.y = smileyr32.SampleCmp(linearcompare, uv, 0.1); + Color.z = smileyr32.SampleCmp(linearcompare, uv, 0.7); + Color.w = smileyr32.SampleCmp(linearcompare, uv, 1.0); + return Color; + } return float4(0.4f, 0.4f, 0.4f, 0.4f); } )EOSHADER"; @@ -2190,6 +2247,14 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui staticSamp.AddressU = staticSamp.AddressV = staticSamp.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; staticSamp.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + D3D12_STATIC_SAMPLER_DESC samplers[] = {staticSamp, staticSamp}; + samplers[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; + + samplers[1].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; + samplers[1].Filter = D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; + samplers[1].ComparisonFunc = D3D12_COMPARISON_FUNC_LESS; + samplers[1].ShaderRegister = 1; + D3D12_DESCRIPTOR_RANGE1 multiRanges[4] = { { D3D12_DESCRIPTOR_RANGE_TYPE_SRV, @@ -2245,8 +2310,9 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui srvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 20), tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0, 9, 3, 100), srvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 21), + tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 8, 1, 64), }, - D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT, 1, &staticSamp); + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT, 2, samplers); ID3D12RootSignaturePtr sig = MakeSig( { @@ -2259,6 +2325,7 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui srvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 20), tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0, 9, 3, 100), srvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 21), + tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 8, 1, 64), // Texture2D tex2ds[14] : register(t0, space1); tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0, 14, 150), // SamplerState samplers[14] : register(s0, space1); @@ -2277,7 +2344,7 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui // ConstantBuffer unbounded_cbuffers[] : register(b0, space2); tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 2, 0, 14, 450), }, - D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT, 1, &staticSamp); + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT, 2, samplers); const int numShaderModels = 5; // 5.0, 5.1, 6.0, 6.2, 6.6 ID3D12PipelineStatePtr psos[numShaderModels * 2] = {}; @@ -2579,6 +2646,8 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui ID3D12ResourcePtr smiley = MakeTexture(DXGI_FORMAT_R8G8B8A8_TYPELESS, 48, 48) .Mips(1) .InitialState(D3D12_RESOURCE_STATE_COPY_DEST); + ID3D12ResourcePtr smileyr32 = + MakeTexture(DXGI_FORMAT_R32_TYPELESS, 48, 48).Mips(5).InitialState(D3D12_RESOURCE_STATE_COPY_DEST); ID3D12ResourcePtr uploadBuf = MakeBuffer().Size(1024 * 1024).Upload(); ID3D12ResourcePtr constBuf = MakeBuffer().Size(256).Upload(); @@ -2644,10 +2713,71 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui Submit({cmd}); GPUSync(); } + { + D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout = {}; + + D3D12_RESOURCE_DESC desc = smileyr32->GetDesc(); + + dev->GetCopyableFootprints(&desc, 0, 1, 0, &layout, NULL, NULL, NULL); + + uint32_t *srcptr = (uint32_t *)rgba8.data.data(); + byte *mapptr = NULL; + uploadBuf->Map(0, NULL, (void **)&mapptr); + + ID3D12GraphicsCommandListPtr cmd = GetCommandBuffer(); + + Reset(cmd); + + { + D3D12_TEXTURE_COPY_LOCATION dst, src; + + dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; + dst.pResource = smileyr32; + dst.SubresourceIndex = 0; + + byte *dstptr = mapptr + layout.Offset; + + for(UINT row = 0; row < rgba8.height; row++) + { + float *pix = (float *)dstptr; + for(UINT col = 0; col < rgba8.width; col++) + { + uint32_t texValue = *srcptr; + uint32_t red = texValue & 0xFF; + *pix = (float)red / 255.0f; + pix++; + srcptr++; + } + dstptr += layout.Footprint.RowPitch; + } + + src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; + src.pResource = uploadBuf; + src.PlacedFootprint = layout; + + cmd->CopyTextureRegion(&dst, 0, 0, 0, &src, NULL); + + D3D12_RESOURCE_BARRIER b = {}; + b.Transition.pResource = smileyr32; + b.Transition.Subresource = 0; + b.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST; + b.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; + cmd->ResourceBarrier(1, &b); + } + + cmd->Close(); + + uploadBuf->Unmap(0, NULL); + + Submit({cmd}); + GPUSync(); + } MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_UNORM).CreateGPU(5); MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_SINT).CreateGPU(6); MakeSRV(smiley).Format(DXGI_FORMAT_R8G8B8A8_UINT).CreateGPU(7); + MakeSRV(smileyr32).Format(DXGI_FORMAT_R32_FLOAT).CreateGPU(64); ID3D12ResourcePtr rawBuf2 = MakeBuffer().Size(1024).UAV(); rawBuf2->SetName(L"rawBuf2"); @@ -2971,12 +3101,6 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui computePSOs[2] = MakePSO().RootSig(sigCompute).CS(csblob); } - D3D12_STATIC_SAMPLER_DESC samplers[] = {staticSamp, staticSamp}; - samplers[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; - samplers[1].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; - samplers[1].ComparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL; - samplers[1].ShaderRegister = 1; - ID3D12RootSignaturePtr sigComputeDerivs = MakeSig( { constParam(D3D12_SHADER_VISIBILITY_ALL, 0, 0, 1), @@ -3157,21 +3281,24 @@ void main(uint3 inDTID : SV_DispatchThreadID, uint3 inGID : SV_GroupThreadID, ui cmd->SetGraphicsRootDescriptorTable(7, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); cmd->SetGraphicsRootShaderResourceView( 8, rootbytesrv->GetGPUVirtualAddress() + renderDataSize); + cmd->SetGraphicsRootDescriptorTable(9, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); + if(i >= 2) { - cmd->SetGraphicsRootDescriptorTable(9, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); - cmd->SetGraphicsRootDescriptorTable(10, m_Sampler->GetGPUDescriptorHandleForHeapStart()); - cmd->SetGraphicsRootDescriptorTable(11, + cmd->SetGraphicsRootDescriptorTable(10, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); + cmd->SetGraphicsRootDescriptorTable(11, m_Sampler->GetGPUDescriptorHandleForHeapStart()); cmd->SetGraphicsRootDescriptorTable(12, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); cmd->SetGraphicsRootDescriptorTable(13, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); - cmd->SetGraphicsRootDescriptorTable(14, m_Sampler->GetGPUDescriptorHandleForHeapStart()); - cmd->SetGraphicsRootDescriptorTable(15, + cmd->SetGraphicsRootDescriptorTable(14, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); + cmd->SetGraphicsRootDescriptorTable(15, m_Sampler->GetGPUDescriptorHandleForHeapStart()); cmd->SetGraphicsRootDescriptorTable(16, m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); + cmd->SetGraphicsRootDescriptorTable(17, + m_CBVUAVSRV->GetGPUDescriptorHandleForHeapStart()); } // Add a marker so we can easily locate this draw diff --git a/util/test/demos/vk/vk_resource_usage.cpp b/util/test/demos/vk/vk_resource_usage.cpp index f94d1071ab1..f9ca8ecd20f 100644 --- a/util/test/demos/vk/vk_resource_usage.cpp +++ b/util/test/demos/vk/vk_resource_usage.cpp @@ -452,6 +452,11 @@ RD_TEST(VK_Resource_Usage, VulkanGraphicsTest) draw_indirect_count = hasExt(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME); } + draw_indirect_count = true; + nestedSecondaries = true; + descBuffer = true; + meshShader = true; + if(draw_indirect_count) TEST_LOG("Running tests with draw indirect count"); if(nestedSecondaries) diff --git a/util/test/tests/All_Resource_Usage.py b/util/test/tests/All_Resource_Usage.py new file mode 100644 index 00000000000..9ddc8af28a9 --- /dev/null +++ b/util/test/tests/All_Resource_Usage.py @@ -0,0 +1,38 @@ +import rdtest +import os +import renderdoc as rd + + +class All_Resource_Usage(rdtest.TestCase): + + def resource_usage(self, path: str): + try: + (_, replay) = rdtest.open_capture(path) + except RuntimeError as err: + rdtest.log.print(f"Skipping. Can't open {path}: {err}") + return + + rdtest.log.print("Loaded"); + with rdtest.log.auto_section("Checking Indirect Action Names"): + if not self.check_indirect_action_name_consistency(replay): + raise rdtest.TestFailureException("Indirect action parameters do not match its event parameters") + + resources = replay.GetResources() + resourceUsages = {} + for res in resources: + rdtest.log.print(f"Checking {res.resourceId} ({res.name})") + resourceUsages[res.resourceId] = replay.GetUsage(res.resourceId) + # Special case id = 0 means check event flags + replay.GetUsage(rd.ResourceId.Null()) + replay.Shutdown() + rdtest.log.success("Checked") + + def run(self): + dir_path = self.get_ref_path('', extra=True) + + for file in os.scandir(dir_path): + with rdtest.log.auto_section(f"Checking:{file.name}"): + self.resource_usage(file.path) + + rdtest.log.success("Checked all files") + 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])