Vulkan:Add FramebufferVk cache

src/libANGLE/renderer/serial_utils.h

@@ -75,6 +75,9 @@ class Serial final
     static constexpr uint64_t kInvalid = 0;
 };
 
+// Used as default/initial serial
+static constexpr Serial kZeroSerial = Serial();
+
 template <typename SerialBaseType>
 class SerialFactoryBase final : angle::NonCopyable
 {

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -110,9 +110,6 @@ constexpr size_t kInFlightCommandsLimit = 100u;
 // Initially dumping the command graphs is disabled.
 constexpr bool kEnableCommandGraphDiagnostics = false;
 
-// Used as fallback serial for null sampler objects
-constexpr Serial kZeroSerial = Serial();
-
 void InitializeSubmitInfo(VkSubmitInfo *submitInfo,
                           const vk::PrimaryCommandBuffer &commandBuffer,
                           const std::vector<VkSemaphore> &waitSemaphores,
@@ -3556,7 +3553,7 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context)
         if (sampler == nullptr)
         {
             samplerVk     = nullptr;
-            samplerSerial = kZeroSerial;
+            samplerSerial = rx::kZeroSerial;
         }
         else
         {

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -570,6 +570,7 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
     // avoid calling vkAllocateDesctiporSets each texture update.
     Serial generateTextureSerial() { return mTextureSerialFactory.generate(); }
     const vk::TextureDescriptorDesc &getActiveTexturesDesc() const { return mActiveTexturesDesc; }
+    Serial generateAttachmentImageSerial() { return mAttachmentImageSerialFactory.generate(); }
 
     angle::Result updateScissor(const gl::State &glState);
 
@@ -1023,8 +1024,9 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
     // double.
     uint64_t mGpuEventTimestampOrigin;
 
-    // Generator for texure serials.
+    // Generators for texture & framebuffer serials.
     SerialFactory mTextureSerialFactory;
+    SerialFactory mAttachmentImageSerialFactory;
 
     gl::State::DirtyBits mPipelineDirtyBitsMask;
 

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -114,11 +114,12 @@ class FramebufferVk : public FramebufferImpl
                                    const gl::Rectangle &renderArea,
                                    vk::CommandBuffer **commandBufferOut)
     {
-        return mFramebuffer.appendToStartedRenderPass(resourceUseList, renderArea,
-                                                      commandBufferOut);
+        ASSERT(mFramebuffer);
+        return mFramebuffer->appendToStartedRenderPass(resourceUseList, renderArea,
+                                                       commandBufferOut);
     }
 
-    vk::FramebufferHelper *getFramebuffer() { return &mFramebuffer; }
+    vk::FramebufferHelper *getFramebuffer() { return mFramebuffer; }
 
     angle::Result startNewRenderPass(ContextVk *context,
                                      const gl::Rectangle &renderArea,
@@ -128,6 +129,7 @@ class FramebufferVk : public FramebufferImpl
     GLint getSamples() const;
 
     const vk::RenderPassDesc &getRenderPassDesc() const { return mRenderPassDesc; }
+    const vk::FramebufferDesc &getFramebufferDesc() const { return mCurrentFramebufferDesc; }
 
   private:
     FramebufferVk(RendererVk *renderer,
@@ -179,11 +181,13 @@ class FramebufferVk : public FramebufferImpl
     void updateRenderPassDesc();
     angle::Result updateColorAttachment(const gl::Context *context, size_t colorIndex);
     angle::Result invalidateImpl(ContextVk *contextVk, size_t count, const GLenum *attachments);
+    // Release all FramebufferVk objects in the cache and clear cache
+    void clearCache(ContextVk *contextVk);
 
     WindowSurfaceVk *mBackbuffer;
 
     vk::RenderPassDesc mRenderPassDesc;
-    vk::FramebufferHelper mFramebuffer;
+    vk::FramebufferHelper *mFramebuffer;
     RenderTargetCache<RenderTargetVk> mRenderTargetCache;
 
     // These two variables are used to quickly compute if we need to do a masked clear. If a color
@@ -197,6 +201,9 @@ class FramebufferVk : public FramebufferImpl
     // the framebuffer does not, we need to mask out the alpha channel. This DrawBufferMask will
     // contain the mask to apply to the alpha channel when drawing.
     gl::DrawBufferMask mEmulatedAlphaAttachmentMask;
+
+    vk::FramebufferDesc mCurrentFramebufferDesc;
+    std::unordered_map<vk::FramebufferDesc, vk::FramebufferHelper> mFramebufferCache;
 };
 }  // namespace rx
 

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -54,6 +54,20 @@ void RenderTargetVk::reset()
     mLayerIndex = 0;
 }
 
+vk::AttachmentSerial RenderTargetVk::getAssignSerial(ContextVk *contextVk)
+{
+    ASSERT(mImage && mImage->valid());
+    vk::AttachmentSerial attachmentSerial;
+    ASSERT(mLayerIndex < std::numeric_limits<uint16_t>::max());
+    ASSERT(mLevelIndex < std::numeric_limits<uint16_t>::max());
+    Serial imageSerial = mImage->getAssignSerial(contextVk);
+    ASSERT(imageSerial.getValue() < std::numeric_limits<uint32_t>::max());
+    SetBitField(attachmentSerial.layer, mLayerIndex);
+    SetBitField(attachmentSerial.level, mLevelIndex);
+    SetBitField(attachmentSerial.imageSerial, imageSerial.getValue());
+    return attachmentSerial;
+}
+
 angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk,
                                           vk::FramebufferHelper *framebufferVk,
                                           vk::CommandBuffer *commandBuffer)

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -48,6 +48,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
               uint32_t levelIndex,
               uint32_t layerIndex);
     void reset();
+    // This returns the serial from underlying ImageHelper, first assigning one if required
+    vk::AttachmentSerial getAssignSerial(ContextVk *contextVk);
 
     // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
     angle::Result onColorDraw(ContextVk *contextVk,

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -353,11 +353,6 @@ DestT Int4Array_Get(const uint8_t *arrayBytes, uint32_t arrayIndex)
     }
 }
 
-// Helper macro that casts to a bitfield type then verifies no bits were dropped.
-#define SetBitField(lhs, rhs)                                         \
-    lhs = static_cast<typename std::decay<decltype(lhs)>::type>(rhs); \
-    ASSERT(static_cast<decltype(rhs)>(lhs) == (rhs))
-
 // When converting a byte number to a transition bit index we can shift instead of divide.
 constexpr size_t kTransitionByteShift = Log2(kGraphicsPipelineDirtyBitBytes);
 
@@ -1650,6 +1645,37 @@ bool TextureDescriptorDesc::operator==(const TextureDescriptorDesc &other) const
     return memcmp(mSerials.data(), other.mSerials.data(), sizeof(TexUnitSerials) * mMaxIndex) == 0;
 }
 
+FramebufferDesc::FramebufferDesc()
+{
+    clearSerials();
+}
+
+FramebufferDesc::~FramebufferDesc()                            = default;
+FramebufferDesc::FramebufferDesc(const FramebufferDesc &other) = default;
+FramebufferDesc &FramebufferDesc::operator=(const FramebufferDesc &other) = default;
+
+void FramebufferDesc::update(uint32_t index, AttachmentSerial serial)
+{
+    ASSERT(index < kMaxFramebufferAttachments);
+    mSerials[index] = serial;
+}
+
+size_t FramebufferDesc::hash() const
+{
+    return angle::ComputeGenericHash(&mSerials,
+                                     sizeof(AttachmentSerial) * kMaxFramebufferAttachments);
+}
+
+void FramebufferDesc::clearSerials()
+{
+    memset(&mSerials, 0, sizeof(AttachmentSerial) * kMaxFramebufferAttachments);
+}
+
+bool FramebufferDesc::operator==(const FramebufferDesc &other) const
+{
+    return memcmp(&mSerials, &other.mSerials, sizeof(Serial) * kMaxFramebufferAttachments) == 0;
+}
+
 }  // namespace vk
 
 // RenderPassCache implementation.

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -28,6 +28,11 @@ using PipelineAndSerial   = ObjectAndSerial<Pipeline>;
 using RefCountedDescriptorSetLayout = RefCounted<DescriptorSetLayout>;
 using RefCountedPipelineLayout      = RefCounted<PipelineLayout>;
 
+// Helper macro that casts to a bitfield type then verifies no bits were dropped.
+#define SetBitField(lhs, rhs)                                         \
+    lhs = static_cast<typename std::decay<decltype(lhs)>::type>(rhs); \
+    ASSERT(static_cast<decltype(rhs)>(lhs) == (rhs))
+
 // Packed Vk resource descriptions.
 // Most Vk types use many more bits than required to represent the underlying data.
 // Since ANGLE wants to cache things like RenderPasses and Pipeline State Objects using
@@ -715,6 +720,41 @@ class TextureDescriptorDesc
     };
     gl::ActiveTextureArray<TexUnitSerials> mSerials;
 };
+
+// This is IMPLEMENTATION_MAX_DRAW_BUFFERS + 1 for DS attachment
+constexpr size_t kMaxFramebufferAttachments = gl::IMPLEMENTATION_MAX_FRAMEBUFFER_ATTACHMENTS;
+// Color serials are at index [0:gl::IMPLEMENTATION_MAX_DRAW_BUFFERS-1]
+// Depth index is at gl::IMPLEMENTATION_MAX_DRAW_BUFFERS
+// Stencil index is at gl::IMPLEMENTATION_MAX_DRAW_BUFFERS + 1
+constexpr size_t kFramebufferDescDepthIndex   = gl::IMPLEMENTATION_MAX_DRAW_BUFFERS;
+constexpr size_t kFramebufferDescStencilIndex = gl::IMPLEMENTATION_MAX_DRAW_BUFFERS + 1;
+// Struct for AttachmentSerial cache signatures. Includes level/layer for imageView as
+//  well as a unique Serial value for the underlying image
+struct AttachmentSerial
+{
+    uint16_t level;
+    uint16_t layer;
+    uint32_t imageSerial;
+};
+constexpr AttachmentSerial kZeroAttachmentSerial = {0, 0, 0};
+class FramebufferDesc
+{
+  public:
+    FramebufferDesc();
+    ~FramebufferDesc();
+
+    FramebufferDesc(const FramebufferDesc &other);
+    FramebufferDesc &operator=(const FramebufferDesc &other);
+
+    void update(uint32_t index, AttachmentSerial serial);
+    size_t hash() const;
+
+    bool operator==(const FramebufferDesc &other) const;
+
+  private:
+    void clearSerials();
+    gl::AttachmentArray<AttachmentSerial> mSerials;
+};
 }  // namespace vk
 }  // namespace rx
 
@@ -756,6 +796,12 @@ struct hash<rx::vk::TextureDescriptorDesc>
 {
     size_t operator()(const rx::vk::TextureDescriptorDesc &key) const { return key.hash(); }
 };
+
+template <>
+struct hash<rx::vk::FramebufferDesc>
+{
+    size_t operator()(const rx::vk::FramebufferDesc &key) const { return key.hash(); }
+};
 }  // namespace std
 
 namespace rx

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -1733,6 +1733,7 @@ ImageHelper::ImageHelper()
     : CommandGraphResource(CommandGraphResourceType::Image),
       mFormat(nullptr),
       mSamples(1),
+      mSerial(rx::kZeroSerial),
       mCurrentLayout(ImageLayout::Undefined),
       mCurrentQueueFamilyIndex(std::numeric_limits<uint32_t>::max()),
       mBaseLevel(0),
@@ -1748,6 +1749,7 @@ ImageHelper::ImageHelper(ImageHelper &&other)
       mExtents(other.mExtents),
       mFormat(other.mFormat),
       mSamples(other.mSamples),
+      mSerial(other.mSerial),
       mCurrentLayout(other.mCurrentLayout),
       mCurrentQueueFamilyIndex(other.mCurrentQueueFamilyIndex),
       mBaseLevel(other.mBaseLevel),
@@ -1763,6 +1765,7 @@ ImageHelper::ImageHelper(ImageHelper &&other)
     other.mMaxLevel      = 0;
     other.mLayerCount    = 0;
     other.mLevelCount    = 0;
+    other.mSerial        = rx::kZeroSerial;
 }
 
 ImageHelper::~ImageHelper()
@@ -1790,6 +1793,7 @@ angle::Result ImageHelper::init(Context *context,
                                 uint32_t mipLevels,
                                 uint32_t layerCount)
 {
+    mSerial = rx::kZeroSerial;
     return initExternal(context, textureType, extents, format, samples, usage,
                         ImageLayout::Undefined, nullptr, baseLevel, maxLevel, mipLevels,
                         layerCount);
@@ -1851,6 +1855,7 @@ angle::Result ImageHelper::initExternal(Context *context,
 
 void ImageHelper::releaseImage(RendererVk *renderer)
 {
+    mSerial = rx::kZeroSerial;
     renderer->collectGarbageAndReinit(&mUse, &mImage, &mDeviceMemory);
 }
 
@@ -1955,6 +1960,7 @@ void ImageHelper::destroy(VkDevice device)
     mCurrentLayout = ImageLayout::Undefined;
     mLayerCount    = 0;
     mLevelCount    = 0;
+    mSerial        = rx::kZeroSerial;
 }
 
 void ImageHelper::init2DWeakReference(VkImage handle,
@@ -2196,6 +2202,15 @@ gl::Extents ImageHelper::getSize(const gl::ImageIndex &index) const
                        std::max(1u, mExtents.height >> mipLevel), mExtents.depth);
 }
 
+Serial ImageHelper::getAssignSerial(ContextVk *contextVk)
+{
+    if (mSerial.getValue() == 0)
+    {
+        mSerial = contextVk->generateAttachmentImageSerial();
+    }
+    return mSerial;
+}
+
 // static
 void ImageHelper::Copy(ImageHelper *srcImage,
                        ImageHelper *dstImage,
@@ -3515,6 +3530,18 @@ FramebufferHelper::FramebufferHelper() : CommandGraphResource(CommandGraphResour
 
 FramebufferHelper::~FramebufferHelper() = default;
 
+FramebufferHelper::FramebufferHelper(FramebufferHelper &&other)
+    : CommandGraphResource(CommandGraphResourceType::Framebuffer)
+{
+    mFramebuffer = std::move(other.mFramebuffer);
+}
+
+FramebufferHelper &FramebufferHelper::operator=(FramebufferHelper &&other)
+{
+    std::swap(mFramebuffer, other.mFramebuffer);
+    return *this;
+}
+
 angle::Result FramebufferHelper::init(ContextVk *contextVk,
                                       const VkFramebufferCreateInfo &createInfo)
 {

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -777,6 +777,10 @@ class ImageHelper final : public CommandGraphResource
 
     gl::Extents getSize(const gl::ImageIndex &index) const;
 
+    // Return unique Serial for underlying image, first assigning it if it hasn't been set yet
+    Serial getAssignSerial(ContextVk *contextVk);
+    void resetSerial() { mSerial = rx::kZeroSerial; }
+
     static void Copy(ImageHelper *srcImage,
                      ImageHelper *dstImage,
                      const gl::Offset &srcOffset,
@@ -1058,6 +1062,7 @@ class ImageHelper final : public CommandGraphResource
     VkExtent3D mExtents;
     const Format *mFormat;
     GLint mSamples;
+    Serial mSerial;
 
     // Current state.
     ImageLayout mCurrentLayout;
@@ -1168,6 +1173,9 @@ class FramebufferHelper : public CommandGraphResource
     FramebufferHelper();
     ~FramebufferHelper() override;
 
+    FramebufferHelper(FramebufferHelper &&other);
+    FramebufferHelper &operator=(FramebufferHelper &&other);
+
     angle::Result init(ContextVk *contextVk, const VkFramebufferCreateInfo &createInfo);
     void release(ContextVk *contextVk);