Implement resource usage tracking

This commit is contained in:
baldurk committed 2016-02-07 18:50:05 +01:00
1 parent c746957fb2
commit c8436d3646
10 files changed
+221 -27

No files matched your search

+1
View File
@@ -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
+2 -1
View File
@@ -380,7 +380,8 @@ enum ResourceUsage
eUsage_GS_RWResource,
eUsage_PS_RWResource,
eUsage_CS_RWResource,
eUsage_InputTarget,
eUsage_ColourTarget,
eUsage_DepthStencilTarget,
+147 -3
View File
@@ -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<ResourceId> &descSets = (shad == 5 ? state.computeDescSets : state.graphicsDescSets);
RDCASSERT(sh.mapping);
struct ResUsageType
{
ResUsageType(rdctype::array<BindpointMap> &a, ResourceUsage u)
: arr(a), usage(u) {}
rdctype::array<BindpointMap> &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;
+25 -12
View File
@@ -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<DrawcallTreeNode> children;
vector<VulkanDrawcallTreeNode> children;
DrawcallTreeNode &operator =(FetchDrawcall d) { *this = DrawcallTreeNode(d); return *this; }
vector< pair<ResourceId, EventUsage> > resourceUsage;
VulkanDrawcallTreeNode &operator =(FetchDrawcall d) { *this = VulkanDrawcallTreeNode(d); return *this; }
vector<FetchDrawcall> Bake()
{
@@ -286,12 +288,17 @@ private:
struct BakedCmdBufferInfo
{
vector<FetchAPIEvent> curEvents;
list<DrawcallTreeNode *> drawStack;
list<VulkanDrawcallTreeNode *> drawStack;
struct
struct CmdBufferState
{
ResourceId pipeline;
vector<ResourceId> graphicsDescSets;
vector<ResourceId> computeDescSets;
uint32_t idxWidth;
ResourceId ibuffer;
vector<ResourceId> vbuffers;
ResourceId renderPass;
ResourceId framebuffer;
@@ -300,7 +307,7 @@ private:
vector< pair<ResourceId, ImageRegionState> > 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<ResourceId, BakedCmdBufferInfo> m_BakedCmdBufferInfo;
// immutable creation data
VulkanCreationInfo m_CreationInfo;
map<ResourceId, vector<EventUsage> > 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<DrawcallTreeNode> &nodes, vector<DrawcallTreeNode> &cmdBufNodes, uint32_t baseEventID, uint32_t baseDrawID);
void InsertDrawsAndRefreshIDs(vector<VulkanDrawcallTreeNode> &nodes, vector<VulkanDrawcallTreeNode> &cmdBufNodes, uint32_t baseEventID, uint32_t baseDrawID);
list<DrawcallTreeNode *> m_DrawcallStack;
list<VulkanDrawcallTreeNode *> m_DrawcallStack;
list<DrawcallTreeNode *> &GetDrawcallStack()
list<VulkanDrawcallTreeNode *> &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<EventUsage> 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; }
+1 -1
View File
@@ -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;
+1 -2
View File
@@ -3857,8 +3857,7 @@ void VulkanReplay::InitPostVSBuffers(uint32_t frameID, const vector<uint32_t> &e
vector<EventUsage> VulkanReplay::GetUsage(ResourceId id)
{
VULKANNOTIMP("GetUsage");
return vector<EventUsage>();
return m_pDriver->GetUsage(id);
}
void VulkanReplay::SetContextFilter(ResourceId id, uint32_t firstDefEv, uint32_t lastDefEv)
+2 -1
View File
@@ -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
{
@@ -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<VkCommandBuffer>(cmdid);
layout = GetResourceManager()->GetLiveHandle<VkPipelineLayout>(layoutid);
// track while reading, as we need to track resource usage
vector<ResourceId> &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<VkCommandBuffer>(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);
}
@@ -352,13 +352,13 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(
return true;
}
void WrappedVulkan::InsertDrawsAndRefreshIDs(vector<DrawcallTreeNode> &nodes, vector<DrawcallTreeNode> &cmdBufNodes,
void WrappedVulkan::InsertDrawsAndRefreshIDs(vector<VulkanDrawcallTreeNode> &nodes, vector<VulkanDrawcallTreeNode> &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<DrawcallTreeNode> &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);
}
}
+9 -4
View File
@@ -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";