Vulkan: Fix texture descriptor set alloc count.

samples/simple_texture_cubemap/SimpleTextureCubemap.cpp

@@ -21,8 +21,8 @@
 class SimpleTextureCubemapSample : public SampleApplication
 {
   public:
-    SimpleTextureCubemapSample()
-        : SampleApplication("SimpleTextureCubemap", 1280, 720)
+    SimpleTextureCubemapSample(EGLint displayType)
+        : SampleApplication("SimpleTextureCubemap", 1280, 720, 2, 0, displayType)
     {
     }
 
@@ -129,6 +129,13 @@ class SimpleTextureCubemapSample : public SampleApplication
 
 int main(int argc, char **argv)
 {
-    SimpleTextureCubemapSample app;
+    EGLint displayType = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
+
+    if (argc > 1)
+    {
+        displayType = GetDisplayTypeFromArg(argv[1]);
+    }
+
+    SimpleTextureCubemapSample app(displayType);
     return app.run();
 }

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -431,7 +431,8 @@ void ProgramVk::setUniformImpl(GLint location, GLsizei count, const T *v, GLenum
 
     if (linkedUniform.isSampler())
     {
-        UNIMPLEMENTED();
+        // We could potentially cache some indexing here. For now this is a no-op since the mapping
+        // is handled entirely in ContextVk.
         return;
     }
 

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -19,7 +19,7 @@ namespace vk
 namespace
 {
 // TODO(jmadill): Pick non-arbitrary max.
-constexpr uint32_t kDynamicDescriptorPoolMaxSets = 2048;
+constexpr uint32_t kDefaultDynamicDescriptorPoolMaxSets = 2048;
 
 constexpr VkBufferUsageFlags kLineLoopDynamicBufferUsage =
     (VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
@@ -239,7 +239,8 @@ void DynamicBuffer::setMinimumSizeForTesting(size_t minSize)
 
 // DynamicDescriptorPool implementation.
 DynamicDescriptorPool::DynamicDescriptorPool()
-    : mCurrentAllocatedDescriptorSetCount(0),
+    : mMaxSetsPerPool(kDefaultDynamicDescriptorPoolMaxSets),
+      mCurrentAllocatedDescriptorSetCount(0),
       mUniformBufferDescriptorsPerSet(0),
       mCombinedImageSamplerDescriptorsPerSet(0)
 {
@@ -274,7 +275,7 @@ Error DynamicDescriptorPool::allocateDescriptorSets(
     uint32_t descriptorSetCount,
     VkDescriptorSet *descriptorSetsOut)
 {
-    if (descriptorSetCount + mCurrentAllocatedDescriptorSetCount > kDynamicDescriptorPoolMaxSets)
+    if (descriptorSetCount + mCurrentAllocatedDescriptorSetCount > mMaxSetsPerPool)
     {
         RendererVk *renderer = contextVk->getRenderer();
         Serial currentSerial = renderer->getCurrentQueueSerial();
@@ -303,17 +304,16 @@ Error DynamicDescriptorPool::allocateNewPool(const VkDevice &device)
     VkDescriptorPoolSize poolSizes[DescriptorPoolIndexCount];
     poolSizes[UniformBufferIndex].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
     poolSizes[UniformBufferIndex].descriptorCount =
-        mUniformBufferDescriptorsPerSet * kDynamicDescriptorPoolMaxSets / DescriptorPoolIndexCount;
+        mUniformBufferDescriptorsPerSet * mMaxSetsPerPool;
     poolSizes[TextureIndex].type            = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    poolSizes[TextureIndex].descriptorCount = mCombinedImageSamplerDescriptorsPerSet *
-                                              kDynamicDescriptorPoolMaxSets /
-                                              DescriptorPoolIndexCount;
+    poolSizes[TextureIndex].descriptorCount =
+        mCombinedImageSamplerDescriptorsPerSet * mMaxSetsPerPool;
 
     VkDescriptorPoolCreateInfo descriptorPoolInfo;
     descriptorPoolInfo.sType   = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
     descriptorPoolInfo.pNext   = nullptr;
     descriptorPoolInfo.flags   = 0;
-    descriptorPoolInfo.maxSets = kDynamicDescriptorPoolMaxSets;
+    descriptorPoolInfo.maxSets = mMaxSetsPerPool;
 
     // Reserve pools for uniform blocks and textures.
     descriptorPoolInfo.poolSizeCount = DescriptorPoolIndexCount;
@@ -324,6 +324,12 @@ Error DynamicDescriptorPool::allocateNewPool(const VkDevice &device)
     return NoError();
 }
 
+void DynamicDescriptorPool::setMaxSetsPerPoolForTesting(uint32_t maxSetsPerPool)
+{
+    mMaxSetsPerPool = maxSetsPerPool;
+}
+
+// LineLoopHelper implementation.
 LineLoopHelper::LineLoopHelper()
     : mDynamicIndexBuffer(kLineLoopDynamicBufferUsage, kLineLoopDynamicBufferMinSize)
 {

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -101,9 +101,13 @@ class DynamicDescriptorPool final : angle::NonCopyable
                                  uint32_t descriptorSetCount,
                                  VkDescriptorSet *descriptorSetsOut);
 
+    // For testing only!
+    void setMaxSetsPerPoolForTesting(uint32_t maxSetsPerPool);
+
   private:
     Error allocateNewPool(const VkDevice &device);
 
+    uint32_t mMaxSetsPerPool;
     DescriptorPool mCurrentDescriptorSetPool;
     size_t mCurrentAllocatedDescriptorSetCount;
     uint32_t mUniformBufferDescriptorsPerSet;

src/tests/gl_tests/VulkanUniformUpdatesTest.cpp

@@ -28,39 +28,39 @@ namespace
 
 class VulkanUniformUpdatesTest : public ANGLETest
 {
+  protected:
+    rx::ContextVk *hackANGLE()
+    {
+        // Hack the angle!
+        const gl::Context *context = reinterpret_cast<gl::Context *>(getEGLWindow()->getContext());
+        return rx::GetImplAs<rx::ContextVk>(context);
+    }
 };
 
 // This test updates a uniform until a new buffer is allocated and then make sure the uniform
 // updates still work.
-TEST_P(VulkanUniformUpdatesTest, UpdateUniformUntilNewBufferIsAllocated)
+TEST_P(VulkanUniformUpdatesTest, UpdateUntilNewBufferIsAllocated)
 {
     ASSERT_TRUE(IsVulkan());
 
-    constexpr char kPositionUniformVertexShader[] = R"(
-precision mediump float;
-attribute vec2 position;
+    constexpr char kPositionUniformVertexShader[] = R"(attribute vec2 position;
 uniform vec2 uniPosModifier;
 void main()
 {
     gl_Position = vec4(position + uniPosModifier, 0, 1);
 })";
 
-    constexpr char kColorUniformFragmentShader[] = R"(
-precision mediump float;
+    constexpr char kColorUniformFragmentShader[] = R"(precision mediump float;
 uniform vec4 uniColor;
 void main()
 {
     gl_FragColor = uniColor;
 })";
 
-    // Hack the angle!
-    const gl::Context *context = reinterpret_cast<gl::Context *>(getEGLWindow()->getContext());
-    auto *contextVk            = rx::GetImplAs<rx::ContextVk>(context);
-
     ANGLE_GL_PROGRAM(program, kPositionUniformVertexShader, kColorUniformFragmentShader);
     glUseProgram(program);
 
-    const gl::State &state   = contextVk->getGLState();
+    const gl::State &state   = hackANGLE()->getGLState();
     rx::ProgramVk *programVk = rx::vk::GetImpl(state.getProgram());
 
     // Set a really small min size so that uniform updates often allocates a new buffer.
@@ -83,6 +83,43 @@ void main()
     }
 }
 
+// Force uniform updates until the dynamic descriptor pool wraps into a new pool allocation.
+TEST_P(VulkanUniformUpdatesTest, DescriptorPoolUpdates)
+{
+    ASSERT_TRUE(IsVulkan());
+
+    // Force a small limit on the max sets per pool to more easily trigger a new allocation.
+    constexpr uint32_t kMaxSetsForTesting                = 32;
+    rx::vk::DynamicDescriptorPool *dynamicDescriptorPool = hackANGLE()->getDynamicDescriptorPool();
+    dynamicDescriptorPool->setMaxSetsPerPoolForTesting(kMaxSetsForTesting);
+
+    // Initialize texture program.
+    GLuint program = get2DTexturedQuadProgram();
+    ASSERT_NE(0u, program);
+    glUseProgram(program);
+
+    GLint texLoc = glGetUniformLocation(program, "tex");
+    ASSERT_NE(-1, texLoc);
+
+    // Initialize basic red texture.
+    const std::vector<GLColor> redColors(4, GLColor::red);
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, redColors.data());
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    ASSERT_GL_NO_ERROR();
+
+    // Draw multiple times, each iteration will create a new descriptor set.
+    for (uint32_t iteration = 0; iteration < kMaxSetsForTesting * 8; ++iteration)
+    {
+        glUniform1i(texLoc, 0);
+        drawQuad(program, "position", 0.5f, 1.0f, true);
+        swapBuffers();
+        ASSERT_GL_NO_ERROR();
+    }
+}
+
 ANGLE_INSTANTIATE_TEST(VulkanUniformUpdatesTest, ES2_VULKAN());
 
 }  // anonymous namespace