Vulkan: Track allocated sampler counts.

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -632,7 +632,7 @@ void RendererVk::onDestroy()
     mDescriptorSetLayoutCache.destroy(mDevice);
 
     mPipelineCache.destroy(mDevice);
-    mSamplerCache.destroy(mDevice);
+    mSamplerCache.destroy(this);
 
     vma::DestroyAllocator(mAllocator);
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -246,6 +246,7 @@ class RendererVk : angle::NonCopyable
     bool enableDebugUtils() const { return mEnableDebugUtils; }
 
     SamplerCache &getSamplerCache() { return mSamplerCache; }
+    vk::ActiveHandleCounter &getActiveHandleCounts() { return mActiveHandleCounts; }
 
   private:
     angle::Result initializeDevice(DisplayVk *displayVk, uint32_t queueFamilyIndex);
@@ -363,6 +364,7 @@ class RendererVk : angle::NonCopyable
 
     VmaAllocator mAllocator;
     SamplerCache mSamplerCache;
+    vk::ActiveHandleCounter mActiveHandleCounts;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -2121,13 +2121,17 @@ SamplerCache::~SamplerCache()
     ASSERT(mPayload.empty());
 }
 
-void SamplerCache::destroy(VkDevice device)
+void SamplerCache::destroy(RendererVk *renderer)
 {
+    VkDevice device = renderer->getDevice();
+
     for (auto &iter : mPayload)
     {
         vk::RefCountedSampler &sampler = iter.second;
         ASSERT(!sampler.isReferenced());
         sampler.get().destroy(device);
+
+        renderer->getActiveHandleCounts().onDeallocate(vk::HandleType::Sampler);
     }
 
     mPayload.clear();
@@ -2154,6 +2158,8 @@ angle::Result SamplerCache::getSampler(ContextVk *contextVk,
     vk::RefCountedSampler &insertedSampler = insertedItem.first->second;
     samplerOut->set(&insertedSampler);
 
+    contextVk->getRenderer()->getActiveHandleCounts().onAllocate(vk::HandleType::Sampler);
+
     return angle::Result::Continue;
 }
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -1016,7 +1016,7 @@ class SamplerCache final : angle::NonCopyable
     SamplerCache();
     ~SamplerCache();
 
-    void destroy(VkDevice device);
+    void destroy(RendererVk *renderer);
 
     angle::Result getSampler(ContextVk *contextVk,
                              const vk::SamplerDesc &desc,

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -4018,6 +4018,14 @@ void SamplerHelper::release(RendererVk *renderer)
     renderer->collectGarbageAndReinit(&mUse, &mSampler);
 }
 
+angle::Result SamplerHelper::init(Context *context, const VkSamplerCreateInfo &createInfo)
+{
+    RendererVk *renderer = context->getRenderer();
+    ANGLE_VK_TRY(context, mSampler.init(renderer->getDevice(), createInfo));
+    renderer->getActiveHandleCounts().onAllocate(HandleType::Sampler);
+    return angle::Result::Continue;
+}
+
 // DispatchHelper implementation.
 DispatchHelper::DispatchHelper() = default;
 
@@ -4102,5 +4110,11 @@ angle::Result ShaderProgramHelper::getComputePipeline(Context *context,
     *pipelineOut = &mComputePipeline;
     return angle::Result::Continue;
 }
+
+// ActiveHandleCounter implementation.
+ActiveHandleCounter::ActiveHandleCounter() : mActiveCounts{}, mAllocatedCounts{} {}
+
+ActiveHandleCounter::~ActiveHandleCounter() = default;
+
 }  // namespace vk
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -1215,10 +1215,10 @@ class SamplerHelper final : angle::NonCopyable
     SamplerHelper();
     ~SamplerHelper();
 
+    angle::Result init(Context *context, const VkSamplerCreateInfo &createInfo);
     void release(RendererVk *renderer);
 
     bool valid() const { return mSampler.valid(); }
-    Sampler &get() { return mSampler; }
     const Sampler &get() const { return mSampler; }
 
     void retain(ResourceUseList *resourceUseList) { resourceUseList->add(mUse); }
@@ -1330,6 +1330,30 @@ class ShaderProgramHelper : angle::NonCopyable
     // Specialization constants, currently only used by the graphics queue.
     vk::SpecializationConstantBitSet mSpecializationConstants;
 };
+
+// Tracks current handle allocation counts in the back-end. Useful for debugging and profiling.
+// Note: not all handle types are currently implemented.
+class ActiveHandleCounter final : angle::NonCopyable
+{
+  public:
+    ActiveHandleCounter();
+    ~ActiveHandleCounter();
+
+    void onAllocate(HandleType handleType)
+    {
+        mActiveCounts[handleType]++;
+        mAllocatedCounts[handleType]++;
+    }
+
+    void onDeallocate(HandleType handleType) { mActiveCounts[handleType]--; }
+
+    uint32_t getActive(HandleType handleType) const { return mActiveCounts[handleType]; }
+    uint32_t getAllocated(HandleType handleType) const { return mAllocatedCounts[handleType]; }
+
+  private:
+    angle::PackedEnumMap<HandleType, uint32_t> mActiveCounts;
+    angle::PackedEnumMap<HandleType, uint32_t> mAllocatedCounts;
+};
 }  // namespace vk
 }  // namespace rx
 

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -659,6 +659,8 @@ void GarbageObject::destroy(RendererVk *renderer)
             UNREACHABLE();
             break;
     }
+
+    renderer->getActiveHandleCounts().onDeallocate(mHandleType);
 }
 
 void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label)

src/libANGLE/renderer/vulkan/vk_wrapper.h

@@ -56,7 +56,7 @@ enum class HandleType
 {
     Invalid,
     CommandBuffer,
-    ANGLE_HANDLE_TYPES_X(ANGLE_COMMA_SEP_FUNC)
+    ANGLE_HANDLE_TYPES_X(ANGLE_COMMA_SEP_FUNC) EnumCount
 };
 
 #undef ANGLE_COMMA_SEP_FUNC