Vulkan: Add "ImageViewHelper".

This allows views to track a different lifetime than vk::ImageHelper.
This in turn will fix the race condition on ContextVk destruction when
releasing ImageViews owned by TextureVk and RenderbufferVk. For now
this is a refactoring change only.

Bug: angleproject:2464
Change-Id: I9581975bd5d4913233bbed8439dd4a632cc78a2a
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1843231
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>

Author: null77

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -1472,8 +1472,8 @@ angle::Result ProgramVk::updateImagesDescriptorSet(ContextVk *contextVk,
             vk::ImageHelper *image         = &textureVk->getImage();
             const vk::ImageView *imageView = nullptr;
 
-            ANGLE_TRY(textureVk->getLayerLevelStorageImageView(
-                contextVk, (binding.layered == GL_TRUE), binding.layer, binding.level, &imageView));
+            ANGLE_TRY(textureVk->getStorageImageView(contextVk, (binding.layered == GL_TRUE),
+                                                     binding.level, binding.layer, &imageView));
 
             // Note: binding.access is unused because it is implied by the shader.
 

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -91,6 +91,9 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     uint32_t mLayerIndex;
 };
 
+// A vector of rendertargets
+using RenderTargetVector = std::vector<RenderTargetVk>;
+
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -78,17 +78,13 @@ angle::Result RenderbufferVk::setStorageImpl(const gl::Context *context,
         VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         ANGLE_TRY(mImage->initMemory(contextVk, renderer->getMemoryProperties(), flags));
 
-        VkImageAspectFlags aspect = vk::GetFormatAspectFlags(textureFormat);
-
-        // Note that LUMA textures are not color-renderable, so a read-view with swizzle is not
-        // needed.
-        ANGLE_TRY(mImage->initImageView(contextVk, gl::TextureType::_2D, aspect, gl::SwizzleState(),
-                                        &mImageView, 0, 1));
+        const vk::ImageView *imageView = nullptr;
+        ANGLE_TRY(mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, 0, 0, &imageView));
 
         // Clear the renderbuffer if it has emulated channels.
         mImage->stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), vkFormat);
 
-        mRenderTarget.init(mImage, &mImageView, 0, 0);
+        mRenderTarget.init(mImage, imageView, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -176,11 +172,11 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
                                         imageVk->getImage()->getSamples());
     }
 
-    ANGLE_TRY(mImage->initLayerImageView(contextVk, viewType, aspect, gl::SwizzleState(),
-                                         &mImageView, imageVk->getImageLevel(), 1,
-                                         imageVk->getImageLayer(), 1));
+    const vk::ImageView *imageView = nullptr;
+    ANGLE_TRY(mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, imageVk->getImageLevel(),
+                                                     imageVk->getImageLayer(), &imageView));
 
-    mRenderTarget.init(mImage, &mImageView, imageVk->getImageLevel(), imageVk->getImageLayer());
+    mRenderTarget.init(mImage, imageView, imageVk->getImageLevel(), imageVk->getImageLayer());
 
     return angle::Result::Continue;
 }
@@ -232,7 +228,7 @@ void RenderbufferVk::releaseImage(ContextVk *contextVk)
         mImage = nullptr;
     }
 
-    contextVk->addGarbage(&mImageView);
+    mImageViews.release(contextVk);
 }
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/RenderbufferVk.h

@@ -60,7 +60,7 @@ class RenderbufferVk : public RenderbufferImpl
 
     bool mOwnsImage;
     vk::ImageHelper *mImage;
-    vk::ImageView mImageView;
+    vk::ImageViewHelper mImageViews;
     RenderTargetVk mRenderTarget;
 };
 

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -148,11 +148,7 @@ angle::Result OffscreenSurfaceVk::AttachmentImage::initialize(DisplayVk *display
 
     VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
     ANGLE_TRY(image.initMemory(displayVk, renderer->getMemoryProperties(), flags));
-
-    VkImageAspectFlags aspect = vk::GetFormatAspectFlags(textureFormat);
-
-    ANGLE_TRY(image.initImageView(displayVk, gl::TextureType::_2D, aspect, gl::SwizzleState(),
-                                  &imageView, 0, 1));
+    ANGLE_TRY(imageViews.getLevelLayerDrawImageView(displayVk, image, 0, 0, &drawView));
 
     // Clear the image if it has emulated channels.
     image.stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), vkFormat);
@@ -169,18 +165,14 @@ void OffscreenSurfaceVk::AttachmentImage::destroy(const egl::Display *display)
     // destruction. If this assumption is incorrect, we could use the last submit serial
     // to determine when to destroy the surface.
     image.destroy(device);
-    imageView.destroy(device);
+    imageViews.destroy(device);
 }
 
 OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState,
                                        EGLint width,
                                        EGLint height)
     : SurfaceVk(surfaceState), mWidth(width), mHeight(height)
-{
-    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageView, 0, 0);
-    mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
-                                   &mDepthStencilAttachment.imageView, 0, 0);
-}
+{}
 
 OffscreenSurfaceVk::~OffscreenSurfaceVk() {}
 
@@ -203,12 +195,15 @@ angle::Result OffscreenSurfaceVk::initializeImpl(DisplayVk *displayVk)
     {
         ANGLE_TRY(mColorAttachment.initialize(
             displayVk, mWidth, mHeight, renderer->getFormat(config->renderTargetFormat), samples));
+        mColorRenderTarget.init(&mColorAttachment.image, mColorAttachment.drawView, 0, 0);
     }
 
     if (config->depthStencilFormat != GL_NONE)
     {
         ANGLE_TRY(mDepthStencilAttachment.initialize(
             displayVk, mWidth, mHeight, renderer->getFormat(config->depthStencilFormat), samples));
+        mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
+                                       mDepthStencilAttachment.drawView, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -363,7 +358,7 @@ SwapchainImage::~SwapchainImage() = default;
 
 SwapchainImage::SwapchainImage(SwapchainImage &&other)
     : image(std::move(other.image)),
-      imageView(std::move(other.imageView)),
+      imageViews(std::move(other.imageViews)),
       framebuffer(std::move(other.framebuffer)),
       presentHistory(std::move(other.presentHistory)),
       currentPresentHistoryIndex(other.currentPresentHistoryIndex)
@@ -405,12 +400,7 @@ WindowSurfaceVk::WindowSurfaceVk(const egl::SurfaceState &surfaceState,
       mCompositeAlpha(VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR),
       mCurrentSwapHistoryIndex(0),
       mCurrentSwapchainImageIndex(0)
-{
-    // Initialize the color render target with the multisampled targets.  If not multisampled, the
-    // render target will be updated to refer to a swapchain image on every acquire.
-    mColorRenderTarget.init(&mColorImageMS, &mColorImageViewMS, 0, 0);
-    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, 0, 0);
-}
+{}
 
 WindowSurfaceVk::~WindowSurfaceVk()
 {
@@ -776,9 +766,13 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
         ANGLE_TRY(mColorImageMS.initMemory(context, renderer->getMemoryProperties(),
                                            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT));
 
-        ANGLE_TRY(mColorImageMS.initImageView(context, gl::TextureType::_2D,
-                                              VK_IMAGE_ASPECT_COLOR_BIT, gl::SwizzleState(),
-                                              &mColorImageViewMS, 0, 1));
+        const vk::ImageView *msDrawView = nullptr;
+        ANGLE_TRY(mColorImageMSViews.getLevelLayerDrawImageView(context, mColorImageMS, 0, 0,
+                                                                &msDrawView));
+
+        // Initialize the color render target with the multisampled targets.  If not multisampled,
+        // the render target will be updated to refer to a swapchain image on every acquire.
+        mColorRenderTarget.init(&mColorImageMS, msDrawView, 0, 0);
 
         // Clear the image if it has emulated channels.
         mColorImageMS.stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), format);
@@ -796,9 +790,8 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
             // If the multisampled image is used, we don't need a view on the swapchain image, as
             // it's only used as a resolve destination.  This has the added benefit that we can't
             // accidentally use this image.
-            ANGLE_TRY(member.image.initImageView(context, gl::TextureType::_2D,
-                                                 VK_IMAGE_ASPECT_COLOR_BIT, gl::SwizzleState(),
-                                                 &member.imageView, 0, 1));
+            ANGLE_TRY(member.imageViews.getLevelLayerDrawImageView(context, member.image, 0, 0,
+                                                                   &member.drawView));
 
             // Clear the image if it has emulated channels.  If a multisampled image exists, this
             // image will be unused until a pre-present resolve, at which point it will be fully
@@ -819,11 +812,11 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
         ANGLE_TRY(mDepthStencilImage.initMemory(context, renderer->getMemoryProperties(),
                                                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT));
 
-        const VkImageAspectFlags aspect = vk::GetDepthStencilAspectFlags(dsFormat.imageFormat());
+        const vk::ImageView *dsDrawView = nullptr;
+        ANGLE_TRY(mDepthStencilImageViews.getLevelLayerDrawImageView(context, mDepthStencilImage, 0,
+                                                                     0, &dsDrawView));
 
-        ANGLE_TRY(mDepthStencilImage.initImageView(context, gl::TextureType::_2D, aspect,
-                                                   gl::SwizzleState(), &mDepthStencilImageView, 0,
-                                                   1));
+        mDepthStencilRenderTarget.init(&mDepthStencilImage, dsDrawView, 0, 0);
 
         // We will need to pass depth/stencil image views to the RenderTargetVk in the future.
 
@@ -893,19 +886,14 @@ void WindowSurfaceVk::releaseSwapchainImages(ContextVk *contextVk)
     {
         mDepthStencilImage.releaseImage(renderer);
         mDepthStencilImage.releaseStagingBuffer(renderer);
-
-        if (mDepthStencilImageView.valid())
-        {
-            contextVk->addGarbage(&mDepthStencilImageView);
-        }
+        mDepthStencilImageViews.release(contextVk);
     }
 
     if (mColorImageMS.valid())
     {
         mColorImageMS.releaseImage(renderer);
         mColorImageMS.releaseStagingBuffer(renderer);
-
-        contextVk->addGarbage(&mColorImageViewMS);
+        mColorImageMSViews.release(contextVk);
         contextVk->addGarbage(&mFramebufferMS);
     }
 
@@ -915,7 +903,7 @@ void WindowSurfaceVk::releaseSwapchainImages(ContextVk *contextVk)
         swapchainImage.image.resetImageWeakReference();
         swapchainImage.image.destroy(contextVk->getDevice());
 
-        contextVk->addGarbage(&swapchainImage.imageView);
+        swapchainImage.imageViews.release(contextVk);
         contextVk->addGarbage(&swapchainImage.framebuffer);
 
         // present history must have already been taken care of.
@@ -934,17 +922,17 @@ void WindowSurfaceVk::destroySwapChainImages(DisplayVk *displayVk)
     VkDevice device = displayVk->getDevice();
 
     mDepthStencilImage.destroy(device);
-    mDepthStencilImageView.destroy(device);
+    mDepthStencilImageViews.destroy(device);
     mColorImageMS.destroy(device);
-    mColorImageViewMS.destroy(device);
+    mColorImageMSViews.destroy(device);
     mFramebufferMS.destroy(device);
 
     for (SwapchainImage &swapchainImage : mSwapchainImages)
     {
         // We don't own the swapchain image handles, so we just remove our reference to it.
         swapchainImage.image.resetImageWeakReference();
         swapchainImage.image.destroy(device);
-        swapchainImage.imageView.destroy(device);
+        swapchainImage.imageViews.destroy(device);
         swapchainImage.framebuffer.destroy(device);
 
         for (ImagePresentHistory &presentHistory : swapchainImage.presentHistory)
@@ -1198,7 +1186,7 @@ VkResult WindowSurfaceVk::nextSwapchainImage(vk::Context *context)
     // multisampling, as the swapchain image is essentially unused until then.
     if (!mColorImageMS.valid())
     {
-        mColorRenderTarget.updateSwapchainImage(&image.image, &image.imageView);
+        mColorRenderTarget.updateSwapchainImage(&image.image, image.drawView);
     }
 
     return VK_SUCCESS;
@@ -1313,7 +1301,12 @@ angle::Result WindowSurfaceVk::getCurrentFramebuffer(vk::Context *context,
     VkFramebufferCreateInfo framebufferInfo = {};
 
     const gl::Extents extents             = mColorRenderTarget.getExtents();
-    std::array<VkImageView, 2> imageViews = {{VK_NULL_HANDLE, mDepthStencilImageView.getHandle()}};
+    std::array<VkImageView, 2> imageViews = {};
+
+    if (mDepthStencilImage.valid())
+    {
+        imageViews[1] = mDepthStencilRenderTarget.getDrawImageView()->getHandle();
+    }
 
     framebufferInfo.sType           = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     framebufferInfo.flags           = 0;
@@ -1327,14 +1320,14 @@ angle::Result WindowSurfaceVk::getCurrentFramebuffer(vk::Context *context,
     if (isMultiSampled())
     {
         // If multisampled, there is only a single color image and framebuffer.
-        imageViews[0] = mColorImageViewMS.getHandle();
+        imageViews[0] = mColorRenderTarget.getDrawImageView()->getHandle();
         ANGLE_VK_TRY(context, mFramebufferMS.init(context->getDevice(), framebufferInfo));
     }
     else
     {
         for (SwapchainImage &swapchainImage : mSwapchainImages)
         {
-            imageViews[0] = swapchainImage.imageView.getHandle();
+            imageViews[0] = swapchainImage.drawView->getHandle();
             ANGLE_VK_TRY(context,
                          swapchainImage.framebuffer.init(context->getDevice(), framebufferInfo));
         }
@@ -1399,7 +1392,7 @@ angle::Result WindowSurfaceVk::updateAndDrawOverlay(ContextVk *contextVk,
     }
 
     // Draw overlay
-    ANGLE_TRY(overlayVk->onPresent(contextVk, &image->image, &image->imageView));
+    ANGLE_TRY(overlayVk->onPresent(contextVk, &image->image, image->drawView));
 
     overlay->getRunningGraphWidget(gl::WidgetId::VulkanCommandGraphSize)->next();
 

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -88,7 +88,8 @@ class OffscreenSurfaceVk : public SurfaceVk
         void destroy(const egl::Display *display);
 
         vk::ImageHelper image;
-        vk::ImageView imageView;
+        vk::ImageViewHelper imageViews;
+        const vk::ImageView *drawView = nullptr;
     };
 
     angle::Result initializeImpl(DisplayVk *displayVk);
@@ -162,7 +163,8 @@ struct SwapchainImage : angle::NonCopyable
     ~SwapchainImage();
 
     vk::ImageHelper image;
-    vk::ImageView imageView;
+    vk::ImageViewHelper imageViews;
+    const vk::ImageView *drawView = nullptr;
     vk::Framebuffer framebuffer;
 
     // A circular array of semaphores used for presenting this image.
@@ -286,11 +288,11 @@ class WindowSurfaceVk : public SurfaceVk
 
     // Depth/stencil image.  Possibly multisampled.
     vk::ImageHelper mDepthStencilImage;
-    vk::ImageView mDepthStencilImageView;
+    vk::ImageViewHelper mDepthStencilImageViews;
 
     // Multisample color image, view and framebuffer, if multisampling enabled.
     vk::ImageHelper mColorImageMS;
-    vk::ImageView mColorImageViewMS;
+    vk::ImageViewHelper mColorImageMSViews;
     vk::Framebuffer mFramebufferMS;
 };