From c8436d364614e3943354810ca186dfe6a65e9579 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 2 Jan 2016 20:26:45 +0100 Subject: [PATCH] Implement resource usage tracking --- ReleaseNotes.md | 1 + renderdoc/api/replay/replay_enums.h | 3 +- renderdoc/driver/vulkan/vk_core.cpp | 150 +++++++++++++++++- renderdoc/driver/vulkan/vk_core.h | 37 +++-- renderdoc/driver/vulkan/vk_info.cpp | 2 +- renderdoc/driver/vulkan/vk_replay.cpp | 3 +- renderdoc/driver/vulkan/vk_resources.h | 3 +- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 25 ++- .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 11 +- renderdocui/Interop/Enums.cs | 13 +- 10 files changed, 221 insertions(+), 27 deletions(-) diff --git a/ReleaseNotes.md b/ReleaseNotes.md index d8859ae23..2eed10ebb 100644 --- a/ReleaseNotes.md +++ b/ReleaseNotes.md @@ -23,6 +23,7 @@ Current Support * Pipeline export to HTML * Render overlays like Drawcall highlight, wireframe, depth-test pass/fail etc * Texture range auto-fit and histogram display +* Show resource usage of each image/buffer and where it's used in different parts of the pipeline during the frame. * Threading should be pretty efficient - no heavy locks on common paths (outside of creation/deletion) * Saving textures to file diff --git a/renderdoc/api/replay/replay_enums.h b/renderdoc/api/replay/replay_enums.h index 01bcaff37..0aeef6c8b 100644 --- a/renderdoc/api/replay/replay_enums.h +++ b/renderdoc/api/replay/replay_enums.h @@ -380,7 +380,8 @@ enum ResourceUsage eUsage_GS_RWResource, eUsage_PS_RWResource, eUsage_CS_RWResource, - + + eUsage_InputTarget, eUsage_ColourTarget, eUsage_DepthStencilTarget, diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index b45d29794..230109544 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -1999,14 +1999,16 @@ void WrappedVulkan::AddDrawcall(FetchDrawcall d, bool hasEvents) draw.events = srcEvents; srcEvents.clear(); } - - //AddUsage(draw); // should have at least the root drawcall here, push this drawcall // onto the back's children list. if(!GetDrawcallStack().empty()) { - DrawcallTreeNode node(draw); + VulkanDrawcallTreeNode node(draw); + + if(m_LastCmdBufferID != ResourceId()) + AddUsage(node); + node.children.insert(node.children.begin(), draw.children.elems, draw.children.elems+draw.children.count); GetDrawcallStack().back()->children.push_back(node); } @@ -2014,6 +2016,148 @@ void WrappedVulkan::AddDrawcall(FetchDrawcall d, bool hasEvents) RDCERR("Somehow lost drawcall stack!"); } +void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode) +{ + FetchDrawcall &d = drawNode.draw; + + const BakedCmdBufferInfo::CmdBufferState &state = m_BakedCmdBufferInfo[m_LastCmdBufferID].state; + VulkanCreationInfo &c = m_CreationInfo; + uint32_t e = d.eventID; + + if((d.flags & (eDraw_Drawcall|eDraw_Dispatch)) == 0) + return; + + ////////////////////////////// + // Vertex input + + if(d.flags & eDraw_UseIBuffer && state.ibuffer != ResourceId()) + drawNode.resourceUsage.push_back(std::make_pair(state.ibuffer, EventUsage(e, eUsage_IndexBuffer))); + + for(size_t i=0; i < state.vbuffers.size(); i++) + drawNode.resourceUsage.push_back(std::make_pair(state.vbuffers[i], EventUsage(e, eUsage_VertexBuffer))); + + ////////////////////////////// + // Shaders + + for(int shad=0; shad < 6; shad++) + { + VulkanCreationInfo::Pipeline::Shader &sh = c.m_Pipeline[state.pipeline].shaders[shad]; + if(sh.module == ResourceId()) continue; + + // 5 is the compute shader's index (VS, TCS, TES, GS, FS, CS) + const vector &descSets = (shad == 5 ? state.computeDescSets : state.graphicsDescSets); + + RDCASSERT(sh.mapping); + + struct ResUsageType + { + ResUsageType(rdctype::array &a, ResourceUsage u) + : arr(a), usage(u) {} + rdctype::array &arr; + ResourceUsage usage; + }; + + ResUsageType types[] = { + ResUsageType(sh.mapping->ReadOnlyResources, eUsage_VS_Resource), + ResUsageType(sh.mapping->ReadWriteResources, eUsage_VS_RWResource), + ResUsageType(sh.mapping->ConstantBlocks, eUsage_VS_Constants), + }; + + for(size_t t=0; t < ARRAY_COUNT(types); t++) + { + for(int32_t i=0; i < types[t].arr.count; i++) + { + if(!types[t].arr[i].used) continue; + + int32_t bindset = types[t].arr[i].bindset; + int32_t bind = types[t].arr[i].bind; + + RDCASSERT(bindset < (int32_t)descSets.size()); + + DescriptorSetInfo &descset = m_DescriptorSetState[ descSets[bindset] ]; + DescSetLayout &layout = c.m_DescSetLayout[ descset.layout ]; + + RDCASSERT(bind < (int32_t)layout.bindings.size()); + + // handled as part of the framebuffer attachments + if(layout.bindings[bind].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) + continue; + + // we don't mark samplers with usage + if(layout.bindings[bind].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) + continue; + + ResourceUsage usage = ResourceUsage(types[t].usage + shad); + + RDCASSERT(bind < (int32_t)descset.currentBindings.size()); + + for(uint32_t a=0; a < layout.bindings[bind].descriptorCount; a++) + { + DescriptorSetSlot &slot = descset.currentBindings[bind][a]; + + ResourceId id; + + switch(layout.bindings[bind].descriptorType) + { + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + if(slot.imageInfo.imageView != VK_NULL_HANDLE) + id = c.m_ImageView[GetResourceManager()->GetNonDispWrapper(slot.imageInfo.imageView)->id].image; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + if(slot.texelBufferView != VK_NULL_HANDLE) + id = c.m_BufferView[GetResourceManager()->GetNonDispWrapper(slot.texelBufferView)->id].buffer; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + if(slot.bufferInfo.buffer != VK_NULL_HANDLE) + id = GetResourceManager()->GetNonDispWrapper(slot.bufferInfo.buffer)->id; + break; + default: + RDCERR("Unexpected type %d", layout.bindings[bind].descriptorType); + break; + } + + drawNode.resourceUsage.push_back(std::make_pair(id, EventUsage(e, usage))); + } + } + } + } + + ////////////////////////////// + // Framebuffer/renderpass + + if(state.renderPass != ResourceId() && state.framebuffer != ResourceId()) + { + VulkanCreationInfo::RenderPass &rp = c.m_RenderPass[state.renderPass]; + VulkanCreationInfo::Framebuffer &fb = c.m_Framebuffer[state.framebuffer]; + + RDCASSERT(state.subpass < rp.subpasses.size()); + + for(size_t i=0; i < rp.subpasses[state.subpass].inputAttachments.size(); i++) + { + uint32_t att = rp.subpasses[state.subpass].inputAttachments[i]; + drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image, EventUsage(e, eUsage_InputTarget))); + } + + for(size_t i=0; i < rp.subpasses[state.subpass].colorAttachments.size(); i++) + { + uint32_t att = rp.subpasses[state.subpass].colorAttachments[i]; + drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image, EventUsage(e, eUsage_ColourTarget))); + } + + if(rp.subpasses[state.subpass].depthstencilAttachment >= 0) + { + int32_t att = rp.subpasses[state.subpass].depthstencilAttachment; + drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image, EventUsage(e, eUsage_DepthStencilTarget))); + } + } +} + void WrappedVulkan::AddEvent(VulkanChunkType type, string description) { FetchAPIEvent apievent; diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 5a8b3d4b8..2fd003548 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -60,14 +60,16 @@ struct VkInitParams : public RDCInitParams ResourceId InstanceID; }; -struct DrawcallTreeNode +struct VulkanDrawcallTreeNode { - DrawcallTreeNode() {} - explicit DrawcallTreeNode(FetchDrawcall d) : draw(d) {} + VulkanDrawcallTreeNode() {} + explicit VulkanDrawcallTreeNode(FetchDrawcall d) : draw(d) {} FetchDrawcall draw; - vector children; + vector children; - DrawcallTreeNode &operator =(FetchDrawcall d) { *this = DrawcallTreeNode(d); return *this; } + vector< pair > resourceUsage; + + VulkanDrawcallTreeNode &operator =(FetchDrawcall d) { *this = VulkanDrawcallTreeNode(d); return *this; } vector Bake() { @@ -286,12 +288,17 @@ private: struct BakedCmdBufferInfo { vector curEvents; - list drawStack; + list drawStack; - struct + struct CmdBufferState { ResourceId pipeline; + vector graphicsDescSets; + vector computeDescSets; + uint32_t idxWidth; + ResourceId ibuffer; + vector vbuffers; ResourceId renderPass; ResourceId framebuffer; @@ -300,7 +307,7 @@ private: vector< pair > imgbarriers; - DrawcallTreeNode *draw; // the root draw to copy from when submitting + VulkanDrawcallTreeNode *draw; // the root draw to copy from when submitting uint32_t eventCount; // how many events are in this cmd buffer, for quick skipping uint32_t curEventID; // current event ID while reading or executing uint32_t drawCount; // similar to above @@ -426,6 +433,8 @@ private: map m_BakedCmdBufferInfo; // immutable creation data VulkanCreationInfo m_CreationInfo; + + map > m_ResourceUses; static const char *GetChunkName(uint32_t idx); @@ -465,13 +474,13 @@ private: uint32_t m_RootEventID, m_RootDrawcallID; uint32_t m_FirstEventID, m_LastEventID; - DrawcallTreeNode m_ParentDrawcall; + VulkanDrawcallTreeNode m_ParentDrawcall; - void InsertDrawsAndRefreshIDs(vector &nodes, vector &cmdBufNodes, uint32_t baseEventID, uint32_t baseDrawID); + void InsertDrawsAndRefreshIDs(vector &nodes, vector &cmdBufNodes, uint32_t baseEventID, uint32_t baseDrawID); - list m_DrawcallStack; + list m_DrawcallStack; - list &GetDrawcallStack() + list &GetDrawcallStack() { if(m_LastCmdBufferID != ResourceId()) return m_BakedCmdBufferInfo[m_LastCmdBufferID].drawStack; @@ -484,6 +493,8 @@ private: void ContextProcessChunk(uint64_t offset, VulkanChunkType chunk, bool forceExecute); void AddDrawcall(FetchDrawcall d, bool hasEvents); void AddEvent(VulkanChunkType type, string description); + + void AddUsage(VulkanDrawcallTreeNode &drawNode); // no copy semantics WrappedVulkan(const WrappedVulkan &); @@ -542,6 +553,8 @@ public: uint32_t GetMaxEID() { return m_Events.back().eventID; } const FetchDrawcall *GetDrawcall(uint32_t frameID, uint32_t eventID); + vector GetUsage(ResourceId id) { return m_ResourceUses[id]; } + // return the pre-selected device and queue VkDevice GetDev() { RDCASSERT(m_Device != VK_NULL_HANDLE); return m_Device; } VkQueue GetQ() { RDCASSERT(m_Device != VK_NULL_HANDLE); return m_Queue; } diff --git a/renderdoc/driver/vulkan/vk_info.cpp b/renderdoc/driver/vulkan/vk_info.cpp index 730fec343..59420062c 100644 --- a/renderdoc/driver/vulkan/vk_info.cpp +++ b/renderdoc/driver/vulkan/vk_info.cpp @@ -225,7 +225,7 @@ void VulkanCreationInfo::Pipeline::Init(VulkanResourceManager *resourceMan, Vulk // VkPipelineShaderStageCreateInfo { ResourceId id = resourceMan->GetNonDispWrapper(pCreateInfo->stage.module)->id; - Shader &shad = shaders[0]; + Shader &shad = shaders[5]; // 5 is the compute shader's index (VS, TCS, TES, GS, FS, CS) shad.module = id; shad.entryPoint = pCreateInfo->stage.pName; diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index dfadf8c09..0177ca4a4 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -3857,8 +3857,7 @@ void VulkanReplay::InitPostVSBuffers(uint32_t frameID, const vector &e vector VulkanReplay::GetUsage(ResourceId id) { - VULKANNOTIMP("GetUsage"); - return vector(); + return m_pDriver->GetUsage(id); } void VulkanReplay::SetContextFilter(ResourceId id, uint32_t firstDefEv, uint32_t lastDefEv) diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index ad7502bb6..447a39a08 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/renderdoc/driver/vulkan/vk_resources.h @@ -125,7 +125,8 @@ struct TypedRealHandle bool operator ==(const TypedRealHandle o) const { - return type == o.type && real == o.real; + // NULL compares as equal regardless of type. + return (real.handle == 0 && o.real.handle == 0) || (type == o.type && real == o.real); } bool operator !=(const TypedRealHandle o) const { diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index ea984b521..9c0b35c52 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -411,7 +411,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( } { - DrawcallTreeNode *draw = new DrawcallTreeNode; + VulkanDrawcallTreeNode *draw = new VulkanDrawcallTreeNode; m_BakedCmdBufferInfo[cmdId].draw = draw; // On queue submit we increment all child events/drawcalls by @@ -1153,6 +1153,19 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( { commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); layout = GetResourceManager()->GetLiveHandle(layoutid); + + // track while reading, as we need to track resource usage + vector &descsets = + (bind == VK_PIPELINE_BIND_POINT_GRAPHICS) + ? m_BakedCmdBufferInfo[m_LastCmdBufferID].state.graphicsDescSets + : m_BakedCmdBufferInfo[m_LastCmdBufferID].state.computeDescSets; + + // expand as necessary + if(descsets.size() < first + numSets) + descsets.resize(first + numSets); + + for(uint32_t i=0; i < numSets; i++) + descsets[first+i] = descriptorIDs[i]; ObjDisp(commandBuffer)->CmdBindDescriptorSets(Unwrap(commandBuffer), bind, Unwrap(layout), first, numSets, sets, offsCount, offs); } @@ -1258,6 +1271,13 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( { commandBuffer = GetResourceManager()->GetLiveHandle(cmdid); + // track while reading, as we need to track resource usage + if(m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers.size() < start + count) + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers.resize(start + count); + + for(uint32_t i=0; i < count; i++) + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.vbuffers[start + i] = bufids[i]; + ObjDisp(commandBuffer)->CmdBindVertexBuffers(Unwrap(commandBuffer), start, count, &bufs[0], &offs[0]); } @@ -1334,6 +1354,9 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( // track while reading, as we need to bind current topology & index byte width in AddDrawcall m_BakedCmdBufferInfo[m_LastCmdBufferID].state.idxWidth = (idxType == VK_INDEX_TYPE_UINT32 ? 4 : 2); + // track while reading, as we need to track resource usage + m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer = GetResID(buffer); + ObjDisp(commandBuffer)->CmdBindIndexBuffer(Unwrap(commandBuffer), Unwrap(buffer), offs, idxType); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 2ca636c6d..3f370a3f3 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -352,13 +352,13 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( return true; } -void WrappedVulkan::InsertDrawsAndRefreshIDs(vector &nodes, vector &cmdBufNodes, +void WrappedVulkan::InsertDrawsAndRefreshIDs(vector &nodes, vector &cmdBufNodes, uint32_t baseEventID, uint32_t baseDrawID) { // assign new drawcall IDs for(size_t i=0; i < cmdBufNodes.size(); i++) { - DrawcallTreeNode n = cmdBufNodes[i]; + VulkanDrawcallTreeNode n = cmdBufNodes[i]; n.draw.eventID += baseEventID; n.draw.drawcallID += baseDrawID; @@ -377,6 +377,13 @@ void WrappedVulkan::InsertDrawsAndRefreshIDs(vector &nodes, ve n.children.clear(); InsertDrawsAndRefreshIDs(n.children, cmdBufNodes[i].children, baseEventID, baseDrawID); + for(auto it=n.resourceUsage.begin(); it != n.resourceUsage.end(); ++it) + { + EventUsage u = it->second; + u.eventID += baseEventID; + m_ResourceUses[it->first].push_back(u); + } + nodes.push_back(n); } } diff --git a/renderdocui/Interop/Enums.cs b/renderdocui/Interop/Enums.cs index 63fd1b030..04d0c29ca 100644 --- a/renderdocui/Interop/Enums.cs +++ b/renderdocui/Interop/Enums.cs @@ -377,6 +377,7 @@ namespace renderdoc PS_RWResource, CS_RWResource, + InputTarget, ColourTarget, DepthStencilTarget, @@ -636,6 +637,7 @@ namespace renderdoc case ResourceUsage.PS_RWResource: return "PS - UAV"; case ResourceUsage.CS_RWResource: return "CS - UAV"; + case ResourceUsage.InputTarget: return "Colour Input"; case ResourceUsage.ColourTarget: return "Rendertarget"; case ResourceUsage.DepthStencilTarget: return "Depthstencil"; @@ -650,8 +652,10 @@ namespace renderdoc case ResourceUsage.CopyDst: return "Copy - Dest"; } } - else if (apitype == APIPipelineStateType.OpenGL) + else if (apitype == APIPipelineStateType.OpenGL || apitype == APIPipelineStateType.Vulkan) { + bool vk = (apitype == APIPipelineStateType.Vulkan); + switch (usage) { case ResourceUsage.VertexBuffer: return "Vertex Buffer"; @@ -680,15 +684,16 @@ namespace renderdoc case ResourceUsage.PS_RWResource: return "PS - Image/SSBO"; case ResourceUsage.CS_RWResource: return "CS - Image/SSBO"; + case ResourceUsage.InputTarget: return "FBO Input"; case ResourceUsage.ColourTarget: return "FBO Colour"; case ResourceUsage.DepthStencilTarget: return "FBO Depthstencil"; case ResourceUsage.Clear: return "Clear"; case ResourceUsage.GenMips: return "Generate Mips"; - case ResourceUsage.Resolve: return "Framebuffer blit"; - case ResourceUsage.ResolveSrc: return "Framebuffer blit - Source"; - case ResourceUsage.ResolveDst: return "Framebuffer blit - Dest"; + case ResourceUsage.Resolve: return vk ? "Resolve" : "Framebuffer blit"; + case ResourceUsage.ResolveSrc: return vk ? "Resolve - Source" : "Framebuffer blit - Source"; + case ResourceUsage.ResolveDst: return vk ? "Resolve - Dest" : "Framebuffer blit - Dest"; case ResourceUsage.Copy: return "Copy"; case ResourceUsage.CopySrc: return "Copy - Source"; case ResourceUsage.CopyDst: return "Copy - Dest";