Add resource usage for CPU writes to resources

qrenderdoc/Code/QRDUtils.cpp

@@ -932,6 +932,8 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype)
   {
     switch(usage)
     {
+      case ResourceUsage::Unused: return lit("Unused");
+
       case ResourceUsage::VertexBuffer: return lit("Vertex Buffer");
       case ResourceUsage::IndexBuffer: return lit("Index Buffer");
 
@@ -978,7 +980,8 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype)
       case ResourceUsage::CopyDst: return lit("Copy - Dest");
 
       case ResourceUsage::Barrier: return lit("Barrier");
-      default: break;
+
+      case ResourceUsage::CPUWrite: return lit("CPU Write");
     }
   }
   else if(apitype == GraphicsAPI::OpenGL || apitype == GraphicsAPI::Vulkan)
@@ -987,6 +990,8 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype)
 
     switch(usage)
     {
+      case ResourceUsage::Unused: return lit("Unused");
+
       case ResourceUsage::VertexBuffer: return lit("Vertex Buffer");
       case ResourceUsage::IndexBuffer: return lit("Index Buffer");
 
@@ -1035,7 +1040,8 @@ QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype)
       case ResourceUsage::CopyDst: return lit("Copy - Dest");
 
       case ResourceUsage::Barrier: return lit("Barrier");
-      default: break;
+
+      case ResourceUsage::CPUWrite: return lit("CPU Write");
     }
   }
 

renderdoc/api/replay/renderdoc_tostr.inl

@@ -783,6 +783,8 @@ rdcstr DoStringise(const ResourceUsage &el)
     STRINGISE_ENUM_CLASS_NAMED(CopyDst, "Copy - Destination");
 
     STRINGISE_ENUM_CLASS_NAMED(Barrier, "Barrier");
+
+    STRINGISE_ENUM_CLASS_NAMED(CPUWrite, "CPU Write");
   }
   END_ENUM_STRINGISE();
 }

renderdoc/api/replay/replay_enums.h

@@ -2403,6 +2403,8 @@ enum class ResourceUsage : uint32_t
   CopyDst,
 
   Barrier,
+
+  CPUWrite,
 };
 
 DECLARE_REFLECTION_ENUM(ResourceUsage);

renderdoc/driver/d3d11/d3d11_context1_wrap.cpp

@@ -229,6 +229,12 @@ bool WrappedID3D11DeviceContext::Serialise_UpdateSubresource1(
               "Replaying a call to UpdateSubresource1() without D3D11.1 available");
         }
       }
+
+      if(IsLoading(m_State))
+      {
+        m_ResourceUses[GetIDForResource(pDstResource)].push_back(
+            EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+      }
     }
   }
   else
@@ -345,6 +351,12 @@ bool WrappedID3D11DeviceContext::Serialise_UpdateSubresource1(
               "Replaying a call to UpdateSubresource1() without D3D11.1 available");
         }
       }
+
+      if(IsLoading(m_State))
+      {
+        m_ResourceUses[GetIDForResource(pDstResource)].push_back(
+            EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+      }
     }
   }
 
@@ -431,6 +443,41 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion1(
           MessageSource::UnsupportedConfiguration,
           "Replaying a call to CopySubresourceRegion1() without D3D11.1 available");
     }
+
+    if(IsLoading(m_State))
+    {
+      ResourceId dstLiveID = GetIDForResource(pDstResource);
+      ResourceId srcLiveID = GetIDForResource(pSrcResource);
+      ResourceId dstOrigID = GetResourceManager()->GetOriginalID(dstLiveID);
+      ResourceId srcOrigID = GetResourceManager()->GetOriginalID(srcLiveID);
+
+      AddEvent();
+
+      DrawcallDescription draw;
+      draw.name = "CopySubresourceRegion1(" + ToStr(dstOrigID) + ", " + ToStr(srcOrigID) + ")";
+      draw.flags |= DrawFlags::Copy;
+
+      if(pDstResource && pSrcResource)
+      {
+        draw.copySource = srcOrigID;
+        draw.copyDestination = dstOrigID;
+
+        if(m_CurEventID)
+        {
+          if(dstLiveID == srcLiveID)
+          {
+            m_ResourceUses[dstLiveID].push_back(EventUsage(m_CurEventID, ResourceUsage::Copy));
+          }
+          else
+          {
+            m_ResourceUses[dstLiveID].push_back(EventUsage(m_CurEventID, ResourceUsage::CopyDst));
+            m_ResourceUses[srcLiveID].push_back(EventUsage(m_CurEventID, ResourceUsage::CopySrc));
+          }
+        }
+      }
+
+      AddDrawcall(draw, true);
+    }
   }
 
   return true;

renderdoc/driver/d3d11/d3d11_context_wrap.cpp

@@ -7835,8 +7835,12 @@ bool WrappedID3D11DeviceContext::Serialise_Unmap(SerialiserType &ser, ID3D11Reso
     MapWrittenData = (byte *)intercept.app.pData;
 
     if(IsLoading(m_State) && m_CurEventID > 0 && (diffStart < diffEnd))
+    {
       RecordUpdateStats(pResource, diffEnd - diffStart, false);
 
+      m_ResourceUses[mapIdx.resource].push_back(EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+    }
+
     if(diffStart >= diffEnd)
     {
       // do nothing

renderdoc/driver/d3d12/d3d12_commands.cpp

@@ -1561,6 +1561,11 @@ void D3D12CommandData::AddUsage(D3D12DrawcallTreeNode &drawNode, ResourceId id,
   drawNode.resourceUsage.push_back(make_rdcpair(id, EventUsage(EID, usage)));
 }
 
+void D3D12CommandData::AddUsage(ResourceId id, ResourceUsage usage)
+{
+  m_ResourceUses[id].push_back(EventUsage(m_RootEventID, usage));
+}
+
 void D3D12CommandData::AddUsage(const D3D12RenderState &state, D3D12DrawcallTreeNode &drawNode)
 {
   DrawcallDescription &d = drawNode.draw;

renderdoc/driver/d3d12/d3d12_commands.h

@@ -376,4 +376,5 @@ struct D3D12CommandData
   void AddEvent();
   void AddUsage(const D3D12RenderState &state, D3D12DrawcallTreeNode &drawNode);
   void AddUsage(D3D12DrawcallTreeNode &drawNode, ResourceId id, uint32_t EID, ResourceUsage usage);
+  void AddUsage(ResourceId id, ResourceUsage usage);
 };

renderdoc/driver/d3d12/d3d12_device.cpp

@@ -1289,11 +1289,14 @@ bool WrappedID3D12Device::Serialise_MapDataWrite(SerialiserType &ser, ID3D12Reso
   // don't do anything if end <= begin because the range is empty.
   if(IsReplayingAndReading() && Resource && range.End > range.Begin)
   {
+    D3D12CommandData &cmd = *m_Queue->GetCommandData();
+
+    if(IsLoading(m_State))
+      cmd.AddUsage(GetResID(Resource), ResourceUsage::CPUWrite);
+
     ResourceId origid = GetResourceManager()->GetOriginalID(GetResID(Resource));
     if(m_UploadResourceIds.find(origid) != m_UploadResourceIds.end())
     {
-      D3D12CommandData &cmd = *m_Queue->GetCommandData();
-
       ID3D12Resource *uploadBuf = GetUploadBuffer(cmd.m_CurChunkOffset, rangeSize);
 
       SetObjName(uploadBuf,
@@ -1444,11 +1447,14 @@ bool WrappedID3D12Device::Serialise_WriteToSubresource(SerialiserType &ser, ID3D
 
   if(IsReplayingAndReading() && Resource)
   {
+    D3D12CommandData &cmd = *m_Queue->GetCommandData();
+
+    if(IsLoading(m_State))
+      cmd.AddUsage(GetResID(Resource), ResourceUsage::CPUWrite);
+
     ResourceId origid = GetResourceManager()->GetOriginalID(GetResID(Resource));
     if(m_UploadResourceIds.find(origid) != m_UploadResourceIds.end())
     {
-      D3D12CommandData &cmd = *m_Queue->GetCommandData();
-
       ID3D12Resource *uploadBuf = GetUploadBuffer(cmd.m_CurChunkOffset, dataSize);
 
       // during reading, fill out the buffer itself

renderdoc/driver/gl/gl_driver.cpp

@@ -2641,6 +2641,8 @@ bool WrappedOpenGL::Serialise_ContextInit(ReadSerialiser &ser)
     // global FBO0 to redirect to.
     ResourceId global_fbo0 = GetResourceManager()->GetID(FramebufferRes(GetCtx(), m_Global_FBO0));
 
+    GetReplay()->GetResourceDesc(global_fbo0).SetCustomName("Backbuffer FBO");
+
     GetResourceManager()->ReplaceResource(FBO0_ID, global_fbo0);
 
     AddResource(FBO0_ID, ResourceType::SwapchainImage, "");

renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp

@@ -568,12 +568,13 @@ bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(SerialiserType &ser, GLuint b
 
   if(IsReplayingAndReading())
   {
+    ResourceId id = GetResourceManager()->GetID(buffer);
+
     // never allow resizing down, even if the application did so. If we encounter that, adjust the
     // size and upload any data with a subdata call
-    if(bytesize < m_Buffers[GetResourceManager()->GetID(buffer)].size)
+    if(bytesize < m_Buffers[id].size)
     {
-      GL.glNamedBufferDataEXT(
-          buffer.name, (GLsizeiptr)m_Buffers[GetResourceManager()->GetID(buffer)].size, NULL, usage);
+      GL.glNamedBufferDataEXT(buffer.name, (GLsizeiptr)m_Buffers[id].size, NULL, usage);
 
       GL.glNamedBufferSubDataEXT(buffer.name, 0, (GLsizeiptr)bytesize, data);
     }
@@ -581,9 +582,12 @@ bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(SerialiserType &ser, GLuint b
     {
       GL.glNamedBufferDataEXT(buffer.name, (GLsizeiptr)bytesize, data, usage);
 
-      m_Buffers[GetResourceManager()->GetID(buffer)].size = bytesize;
+      m_Buffers[id].size = bytesize;
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[id].push_back(EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(buffer);
   }
 
@@ -909,6 +913,10 @@ bool WrappedOpenGL::Serialise_glNamedBufferSubDataEXT(SerialiserType &ser, GLuin
 
   if(IsReplayingAndReading())
   {
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(buffer)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     GL.glNamedBufferSubDataEXT(buffer.name, (GLintptr)offset, (GLsizeiptr)bytesize, data);
 
     AddResourceInitChunk(buffer);
@@ -1049,6 +1057,35 @@ bool WrappedOpenGL::Serialise_glNamedCopyBufferSubDataEXT(SerialiserType &ser,
   {
     GL.glNamedCopyBufferSubDataEXT(readBuffer.name, writeBuffer.name, (GLintptr)readOffset,
                                    (GLintptr)writeOffset, (GLsizeiptr)size);
+
+    if(IsLoading(m_State))
+    {
+      AddEvent();
+
+      ResourceId srcid = GetResourceManager()->GetID(readBuffer);
+      ResourceId dstid = GetResourceManager()->GetID(writeBuffer);
+
+      DrawcallDescription draw;
+      draw.name = StringFormat::Fmt("%s(%s, %s)", ToStr(gl_CurChunk).c_str(),
+                                    ToStr(GetResourceManager()->GetOriginalID(srcid)).c_str(),
+                                    ToStr(GetResourceManager()->GetOriginalID(dstid)).c_str());
+      draw.flags |= DrawFlags::Copy;
+
+      draw.copySource = GetResourceManager()->GetOriginalID(srcid);
+      draw.copyDestination = GetResourceManager()->GetOriginalID(dstid);
+
+      AddDrawcall(draw, true);
+
+      if(srcid == dstid)
+      {
+        m_ResourceUses[srcid].push_back(EventUsage(m_CurEventID, ResourceUsage::Copy));
+      }
+      else
+      {
+        m_ResourceUses[srcid].push_back(EventUsage(m_CurEventID, ResourceUsage::CopySrc));
+        m_ResourceUses[dstid].push_back(EventUsage(m_CurEventID, ResourceUsage::CopyDst));
+      }
+    }
   }
 
   return true;
@@ -2365,6 +2402,10 @@ bool WrappedOpenGL::Serialise_glUnmapNamedBufferEXT(SerialiserType &ser, GLuint
 
   if(IsReplayingAndReading() && diffEnd > diffStart && MapWrittenData && length > 0)
   {
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(buffer)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     void *ptr = GL.glMapNamedBufferRangeEXT(buffer.name, (GLintptr)(offset + diffStart),
                                             GLsizeiptr(diffEnd - diffStart), GL_MAP_WRITE_BIT);
     if(ptr)
@@ -2553,6 +2594,10 @@ bool WrappedOpenGL::Serialise_glFlushMappedNamedBufferRangeEXT(SerialiserType &s
 
   if(IsReplayingAndReading() && buffer.name && FlushedData && length > 0)
   {
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(buffer)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     // perform a map of the range and copy the data, to emulate the modified region being flushed
     void *ptr = GL.glMapNamedBufferRangeEXT(buffer.name, (GLintptr)(MapOffset + offset),
                                             (GLsizeiptr)length, GL_MAP_WRITE_BIT);

renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp

@@ -2317,6 +2317,10 @@ bool WrappedOpenGL::Serialise_glTextureImage1DEXT(SerialiserType &ser, GLuint te
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -2561,6 +2565,10 @@ bool WrappedOpenGL::Serialise_glTextureImage2DEXT(SerialiserType &ser, GLuint te
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -2787,6 +2795,10 @@ bool WrappedOpenGL::Serialise_glTextureImage3DEXT(SerialiserType &ser, GLuint te
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -3018,6 +3030,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(SerialiserType &ser,
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -3363,6 +3379,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(SerialiserType &ser,
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -3596,6 +3616,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage3DEXT(SerialiserType &ser,
       GL.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf);
     GL.glPixelStorei(eGL_UNPACK_ALIGNMENT, align);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -3783,6 +3807,10 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage1DEXT(SerialiserType &ser, GLuin
 
     GL.glCopyTextureImage1DEXT(texture.name, target, level, internalformat, x, y, width, border);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CopyDst));
+
     AddResourceInitChunk(texture);
   }
 
@@ -3943,6 +3971,10 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage2DEXT(SerialiserType &ser, GLuin
     GL.glCopyTextureImage2DEXT(texture.name, target, level, internalformat, x, y, width, height,
                                border);
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CopyDst));
+
     AddResourceInitChunk(texture);
   }
   return true;
@@ -4922,6 +4954,10 @@ bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(SerialiserType &ser, GLuint
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -5145,6 +5181,10 @@ bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(SerialiserType &ser, GLuint
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -5376,6 +5416,10 @@ bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(SerialiserType &ser, GLuint
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -5590,6 +5634,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(SerialiserType &s
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -5810,6 +5858,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(SerialiserType &s
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 
@@ -6039,6 +6091,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT(
       FreeAlignedBuffer((byte *)pixels);
     }
 
+    if(IsLoading(m_State) && m_CurEventID > 0)
+      m_ResourceUses[GetResourceManager()->GetID(texture)].push_back(
+          EventUsage(m_CurEventID, ResourceUsage::CPUWrite));
+
     AddResourceInitChunk(texture);
   }
 

renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp

@@ -627,6 +627,9 @@ bool WrappedVulkan::Serialise_vkUnmapMemory(SerialiserType &ser, VkDevice device
 
   if(IsReplayingAndReading() && memory != VK_NULL_HANDLE)
   {
+    if(IsLoading(m_State))
+      m_ResourceUses[GetResID(memory)].push_back(EventUsage(m_RootEventID, ResourceUsage::CPUWrite));
+
     VkResult vkr = ObjDisp(device)->MapMemory(Unwrap(device), Unwrap(memory), MapOffset, MapSize, 0,
                                               (void **)&MapData);
     if(vkr != VK_SUCCESS)
@@ -752,6 +755,10 @@ bool WrappedVulkan::Serialise_vkFlushMappedMemoryRanges(SerialiserType &ser, VkD
 
   if(IsReplayingAndReading() && MemRange.memory != VK_NULL_HANDLE && MemRange.size > 0)
   {
+    if(IsLoading(m_State))
+      m_ResourceUses[GetResID(MemRange.memory)].push_back(
+          EventUsage(m_RootEventID, ResourceUsage::CPUWrite));
+
     VkResult ret =
         ObjDisp(device)->MapMemory(Unwrap(device), Unwrap(MemRange.memory), MemRange.offset,
                                    MemRange.size, 0, (void **)&MappedData);

renderdoc/replay/replay_controller.cpp

@@ -1530,6 +1530,10 @@ rdcarray<PixelModification> ReplayController::PixelHistory(ResourceId target, ui
         // read-only, not a valid pixel history event
         continue;
 
+      case ResourceUsage::CPUWrite:
+        // writing but CPU-only, don't include
+        continue;
+
       case ResourceUsage::Unused:
       case ResourceUsage::StreamOut:
       case ResourceUsage::VS_RWResource: