Cap the number of presents pending in the compositor.

Author: chinmaygarde

fml/closure.h

@@ -45,11 +45,7 @@ class ScopedCleanupClosure final {
   explicit ScopedCleanupClosure(const fml::closure& closure)
       : closure_(closure) {}
 
-  ~ScopedCleanupClosure() {
-    if (closure_) {
-      closure_();
-    }
-  }
+  ~ScopedCleanupClosure() { Reset(); }
 
   fml::closure SetClosure(const fml::closure& closure) {
     auto old_closure = closure_;
@@ -63,6 +59,13 @@ class ScopedCleanupClosure final {
     return closure;
   }
 
+  void Reset() {
+    if (closure_) {
+      closure_();
+      closure_ = nullptr;
+    }
+  }
+
  private:
   fml::closure closure_;
 

impeller/renderer/backend/vulkan/swapchain/ahb/ahb_swapchain_impl_vk.cc

@@ -4,6 +4,7 @@
 
 #include "impeller/renderer/backend/vulkan/swapchain/ahb/ahb_swapchain_impl_vk.h"
 
+#include "flutter/fml/trace_event.h"
 #include "impeller/base/validation.h"
 #include "impeller/renderer/backend/vulkan/barrier_vk.h"
 #include "impeller/renderer/backend/vulkan/command_buffer_vk.h"
@@ -14,6 +15,12 @@
 
 namespace impeller {
 
+//------------------------------------------------------------------------------
+/// The maximum number of presents pending in the compositor after which the
+/// acquire calls will block.
+///
+static constexpr const size_t kMaxPendingPresents = 2u;
+
 static TextureDescriptor ToSwapchainTextureDescriptor(
     const android::HardwareBufferDescriptor& ahb_desc) {
   TextureDescriptor desc;
@@ -43,7 +50,8 @@ AHBSwapchainImplVK::AHBSwapchainImplVK(
     std::weak_ptr<android::SurfaceControl> surface_control,
     const ISize& size,
     bool enable_msaa)
-    : surface_control_(std::move(surface_control)) {
+    : surface_control_(std::move(surface_control)),
+      pending_presents_(std::make_shared<fml::Semaphore>(kMaxPendingPresents)) {
   desc_ = android::HardwareBufferDescriptor::MakeForSwapchainImage(size);
   pool_ = std::make_shared<AHBTexturePoolVK>(context, desc_);
   if (!pool_->IsValid()) {
@@ -70,6 +78,17 @@ const android::HardwareBufferDescriptor& AHBSwapchainImplVK::GetDescriptor()
 }
 
 std::unique_ptr<Surface> AHBSwapchainImplVK::AcquireNextDrawable() {
+  {
+    TRACE_EVENT0("impeller", "CompositorPendingWait");
+    if (!pending_presents_->Wait()) {
+      return nullptr;
+    }
+  }
+
+  AutoSemaSignaler auto_sema_signaler =
+      std::make_shared<fml::ScopedCleanupClosure>(
+          [sema = pending_presents_]() { sema->Signal(); });
+
   if (!is_valid_) {
     return nullptr;
   }
@@ -81,18 +100,26 @@ std::unique_ptr<Surface> AHBSwapchainImplVK::AcquireNextDrawable() {
     return nullptr;
   }
 
-  return SurfaceVK::WrapSwapchainImage(
-      transients_, texture, [weak = weak_from_this(), texture]() {
+  auto surface = SurfaceVK::WrapSwapchainImage(
+      transients_, texture,
+      [signaler = auto_sema_signaler, weak = weak_from_this(), texture]() {
         auto thiz = weak.lock();
         if (!thiz) {
           VALIDATION_LOG << "Swapchain died before image could be presented.";
           return false;
         }
-        return thiz->Present(texture);
+        return thiz->Present(signaler, texture);
       });
+
+  if (!surface) {
+    return nullptr;
+  }
+
+  return surface;
 }
 
 bool AHBSwapchainImplVK::Present(
+    const AutoSemaSignaler& signaler,
     const std::shared_ptr<AHBTextureSourceVK>& texture) {
   auto control = surface_control_.lock();
   if (!control || !control->IsValid()) {
@@ -121,12 +148,12 @@ bool AHBSwapchainImplVK::Present(
                       "control.";
     return false;
   }
-  return transaction.Apply([texture, weak = weak_from_this()]() {
+  return transaction.Apply([signaler, texture, weak = weak_from_this()]() {
     auto thiz = weak.lock();
     if (!thiz) {
       return;
     }
-    thiz->OnTextureSetOnSurfaceControl(texture);
+    thiz->OnTextureSetOnSurfaceControl(signaler, texture);
   });
 }
 
@@ -180,7 +207,9 @@ std::shared_ptr<ExternalFenceVK> AHBSwapchainImplVK::SubmitCompletionSignal(
 }
 
 void AHBSwapchainImplVK::OnTextureSetOnSurfaceControl(
+    const AutoSemaSignaler& signaler,
     std::shared_ptr<AHBTextureSourceVK> texture) {
+  signaler->Reset();
   // The transaction completion indicates that the surface control now
   // references the hardware buffer. We can recycle the previous set buffer
   // safely.

impeller/renderer/backend/vulkan/swapchain/ahb/ahb_swapchain_impl_vk.h

@@ -7,6 +7,8 @@
 
 #include <memory>
 
+#include "flutter/fml/closure.h"
+#include "flutter/fml/synchronization/semaphore.h"
 #include "impeller/base/thread.h"
 #include "impeller/renderer/backend/vulkan/android/ahb_texture_source_vk.h"
 #include "impeller/renderer/backend/vulkan/swapchain/ahb/ahb_texture_pool_vk.h"
@@ -87,6 +89,8 @@ class AHBSwapchainImplVK final
   std::unique_ptr<Surface> AcquireNextDrawable();
 
  private:
+  using AutoSemaSignaler = std::shared_ptr<fml::ScopedCleanupClosure>;
+
   std::weak_ptr<android::SurfaceControl> surface_control_;
   android::HardwareBufferDescriptor desc_;
   std::shared_ptr<AHBTexturePoolVK> pool_;
@@ -96,6 +100,7 @@ class AHBSwapchainImplVK final
   Mutex currently_displayed_texture_mutex_;
   std::shared_ptr<AHBTextureSourceVK> currently_displayed_texture_
       IPLR_GUARDED_BY(currently_displayed_texture_mutex_);
+  std::shared_ptr<fml::Semaphore> pending_presents_;
   bool is_valid_ = false;
 
   explicit AHBSwapchainImplVK(
@@ -104,12 +109,14 @@ class AHBSwapchainImplVK final
       const ISize& size,
       bool enable_msaa);
 
-  bool Present(const std::shared_ptr<AHBTextureSourceVK>& texture);
+  bool Present(const AutoSemaSignaler& signaler,
+               const std::shared_ptr<AHBTextureSourceVK>& texture);
 
   std::shared_ptr<ExternalFenceVK> SubmitCompletionSignal(
       const std::shared_ptr<AHBTextureSourceVK>& texture) const;
 
   void OnTextureSetOnSurfaceControl(
+      const AutoSemaSignaler& signaler,
       std::shared_ptr<AHBTextureSourceVK> texture);
 };