Vulkan: Squash Texture+ImageView Serial and improve caching.

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -3875,8 +3875,9 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context)
 
         mActiveTextures[textureUnit].texture = textureVk;
         mActiveTextures[textureUnit].sampler = &samplerVk;
-        mActiveTexturesDesc.update(textureUnit, textureVk->getSerial(),
-                                   samplerVk.getSamplerSerial());
+
+        vk::ImageViewSubresourceSerial imageViewSerial = textureVk->getImageViewSubresourceSerial();
+        mActiveTexturesDesc.update(textureUnit, imageViewSerial, samplerVk.getSamplerSerial());
 
         if (textureVk->getImage().hasImmutableSampler())
         {

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -77,7 +77,7 @@ vk::ImageViewSubresourceSerial RenderTargetVk::getSubresourceSerialImpl(
     ASSERT(mLevelIndexGL < std::numeric_limits<uint16_t>::max());
 
     vk::ImageViewSubresourceSerial imageViewSerial =
-        imageViews->getSubresourceSerial(mLevelIndexGL, mLayerIndex);
+        imageViews->getSubresourceSerial(mLevelIndexGL, 1, mLayerIndex, vk::LayerMode::Single);
     return imageViewSerial;
 }
 

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -1249,7 +1249,6 @@ void TextureVk::setImageHelper(ContextVk *contextVk,
 
     RendererVk *renderer = contextVk->getRenderer();
 
-    updateSerial(contextVk);
     mImageViews.init(renderer);
 }
 
@@ -1699,8 +1698,6 @@ angle::Result TextureVk::updateBaseMaxLevels(ContextVk *contextVk,
         // Track the levels in our ImageHelper
         mImage->setBaseAndMaxLevels(baseLevel, maxLevel);
 
-        updateSerial(contextVk);
-
         // Update the current max level in ImageViewHelper
         const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
         // We use a special layer count here to handle EGLImages. They might only be
@@ -2162,8 +2159,6 @@ angle::Result TextureVk::syncState(const gl::Context *context,
                                 mImage->getExternalFormat());
     ANGLE_TRY(renderer->getSamplerCache().getSampler(contextVk, samplerDesc, &mSampler));
 
-    updateSerial(contextVk);
-
     return angle::Result::Continue;
 }
 
@@ -2301,8 +2296,6 @@ angle::Result TextureVk::initImage(ContextVk *contextVk,
 
     ANGLE_TRY(initImageViews(contextVk, format, sized, levelCount, layerCount));
 
-    updateSerial(contextVk);
-
     return angle::Result::Continue;
 }
 
@@ -2522,9 +2515,11 @@ void TextureVk::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMe
     onStateChange(angle::SubjectMessage::SubjectChanged);
 }
 
-void TextureVk::updateSerial(ContextVk *contextVk)
+vk::ImageViewSubresourceSerial TextureVk::getImageViewSubresourceSerial() const
 {
-    vk::ResourceSerialFactory &factory = contextVk->getRenderer()->getResourceSerialFactory();
-    mSerial                            = factory.generateTextureSerial();
+    uint32_t baseLevel = mState.getEffectiveBaseLevel();
+    // getMipmapMaxLevel will clamp to the max level if it is smaller than the number of mips.
+    uint32_t levelCount = mState.getMipmapMaxLevel() - baseLevel + 1;
+    return mImageViews.getSubresourceSerial(baseLevel, levelCount, 0, vk::LayerMode::All);
 }
 }  // namespace rx

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -191,7 +191,7 @@ class TextureVk : public TextureImpl, public angle::ObserverInterface
     // Normally, initialize the image with enabled mipmap level counts.
     angle::Result ensureImageInitialized(ContextVk *contextVk, ImageMipLevels mipLevels);
 
-    vk::TextureSerial getSerial() const { return mSerial; }
+    vk::ImageViewSubresourceSerial getImageViewSubresourceSerial() const;
 
     void overrideStagingBufferSizeForTesting(size_t initialSizeForTesting)
     {
@@ -397,8 +397,6 @@ class TextureVk : public TextureImpl, public angle::ObserverInterface
         return (mImage->valid()) ? mImage->getTilingMode() : VK_IMAGE_TILING_OPTIMAL;
     }
 
-    void updateSerial(ContextVk *contextVk);
-
     bool mOwnsImage;
     bool mRequiresSRGBViews;
 
@@ -435,9 +433,6 @@ class TextureVk : public TextureImpl, public angle::ObserverInterface
     // Level is first dimension, layer is second
     std::vector<RenderTargetVector> mRenderTargets;
 
-    // The unique object id is used for cache indexing.
-    vk::TextureSerial mSerial;
-
     // Overridden in some tests.
     size_t mStagingBufferInitialSize;
 

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -1711,7 +1711,7 @@ void PipelineHelper::addTransition(GraphicsPipelineTransitionBits bits,
 
 TextureDescriptorDesc::TextureDescriptorDesc() : mMaxIndex(0)
 {
-    mSerials.fill({0, 0});
+    mSerials.fill({kInvalidImageViewSubresourceSerial, kInvalidSamplerSerial});
 }
 
 TextureDescriptorDesc::~TextureDescriptorDesc()                                  = default;
@@ -1720,7 +1720,7 @@ TextureDescriptorDesc &TextureDescriptorDesc::operator=(const TextureDescriptorD
     default;
 
 void TextureDescriptorDesc::update(size_t index,
-                                   TextureSerial textureSerial,
+                                   ImageViewSubresourceSerial imageViewSerial,
                                    SamplerSerial samplerSerial)
 {
     if (index >= mMaxIndex)
@@ -1728,12 +1728,8 @@ void TextureDescriptorDesc::update(size_t index,
         mMaxIndex = static_cast<uint32_t>(index + 1);
     }
 
-    // If the serial number overflows we should defragment and regenerate all serials.
-    // There should never be more than UINT_MAX textures alive at a time.
-    ASSERT(textureSerial.getValue() < std::numeric_limits<uint32_t>::max());
-    ASSERT(samplerSerial.getValue() < std::numeric_limits<uint32_t>::max());
-    mSerials[index].texture = static_cast<uint32_t>(textureSerial.getValue());
-    mSerials[index].sampler = static_cast<uint32_t>(samplerSerial.getValue());
+    mSerials[index].imageView = imageViewSerial;
+    mSerials[index].sampler   = samplerSerial;
 }
 
 size_t TextureDescriptorDesc::hash() const

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -789,14 +789,16 @@ ANGLE_INLINE PipelineHelper::PipelineHelper(Pipeline &&pipeline) : mPipeline(std
 struct ImageViewSubresourceSerial
 {
     ImageViewSerial imageViewSerial;
-    uint16_t level;
-    uint16_t layer;
+    uint16_t level : 10;       // GL max is 1000 (fits in 10 bits).
+    uint16_t levelCount : 6;   // Max 63 levels (2 ** 6 - 1). If we need more, take from layer.
+    uint16_t layer : 15;       // Implementation max is 2048 (11 bits).
+    uint16_t singleLayer : 1;  // true/false only. Not possible to use sub-slices of levels.
 };
 
 static_assert(sizeof(ImageViewSubresourceSerial) == sizeof(uint64_t), "Size mismatch");
 
 constexpr ImageViewSubresourceSerial kInvalidImageViewSubresourceSerial = {kInvalidImageViewSerial,
-                                                                           0, 0};
+                                                                           0, 0, 0, 0};
 
 class TextureDescriptorDesc
 {
@@ -807,7 +809,9 @@ class TextureDescriptorDesc
     TextureDescriptorDesc(const TextureDescriptorDesc &other);
     TextureDescriptorDesc &operator=(const TextureDescriptorDesc &other);
 
-    void update(size_t index, TextureSerial textureSerial, SamplerSerial samplerSerial);
+    void update(size_t index,
+                ImageViewSubresourceSerial imageViewSerial,
+                SamplerSerial samplerSerial);
     size_t hash() const;
     void reset();
 
@@ -818,12 +822,15 @@ class TextureDescriptorDesc
 
   private:
     uint32_t mMaxIndex;
+
+    ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
     struct TexUnitSerials
     {
-        uint32_t texture;
-        uint32_t sampler;
+        ImageViewSubresourceSerial imageView;
+        SamplerSerial sampler;
     };
     gl::ActiveTextureArray<TexUnitSerials> mSerials;
+    ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
 };
 
 class UniformsAndXfbDesc

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -5331,14 +5331,19 @@ angle::Result ImageViewHelper::getLevelLayerDrawImageView(ContextVk *contextVk,
                                     imageView, levelVK, 1, layer, 1);
 }
 
-ImageViewSubresourceSerial ImageViewHelper::getSubresourceSerial(uint32_t levelGL, uint32_t layer)
+ImageViewSubresourceSerial ImageViewHelper::getSubresourceSerial(uint32_t levelGL,
+                                                                 uint32_t levelCount,
+                                                                 uint32_t layer,
+                                                                 LayerMode layerMode) const
 {
     ASSERT(mImageViewSerial.valid());
 
     ImageViewSubresourceSerial serial;
     serial.imageViewSerial = mImageViewSerial;
     SetBitField(serial.level, levelGL);
+    SetBitField(serial.levelCount, levelCount);
     SetBitField(serial.layer, layer);
+    SetBitField(serial.singleLayer, layerMode == LayerMode::Single ? 1 : 0);
     return serial;
 }
 

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -1588,6 +1588,13 @@ using ImageViewVector = std::vector<ImageView>;
 // A vector of vector of image views.  Primary index is layer, secondary index is level.
 using LayerLevelImageViewVector = std::vector<ImageViewVector>;
 
+// Address mode for layers: only possible to access either 1 layer or all layers.
+enum LayerMode
+{
+    Single,
+    All
+};
+
 class ImageViewHelper : angle::NonCopyable
 {
   public:
@@ -1717,7 +1724,12 @@ class ImageViewHelper : angle::NonCopyable
                                              const ImageView **imageViewOut);
 
     // Return unique Serial for an imageView.
-    ImageViewSubresourceSerial getSubresourceSerial(uint32_t levelGL, uint32_t layer);
+    ImageViewSubresourceSerial getSubresourceSerial(uint32_t levelGL,
+                                                    uint32_t levelCount,
+                                                    uint32_t layer,
+                                                    LayerMode layerMode) const;
+
+    uint32_t getCurrentMaxLevel() const { return mCurrentMaxLevel; }
 
   private:
     ImageView &getReadImageView()

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -696,8 +696,7 @@ class ClearValuesArray final
 #define ANGLE_VK_SERIAL_OP(X) \
     X(Buffer)                 \
     X(ImageView)              \
-    X(Sampler)                \
-    X(Texture)
+    X(Sampler)
 
 #define ANGLE_DEFINE_VK_SERIAL_TYPE(Type)                                     \
     class Type##Serial                                                        \

src/tests/gl_tests/VulkanPerformanceCounterTest.cpp

@@ -88,6 +88,58 @@ TEST_P(VulkanPerformanceCounterTest, NewTextureDoesNotBreakRenderPass)
     EXPECT_EQ(expectedRenderPassCount, actualRenderPassCount);
 }
 
-ANGLE_INSTANTIATE_TEST(VulkanPerformanceCounterTest, ES2_VULKAN(), ES3_VULKAN());
+// Tests that changing a Texture's max level hits the descriptor set cache.
+TEST_P(VulkanPerformanceCounterTest, ChangingMaxLevelHitsDescriptorCache)
+{
+    rx::ContextVk *contextVk = hackANGLE();
+
+    GLColor kInitialData[4] = {GLColor::red, GLColor::blue, GLColor::green, GLColor::yellow};
+
+    // Step 1: Set up a simple mipped 2D Texture rendering loop.
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, kInitialData);
+    glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, kInitialData);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
+
+    auto quadVerts = GetQuadVertices();
+
+    GLBuffer vertexBuffer;
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, quadVerts.size() * sizeof(quadVerts[0]), quadVerts.data(),
+                 GL_STATIC_DRAW);
+
+    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Texture2D(), essl1_shaders::fs::Texture2D());
+    glUseProgram(program);
+
+    GLint posLoc = glGetAttribLocation(program, essl1_shaders::PositionAttrib());
+    ASSERT_NE(-1, posLoc);
+
+    glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+    glEnableVertexAttribArray(posLoc);
+    ASSERT_GL_NO_ERROR();
+
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+    ASSERT_GL_NO_ERROR();
+
+    // Step 2: Change max level and draw.
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+    ASSERT_GL_NO_ERROR();
+
+    uint32_t expectedWriteDescriptorSetCount = contextVk->getWriteDescriptorSetCounter();
+
+    // Step 3: Change max level back to original value and verify we hit the cache.
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+    ASSERT_GL_NO_ERROR();
+
+    uint32_t actualWriteDescriptorSetCount = contextVk->getWriteDescriptorSetCounter();
+    EXPECT_EQ(expectedWriteDescriptorSetCount, actualWriteDescriptorSetCount);
+}
+
+ANGLE_INSTANTIATE_TEST(VulkanPerformanceCounterTest, ES3_VULKAN());
 
 }  // anonymous namespace