Vulkan: Store ImageView access in the graph.

null77 · Commit Bot · commit 68591effc086 · 2019-10-21T00:44:25.000Z
This will ensure we don't destroy the image views when they are still in use by other Contexts. Bug: angleproject:2464 Change-Id: I1d3ba2ad241250e31ea32873446c4cb23971750d Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1843236 Reviewed-by: Tim Van Patten <timvp@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/src/libANGLE/renderer/vulkan/CommandGraph.h b/src/libANGLE/renderer/vulkan/CommandGraph.h
@@ -717,7 +717,9 @@ ANGLE_INLINE bool CommandGraphResource::hasChildlessWritingNode() const
 // CommandGraph inlines.
 ANGLE_INLINE void CommandGraph::onResourceUse(const SharedResourceUse &resourceUse)
 {
-    ASSERT(!empty());
+    // Disabled the assert because of difficulties with ImageView references.
+    // TODO(jmadill): Clean up with graph redesign. http://anglebug.com/4029
+    // ASSERT(!empty());
     SharedResourceUse newUse;
     newUse.set(resourceUse);
     mResourceUses.emplace_back(std::move(newUse));
diff --git a/src/libANGLE/renderer/vulkan/ContextVk.cpp b/src/libANGLE/renderer/vulkan/ContextVk.cpp
@@ -2959,6 +2959,7 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context,
             image.changeLayout(aspectFlags, textureLayout, srcLayoutChange);
         }
 
+        textureVk->onImageViewGraphAccess(&mCommandGraph);
         image.addReadDependency(this, recorder);
 
         mActiveTextures[textureUnit].texture = textureVk;
diff --git a/src/libANGLE/renderer/vulkan/FramebufferVk.cpp b/src/libANGLE/renderer/vulkan/FramebufferVk.cpp
@@ -823,6 +823,7 @@ angle::Result FramebufferVk::blit(const gl::Context *context,
         {
             const vk::ImageView *readImageView = nullptr;
             ANGLE_TRY(readRenderTarget->getImageView(contextVk, &readImageView));
+            readRenderTarget->onImageViewGraphAccess(contextVk);
             ANGLE_TRY(utilsVk.colorBlitResolve(contextVk, this, &readRenderTarget->getImage(),
                                                readImageView, params));
         }
@@ -1578,10 +1579,12 @@ angle::Result FramebufferVk::readPixelsImpl(ContextVk *contextVk,
 
 gl::Extents FramebufferVk::getReadImageExtents() const
 {
-    ASSERT(getColorReadRenderTarget()->getExtents().width == mState.getDimensions().width);
-    ASSERT(getColorReadRenderTarget()->getExtents().height == mState.getDimensions().height);
+    RenderTargetVk *readRenderTarget = mRenderTargetCache.getColorRead(mState);
 
-    return getColorReadRenderTarget()->getExtents();
+    ASSERT(readRenderTarget->getExtents().width == mState.getDimensions().width);
+    ASSERT(readRenderTarget->getExtents().height == mState.getDimensions().height);
+
+    return readRenderTarget->getExtents();
 }
 
 gl::Rectangle FramebufferVk::getCompleteRenderArea() const
diff --git a/src/libANGLE/renderer/vulkan/ProgramVk.cpp b/src/libANGLE/renderer/vulkan/ProgramVk.cpp
@@ -1648,16 +1648,23 @@ angle::Result ProgramVk::updateTexturesDescriptorSet(ContextVk *contextVk)
             VkDescriptorImageInfo &imageInfo = descriptorImageInfo[writeCount];
 
             // Use bound sampler object if one present, otherwise use texture's sampler
-            imageInfo.sampler = (samplerVk != nullptr) ? samplerVk->getSampler().getHandle()
-                                                       : textureVk->getSampler().getHandle();
-            imageInfo.imageView   = textureVk->getReadImageView().getHandle();
+            const vk::Sampler &sampler =
+                (samplerVk != nullptr) ? samplerVk->getSampler() : textureVk->getSampler();
+
+            imageInfo.sampler     = sampler.getHandle();
             imageInfo.imageLayout = image.getCurrentLayout();
 
             if (emulateSeamfulCubeMapSampling)
             {
                 // If emulating seamful cubemapping, use the fetch image view.  This is basically
                 // the same image view as read, except it's a 2DArray view for cube maps.
-                imageInfo.imageView = textureVk->getFetchImageView().getHandle();
+                imageInfo.imageView =
+                    textureVk->getFetchImageViewAndRecordUse(contextVk).getHandle();
+            }
+            else
+            {
+                imageInfo.imageView =
+                    textureVk->getReadImageViewAndRecordUse(contextVk).getHandle();
             }
 
             VkWriteDescriptorSet &writeInfo = writeDescriptorInfo[writeCount];
diff --git a/src/libANGLE/renderer/vulkan/RenderTargetVk.cpp b/src/libANGLE/renderer/vulkan/RenderTargetVk.cpp
@@ -28,7 +28,12 @@ RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
       mImageViews(other.mImageViews),
       mLevelIndex(other.mLevelIndex),
       mLayerIndex(other.mLayerIndex)
-{}
+{
+    other.mImage      = nullptr;
+    other.mImageViews = nullptr;
+    other.mLevelIndex = 0;
+    other.mLayerIndex = 0;
+}
 
 void RenderTargetVk::init(vk::ImageHelper *image,
                           vk::ImageViewHelper *imageViews,
@@ -63,6 +68,8 @@ angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk,
     // Set up dependencies between the RT resource and the Framebuffer.
     mImage->addWriteDependency(contextVk, framebufferVk);
 
+    onImageViewGraphAccess(contextVk);
+
     return angle::Result::Continue;
 }
 
@@ -82,6 +89,8 @@ angle::Result RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk,
     // Set up dependencies between the RT resource and the Framebuffer.
     mImage->addWriteDependency(contextVk, framebufferVk);
 
+    onImageViewGraphAccess(contextVk);
+
     return angle::Result::Continue;
 }
 
@@ -147,9 +156,8 @@ vk::ImageHelper *RenderTargetVk::getImageForRead(ContextVk *contextVk,
     // However, this needs context to be available here, or all call sites changed
     // to perform the layout transition and set the dependency.
     mImage->addWriteDependency(contextVk, readingResource);
-
     mImage->changeLayout(mImage->getAspectFlags(), layout, commandBuffer);
-
+    onImageViewGraphAccess(contextVk);
     return mImage;
 }
 
@@ -158,6 +166,7 @@ vk::ImageHelper *RenderTargetVk::getImageForWrite(ContextVk *contextVk,
 {
     ASSERT(mImage && mImage->valid());
     mImage->addWriteDependency(contextVk, writingResource);
+    onImageViewGraphAccess(contextVk);
     return mImage;
 }
 
@@ -173,4 +182,8 @@ angle::Result RenderTargetVk::flushStagedUpdates(ContextVk *contextVk)
                                       mLayerIndex + 1, commandBuffer);
 }
 
+void RenderTargetVk::onImageViewGraphAccess(ContextVk *contextVk) const
+{
+    mImageViews->onGraphAccess(contextVk->getCommandGraph());
+}
 }  // namespace rx
diff --git a/src/libANGLE/renderer/vulkan/RenderTargetVk.h b/src/libANGLE/renderer/vulkan/RenderTargetVk.h
@@ -82,6 +82,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     angle::Result flushStagedUpdates(ContextVk *contextVk);
 
+    void onImageViewGraphAccess(ContextVk *contextVk) const;
+
   private:
     vk::ImageHelper *mImage;
     vk::ImageViewHelper *mImageViews;
diff --git a/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp b/src/libANGLE/renderer/vulkan/RenderbufferVk.cpp
@@ -210,10 +210,10 @@ void RenderbufferVk::releaseAndDeleteImage(ContextVk *contextVk)
 
 void RenderbufferVk::releaseImage(ContextVk *contextVk)
 {
+    RendererVk *renderer = contextVk->getRenderer();
+
     if (mImage && mOwnsImage)
     {
-        RendererVk *renderer = contextVk->getRenderer();
-
         mImage->releaseImage(renderer);
         mImage->releaseStagingBuffer(renderer);
     }
@@ -222,7 +222,7 @@ void RenderbufferVk::releaseImage(ContextVk *contextVk)
         mImage = nullptr;
     }
 
-    mImageViews.release(contextVk);
+    mImageViews.release(renderer);
 }
 
 }  // namespace rx
diff --git a/src/libANGLE/renderer/vulkan/RendererVk.h b/src/libANGLE/renderer/vulkan/RendererVk.h
@@ -170,7 +170,7 @@ class RendererVk : angle::NonCopyable
         CollectGarbage(&sharedGarbage, garbageIn...);
         if (!sharedGarbage.empty())
         {
-            mSharedGarbage.emplace_back(std::move(*use), std::move(sharedGarbage));
+            collectGarbage(std::move(*use), std::move(sharedGarbage));
         }
         else
         {
@@ -181,6 +181,11 @@ class RendererVk : angle::NonCopyable
         use->init();
     }
 
+    void collectGarbage(vk::SharedResourceUse &&use, std::vector<vk::GarbageObject> &&sharedGarbage)
+    {
+        mSharedGarbage.emplace_back(std::move(use), std::move(sharedGarbage));
+    }
+
     static constexpr size_t kMaxExtensionNames = 200;
     using ExtensionNameList = angle::FixedVector<const char *, kMaxExtensionNames>;
 
diff --git a/src/libANGLE/renderer/vulkan/SurfaceVk.cpp b/src/libANGLE/renderer/vulkan/SurfaceVk.cpp
@@ -171,7 +171,11 @@ OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState,
                                        EGLint width,
                                        EGLint height)
     : SurfaceVk(surfaceState), mWidth(width), mHeight(height)
-{}
+{
+    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageViews, 0, 0);
+    mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
+                                   &mDepthStencilAttachment.imageViews, 0, 0);
+}
 
 OffscreenSurfaceVk::~OffscreenSurfaceVk() {}
 
@@ -399,7 +403,12 @@ 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, &mColorImageMSViews, 0, 0);
+    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageViews, 0, 0);
+}
 
 WindowSurfaceVk::~WindowSurfaceVk()
 {
@@ -871,14 +880,14 @@ void WindowSurfaceVk::releaseSwapchainImages(ContextVk *contextVk)
     {
         mDepthStencilImage.releaseImage(renderer);
         mDepthStencilImage.releaseStagingBuffer(renderer);
-        mDepthStencilImageViews.release(contextVk);
+        mDepthStencilImageViews.release(renderer);
     }
 
     if (mColorImageMS.valid())
     {
         mColorImageMS.releaseImage(renderer);
         mColorImageMS.releaseStagingBuffer(renderer);
-        mColorImageMSViews.release(contextVk);
+        mColorImageMSViews.release(renderer);
         contextVk->addGarbage(&mFramebufferMS);
     }
 
@@ -888,7 +897,7 @@ void WindowSurfaceVk::releaseSwapchainImages(ContextVk *contextVk)
         swapchainImage.image.resetImageWeakReference();
         swapchainImage.image.destroy(contextVk->getDevice());
 
-        swapchainImage.imageViews.release(contextVk);
+        swapchainImage.imageViews.release(renderer);
         contextVk->addGarbage(&swapchainImage.framebuffer);
 
         // present history must have already been taken care of.
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.cpp b/src/libANGLE/renderer/vulkan/TextureVk.cpp
@@ -403,6 +403,7 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
 
         const vk::ImageView *readImageView = nullptr;
         ANGLE_TRY(colorReadRT->getImageView(contextVk, &readImageView));
+        colorReadRT->onImageViewGraphAccess(contextVk);
 
         return copySubImageImplWithDraw(contextVk, offsetImageIndex, modifiedDestOffset, destFormat,
                                         0, clippedSourceArea, isViewportFlipY, false, false, false,
@@ -452,10 +453,10 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     // If it's possible to perform the copy with a draw call, do that.
     if (CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat) && !forceCPUPath)
     {
-        return copySubImageImplWithDraw(contextVk, offsetImageIndex, destOffset, destVkFormat,
-                                        sourceLevel, sourceArea, false, unpackFlipY,
-                                        unpackPremultiplyAlpha, unpackUnmultiplyAlpha,
-                                        &source->getImage(), &source->getFetchImageView());
+        return copySubImageImplWithDraw(
+            contextVk, offsetImageIndex, destOffset, destVkFormat, sourceLevel, sourceArea, false,
+            unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, &source->getImage(),
+            &source->getFetchImageViewAndRecordUse(contextVk));
     }
 
     if (sourceLevel != 0)
@@ -1362,7 +1363,7 @@ angle::Result TextureVk::syncState(const gl::Context *context,
             uint32_t layerCount =
                 mState.getType() == gl::TextureType::_2D ? 1 : mImage->getLayerCount();
 
-            mImageViews.release(contextVk);
+            mImageViews.release(contextVk->getRenderer());
             const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
 
             ANGLE_TRY(initImageViews(contextVk, mImage->getFormat(),
@@ -1457,30 +1458,33 @@ void TextureVk::releaseOwnershipOfImage(const gl::Context *context)
     releaseAndDeleteImage(contextVk);
 }
 
-const vk::ImageView &TextureVk::getReadImageView() const
+const vk::ImageView &TextureVk::getReadImageViewAndRecordUse(ContextVk *contextVk) const
 {
     ASSERT(mImage->valid());
 
-    if (mState.isStencilMode() && mImageViews.getStencilReadImageView().valid())
+    mImageViews.onGraphAccess(contextVk->getCommandGraph());
+
+    if (mState.isStencilMode() && mImageViews.hasStencilReadImageView())
     {
         return mImageViews.getStencilReadImageView();
     }
 
     return mImageViews.getReadImageView();
 }
 
-const vk::ImageView &TextureVk::getFetchImageView() const
+const vk::ImageView &TextureVk::getFetchImageViewAndRecordUse(ContextVk *contextVk) const
 {
     ASSERT(mImage->valid());
 
+    mImageViews.onGraphAccess(contextVk->getCommandGraph());
+
     // We don't currently support fetch for depth/stencil cube map textures.
-    ASSERT(!mImageViews.getStencilReadImageView().valid() ||
-           !mImageViews.getFetchImageView().valid());
-    return (mImageViews.getFetchImageView().valid() ? mImageViews.getFetchImageView()
-                                                    : mImageViews.getReadImageView());
+    ASSERT(!mImageViews.hasStencilReadImageView() || !mImageViews.hasFetchImageView());
+    return (mImageViews.hasFetchImageView() ? mImageViews.getFetchImageView()
+                                            : mImageViews.getReadImageView());
 }
 
-angle::Result TextureVk::getLevelLayerImageView(vk::Context *context,
+angle::Result TextureVk::getLevelLayerImageView(ContextVk *contextVk,
                                                 size_t level,
                                                 size_t layer,
                                                 const vk::ImageView **imageViewOut)
@@ -1490,7 +1494,7 @@ angle::Result TextureVk::getLevelLayerImageView(vk::Context *context,
     uint32_t nativeLevel = getNativeImageLevel(static_cast<uint32_t>(level));
     uint32_t nativeLayer = getNativeImageLayer(static_cast<uint32_t>(layer));
 
-    return mImageViews.getLevelLayerDrawImageView(context, *mImage, nativeLevel, nativeLayer,
+    return mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, nativeLevel, nativeLayer,
                                                   imageViewOut);
 }
 
@@ -1602,19 +1606,21 @@ angle::Result TextureVk::initImageViews(ContextVk *contextVk,
 
 void TextureVk::releaseImage(ContextVk *contextVk)
 {
+    RendererVk *renderer = contextVk->getRenderer();
+
     if (mImage)
     {
         if (mOwnsImage)
         {
-            mImage->releaseImage(contextVk->getRenderer());
+            mImage->releaseImage(renderer);
         }
         else
         {
             mImage = nullptr;
         }
     }
 
-    mImageViews.release(contextVk);
+    mImageViews.release(renderer);
 
     for (RenderTargetVector &renderTargetLevels : mRenderTargets)
     {
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.h b/src/libANGLE/renderer/vulkan/TextureVk.h
@@ -152,12 +152,17 @@ class TextureVk : public TextureImpl
         return *mImage;
     }
 
+    void onImageViewGraphAccess(vk::CommandGraph *commandGraph)
+    {
+        mImageViews.onGraphAccess(commandGraph);
+    }
+
     void releaseOwnershipOfImage(const gl::Context *context);
 
-    const vk::ImageView &getReadImageView() const;
+    const vk::ImageView &getReadImageViewAndRecordUse(ContextVk *contextVk) const;
     // A special view for cube maps as a 2D array, used with shaders that do texelFetch() and for
     // seamful cube map emulation.
-    const vk::ImageView &getFetchImageView() const;
+    const vk::ImageView &getFetchImageViewAndRecordUse(ContextVk *contextVk) const;
     angle::Result getStorageImageView(ContextVk *contextVk,
                                       bool allLayers,
                                       size_t level,
@@ -295,7 +300,7 @@ class TextureVk : public TextureImpl
                                  uint32_t levelCount,
                                  uint32_t layerCount);
     angle::Result initRenderTargets(ContextVk *contextVk, GLuint layerCount, GLuint levelIndex);
-    angle::Result getLevelLayerImageView(vk::Context *context,
+    angle::Result getLevelLayerImageView(ContextVk *contextVk,
                                          size_t level,
                                          size_t layer,
                                          const vk::ImageView **imageViewOut);
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.cpp b/src/libANGLE/renderer/vulkan/vk_helpers.cpp
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.h b/src/libANGLE/renderer/vulkan/vk_helpers.h

Original file line number	Diff line number	Diff line change
`@@ -2959,6 +2959,7 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context,`
`2959`	`2959`	`image.changeLayout(aspectFlags, textureLayout, srcLayoutChange);`
`2960`	`2960`	`}`
`2961`	`2961`
	`2962`	`+ textureVk->onImageViewGraphAccess(&mCommandGraph);`
`2962`	`2963`	`image.addReadDependency(this, recorder);`
`2963`	`2964`
`2964`	`2965`	`mActiveTextures[textureUnit].texture = textureVk;`
Original file line number	Diff line number	Diff line change
`@@ -823,6 +823,7 @@ angle::Result FramebufferVk::blit(const gl::Context *context,`
`823`	`823`	`{`
`824`	`824`	`const vk::ImageView *readImageView = nullptr;`
`825`	`825`	`ANGLE_TRY(readRenderTarget->getImageView(contextVk, &readImageView));`
	`826`	`+ readRenderTarget->onImageViewGraphAccess(contextVk);`
`826`	`827`	`ANGLE_TRY(utilsVk.colorBlitResolve(contextVk, this, &readRenderTarget->getImage(),`
`827`	`828`	`readImageView, params));`
`828`	`829`	`}`
`@@ -1578,10 +1579,12 @@ angle::Result FramebufferVk::readPixelsImpl(ContextVk *contextVk,`
`1578`	`1579`
`1579`	`1580`	`gl::Extents FramebufferVk::getReadImageExtents() const`
`1580`	`1581`	`{`
`1581`		`- ASSERT(getColorReadRenderTarget()->getExtents().width == mState.getDimensions().width);`
`1582`		`- ASSERT(getColorReadRenderTarget()->getExtents().height == mState.getDimensions().height);`
	`1582`	`+ RenderTargetVk *readRenderTarget = mRenderTargetCache.getColorRead(mState);`
`1583`	`1583`
`1584`		`- return getColorReadRenderTarget()->getExtents();`
	`1584`	`+ ASSERT(readRenderTarget->getExtents().width == mState.getDimensions().width);`
	`1585`	`+ ASSERT(readRenderTarget->getExtents().height == mState.getDimensions().height);`
	`1586`	`+`
	`1587`	`+ return readRenderTarget->getExtents();`
`1585`	`1588`	`}`
`1586`	`1589`
`1587`	`1590`	`gl::Rectangle FramebufferVk::getCompleteRenderArea() const`
Original file line number	Diff line number	Diff line change
`@@ -210,10 +210,10 @@ void RenderbufferVk::releaseAndDeleteImage(ContextVk *contextVk)`
`210`	`210`
`211`	`211`	`void RenderbufferVk::releaseImage(ContextVk *contextVk)`
`212`	`212`	`{`
	`213`	`+ RendererVk *renderer = contextVk->getRenderer();`
	`214`	`+`
`213`	`215`	`if (mImage && mOwnsImage)`
`214`	`216`	`{`
`215`		`- RendererVk *renderer = contextVk->getRenderer();`
`216`		`-`
`217`	`217`	`mImage->releaseImage(renderer);`
`218`	`218`	`mImage->releaseStagingBuffer(renderer);`
`219`	`219`	`}`
`@@ -222,7 +222,7 @@ void RenderbufferVk::releaseImage(ContextVk *contextVk)`
`222`	`222`	`mImage = nullptr;`
`223`	`223`	`}`
`224`	`224`
`225`		`- mImageViews.release(contextVk);`
	`225`	`+ mImageViews.release(renderer);`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`} // namespace rx`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ class RendererVk : angle::NonCopyable`
`170`	`170`	`CollectGarbage(&sharedGarbage, garbageIn...);`
`171`	`171`	`if (!sharedGarbage.empty())`
`172`	`172`	`{`
`173`		`- mSharedGarbage.emplace_back(std::move(*use), std::move(sharedGarbage));`
	`173`	`+ collectGarbage(std::move(*use), std::move(sharedGarbage));`
`174`	`174`	`}`
`175`	`175`	`else`
`176`	`176`	`{`
`@@ -181,6 +181,11 @@ class RendererVk : angle::NonCopyable`
`181`	`181`	`use->init();`
`182`	`182`	`}`
`183`	`183`
	`184`	`+ void collectGarbage(vk::SharedResourceUse &&use, std::vector<vk::GarbageObject> &&sharedGarbage)`
	`185`	`+ {`
	`186`	`+ mSharedGarbage.emplace_back(std::move(use), std::move(sharedGarbage));`
	`187`	`+ }`
	`188`	`+`
`184`	`189`	`static constexpr size_t kMaxExtensionNames = 200;`
`185`	`190`	`using ExtensionNameList = angle::FixedVector<const char *, kMaxExtensionNames>;`
`186`	`191`
Original file line number	Diff line number	Diff line change
`@@ -403,6 +403,7 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,`
`403`	`403`
`404`	`404`	`const vk::ImageView *readImageView = nullptr;`
`405`	`405`	`ANGLE_TRY(colorReadRT->getImageView(contextVk, &readImageView));`
	`406`	`+ colorReadRT->onImageViewGraphAccess(contextVk);`
`406`	`407`
`407`	`408`	`return copySubImageImplWithDraw(contextVk, offsetImageIndex, modifiedDestOffset, destFormat,`
`408`	`409`	`0, clippedSourceArea, isViewportFlipY, false, false, false,`
`@@ -452,10 +453,10 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,`
`452`	`453`	`// If it's possible to perform the copy with a draw call, do that.`
`453`	`454`	`if (CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat) && !forceCPUPath)`
`454`	`455`	`{`
`455`		`- return copySubImageImplWithDraw(contextVk, offsetImageIndex, destOffset, destVkFormat,`
`456`		`- sourceLevel, sourceArea, false, unpackFlipY,`
`457`		`- unpackPremultiplyAlpha, unpackUnmultiplyAlpha,`
`458`		`- &source->getImage(), &source->getFetchImageView());`
	`456`	`+ return copySubImageImplWithDraw(`
	`457`	`+ contextVk, offsetImageIndex, destOffset, destVkFormat, sourceLevel, sourceArea, false,`
	`458`	`+ unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, &source->getImage(),`
	`459`	`+ &source->getFetchImageViewAndRecordUse(contextVk));`
`459`	`460`	`}`
`460`	`461`
`461`	`462`	`if (sourceLevel != 0)`
`@@ -1362,7 +1363,7 @@ angle::Result TextureVk::syncState(const gl::Context *context,`
`1362`	`1363`	`uint32_t layerCount =`
`1363`	`1364`	`mState.getType() == gl::TextureType::_2D ? 1 : mImage->getLayerCount();`
`1364`	`1365`
`1365`		`- mImageViews.release(contextVk);`
	`1366`	`+ mImageViews.release(contextVk->getRenderer());`
`1366`	`1367`	`const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();`
`1367`	`1368`
`1368`	`1369`	`ANGLE_TRY(initImageViews(contextVk, mImage->getFormat(),`
`@@ -1457,30 +1458,33 @@ void TextureVk::releaseOwnershipOfImage(const gl::Context *context)`
`1457`	`1458`	`releaseAndDeleteImage(contextVk);`
`1458`	`1459`	`}`
`1459`	`1460`
`1460`		`-const vk::ImageView &TextureVk::getReadImageView() const`
	`1461`	`+const vk::ImageView &TextureVk::getReadImageViewAndRecordUse(ContextVk *contextVk) const`
`1461`	`1462`	`{`
`1462`	`1463`	`ASSERT(mImage->valid());`
`1463`	`1464`
`1464`		`- if (mState.isStencilMode() && mImageViews.getStencilReadImageView().valid())`
	`1465`	`+ mImageViews.onGraphAccess(contextVk->getCommandGraph());`
	`1466`	`+`
	`1467`	`+ if (mState.isStencilMode() && mImageViews.hasStencilReadImageView())`
`1465`	`1468`	`{`
`1466`	`1469`	`return mImageViews.getStencilReadImageView();`
`1467`	`1470`	`}`
`1468`	`1471`
`1469`	`1472`	`return mImageViews.getReadImageView();`
`1470`	`1473`	`}`
`1471`	`1474`
`1472`		`-const vk::ImageView &TextureVk::getFetchImageView() const`
	`1475`	`+const vk::ImageView &TextureVk::getFetchImageViewAndRecordUse(ContextVk *contextVk) const`
`1473`	`1476`	`{`
`1474`	`1477`	`ASSERT(mImage->valid());`
`1475`	`1478`
	`1479`	`+ mImageViews.onGraphAccess(contextVk->getCommandGraph());`
	`1480`	`+`
`1476`	`1481`	`// We don't currently support fetch for depth/stencil cube map textures.`
`1477`		`- ASSERT(!mImageViews.getStencilReadImageView().valid() \|\|`
`1478`		`- !mImageViews.getFetchImageView().valid());`
`1479`		`- return (mImageViews.getFetchImageView().valid() ? mImageViews.getFetchImageView()`
`1480`		`- : mImageViews.getReadImageView());`
	`1482`	`+ ASSERT(!mImageViews.hasStencilReadImageView() \|\| !mImageViews.hasFetchImageView());`
	`1483`	`+ return (mImageViews.hasFetchImageView() ? mImageViews.getFetchImageView()`
	`1484`	`+ : mImageViews.getReadImageView());`
`1481`	`1485`	`}`
`1482`	`1486`
`1483`		`-angle::Result TextureVk::getLevelLayerImageView(vk::Context *context,`
	`1487`	`+angle::Result TextureVk::getLevelLayerImageView(ContextVk *contextVk,`
`1484`	`1488`	`size_t level,`
`1485`	`1489`	`size_t layer,`
`1486`	`1490`	`const vk::ImageView **imageViewOut)`
`@@ -1490,7 +1494,7 @@ angle::Result TextureVk::getLevelLayerImageView(vk::Context *context,`
`1490`	`1494`	`uint32_t nativeLevel = getNativeImageLevel(static_cast<uint32_t>(level));`
`1491`	`1495`	`uint32_t nativeLayer = getNativeImageLayer(static_cast<uint32_t>(layer));`
`1492`	`1496`
`1493`		`- return mImageViews.getLevelLayerDrawImageView(context, *mImage, nativeLevel, nativeLayer,`
	`1497`	`+ return mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, nativeLevel, nativeLayer,`
`1494`	`1498`	`imageViewOut);`
`1495`	`1499`	`}`
`1496`	`1500`
`@@ -1602,19 +1606,21 @@ angle::Result TextureVk::initImageViews(ContextVk *contextVk,`
`1602`	`1606`
`1603`	`1607`	`void TextureVk::releaseImage(ContextVk *contextVk)`
`1604`	`1608`	`{`
	`1609`	`+ RendererVk *renderer = contextVk->getRenderer();`
	`1610`	`+`
`1605`	`1611`	`if (mImage)`
`1606`	`1612`	`{`
`1607`	`1613`	`if (mOwnsImage)`
`1608`	`1614`	`{`
`1609`		`- mImage->releaseImage(contextVk->getRenderer());`
	`1615`	`+ mImage->releaseImage(renderer);`
`1610`	`1616`	`}`
`1611`	`1617`	`else`
`1612`	`1618`	`{`
`1613`	`1619`	`mImage = nullptr;`
`1614`	`1620`	`}`
`1615`	`1621`	`}`
`1616`	`1622`
`1617`		`- mImageViews.release(contextVk);`
	`1623`	`+ mImageViews.release(renderer);`
`1618`	`1624`
`1619`	`1625`	`for (RenderTargetVector &renderTargetLevels : mRenderTargets)`
`1620`	`1626`	`{`