Vulkan: Add descriptor set allocation counters

Add descriptor set allocation counters for the following:
- ContextVk
  - Driver uniform allocations for graphics and compute pipelines.
- ProgramExecutableVk
  - ANGLE driver uniforms
  - Uniforms
  - Textures
  - Other shader resources
- UtilsVk
  - All of the UtilsVk::Function types increment the same counter

Each object's counters live within the object itself and the cumulative
total is output as part of that object's destruction. On Present, all of
the descriptor set counts are collected into a single total which is
used to update the overlay each frame.

In order to see the cumulative total output for each object, the
following GN args must be enabled:
is_debug = true
angle_enable_perf_counter_output = true

To see the descriptor set allocation overlay:
ANGLE_OVERLAY=VulkanDescriptorSetAllocations

Bug: angleproject:5067
Test: Manual verification with angle_perftests
Change-Id: Ie45fda56ade3e68bfba7bf6da9554eb05a02c6b6
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2429487
Commit-Queue: Tim Van Patten <timvp@google.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>

Author: timvpGoogle

BUILD.gn

@@ -606,6 +606,9 @@ config("libANGLE_config") {
   if (angle_enable_overlay) {
     defines += [ "ANGLE_ENABLE_OVERLAY=1" ]
   }
+  if (angle_enable_perf_counter_output) {
+    defines += [ "ANGLE_ENABLE_PERF_COUNTER_OUTPUT=1" ]
+  }
 }
 
 angle_source_set("libANGLE_headers") {

gni/angle.gni

@@ -131,6 +131,9 @@ declare_args() {
 
   # Disable overlay by default
   angle_enable_overlay = false
+
+  # Disable performance counter output by default
+  angle_enable_perf_counter_output = false
 }
 
 if (!defined(angle_zlib_compression_utils_dir)) {

scripts/code_generation_hashes/overlay_widgets.json

@@ -1,10 +1,10 @@
 {
   "src/libANGLE/Overlay_autogen.cpp":
-    "6c9c7df59562390505222145c1f32277",
+    "849f447a220cb0ce00a41f99db179a6b",
   "src/libANGLE/Overlay_autogen.h":
-    "03ac72d8286f1f933696fa3dabb75eb1",
+    "4f29dd0e9c2030b98b396fdf03eaeb29",
   "src/libANGLE/gen_overlay_widgets.py":
     "f4395481db010c82af2e2981353e8592",
   "src/libANGLE/overlay_widgets.json":
-    "dd9d2a72035e754bbc5f614410e76df1"
+    "93205f3d9585228428bc62463f478dc6"
 }

src/libANGLE/FrameCapture.cpp

@@ -2798,7 +2798,7 @@ void CaptureMidExecutionSetup(const gl::Context *context,
     const gl::ResourceMap<gl::Shader, gl::ShaderProgramID> &shaders =
         shadersAndPrograms.getShadersForCapture();
     const gl::ResourceMap<gl::Program, gl::ShaderProgramID> &programs =
-        shadersAndPrograms.getProgramsForCapture();
+        shadersAndPrograms.getProgramsForCaptureAndPerf();
 
     // Capture Program binary state. Use max ID as a temporary shader ID.
     gl::ShaderProgramID tempShaderID = {resourceTracker->getMaxShaderPrograms()};

src/libANGLE/OverlayWidgets.cpp

@@ -300,10 +300,10 @@ void AppendWidgetDataHelper::AppendRunningHistogramCommon(const overlay::Widget
                                                           OverlayWidgetCounts *widgetCounts,
                                                           FormatHistogramTitleFunc formatFunc)
 {
-    const overlay::RunningHistogram *secondaryCommandBufferPoolWaste =
+    const overlay::RunningHistogram *runningHistogram =
         static_cast<const overlay::RunningHistogram *>(widget);
 
-    std::vector<size_t> histogram = CreateHistogram(secondaryCommandBufferPoolWaste->runningValues);
+    std::vector<size_t> histogram = CreateHistogram(runningHistogram->runningValues);
     auto peakRangeIt              = std::max_element(histogram.rbegin(), histogram.rend());
     const size_t peakRangeValue   = *peakRangeIt;
     const int32_t graphHeight     = std::abs(widget->coords[3] - widget->coords[1]);
@@ -320,8 +320,8 @@ void AppendWidgetDataHelper::AppendRunningHistogramCommon(const overlay::Widget
         size_t maxValueRange = std::distance(maxValueIter, histogram.rend() - 1);
 
         std::string text = formatFunc(peakRange, maxValueRange, histogram.size());
-        AppendTextCommon(&secondaryCommandBufferPoolWaste->description, imageExtent, text,
-                         textWidget, widgetCounts);
+        AppendTextCommon(&runningHistogram->description, imageExtent, text, textWidget,
+                         widgetCounts);
     }
 }
 
@@ -431,6 +431,21 @@ void AppendWidgetDataHelper::AppendVulkanWriteDescriptorSetCount(const overlay::
     AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
 }
 
+void AppendWidgetDataHelper::AppendVulkanDescriptorSetAllocations(const overlay::Widget *widget,
+                                                                  const gl::Extents &imageExtent,
+                                                                  TextWidgetData *textWidget,
+                                                                  GraphWidgetData *graphWidget,
+                                                                  OverlayWidgetCounts *widgetCounts)
+{
+    auto format = [](size_t maxValue) {
+        std::ostringstream text;
+        text << "Descriptor Set Allocations (Max: " << maxValue << ")";
+        return text.str();
+    };
+
+    AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
+}
+
 std::ostream &AppendWidgetDataHelper::OutputPerSecond(std::ostream &out,
                                                       const overlay::PerSecond *perSecond)
 {

src/libANGLE/Overlay_autogen.cpp

@@ -274,6 +274,49 @@ void Overlay::initOverlayWidgets()
             widget->description.color[3]  = 1.0f;
         }
     }
+
+    {
+        RunningGraph *widget = new RunningGraph(60);
+        {
+            const int32_t fontSize = GetFontSize(0, kLargeFont);
+            const int32_t offsetX  = -50;
+            const int32_t offsetY  = 250;
+            const int32_t width    = 6 * static_cast<uint32_t>(widget->runningValues.size());
+            const int32_t height   = 100;
+
+            widget->type      = WidgetType::RunningGraph;
+            widget->fontSize  = fontSize;
+            widget->coords[0] = offsetX - width;
+            widget->coords[1] = offsetY;
+            widget->coords[2] = offsetX;
+            widget->coords[3] = offsetY + height;
+            widget->color[0]  = 1.0f;
+            widget->color[1]  = 0.0f;
+            widget->color[2]  = 0.294117647059f;
+            widget->color[3]  = 0.78431372549f;
+        }
+        mState.mOverlayWidgets[WidgetId::VulkanDescriptorSetAllocations].reset(widget);
+        {
+            const int32_t fontSize = GetFontSize(kFontLayerSmall, kLargeFont);
+            const int32_t offsetX =
+                mState.mOverlayWidgets[WidgetId::VulkanDescriptorSetAllocations]->coords[0];
+            const int32_t offsetY =
+                mState.mOverlayWidgets[WidgetId::VulkanDescriptorSetAllocations]->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] = std::min(offsetX + width, -1);
+            widget->description.coords[3] = offsetY;
+            widget->description.color[0]  = 1.0f;
+            widget->description.color[1]  = 0.0f;
+            widget->description.color[2]  = 0.294117647059f;
+            widget->description.color[3]  = 1.0f;
+        }
+    }
 }
 
 }  // namespace gl

src/libANGLE/Overlay_autogen.h

@@ -26,6 +26,8 @@ enum class WidgetId
     VulkanSecondaryCommandBufferPoolWaste,
     // Number of Descriptor Set writes in a frame (Count).
     VulkanWriteDescriptorSetCount,
+    // Descriptor Set Allocations.
+    VulkanDescriptorSetAllocations,
 
     InvalidEnum,
     EnumCount = InvalidEnum,
@@ -39,6 +41,7 @@ enum class WidgetId
     PROC(VulkanRenderPassCount)                 \
     PROC(VulkanRenderPassBufferCount)           \
     PROC(VulkanSecondaryCommandBufferPoolWaste) \
-    PROC(VulkanWriteDescriptorSetCount)
+    PROC(VulkanWriteDescriptorSetCount)         \
+    PROC(VulkanDescriptorSetAllocations)
 
 }  // namespace gl

src/libANGLE/ResourceManager.h

@@ -164,9 +164,12 @@ class ShaderProgramManager : public ResourceManagerBase
         return mPrograms.query(handle);
     }
 
-    // For capture only.
+    // For capture and performance counters only.
     const ResourceMap<Shader, ShaderProgramID> &getShadersForCapture() const { return mShaders; }
-    const ResourceMap<Program, ShaderProgramID> &getProgramsForCapture() const { return mPrograms; }
+    const ResourceMap<Program, ShaderProgramID> &getProgramsForCaptureAndPerf() const
+    {
+        return mPrograms;
+    }
 
   protected:
     ~ShaderProgramManager() override;

src/libANGLE/frame_capture_utils.cpp

@@ -991,7 +991,7 @@ Result SerializeContext(gl::BinaryOutputStream *bos, const gl::Context *context)
         SerializeShader(bos, shaderPtr);
     }
     const gl::ResourceMap<gl::Program, gl::ShaderProgramID> &programManager =
-        shaderProgramManager.getProgramsForCapture();
+        shaderProgramManager.getProgramsForCaptureAndPerf();
     for (const auto &program : programManager)
     {
         gl::Program *programPtr = program.second;

src/libANGLE/overlay_widgets.json

@@ -116,6 +116,22 @@
                 "font": "small",
                 "length": 40
             }
+        },
+        {
+            "name": "VulkanDescriptorSetAllocations",
+            "comment": "Descriptor Set Allocations.",
+            "type": "RunningGraph(60)",
+            "color": [255, 0, 75, 200],
+            "coords": [-50, 250],
+            "bar_width": 6,
+            "height": 100,
+            "description": {
+                "color": [255, 0, 75, 255],
+                "coords": ["VulkanDescriptorSetAllocations.left.align",
+                           "VulkanDescriptorSetAllocations.top.adjacent"],
+                "font": "small",
+                "length": 40
+            }
         }
     ]
 }