Vulkan: Add an overlay counter for descriptor writes.

scripts/code_generation_hashes/overlay_widgets.json

 {
   "src/libANGLE/Overlay_autogen.cpp":
-    "b0d9803f2db7b962a53d4d8857a63fbc",
+    "7d26b524a7547a19410ea7de72f17b6e",
   "src/libANGLE/gen_overlay_widgets.py":
     "07252fbde304fd48559ae07f8f920a08",
   "src/libANGLE/overlay_widgets.json":
-    "13629734c314cc88c485cb27527913f3"
+    "2d1804eb11e4f3ea214e80bf2e63c0df"
 }
\ No newline at end of file

src/libANGLE/Overlay.cpp

@@ -28,6 +28,7 @@ constexpr std::pair<const char *, WidgetId> kWidgetNames[] = {
     {"VulkanValidationMessageCount", WidgetId::VulkanValidationMessageCount},
     {"VulkanRenderPassCount", WidgetId::VulkanRenderPassCount},
     {"VulkanSecondaryCommandBufferPoolWaste", WidgetId::VulkanSecondaryCommandBufferPoolWaste},
+    {"VulkanWriteDescriptorSetCount", WidgetId::VulkanWriteDescriptorSetCount},
 };
 }  // namespace
 

src/libANGLE/OverlayWidgets.cpp

@@ -215,6 +215,11 @@ class AppendWidgetDataHelper
                                                             TextWidgetData *textWidget,
                                                             GraphWidgetData *graphWidget,
                                                             OverlayWidgetCounts *widgetCounts);
+    static void AppendVulkanWriteDescriptorSetCount(const overlay::Widget *widget,
+                                                    const gl::Extents &imageExtent,
+                                                    TextWidgetData *textWidget,
+                                                    GraphWidgetData *graphWidget,
+                                                    OverlayWidgetCounts *widgetCounts);
 
   private:
     static std::ostream &OutputPerSecond(std::ostream &out, const overlay::PerSecond *perSecond);
@@ -398,6 +403,34 @@ void AppendWidgetDataHelper::AppendVulkanSecondaryCommandBufferPoolWaste(
     }
 }
 
+void AppendWidgetDataHelper::AppendVulkanWriteDescriptorSetCount(const overlay::Widget *widget,
+                                                                 const gl::Extents &imageExtent,
+                                                                 TextWidgetData *textWidget,
+                                                                 GraphWidgetData *graphWidget,
+                                                                 OverlayWidgetCounts *widgetCounts)
+{
+    const overlay::RunningGraph *writeDescriptorSetCount =
+        static_cast<const overlay::RunningGraph *>(widget);
+
+    const size_t maxValue     = *std::max_element(writeDescriptorSetCount->runningValues.begin(),
+                                              writeDescriptorSetCount->runningValues.end());
+    const int32_t graphHeight = std::abs(widget->coords[3] - widget->coords[1]);
+    const float graphScale    = static_cast<float>(graphHeight) / maxValue;
+
+    AppendGraphCommon(widget, imageExtent, writeDescriptorSetCount->runningValues,
+                      writeDescriptorSetCount->lastValueIndex + 1, graphScale, graphWidget,
+                      widgetCounts);
+
+    if ((*widgetCounts)[WidgetInternalType::Text] <
+        kWidgetInternalTypeMaxWidgets[WidgetInternalType::Text])
+    {
+        std::ostringstream text;
+        text << "WriteDescriptorSet Count (Max: " << maxValue << ")";
+        AppendTextCommon(&writeDescriptorSetCount->description, imageExtent, text.str(), textWidget,
+                         widgetCounts);
+    }
+}
+
 std::ostream &AppendWidgetDataHelper::OutputPerSecond(std::ostream &out,
                                                       const overlay::PerSecond *perSecond)
 {
@@ -427,6 +460,8 @@ constexpr angle::PackedEnumMap<WidgetId, AppendWidgetDataFunc> kWidgetIdToAppend
      overlay_impl::AppendWidgetDataHelper::AppendVulkanRenderPassCount},
     {WidgetId::VulkanSecondaryCommandBufferPoolWaste,
      overlay_impl::AppendWidgetDataHelper::AppendVulkanSecondaryCommandBufferPoolWaste},
+    {WidgetId::VulkanWriteDescriptorSetCount,
+     overlay_impl::AppendWidgetDataHelper::AppendVulkanWriteDescriptorSetCount},
 };
 }
 

src/libANGLE/OverlayWidgets.h

@@ -20,7 +20,7 @@ class OverlayState;
 namespace overlay_impl
 {
 class AppendWidgetDataHelper;
-}
+}  // namespace overlay_impl
 
 enum class WidgetType
 {
@@ -61,6 +61,8 @@ enum class WidgetId
     VulkanRenderPassCount,
     // Secondary Command Buffer pool memory waste (RunningHistogram).
     VulkanSecondaryCommandBufferPoolWaste,
+    // Number of Descriptor Set writes in a frame (RunningGraph).
+    VulkanWriteDescriptorSetCount,
 
     InvalidEnum,
     EnumCount = InvalidEnum,

src/libANGLE/Overlay_autogen.cpp

@@ -188,6 +188,49 @@ void Overlay::initOverlayWidgets()
             widget->description.color[3]  = 1.0;
         }
     }
+
+    {
+        RunningGraph *widget = new RunningGraph(60);
+        {
+            const int32_t fontSize = GetFontSize(0, kLargeFont);
+            const int32_t offsetX  = 10;
+            const int32_t offsetY  = 220;
+            const int32_t width    = 5 * static_cast<uint32_t>(widget->runningValues.size());
+            const int32_t height   = 100;
+
+            widget->type      = WidgetType::RunningGraph;
+            widget->fontSize  = fontSize;
+            widget->coords[0] = offsetX;
+            widget->coords[1] = offsetY;
+            widget->coords[2] = offsetX + width;
+            widget->coords[3] = offsetY + height;
+            widget->color[0]  = 0.294117647059;
+            widget->color[1]  = 0.78431372549;
+            widget->color[2]  = 0.0;
+            widget->color[3]  = 0.78431372549;
+        }
+        mState.mOverlayWidgets[WidgetId::VulkanWriteDescriptorSetCount].reset(widget);
+        {
+            const int32_t fontSize = GetFontSize(kFontLayerSmall, kLargeFont);
+            const int32_t offsetX =
+                mState.mOverlayWidgets[WidgetId::VulkanWriteDescriptorSetCount]->coords[0];
+            const int32_t offsetY =
+                mState.mOverlayWidgets[WidgetId::VulkanWriteDescriptorSetCount]->coords[1];
+            const int32_t width  = 40 * kFontGlyphWidths[fontSize];
+            const int32_t height = kFontGlyphHeights[fontSize];
+
+            widget->description.type      = WidgetType::Text;
+            widget->description.fontSize  = fontSize;
+            widget->description.coords[0] = offsetX;
+            widget->description.coords[1] = std::max(offsetY - height, 1);
+            widget->description.coords[2] = offsetX + width;
+            widget->description.coords[3] = offsetY;
+            widget->description.color[0]  = 0.294117647059;
+            widget->description.color[1]  = 0.78431372549;
+            widget->description.color[2]  = 0.0;
+            widget->description.color[3]  = 1.0;
+        }
+    }
 }
 
 }  // namespace gl

src/libANGLE/overlay_widgets.json

@@ -80,6 +80,20 @@
                 "font": "small",
                 "length": 40
             }
+        },
+        {
+            "name": "VulkanWriteDescriptorSetCount",
+            "type": "RunningGraph(60)",
+            "color": [75, 200, 0, 200],
+            "coords": [10, 220],
+            "bar_width": 5,
+            "height": 100,
+            "description": {
+                "color": [75, 200, 0, 255],
+                "coords": ["VulkanWriteDescriptorSetCount.left.align", "VulkanWriteDescriptorSetCount.top.adjacent"],
+                "font": "small",
+                "length": 40
+            }
         }
     ]
 }

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -657,6 +657,7 @@ ContextVk::ContextVk(const gl::State &state, gl::ErrorSet *errorSet, RendererVk
       mGpuEventTimestampOrigin(0),
       mPrimaryBufferCounter(0),
       mRenderPassCounter(0),
+      mWriteDescriptorSetCounter(0),
       mContextPriority(renderer->getDriverPriority(GetContextPriority(state))),
       mCurrentIndirectBuffer(nullptr),
       mShareGroupVk(vk::GetImpl(state.getShareGroup()))
@@ -1620,10 +1621,21 @@ angle::Result ContextVk::handleDirtyDescriptorSets(const gl::Context *context,
 void ContextVk::updateOverlayOnPresent()
 {
     // Update overlay if active.
-    gl::RunningGraphWidget *renderPassCount =
-        mState.getOverlay()->getRunningGraphWidget(gl::WidgetId::VulkanRenderPassCount);
-    renderPassCount->add(mRenderPassCommands->getAndResetCounter());
-    renderPassCount->next();
+    {
+        gl::RunningGraphWidget *renderPassCount =
+            mState.getOverlay()->getRunningGraphWidget(gl::WidgetId::VulkanRenderPassCount);
+        renderPassCount->add(mRenderPassCommands->getAndResetCounter());
+        renderPassCount->next();
+    }
+
+    {
+        gl::RunningGraphWidget *writeDescriptorSetCount =
+            mState.getOverlay()->getRunningGraphWidget(gl::WidgetId::VulkanWriteDescriptorSetCount);
+        writeDescriptorSetCount->add(mWriteDescriptorSetCounter);
+        writeDescriptorSetCount->next();
+
+        mWriteDescriptorSetCounter = 0;
+    }
 }
 
 angle::Result ContextVk::submitFrame(const VkSubmitInfo &submitInfo,
@@ -4039,7 +4051,9 @@ angle::Result ContextVk::flushImpl(const vk::Semaphore *signalSemaphore)
 
     ANGLE_TRY(startPrimaryCommandBuffer());
 
-    mRenderPassCounter = 0;
+    mRenderPassCounter         = 0;
+    mWriteDescriptorSetCounter = 0;
+
     mWaitSemaphores.clear();
     mWaitSemaphoreStageMasks.clear();
 
@@ -4742,6 +4756,8 @@ VkDescriptorImageInfo *ContextVk::allocDescriptorImageInfos(size_t count)
 
 VkWriteDescriptorSet *ContextVk::allocWriteDescriptorSets(size_t count)
 {
+    mWriteDescriptorSetCounter += count;
+
     size_t oldSize = mWriteDescriptorSets.size();
     size_t newSize = oldSize + count;
     mWriteDescriptorSets.resize(newSize);

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -590,6 +590,7 @@ class ContextVk : public ContextImpl, public vk::Context
     vk::DynamicBuffer *getStagingBufferStorage() { return &mStagingBufferStorage; }
 
     uint32_t getRenderPassCounter() const { return mRenderPassCounter; }
+    uint32_t getWriteDescriptorSetCounter() const { return mWriteDescriptorSetCounter; }
 
   private:
     // Dirty bits.
@@ -1041,6 +1042,7 @@ class ContextVk : public ContextImpl, public vk::Context
     // Used to count events for tracing.
     uint32_t mPrimaryBufferCounter;
     uint32_t mRenderPassCounter;
+    uint32_t mWriteDescriptorSetCounter;
 
     gl::State::DirtyBits mPipelineDirtyBitsMask;