Vulkan: Allow descriptor pool to allocate different types

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -194,12 +194,15 @@ angle::Result ContextVk::initialize()
 {
     TRACE_EVENT0("gpu.angle", "ContextVk::initialize");
     // Note that this may reserve more sets than strictly necessary for a particular layout.
-    ANGLE_TRY(mDynamicDescriptorPools[kUniformsDescriptorSetIndex].init(
-        this, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, GetUniformBufferDescriptorCount()));
-    ANGLE_TRY(mDynamicDescriptorPools[kTextureDescriptorSetIndex].init(
-        this, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, mRenderer->getMaxActiveTextures()));
-    ANGLE_TRY(mDynamicDescriptorPools[kDriverUniformsDescriptorSetIndex].init(
-        this, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1));
+    VkDescriptorPoolSize uniformSetSize = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+                                           GetUniformBufferDescriptorCount()};
+    VkDescriptorPoolSize textureSetSize = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                           mRenderer->getMaxActiveTextures()};
+    VkDescriptorPoolSize driverSetSize  = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1};
+    ANGLE_TRY(mDynamicDescriptorPools[kUniformsDescriptorSetIndex].init(this, &uniformSetSize, 1));
+    ANGLE_TRY(mDynamicDescriptorPools[kTextureDescriptorSetIndex].init(this, &textureSetSize, 1));
+    ANGLE_TRY(
+        mDynamicDescriptorPools[kDriverUniformsDescriptorSetIndex].init(this, &driverSetSize, 1));
 
     ANGLE_TRY(mQueryPools[gl::QueryType::AnySamples].init(this, VK_QUERY_TYPE_OCCLUSION,
                                                           vk::kDefaultOcclusionQueryPoolSize));

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -291,7 +291,7 @@ bool DescriptorPoolHelper::hasCapacity(uint32_t descriptorSetCount) const
 }
 
 angle::Result DescriptorPoolHelper::init(Context *context,
-                                         const VkDescriptorPoolSize &poolSize,
+                                         const std::vector<VkDescriptorPoolSize> &poolSizes,
                                          uint32_t maxSets)
 {
     if (mDescriptorPool.valid())
@@ -304,8 +304,8 @@ angle::Result DescriptorPoolHelper::init(Context *context,
     descriptorPoolInfo.sType                      = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
     descriptorPoolInfo.flags                      = 0;
     descriptorPoolInfo.maxSets                    = maxSets;
-    descriptorPoolInfo.poolSizeCount              = 1u;
-    descriptorPoolInfo.pPoolSizes                 = &poolSize;
+    descriptorPoolInfo.poolSizeCount              = static_cast<uint32_t>(poolSizes.size());
+    descriptorPoolInfo.pPoolSizes                 = poolSizes.data();
 
     mFreeDescriptorSets = maxSets;
 
@@ -339,24 +339,27 @@ angle::Result DescriptorPoolHelper::allocateSets(Context *context,
 
 // DynamicDescriptorPool implementation.
 DynamicDescriptorPool::DynamicDescriptorPool()
-    : mMaxSetsPerPool(kDefaultDescriptorPoolMaxSets), mCurrentPoolIndex(0), mPoolSize{}
+    : mMaxSetsPerPool(kDefaultDescriptorPoolMaxSets), mCurrentPoolIndex(0)
 {}
 
 DynamicDescriptorPool::~DynamicDescriptorPool() = default;
 
-angle::Result DynamicDescriptorPool::init(ContextVk *contextVk,
-                                          VkDescriptorType descriptorType,
-                                          uint32_t descriptorsPerSet)
+angle::Result DynamicDescriptorPool::init(Context *context,
+                                          const VkDescriptorPoolSize *setSizes,
+                                          uint32_t setSizeCount)
 {
     ASSERT(mCurrentPoolIndex == 0);
     ASSERT(mDescriptorPools.empty() || (mDescriptorPools.size() == 1 &&
                                         mDescriptorPools[0]->get().hasCapacity(mMaxSetsPerPool)));
 
-    mPoolSize.type            = descriptorType;
-    mPoolSize.descriptorCount = descriptorsPerSet * mMaxSetsPerPool;
+    mPoolSizes.assign(setSizes, setSizes + setSizeCount);
+    for (uint32_t i = 0; i < setSizeCount; ++i)
+    {
+        mPoolSizes[i].descriptorCount *= mMaxSetsPerPool;
+    }
 
     mDescriptorPools.push_back(new SharedDescriptorPoolHelper());
-    return mDescriptorPools[0]->get().init(contextVk, mPoolSize, mMaxSetsPerPool);
+    return mDescriptorPools[0]->get().init(context, mPoolSizes, mMaxSetsPerPool);
 }
 
 void DynamicDescriptorPool::destroy(VkDevice device)
@@ -371,7 +374,7 @@ void DynamicDescriptorPool::destroy(VkDevice device)
     mDescriptorPools.clear();
 }
 
-angle::Result DynamicDescriptorPool::allocateSets(ContextVk *contextVk,
+angle::Result DynamicDescriptorPool::allocateSets(Context *context,
                                                   const VkDescriptorSetLayout *descriptorSetLayout,
                                                   uint32_t descriptorSetCount,
                                                   SharedDescriptorPoolBinding *bindingOut,
@@ -381,7 +384,7 @@ angle::Result DynamicDescriptorPool::allocateSets(ContextVk *contextVk,
     {
         if (!mDescriptorPools[mCurrentPoolIndex]->get().hasCapacity(descriptorSetCount))
         {
-            ANGLE_TRY(allocateNewPool(contextVk));
+            ANGLE_TRY(allocateNewPool(context));
         }
 
         // Make sure the old binding knows the descriptor sets can still be in-use. We only need
@@ -389,20 +392,20 @@ angle::Result DynamicDescriptorPool::allocateSets(ContextVk *contextVk,
         // when we move to a new pool.
         if (bindingOut->valid())
         {
-            Serial currentSerial = contextVk->getRenderer()->getCurrentQueueSerial();
+            Serial currentSerial = context->getRenderer()->getCurrentQueueSerial();
             bindingOut->get().updateSerial(currentSerial);
         }
 
         bindingOut->set(mDescriptorPools[mCurrentPoolIndex]);
     }
 
-    return bindingOut->get().allocateSets(contextVk, descriptorSetLayout, descriptorSetCount,
+    return bindingOut->get().allocateSets(context, descriptorSetLayout, descriptorSetCount,
                                           descriptorSetsOut);
 }
 
-angle::Result DynamicDescriptorPool::allocateNewPool(ContextVk *contextVk)
+angle::Result DynamicDescriptorPool::allocateNewPool(Context *context)
 {
-    RendererVk *renderer = contextVk->getRenderer();
+    RendererVk *renderer = context->getRenderer();
 
     bool found = false;
 
@@ -425,10 +428,10 @@ angle::Result DynamicDescriptorPool::allocateNewPool(ContextVk *contextVk)
         mCurrentPoolIndex = mDescriptorPools.size() - 1;
 
         static constexpr size_t kMaxPools = 99999;
-        ANGLE_VK_CHECK(contextVk, mDescriptorPools.size() < kMaxPools, VK_ERROR_TOO_MANY_OBJECTS);
+        ANGLE_VK_CHECK(context, mDescriptorPools.size() < kMaxPools, VK_ERROR_TOO_MANY_OBJECTS);
     }
 
-    return mDescriptorPools[mCurrentPoolIndex]->get().init(contextVk, mPoolSize, mMaxSetsPerPool);
+    return mDescriptorPools[mCurrentPoolIndex]->get().init(context, mPoolSizes, mMaxSetsPerPool);
 }
 
 void DynamicDescriptorPool::setMaxSetsPerPoolForTesting(uint32_t maxSetsPerPool)

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -102,7 +102,9 @@ class DescriptorPoolHelper
     bool valid() { return mDescriptorPool.valid(); }
 
     bool hasCapacity(uint32_t descriptorSetCount) const;
-    angle::Result init(Context *context, const VkDescriptorPoolSize &poolSize, uint32_t maxSets);
+    angle::Result init(Context *context,
+                       const std::vector<VkDescriptorPoolSize> &poolSizes,
+                       uint32_t maxSets);
     void destroy(VkDevice device);
 
     angle::Result allocateSets(Context *context,
@@ -130,14 +132,16 @@ class DynamicDescriptorPool final : angle::NonCopyable
     ~DynamicDescriptorPool();
 
     // The DynamicDescriptorPool only handles one pool size at this time.
-    angle::Result init(ContextVk *contextVk,
-                       VkDescriptorType descriptorType,
-                       uint32_t descriptorsPerSet);
+    // Note that setSizes[i].descriptorCount is expected to be the number of descriptors in
+    // an individual set.  The pool size will be calculated accordingly.
+    angle::Result init(Context *context,
+                       const VkDescriptorPoolSize *setSizes,
+                       uint32_t setSizeCount);
     void destroy(VkDevice device);
 
     // We use the descriptor type to help count the number of free sets.
     // By convention, sets are indexed according to the constants in vk_cache_utils.h.
-    angle::Result allocateSets(ContextVk *contextVk,
+    angle::Result allocateSets(Context *context,
                                const VkDescriptorSetLayout *descriptorSetLayout,
                                uint32_t descriptorSetCount,
                                SharedDescriptorPoolBinding *bindingOut,
@@ -147,12 +151,12 @@ class DynamicDescriptorPool final : angle::NonCopyable
     void setMaxSetsPerPoolForTesting(uint32_t maxSetsPerPool);
 
   private:
-    angle::Result allocateNewPool(ContextVk *contextVk);
+    angle::Result allocateNewPool(Context *context);
 
     uint32_t mMaxSetsPerPool;
     size_t mCurrentPoolIndex;
     std::vector<SharedDescriptorPoolHelper *> mDescriptorPools;
-    VkDescriptorPoolSize mPoolSize;
+    std::vector<VkDescriptorPoolSize> mPoolSizes;
 };
 
 template <typename Pool>

src/tests/gl_tests/VulkanUniformUpdatesTest.cpp

@@ -53,14 +53,16 @@ class VulkanUniformUpdatesTest : public ANGLETest
         rx::vk::DynamicDescriptorPool *uniformPool =
             contextVk->getDynamicDescriptorPool(rx::kUniformsDescriptorSetIndex);
         uniformPool->setMaxSetsPerPoolForTesting(kMaxSetsForTesting);
-        (void)uniformPool->init(contextVk, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-                                rx::GetUniformBufferDescriptorCount());
+        VkDescriptorPoolSize uniformSetSize = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+                                               rx::GetUniformBufferDescriptorCount()};
+        (void)uniformPool->init(contextVk, &uniformSetSize, 1);
 
         rx::vk::DynamicDescriptorPool *texturePool =
             contextVk->getDynamicDescriptorPool(rx::kTextureDescriptorSetIndex);
         texturePool->setMaxSetsPerPoolForTesting(kMaxSetsForTesting);
-        (void)texturePool->init(contextVk, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-                                contextVk->getRenderer()->getMaxActiveTextures());
+        VkDescriptorPoolSize textureSetSize = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                               contextVk->getRenderer()->getMaxActiveTextures()};
+        (void)texturePool->init(contextVk, &textureSetSize, 1);
     }
 };