Vulkan: Refactor ImageViewHelper serials.

src/libANGLE/renderer/vulkan/DisplayVk.cpp

@@ -125,7 +125,7 @@ SurfaceImpl *DisplayVk::createPbufferSurface(const egl::SurfaceState &state,
     }
 
     ASSERT(mRenderer);
-    return new OffscreenSurfaceVk(state);
+    return new OffscreenSurfaceVk(state, mRenderer);
 }
 
 SurfaceImpl *DisplayVk::createPbufferFromClientBuffer(const egl::SurfaceState &state,

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -1476,22 +1476,22 @@ angle::Result FramebufferVk::updateColorAttachment(const gl::Context *context,
 
     if (enabledColor)
     {
-        mCurrentFramebufferDesc.updateColor(colorIndexGL,
-                                            renderTarget->getAssignImageViewSerial(contextVk));
+        mCurrentFramebufferDesc.updateColor(colorIndexGL, renderTarget->getDrawSubresourceSerial());
     }
     else
     {
-        mCurrentFramebufferDesc.updateColor(colorIndexGL, vk::kInvalidImageViewSerial);
+        mCurrentFramebufferDesc.updateColor(colorIndexGL, vk::kInvalidImageViewSubresourceSerial);
     }
 
     if (enabledResolve)
     {
-        mCurrentFramebufferDesc.updateColorResolve(
-            colorIndexGL, renderTarget->getAssignResolveImageViewSerial(contextVk));
+        mCurrentFramebufferDesc.updateColorResolve(colorIndexGL,
+                                                   renderTarget->getResolveSubresourceSerial());
     }
     else
     {
-        mCurrentFramebufferDesc.updateColorResolve(colorIndexGL, vk::kInvalidImageViewSerial);
+        mCurrentFramebufferDesc.updateColorResolve(colorIndexGL,
+                                                   vk::kInvalidImageViewSubresourceSerial);
     }
 
     return angle::Result::Continue;
@@ -1528,12 +1528,11 @@ void FramebufferVk::updateDepthStencilAttachmentSerial(ContextVk *contextVk)
 
     if (depthStencilRT != nullptr)
     {
-        mCurrentFramebufferDesc.updateDepthStencil(
-            depthStencilRT->getAssignImageViewSerial(contextVk));
+        mCurrentFramebufferDesc.updateDepthStencil(depthStencilRT->getDrawSubresourceSerial());
     }
     else
     {
-        mCurrentFramebufferDesc.updateDepthStencil(vk::kInvalidImageViewSerial);
+        mCurrentFramebufferDesc.updateDepthStencil(vk::kInvalidImageViewSubresourceSerial);
     }
 }
 
@@ -1580,15 +1579,15 @@ angle::Result FramebufferVk::syncState(const gl::Context *context,
                 mCurrentFramebufferDesc.reset();
                 for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
                 {
+                    uint32_t colorIndex32 = static_cast<uint32_t>(colorIndexGL);
+
                     RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[colorIndexGL];
-                    mCurrentFramebufferDesc.updateColor(
-                        static_cast<uint32_t>(colorIndexGL),
-                        renderTarget->getAssignImageViewSerial(contextVk));
+                    mCurrentFramebufferDesc.updateColor(colorIndex32,
+                                                        renderTarget->getDrawSubresourceSerial());
                     if (renderTarget->hasResolveAttachment())
                     {
                         mCurrentFramebufferDesc.updateColorResolve(
-                            static_cast<uint32_t>(colorIndexGL),
-                            renderTarget->getAssignResolveImageViewSerial(contextVk));
+                            colorIndex32, renderTarget->getResolveSubresourceSerial());
                     }
                 }
                 updateDepthStencilAttachmentSerial(contextVk);

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -69,27 +69,26 @@ void RenderTargetVk::reset()
     mContentDefined    = false;
 }
 
-vk::ImageViewSerial RenderTargetVk::getAssignViewSerialImpl(ContextVk *contextVk,
-                                                            vk::ImageViewHelper *imageViews) const
+vk::ImageViewSubresourceSerial RenderTargetVk::getSubresourceSerialImpl(
+    vk::ImageViewHelper *imageViews) const
 {
     ASSERT(imageViews);
     ASSERT(mLayerIndex < std::numeric_limits<uint16_t>::max());
     ASSERT(mLevelIndexGL < std::numeric_limits<uint16_t>::max());
 
-    vk::ImageViewSerial imageViewSerial =
-        imageViews->getAssignSerial(contextVk, mLevelIndexGL, mLayerIndex);
-    ASSERT(imageViewSerial.getValue() < std::numeric_limits<uint32_t>::max());
+    vk::ImageViewSubresourceSerial imageViewSerial =
+        imageViews->getSubresourceSerial(mLevelIndexGL, mLayerIndex);
     return imageViewSerial;
 }
 
-vk::ImageViewSerial RenderTargetVk::getAssignImageViewSerial(ContextVk *contextVk) const
+vk::ImageViewSubresourceSerial RenderTargetVk::getDrawSubresourceSerial() const
 {
-    return getAssignViewSerialImpl(contextVk, mImageViews);
+    return getSubresourceSerialImpl(mImageViews);
 }
 
-vk::ImageViewSerial RenderTargetVk::getAssignResolveImageViewSerial(ContextVk *contextVk) const
+vk::ImageViewSubresourceSerial RenderTargetVk::getResolveSubresourceSerial() const
 {
-    return getAssignViewSerialImpl(contextVk, mResolveImageViews);
+    return getSubresourceSerialImpl(mResolveImageViews);
 }
 
 angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk)

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -50,9 +50,9 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
               uint32_t layerIndex,
               bool isImageTransient);
     void reset();
-    // This returns the serial from underlying ImageViewHelper, first assigning one if required
-    vk::ImageViewSerial getAssignImageViewSerial(ContextVk *contextVk) const;
-    vk::ImageViewSerial getAssignResolveImageViewSerial(ContextVk *contextVk) const;
+
+    vk::ImageViewSubresourceSerial getDrawSubresourceSerial() const;
+    vk::ImageViewSubresourceSerial getResolveSubresourceSerial() const;
 
     // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
     angle::Result onColorDraw(ContextVk *contextVk);
@@ -113,8 +113,7 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
                                    vk::ImageViewHelper *imageViews,
                                    const vk::ImageView **imageViewOut) const;
 
-    vk::ImageViewSerial getAssignViewSerialImpl(ContextVk *contextVk,
-                                                vk::ImageViewHelper *imageViews) const;
+    vk::ImageViewSubresourceSerial getSubresourceSerialImpl(vk::ImageViewHelper *imageViews) const;
 
     bool isResolveImageOwnerOfData() const;
 

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -75,6 +75,7 @@ angle::Result RenderbufferVk::setStorageImpl(const gl::Context *context,
             mImage     = new vk::ImageHelper();
             mOwnsImage = true;
             mImageObserverBinding.bind(mImage);
+            mImageViews.init(renderer);
         }
 
         const angle::Format &textureFormat = vkFormat.actualImageFormat();
@@ -127,6 +128,7 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
     mImage           = imageVk->getImage();
     mOwnsImage       = false;
     mImageObserverBinding.bind(mImage);
+    mImageViews.init(renderer);
 
     const vk::Format &vkFormat = renderer->getFormat(image->getFormat().info->sizedInternalFormat);
     const angle::Format &textureFormat = vkFormat.actualImageFormat();

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -176,6 +176,8 @@ angle::Result OffscreenSurfaceVk::AttachmentImage::initialize(DisplayVk *display
     VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
     ANGLE_TRY(image.initMemory(displayVk, renderer->getMemoryProperties(), flags));
 
+    imageViews.init(renderer);
+
     return angle::Result::Continue;
 }
 
@@ -216,6 +218,8 @@ angle::Result OffscreenSurfaceVk::AttachmentImage::initializeWithExternalMemory(
         displayVk, renderer->getMemoryProperties(), externalMemoryRequirements, nullptr,
         &importMemoryHostPointerInfo, VK_QUEUE_FAMILY_EXTERNAL, flags));
 
+    imageViews.init(renderer);
+
     return angle::Result::Continue;
 }
 
@@ -228,7 +232,7 @@ void OffscreenSurfaceVk::AttachmentImage::destroy(const egl::Display *display)
     imageViews.release(renderer);
 }
 
-OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState)
+OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState, RendererVk *renderer)
     : SurfaceVk(surfaceState),
       mWidth(mState.attributes.getAsInt(EGL_WIDTH, 0)),
       mHeight(mState.attributes.getAsInt(EGL_HEIGHT, 0)),
@@ -547,6 +551,9 @@ angle::Result WindowSurfaceVk::initializeImpl(DisplayVk *displayVk)
 {
     RendererVk *renderer = displayVk->getRenderer();
 
+    mColorImageMSViews.init(renderer);
+    mDepthStencilImageViews.init(renderer);
+
     renderer->reloadVolkIfNeeded();
 
     gl::Extents windowSize;
@@ -946,6 +953,7 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
     {
         SwapchainImage &member = mSwapchainImages[imageIndex];
         member.image.init2DWeakReference(context, swapchainImages[imageIndex], extents, format, 1);
+        member.imageViews.init(renderer);
     }
 
     // Initialize depth/stencil if requested.

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -42,7 +42,7 @@ class SurfaceVk : public SurfaceImpl, public angle::ObserverInterface
 class OffscreenSurfaceVk : public SurfaceVk
 {
   public:
-    OffscreenSurfaceVk(const egl::SurfaceState &surfaceState);
+    OffscreenSurfaceVk(const egl::SurfaceState &surfaceState, RendererVk *renderer);
     ~OffscreenSurfaceVk() override;
 
     egl::Error initialize(const egl::Display *display) override;

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -1247,14 +1247,18 @@ void TextureVk::setImageHelper(ContextVk *contextVk,
     }
     mRenderTargets.clear();
 
+    RendererVk *renderer = contextVk->getRenderer();
+
     updateSerial(contextVk);
+    mImageViews.init(renderer);
 }
 
 void TextureVk::updateImageHelper(ContextVk *contextVk, size_t imageCopyBufferAlignment)
 {
+    RendererVk *renderer = contextVk->getRenderer();
     ASSERT(mImage != nullptr);
-    mImage->initStagingBuffer(contextVk->getRenderer(), imageCopyBufferAlignment,
-                              vk::kStagingBufferFlags, mStagingBufferInitialSize);
+    mImage->initStagingBuffer(renderer, imageCopyBufferAlignment, vk::kStagingBufferFlags,
+                              mStagingBufferInitialSize);
 }
 
 angle::Result TextureVk::redefineLevel(const gl::Context *context,
@@ -1835,6 +1839,10 @@ angle::Result TextureVk::getAttachmentRenderTarget(const gl::Context *context,
     {
         ASSERT(mState.getBaseLevelDesc().samples <= 1);
 
+        // Ensure the view serial is valid.
+        RendererVk *renderer = contextVk->getRenderer();
+        mMultisampledImageViews.init(renderer);
+
         // The image is used as either color or depth/stencil attachment.  Additionally, its memory
         // is lazily allocated as the contents are discarded at the end of the renderpass and with
         // tiling GPUs no actual backing memory is required.
@@ -1866,8 +1874,8 @@ angle::Result TextureVk::getAttachmentRenderTarget(const gl::Context *context,
             VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
             (hasLazilyAllocatedMemory ? VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT : 0);
 
-        ANGLE_TRY(mMultisampledImage.initMemory(
-            contextVk, contextVk->getRenderer()->getMemoryProperties(), kMultisampledMemoryFlags));
+        ANGLE_TRY(mMultisampledImage.initMemory(contextVk, renderer->getMemoryProperties(),
+                                                kMultisampledMemoryFlags));
 
         // Remove the emulated format clear from the multisampled image if any.  There is one
         // already staged on the resolve image if needed.

src/libANGLE/renderer/vulkan/mac/DisplayVkMac.mm

@@ -43,7 +43,7 @@ SurfaceImpl *DisplayVkMac::createPbufferFromClientBuffer(const egl::SurfaceState
 {
     ASSERT(buftype == EGL_IOSURFACE_ANGLE);
 
-    return new IOSurfaceSurfaceVkMac(state, clientBuffer, attribs);
+    return new IOSurfaceSurfaceVkMac(state, clientBuffer, attribs, mRenderer);
 }
 
 egl::ConfigSet DisplayVkMac::generateConfigs()

src/libANGLE/renderer/vulkan/mac/IOSurfaceSurfaceVkMac.h

@@ -28,7 +28,8 @@ class IOSurfaceSurfaceVkMac : public OffscreenSurfaceVk
   public:
     IOSurfaceSurfaceVkMac(const egl::SurfaceState &state,
                           EGLClientBuffer buffer,
-                          const egl::AttributeMap &attribs);
+                          const egl::AttributeMap &attribs,
+                          RendererVk *renderer);
     ~IOSurfaceSurfaceVkMac() override;
 
     egl::Error initialize(const egl::Display *display) override;

src/libANGLE/renderer/vulkan/mac/IOSurfaceSurfaceVkMac.mm

@@ -63,8 +63,9 @@ int FindIOSurfaceFormatIndex(GLenum internalFormat, GLenum type)
 
 IOSurfaceSurfaceVkMac::IOSurfaceSurfaceVkMac(const egl::SurfaceState &state,
                                              EGLClientBuffer buffer,
-                                             const egl::AttributeMap &attribs)
-    : OffscreenSurfaceVk(state), mIOSurface(nullptr), mPlane(0), mFormatIndex(-1)
+                                             const egl::AttributeMap &attribs,
+                                             RendererVk *renderer)
+    : OffscreenSurfaceVk(state, renderer), mIOSurface(nullptr), mPlane(0), mFormatIndex(-1)
 {
     // Keep reference to the IOSurface so it doesn't get deleted while the pbuffer exists.
     mIOSurface = reinterpret_cast<IOSurfaceRef>(buffer);

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -1800,59 +1800,59 @@ FramebufferDesc::~FramebufferDesc()                            = default;
 FramebufferDesc::FramebufferDesc(const FramebufferDesc &other) = default;
 FramebufferDesc &FramebufferDesc::operator=(const FramebufferDesc &other) = default;
 
-void FramebufferDesc::update(uint32_t index, ImageViewSerial serial)
+void FramebufferDesc::update(uint32_t index, ImageViewSubresourceSerial serial)
 {
     ASSERT(index < kMaxFramebufferAttachments);
     mSerials[index] = serial;
-    if (serial.valid())
+    if (serial.imageViewSerial.valid())
     {
-        mMaxValidSerialIndex = std::max(mMaxValidSerialIndex, index);
+        mMaxIndex = std::max(mMaxIndex, index + 1);
     }
 }
 
-void FramebufferDesc::updateColor(uint32_t index, ImageViewSerial serial)
+void FramebufferDesc::updateColor(uint32_t index, ImageViewSubresourceSerial serial)
 {
     update(kFramebufferDescColorIndexOffset + index, serial);
 }
 
-void FramebufferDesc::updateColorResolve(uint32_t index, ImageViewSerial serial)
+void FramebufferDesc::updateColorResolve(uint32_t index, ImageViewSubresourceSerial serial)
 {
     update(kFramebufferDescResolveIndexOffset + index, serial);
 }
 
-void FramebufferDesc::updateDepthStencil(ImageViewSerial serial)
+void FramebufferDesc::updateDepthStencil(ImageViewSubresourceSerial serial)
 {
     update(kFramebufferDescDepthStencilIndex, serial);
 }
 
 size_t FramebufferDesc::hash() const
 {
-    return angle::ComputeGenericHash(&mSerials, sizeof(mSerials[0]) * (mMaxValidSerialIndex + 1));
+    return angle::ComputeGenericHash(&mSerials, sizeof(mSerials[0]) * (mMaxIndex + 1));
 }
 
 void FramebufferDesc::reset()
 {
+    mMaxIndex = 0;
     memset(&mSerials, 0, sizeof(mSerials));
-    mMaxValidSerialIndex = 0;
 }
 
 bool FramebufferDesc::operator==(const FramebufferDesc &other) const
 {
-    if (mMaxValidSerialIndex != other.mMaxValidSerialIndex)
+    if (mMaxIndex != other.mMaxIndex)
     {
         return false;
     }
 
-    return memcmp(&mSerials, &other.mSerials, sizeof(mSerials[0]) * (mMaxValidSerialIndex + 1)) ==
-           0;
+    size_t validRegionSize = sizeof(mSerials[0]) * mMaxIndex;
+    return memcmp(&mSerials, &other.mSerials, validRegionSize) == 0;
 }
 
 uint32_t FramebufferDesc::attachmentCount() const
 {
     uint32_t count = 0;
-    for (const ImageViewSerial &serial : mSerials)
+    for (const ImageViewSubresourceSerial &serial : mSerials)
     {
-        if (serial.valid())
+        if (serial.imageViewSerial.valid())
         {
             count++;
         }

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -787,6 +787,18 @@ class PipelineHelper final : angle::NonCopyable
 
 ANGLE_INLINE PipelineHelper::PipelineHelper(Pipeline &&pipeline) : mPipeline(std::move(pipeline)) {}
 
+struct ImageViewSubresourceSerial
+{
+    ImageViewSerial imageViewSerial;
+    uint16_t level;
+    uint16_t layer;
+};
+
+static_assert(sizeof(ImageViewSubresourceSerial) == sizeof(uint64_t), "Size mismatch");
+
+constexpr ImageViewSubresourceSerial kInvalidImageViewSubresourceSerial = {kInvalidImageViewSerial,
+                                                                           0, 0};
+
 class TextureDescriptorDesc
 {
   public:
@@ -867,9 +879,9 @@ class FramebufferDesc
     FramebufferDesc(const FramebufferDesc &other);
     FramebufferDesc &operator=(const FramebufferDesc &other);
 
-    void updateColor(uint32_t index, ImageViewSerial serial);
-    void updateColorResolve(uint32_t index, ImageViewSerial serial);
-    void updateDepthStencil(ImageViewSerial serial);
+    void updateColor(uint32_t index, ImageViewSubresourceSerial serial);
+    void updateColorResolve(uint32_t index, ImageViewSubresourceSerial serial);
+    void updateDepthStencil(ImageViewSubresourceSerial serial);
     size_t hash() const;
     void reset();
 
@@ -878,22 +890,11 @@ class FramebufferDesc
     uint32_t attachmentCount() const;
 
   private:
-    void update(uint32_t index, ImageViewSerial serial);
-
-    FramebufferAttachmentArray<ImageViewSerial> mSerials;
-    uint32_t mMaxValidSerialIndex;
-};
-
-// Layer/level pair type used to index into Serial Cache in ImageViewHelper
-struct LayerLevel
-{
-    uint32_t layer;
-    uint32_t level;
+    void update(uint32_t index, ImageViewSubresourceSerial serial);
 
-    bool operator==(const LayerLevel &other) const
-    {
-        return layer == other.layer && level == other.level;
-    }
+    // Note: this is an exclusive index. If there is one index it will be "1".
+    uint32_t mMaxIndex;
+    FramebufferAttachmentArray<ImageViewSubresourceSerial> mSerials;
 };
 }  // namespace vk
 }  // namespace rx
@@ -955,20 +956,6 @@ struct hash<rx::vk::SamplerDesc>
     size_t operator()(const rx::vk::SamplerDesc &key) const { return key.hash(); }
 };
 
-template <>
-struct hash<rx::vk::LayerLevel>
-{
-    size_t operator()(const rx::vk::LayerLevel &layerLevel) const
-    {
-        // The left-shift by 11 was found to produce unique hash values
-        // in a [0..1000][0..2048] space for layer/level
-        // Make sure that layer/level hash bits don't overlap or overflow
-        ASSERT((layerLevel.layer & 0x000007FF) == layerLevel.layer);
-        ASSERT((layerLevel.level & 0xFFE00000) == 0);
-        return layerLevel.layer | (layerLevel.level << 11);
-    }
-};
-
 // See Resource Serial types defined in vk_utils.h.
 #define ANGLE_HASH_VK_SERIAL(Type)                                                          \
     template <>                                                                             \

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -5004,7 +5004,7 @@ ImageViewHelper::ImageViewHelper(ImageViewHelper &&other)
     std::swap(mPerLevelStencilReadImageViews, other.mPerLevelStencilReadImageViews);
     std::swap(mLevelDrawImageViews, other.mLevelDrawImageViews);
     std::swap(mLayerLevelDrawImageViews, other.mLayerLevelDrawImageViews);
-    std::swap(mSerialCache, other.mSerialCache);
+    std::swap(mImageViewSerial, other.mImageViewSerial);
 }
 
 ImageViewHelper::~ImageViewHelper()
@@ -5012,6 +5012,14 @@ ImageViewHelper::~ImageViewHelper()
     mUse.release();
 }
 
+void ImageViewHelper::init(RendererVk *renderer)
+{
+    if (!mImageViewSerial.valid())
+    {
+        mImageViewSerial = renderer->getResourceSerialFactory().generateImageViewSerial();
+    }
+}
+
 void ImageViewHelper::release(RendererVk *renderer)
 {
     std::vector<GarbageObject> garbage;
@@ -5049,7 +5057,8 @@ void ImageViewHelper::release(RendererVk *renderer)
         mUse.init();
     }
 
-    mSerialCache.clear();
+    // Update image view serial.
+    mImageViewSerial = renderer->getResourceSerialFactory().generateImageViewSerial();
 }
 
 void ImageViewHelper::destroy(VkDevice device)
@@ -5076,7 +5085,7 @@ void ImageViewHelper::destroy(VkDevice device)
     }
     mLayerLevelDrawImageViews.clear();
 
-    mSerialCache.clear();
+    mImageViewSerial = vk::kInvalidImageViewSerial;
 }
 
 angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
@@ -5105,19 +5114,21 @@ angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
     }
     mCurrentMaxLevel = levelCount - 1;
 
-    // Determine if we already have ImageView's for the new max level
-    if (getReadImageView().getHandle() == VK_NULL_HANDLE)
+    // Determine if we already have ImageViews for the new max level
+    if (getReadImageView().valid())
     {
-        // Since we don't have a readImageView, we must create ImageView's for the new max level
-        ANGLE_TRY(initReadViewsImpl(contextVk, viewType, image, format, formatSwizzle, readSwizzle,
-                                    baseLevel, levelCount, baseLayer, layerCount));
+        return angle::Result::Continue;
+    }
 
-        if (requiresSRGBViews)
-        {
-            ANGLE_TRY(initSRGBReadViewsImpl(contextVk, viewType, image, format, formatSwizzle,
-                                            readSwizzle, baseLevel, levelCount, baseLayer,
-                                            layerCount, imageUsageFlags));
-        }
+    // Since we don't have a readImageView, we must create ImageViews for the new max level
+    ANGLE_TRY(initReadViewsImpl(contextVk, viewType, image, format, formatSwizzle, readSwizzle,
+                                baseLevel, levelCount, baseLayer, layerCount));
+
+    if (requiresSRGBViews)
+    {
+        ANGLE_TRY(initSRGBReadViewsImpl(contextVk, viewType, image, format, formatSwizzle,
+                                        readSwizzle, baseLevel, levelCount, baseLayer, layerCount,
+                                        imageUsageFlags));
     }
 
     return angle::Result::Continue;
@@ -5134,6 +5145,8 @@ angle::Result ImageViewHelper::initReadViewsImpl(ContextVk *contextVk,
                                                  uint32_t baseLayer,
                                                  uint32_t layerCount)
 {
+    ASSERT(mImageViewSerial.valid());
+
     const VkImageAspectFlags aspectFlags = GetFormatAspectFlags(format.intendedFormat());
     mLinearColorspace                    = IsLinearFormat(format.vkImageFormat);
 
@@ -5262,6 +5275,8 @@ angle::Result ImageViewHelper::getLevelDrawImageView(ContextVk *contextVk,
                                                      VkFormat vkImageFormat,
                                                      const ImageView **imageViewOut)
 {
+    ASSERT(mImageViewSerial.valid());
+
     retain(&contextVk->getResourceUseList());
 
     ImageView *imageView = GetLevelImageView(&mLevelDrawImageViews, levelVK, image.getLevelCount());
@@ -5285,6 +5300,7 @@ angle::Result ImageViewHelper::getLevelLayerDrawImageView(ContextVk *contextVk,
                                                           const ImageView **imageViewOut)
 {
     ASSERT(image.valid());
+    ASSERT(mImageViewSerial.valid());
     ASSERT(!image.getFormat().actualImageFormat().isBlock);
 
     retain(&contextVk->getResourceUseList());
@@ -5315,17 +5331,15 @@ angle::Result ImageViewHelper::getLevelLayerDrawImageView(ContextVk *contextVk,
                                     imageView, levelVK, 1, layer, 1);
 }
 
-ImageViewSerial ImageViewHelper::getAssignSerial(ContextVk *contextVk,
-                                                 uint32_t levelGL,
-                                                 uint32_t layer)
+ImageViewSubresourceSerial ImageViewHelper::getSubresourceSerial(uint32_t levelGL, uint32_t layer)
 {
-    LayerLevel layerLevelPair = {layer, levelGL};
-    if (mSerialCache.find(layerLevelPair) == mSerialCache.end())
-    {
-        vk::ResourceSerialFactory &factory = contextVk->getRenderer()->getResourceSerialFactory();
-        mSerialCache[layerLevelPair]       = factory.generateImageViewSerial();
-    }
-    return mSerialCache[layerLevelPair];
+    ASSERT(mImageViewSerial.valid());
+
+    ImageViewSubresourceSerial serial;
+    serial.imageViewSerial = mImageViewSerial;
+    SetBitField(serial.level, levelGL);
+    SetBitField(serial.layer, layer);
+    return serial;
 }
 
 // SamplerHelper implementation.

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -1595,6 +1595,7 @@ class ImageViewHelper : angle::NonCopyable
     ImageViewHelper(ImageViewHelper &&other);
     ~ImageViewHelper();
 
+    void init(RendererVk *renderer);
     void release(RendererVk *renderer);
     void destroy(VkDevice device);
 
@@ -1715,8 +1716,8 @@ class ImageViewHelper : angle::NonCopyable
                                              uint32_t layer,
                                              const ImageView **imageViewOut);
 
-    // Return unique Serial for this imageView, first assigning it if it hasn't yet been set
-    ImageViewSerial getAssignSerial(ContextVk *contextVk, uint32_t levelGL, uint32_t layer);
+    // Return unique Serial for an imageView.
+    ImageViewSubresourceSerial getSubresourceSerial(uint32_t levelGL, uint32_t layer);
 
   private:
     ImageView &getReadImageView()
@@ -1805,8 +1806,8 @@ class ImageViewHelper : angle::NonCopyable
     ImageViewVector mLevelDrawImageViews;
     LayerLevelImageViewVector mLayerLevelDrawImageViews;
 
-    // Store Serials per layer/level of imageView
-    std::unordered_map<LayerLevel, ImageViewSerial> mSerialCache;
+    // Serial for the image view set. getSubresourceSerial combines it with subresource info.
+    ImageViewSerial mImageViewSerial;
 };
 
 // The SamplerHelper allows a Sampler to be coupled with a resource lifetime.