Vulkan: Accumulate internal cache stats in renderer

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -363,6 +363,7 @@ void ContextVk::DriverUniformsDescriptorSet::destroy(RendererVk *renderer)
     descriptorPoolBinding.reset();
     dynamicBuffer.destroy(renderer);
     descriptorSetCache.clear();
+    descriptorSetCache.destroy(renderer);
 }
 
 // ContextVk implementation.
@@ -541,7 +542,7 @@ void ContextVk::onDestroy(const gl::Context *context)
 
     mUtils.destroy(mRenderer);
 
-    mRenderPassCache.destroy(device);
+    mRenderPassCache.destroy(mRenderer);
     mShaderLibrary.destroy(device);
     mGpuEventQueryPool.destroy(device);
     mCommandPool.destroy(device);

src/libANGLE/renderer/vulkan/DisplayVk.cpp

@@ -288,7 +288,7 @@ void ShareGroupVk::onDestroy(const egl::Display *display)
 {
     DisplayVk *displayVk = vk::GetImpl(display);
 
-    mPipelineLayoutCache.destroy(displayVk->getDevice());
-    mDescriptorSetLayoutCache.destroy(displayVk->getDevice());
+    mPipelineLayoutCache.destroy(displayVk->getRenderer());
+    mDescriptorSetLayoutCache.destroy(displayVk->getRenderer());
 }
 }  // namespace rx

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -349,10 +349,12 @@ FramebufferVk::~FramebufferVk() = default;
 
 void FramebufferVk::destroy(const gl::Context *context)
 {
-    ContextVk *contextVk = vk::GetImpl(context);
+    ContextVk *contextVk   = vk::GetImpl(context);
+    RendererVk *rendererVk = contextVk->getRenderer();
 
-    mReadPixelBuffer.release(contextVk->getRenderer());
+    mReadPixelBuffer.release(rendererVk);
     mFramebufferCache.clear(contextVk);
+    mFramebufferCache.destroy(rendererVk);
 }
 
 angle::Result FramebufferVk::discard(const gl::Context *context,

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -190,11 +190,12 @@ void ProgramExecutableVk::reset(ContextVk *contextVk)
         descriptorPool.release(contextVk);
     }
 
-    mTextureDescriptorsCache.clear();
-    mUniformsAndXfbDescriptorSetCache.clear();
+    RendererVk *rendererVk = contextVk->getRenderer();
+    mTextureDescriptorsCache.destroy(rendererVk);
+    mUniformsAndXfbDescriptorSetCache.destroy(rendererVk);
 
     // Initialize with a unique BufferSerial
-    vk::ResourceSerialFactory &factory = contextVk->getRenderer()->getResourceSerialFactory();
+    vk::ResourceSerialFactory &factory = rendererVk->getResourceSerialFactory();
     mCurrentDefaultUniformBufferSerial = factory.generateBufferSerial();
 
     for (ProgramInfo &programInfo : mGraphicsProgramInfos)
@@ -376,7 +377,7 @@ angle::Result ProgramExecutableVk::allocUniformAndXfbDescriptorSet(
     // Clear descriptor set cache. It may no longer be valid.
     if (newPoolAllocated)
     {
-        mUniformsAndXfbDescriptorSetCache.clear();
+        mUniformsAndXfbDescriptorSetCache.destroy(contextVk->getRenderer());
     }
 
     // Add the descriptor set into cache
@@ -1475,7 +1476,7 @@ angle::Result ProgramExecutableVk::updateTexturesDescriptorSet(ContextVk *contex
                 // Clear descriptor set cache. It may no longer be valid.
                 if (newPoolAllocated)
                 {
-                    mTextureDescriptorsCache.clear();
+                    mTextureDescriptorsCache.destroy(contextVk->getRenderer());
                 }
 
                 descriptorSet = mDescriptorSets[ToUnderlying(DescriptorSetIndex::Texture)];

src/libANGLE/renderer/vulkan/ProgramExecutableVk.h

@@ -245,8 +245,10 @@ class ProgramExecutableVk
     size_t mNumDefaultUniformDescriptors;
     vk::BufferSerial mCurrentDefaultUniformBufferSerial;
 
-    DescriptorSetCache<vk::UniformsAndXfbDesc> mUniformsAndXfbDescriptorSetCache;
-    DescriptorSetCache<vk::TextureDescriptorDesc> mTextureDescriptorsCache;
+    DescriptorSetCache<vk::UniformsAndXfbDesc, VulkanCacheType::UniformsAndXfbDescriptorSet>
+        mUniformsAndXfbDescriptorSetCache;
+    DescriptorSetCache<vk::TextureDescriptorDesc, VulkanCacheType::TextureDescriptors>
+        mTextureDescriptorsCache;
 
     // We keep a reference to the pipeline and descriptor set layouts. This ensures they don't get
     // deleted while this program is in use.

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -576,6 +576,8 @@ void RendererVk::onDestroy(vk::Context *context)
         vkDestroyDebugReportCallbackEXT(mInstance, mDebugReportCallback, nullptr);
     }
 
+    logCacheStats();
+
     if (mInstance)
     {
         vkDestroyInstance(mInstance, nullptr);
@@ -2711,6 +2713,21 @@ void RendererVk::recycleCommandBufferHelper(vk::CommandBufferHelper *commandBuff
     mCommandBufferHelperFreeList.push_back(commandBuffer);
 }
 
+void RendererVk::logCacheStats() const
+{
+    if (!vk::kOutputCumulativePerfCounters)
+    {
+        return;
+    }
+
+    int cacheType = 0;
+    INFO() << "Vulkan object cache hit ratios: ";
+    for (const CacheStats &stats : mVulkanCacheStats)
+    {
+        INFO() << "    CacheType " << cacheType++ << ": " << stats.getHitRatio();
+    }
+}
+
 vk::MemoryReport::MemoryReport()
     : mCurrentTotalAllocatedMemory(0),
       mMaxTotalAllocatedMemory(0),

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -365,6 +365,14 @@ class RendererVk : angle::NonCopyable
         mMemoryReport.processCallback(callbackData, logCallback);
     }
 
+    // Accumulate cache stats for a specific cache
+    void accumulateCacheStats(VulkanCacheType cache, const CacheStats &stats)
+    {
+        mVulkanCacheStats[cache].accumulate(stats);
+    }
+    // Log cache stats for all caches
+    void logCacheStats() const;
+
   private:
     angle::Result initializeDevice(DisplayVk *displayVk, uint32_t queueFamilyIndex);
     void ensureCapsInitialized() const;
@@ -491,6 +499,10 @@ class RendererVk : angle::NonCopyable
 
     // Process GPU memory reports
     vk::MemoryReport mMemoryReport;
+
+    // Stats about all Vulkan object caches
+    using VulkanCacheStats = angle::PackedEnumMap<VulkanCacheType, CacheStats>;
+    VulkanCacheStats mVulkanCacheStats;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -573,54 +573,54 @@ void UtilsVk::destroy(RendererVk *renderer)
 
     for (vk::ShaderProgramHelper &program : mConvertIndexPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mConvertIndirectLineLoopPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mConvertIndexIndirectLineLoopPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mConvertVertexPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
-    mImageClearProgramVSOnly.destroy(device);
+    mImageClearProgramVSOnly.destroy(renderer);
     for (vk::ShaderProgramHelper &program : mImageClearProgram)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mImageCopyPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mBlitResolvePrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mBlitResolveStencilNoExportPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mOverlayCullPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mOverlayDrawPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
     for (vk::ShaderProgramHelper &program : mGenerateMipmapPrograms)
     {
-        program.destroy(device);
+        program.destroy(renderer);
     }
 
     for (auto &programIter : mUnresolvePrograms)
     {
         vk::ShaderProgramHelper &program = programIter.second;
-        program.destroy(device);
+        program.destroy(renderer);
     }
     mUnresolvePrograms.clear();
 

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -3199,8 +3199,15 @@ RenderPassCache::~RenderPassCache()
     ASSERT(mPayload.empty());
 }
 
-void RenderPassCache::destroy(VkDevice device)
+void RenderPassCache::destroy(RendererVk *rendererVk)
 {
+    rendererVk->accumulateCacheStats(VulkanCacheType::CompatibleRenderPass,
+                                     mCompatibleRenderPassCacheStats);
+    rendererVk->accumulateCacheStats(VulkanCacheType::RenderPassWithOps,
+                                     mRenderPassWithOpsCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
+
     for (auto &outerIt : mPayload)
     {
         for (auto &innerIt : outerIt.second)
@@ -3306,8 +3313,12 @@ GraphicsPipelineCache::~GraphicsPipelineCache()
     ASSERT(mPayload.empty());
 }
 
-void GraphicsPipelineCache::destroy(VkDevice device)
+void GraphicsPipelineCache::destroy(RendererVk *rendererVk)
 {
+    rendererVk->accumulateCacheStats(VulkanCacheType::GraphicsPipeline, mCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
+
     for (auto &item : mPayload)
     {
         vk::PipelineHelper &pipeline = item.second;
@@ -3382,8 +3393,12 @@ DescriptorSetLayoutCache::~DescriptorSetLayoutCache()
     ASSERT(mPayload.empty());
 }
 
-void DescriptorSetLayoutCache::destroy(VkDevice device)
+void DescriptorSetLayoutCache::destroy(RendererVk *rendererVk)
 {
+    rendererVk->accumulateCacheStats(VulkanCacheType::DescriptorSetLayout, mCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
+
     for (auto &item : mPayload)
     {
         vk::RefCountedDescriptorSetLayout &layout = item.second;
@@ -3439,8 +3454,12 @@ PipelineLayoutCache::~PipelineLayoutCache()
     ASSERT(mPayload.empty());
 }
 
-void PipelineLayoutCache::destroy(VkDevice device)
+void PipelineLayoutCache::destroy(RendererVk *rendererVk)
 {
+    rendererVk->accumulateCacheStats(VulkanCacheType::PipelineLayout, mCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
+
     for (auto &item : mPayload)
     {
         vk::RefCountedPipelineLayout &layout = item.second;
@@ -3526,9 +3545,11 @@ SamplerYcbcrConversionCache::~SamplerYcbcrConversionCache()
     ASSERT(mPayload.empty());
 }
 
-void SamplerYcbcrConversionCache::destroy(RendererVk *renderer)
+void SamplerYcbcrConversionCache::destroy(RendererVk *rendererVk)
 {
-    VkDevice device = renderer->getDevice();
+    rendererVk->accumulateCacheStats(VulkanCacheType::SamplerYcbcrConversion, mCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
 
     for (auto &iter : mPayload)
     {
@@ -3536,7 +3557,7 @@ void SamplerYcbcrConversionCache::destroy(RendererVk *renderer)
         ASSERT(!yuvSampler.isReferenced());
         yuvSampler.get().destroy(device);
 
-        renderer->getActiveHandleCounts().onDeallocate(vk::HandleType::SamplerYcbcrConversion);
+        rendererVk->getActiveHandleCounts().onDeallocate(vk::HandleType::SamplerYcbcrConversion);
     }
 
     mPayload.clear();
@@ -3595,9 +3616,11 @@ SamplerCache::~SamplerCache()
     ASSERT(mPayload.empty());
 }
 
-void SamplerCache::destroy(RendererVk *renderer)
+void SamplerCache::destroy(RendererVk *rendererVk)
 {
-    VkDevice device = renderer->getDevice();
+    rendererVk->accumulateCacheStats(VulkanCacheType::Sampler, mCacheStats);
+
+    VkDevice device = rendererVk->getDevice();
 
     for (auto &iter : mPayload)
     {
@@ -3605,7 +3628,7 @@ void SamplerCache::destroy(RendererVk *renderer)
         ASSERT(!sampler.isReferenced());
         sampler.get().get().destroy(device);
 
-        renderer->getActiveHandleCounts().onDeallocate(vk::HandleType::Sampler);
+        rendererVk->getActiveHandleCounts().onDeallocate(vk::HandleType::Sampler);
     }
 
     mPayload.clear();
@@ -3639,6 +3662,12 @@ angle::Result SamplerCache::getSampler(ContextVk *contextVk,
 }
 
 // FramebufferCache implementation.
+void FramebufferCache::destroy(RendererVk *rendererVk)
+{
+    rendererVk->accumulateCacheStats(VulkanCacheType::Framebuffer, mCacheStats);
+    mPayload.clear();
+}
+
 bool FramebufferCache::get(ContextVk *contextVk,
                            const vk::FramebufferDesc &desc,
                            vk::FramebufferHelper **framebufferHelperOut)
@@ -3670,4 +3699,26 @@ void FramebufferCache::clear(ContextVk *contextVk)
     }
     mPayload.clear();
 }
+
+// DriverUniformsDescriptorSetCache implementation.
+void DriverUniformsDescriptorSetCache::destroy(RendererVk *rendererVk)
+{
+    rendererVk->accumulateCacheStats(VulkanCacheType::DescriptorSet, mCacheStats);
+    mPayload.clear();
+}
+
+// DescriptorSetCache implementation.
+template <typename key, VulkanCacheType cacheType>
+void DescriptorSetCache<key, cacheType>::destroy(RendererVk *rendererVk)
+{
+    rendererVk->accumulateCacheStats(cacheType, mCacheStats);
+    mPayload.clear();
+}
+
+// RendererVk's methods are not accessible in vk_cache_utils.h
+// Below declarations are needed to avoid linker errors.
+template class DescriptorSetCache<vk::TextureDescriptorDesc, VulkanCacheType::TextureDescriptors>;
+
+template class DescriptorSetCache<vk::UniformsAndXfbDesc,
+                                  VulkanCacheType::UniformsAndXfbDescriptorSet>;
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -1312,6 +1312,23 @@ ANGLE_VK_SERIAL_OP(ANGLE_HASH_VK_SERIAL)
 
 namespace rx
 {
+// Cache types for various Vulkan objects
+enum class VulkanCacheType
+{
+    CompatibleRenderPass,
+    RenderPassWithOps,
+    GraphicsPipeline,
+    PipelineLayout,
+    Sampler,
+    SamplerYcbcrConversion,
+    DescriptorSet,
+    DescriptorSetLayout,
+    TextureDescriptors,
+    UniformsAndXfbDescriptorSet,
+    Framebuffer,
+    EnumCount
+};
+
 // Base class for all caches. Provides cache hit and miss counters.
 class CacheStats final : angle::NonCopyable
 {
@@ -1321,6 +1338,12 @@ class CacheStats final : angle::NonCopyable
 
     ANGLE_INLINE void hit() { mHitCount++; }
     ANGLE_INLINE void miss() { mMissCount++; }
+    ANGLE_INLINE void accumulate(const CacheStats &stats)
+    {
+        mHitCount += stats.mHitCount;
+        mMissCount += stats.mMissCount;
+    }
+
     ANGLE_INLINE double getHitRatio() const
     {
         if (mHitCount + mMissCount == 0)
@@ -1345,7 +1368,7 @@ class RenderPassCache final : angle::NonCopyable
     RenderPassCache();
     ~RenderPassCache();
 
-    void destroy(VkDevice device);
+    void destroy(RendererVk *rendererVk);
 
     ANGLE_INLINE angle::Result getCompatibleRenderPass(ContextVk *contextVk,
                                                        const vk::RenderPassDesc &desc,
@@ -1400,7 +1423,7 @@ class GraphicsPipelineCache final : angle::NonCopyable
     GraphicsPipelineCache();
     ~GraphicsPipelineCache();
 
-    void destroy(VkDevice device);
+    void destroy(RendererVk *rendererVk);
     void release(ContextVk *context);
 
     void populate(const vk::GraphicsPipelineDesc &desc, vk::Pipeline &&pipeline);
@@ -1460,7 +1483,7 @@ class DescriptorSetLayoutCache final : angle::NonCopyable
     DescriptorSetLayoutCache();
     ~DescriptorSetLayoutCache();
 
-    void destroy(VkDevice device);
+    void destroy(RendererVk *rendererVk);
 
     angle::Result getDescriptorSetLayout(
         vk::Context *context,
@@ -1478,7 +1501,7 @@ class PipelineLayoutCache final : angle::NonCopyable
     PipelineLayoutCache();
     ~PipelineLayoutCache();
 
-    void destroy(VkDevice device);
+    void destroy(RendererVk *rendererVk);
 
     angle::Result getPipelineLayout(vk::Context *context,
                                     const vk::PipelineLayoutDesc &desc,
@@ -1496,7 +1519,7 @@ class SamplerCache final : angle::NonCopyable
     SamplerCache();
     ~SamplerCache();
 
-    void destroy(RendererVk *renderer);
+    void destroy(RendererVk *rendererVk);
 
     angle::Result getSampler(ContextVk *contextVk,
                              const vk::SamplerDesc &desc,
@@ -1514,7 +1537,7 @@ class SamplerYcbcrConversionCache final : angle::NonCopyable
     SamplerYcbcrConversionCache();
     ~SamplerYcbcrConversionCache();
 
-    void destroy(RendererVk *render);
+    void destroy(RendererVk *rendererVk);
 
     angle::Result getYuvConversion(
         vk::Context *context,
@@ -1535,6 +1558,8 @@ class FramebufferCache final : angle::NonCopyable
     FramebufferCache() = default;
     ~FramebufferCache() { ASSERT(mPayload.empty()); }
 
+    void destroy(RendererVk *rendererVk);
+
     bool get(ContextVk *contextVk,
              const vk::FramebufferDesc &desc,
              vk::FramebufferHelper **framebufferOut);
@@ -1553,6 +1578,8 @@ class DriverUniformsDescriptorSetCache final : angle::NonCopyable
     DriverUniformsDescriptorSetCache() = default;
     ~DriverUniformsDescriptorSetCache() { ASSERT(mPayload.empty()); }
 
+    void destroy(RendererVk *rendererVk);
+
     ANGLE_INLINE bool get(uint32_t serial, VkDescriptorSet *descriptorSet)
     {
         if (mPayload.get(serial, descriptorSet))
@@ -1577,13 +1604,15 @@ class DriverUniformsDescriptorSetCache final : angle::NonCopyable
 };
 
 // Templated Descriptors Cache
-template <typename key>
+template <typename key, VulkanCacheType cacheType>
 class DescriptorSetCache final : angle::NonCopyable
 {
   public:
     DescriptorSetCache() = default;
     ~DescriptorSetCache() { ASSERT(mPayload.empty()); }
 
+    void destroy(RendererVk *rendererVk);
+
     ANGLE_INLINE bool get(const key &desc, VkDescriptorSet *descriptorSet)
     {
         auto iter = mPayload.find(desc);
@@ -1602,8 +1631,6 @@ class DescriptorSetCache final : angle::NonCopyable
         mPayload.emplace(desc, descriptorSet);
     }
 
-    ANGLE_INLINE void clear() { mPayload.clear(); }
-
   private:
     angle::HashMap<key, VkDescriptorSet> mPayload;
     CacheStats mCacheStats;

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -7044,10 +7044,10 @@ bool ShaderProgramHelper::valid(const gl::ShaderType shaderType) const
     return mShaders[shaderType].valid();
 }
 
-void ShaderProgramHelper::destroy(VkDevice device)
+void ShaderProgramHelper::destroy(RendererVk *rendererVk)
 {
-    mGraphicsPipelines.destroy(device);
-    mComputePipeline.destroy(device);
+    mGraphicsPipelines.destroy(rendererVk);
+    mComputePipeline.destroy(rendererVk->getDevice());
     for (BindingPointer<ShaderAndSerial> &shader : mShaders)
     {
         shader.reset();

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -2288,7 +2288,7 @@ class ShaderProgramHelper : angle::NonCopyable
     ~ShaderProgramHelper();
 
     bool valid(const gl::ShaderType shaderType) const;
-    void destroy(VkDevice device);
+    void destroy(RendererVk *rendererVk);
     void release(ContextVk *contextVk);
 
     ShaderAndSerial &getShader(gl::ShaderType shaderType) { return mShaders[shaderType].get(); }