[Impeller] started recycling vkRenderPass and vkFramebuffer

Author: gaaclarke

impeller/renderer/backend/vulkan/context_vk.h

@@ -17,6 +17,7 @@
 #include "impeller/renderer/backend/vulkan/queue_vk.h"
 #include "impeller/renderer/backend/vulkan/sampler_library_vk.h"
 #include "impeller/renderer/backend/vulkan/shader_library_vk.h"
+#include "impeller/renderer/backend/vulkan/shared_object_vk.h"
 #include "impeller/renderer/capabilities.h"
 #include "impeller/renderer/context.h"
 
@@ -31,6 +32,71 @@ class FenceWaiterVK;
 class ResourceManagerVK;
 class SurfaceContextVK;
 
+/// @brief Ring buffer for one writer thread and one reader thread.
+template <typename T>
+class RingBuffer {
+ public:
+  RingBuffer(int32_t size) : read_(0), write_(0), buffer_(size) {}
+
+  std::optional<T> Read() {
+    int32_t current_read = read_.load();
+    if (current_read == write_.load()) {
+      return {};
+    } else {
+      int32_t next_read = (current_read + 1) % buffer_.size();
+      read_.store(next_read);
+      return buffer_[current_read];
+    }
+  }
+
+  bool Write(const T& value) {
+    int32_t current_write = write_.load();
+    int32_t next_write = (current_write + 1) % buffer_.size();
+    if (next_write == read_.load()) {  // Buffer full
+      return false;
+    }
+    buffer_[current_write] = value;
+    write_.store(next_write);
+    return true;
+  }
+
+ private:
+  std::atomic<int32_t> read_;
+  std::atomic<int32_t> write_;
+  std::vector<T> buffer_;
+};
+
+template <typename T>
+class RingBufferItem : public SharedObjectVK {
+ public:
+  RingBufferItem(std::weak_ptr<const ContextVK> context,
+                 RingBuffer<T>* ring_buffer,
+                 std::optional<T> value)
+      : context_(context), ring_buffer_(ring_buffer), value_(value) {}
+
+  virtual ~RingBufferItem() {
+    auto context = context_.lock();
+    if (value_ && context) {
+      bool did_write = ring_buffer_->Write(value_.value());
+      FML_CHECK(did_write);
+    }
+  }
+
+  std::optional<T>& GetValue() { return value_; }
+
+ private:
+  FML_DISALLOW_COPY_AND_ASSIGN(RingBufferItem<T>);
+
+  std::weak_ptr<const ContextVK> context_;
+  RingBuffer<T>* ring_buffer_;
+  std::optional<T> value_;
+};
+
+struct RenderPassFrameBufferPair {
+  SharedHandleVK<vk::RenderPass> render_pass;
+  SharedHandleVK<vk::Framebuffer> framebuffer;
+};
+
 class ContextVK final : public Context,
                         public BackendCast<ContextVK, Context>,
                         public std::enable_shared_from_this<ContextVK> {
@@ -135,6 +201,12 @@ class ContextVK final : public Context,
 
   std::shared_ptr<ResourceManagerVK> GetResourceManager() const;
 
+  std::shared_ptr<RingBufferItem<RenderPassFrameBufferPair>>
+  GetRenderPassFrameBufferPair() const {
+    return std::make_shared<RingBufferItem<RenderPassFrameBufferPair>>(
+        shared_from_this(), &render_pass_pool_, render_pass_pool_.Read());
+  }
+
  private:
   struct DeviceHolderImpl : public DeviceHolder {
     // |DeviceHolder|
@@ -162,6 +234,8 @@ class ContextVK final : public Context,
   std::string device_name_;
   std::shared_ptr<fml::ConcurrentMessageLoop> raster_message_loop_;
   const uint64_t hash_;
+  mutable RingBuffer<RenderPassFrameBufferPair> render_pass_pool_ =
+      RingBuffer<RenderPassFrameBufferPair>(10);
 
   bool is_valid_ = false;
 

impeller/renderer/backend/vulkan/render_pass_vk.cc

@@ -609,27 +609,41 @@ bool RenderPassVK::OnEncodeCommands(const Context& context) const {
 
   const auto& target_size = render_target_.GetRenderTargetSize();
 
-  auto render_pass = CreateVKRenderPass(vk_context, command_buffer);
-  if (!render_pass) {
-    VALIDATION_LOG << "Could not create renderpass.";
-    return false;
-  }
+  std::shared_ptr<RingBufferItem<RenderPassFrameBufferPair>>
+      render_pass_frame_buffer_pair = vk_context.GetRenderPassFrameBufferPair();
 
-  auto framebuffer = CreateVKFramebuffer(vk_context, *render_pass);
-  if (!framebuffer) {
-    VALIDATION_LOG << "Could not create framebuffer.";
-    return false;
+  if (!render_pass_frame_buffer_pair->GetValue()) {
+    auto render_pass = CreateVKRenderPass(vk_context, command_buffer);
+    if (!render_pass) {
+      VALIDATION_LOG << "Could not create renderpass.";
+      return false;
+    }
+
+    auto framebuffer = CreateVKFramebuffer(vk_context, *render_pass);
+    if (!framebuffer) {
+      VALIDATION_LOG << "Could not create framebuffer.";
+      return false;
+    }
+
+    RenderPassFrameBufferPair pair = RenderPassFrameBufferPair{
+        .render_pass = render_pass,
+        .framebuffer = framebuffer,
+    };
+
+    render_pass_frame_buffer_pair->GetValue() = std::move(pair);
   }
 
-  if (!encoder->Track(framebuffer) || !encoder->Track(render_pass)) {
+  if (!encoder->Track(render_pass_frame_buffer_pair)) {
     return false;
   }
 
   auto clear_values = GetVKClearValues(render_target_);
 
   vk::RenderPassBeginInfo pass_info;
-  pass_info.renderPass = *render_pass;
-  pass_info.framebuffer = *framebuffer;
+  pass_info.renderPass =
+      *render_pass_frame_buffer_pair->GetValue()->render_pass;
+  pass_info.framebuffer =
+      *render_pass_frame_buffer_pair->GetValue()->framebuffer;
   pass_info.renderArea.extent.width = static_cast<uint32_t>(target_size.width);
   pass_info.renderArea.extent.height =
       static_cast<uint32_t>(target_size.height);