[Impeller] Encode render passes concurrently on iOS.

impeller/entity/contents/content_context.cc

@@ -362,11 +362,7 @@ std::shared_ptr<Texture> ContentContext::MakeSubpass(
     return nullptr;
   }
 
-  if (!sub_renderpass->EncodeCommands()) {
-    return nullptr;
-  }
-
-  if (!sub_command_buffer->SubmitCommands()) {
+  if (!sub_command_buffer->SubmitCommandsAsync(std::move(sub_renderpass))) {
     return nullptr;
   }
 

impeller/entity/inline_pass_context.cc

@@ -54,15 +54,9 @@ bool InlinePassContext::EndPass() {
     return true;
   }
 
-  if (!pass_->EncodeCommands()) {
-    VALIDATION_LOG
-        << "Failed to encode commands while ending the current render pass.";
-    return false;
-  }
-
-  if (!command_buffer_->SubmitCommands()) {
-    VALIDATION_LOG
-        << "Failed to submit command buffer while ending render pass.";
+  if (!command_buffer_->SubmitCommandsAsync(std::move(pass_))) {
+    VALIDATION_LOG << "Failed to encode and submit command buffer while ending "
+                      "render pass.";
     return false;
   }
 

impeller/playground/backend/metal/playground_impl_mtl.h

@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include "flutter/fml/concurrent_message_loop.h"
 #include "flutter/fml/macros.h"
 #include "impeller/playground/playground_impl.h"
 
@@ -27,6 +28,7 @@ class PlaygroundImplMTL final : public PlaygroundImpl {
   // To ensure that ObjC stuff doesn't leak into C++ TUs.
   std::unique_ptr<Data> data_;
   std::shared_ptr<Context> context_;
+  std::shared_ptr<fml::ConcurrentMessageLoop> concurrent_loop_;
 
   // |PlaygroundImpl|
   std::shared_ptr<Context> GetContext() const override;

impeller/playground/backend/metal/playground_impl_mtl.mm

@@ -63,16 +63,18 @@
 PlaygroundImplMTL::PlaygroundImplMTL(PlaygroundSwitches switches)
     : PlaygroundImpl(switches),
       handle_(nullptr, &DestroyWindowHandle),
-      data_(std::make_unique<Data>()) {
+      data_(std::make_unique<Data>()),
+      concurrent_loop_(fml::ConcurrentMessageLoop::Create()) {
   ::glfwDefaultWindowHints();
   ::glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
   ::glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
   auto window = ::glfwCreateWindow(1, 1, "Test", nullptr, nullptr);
   if (!window) {
     return;
   }
+  auto worker_task_runner = concurrent_loop_->GetTaskRunner();
   auto context = ContextMTL::Create(ShaderLibraryMappingsForPlayground(),
-                                    "Playground Library");
+                                    worker_task_runner, "Playground Library");
   if (!context) {
     return;
   }

impeller/renderer/backend/metal/command_buffer_mtl.h

@@ -36,6 +36,9 @@ class CommandBufferMTL final : public CommandBuffer {
   // |CommandBuffer|
   void OnWaitUntilScheduled() override;
 
+  // |CommandBuffer|
+  bool SubmitCommandsAsync(std::shared_ptr<RenderPass> render_pass) override;
+
   // |CommandBuffer|
   std::shared_ptr<RenderPass> OnCreateRenderPass(RenderTarget target) override;
 

impeller/renderer/backend/metal/command_buffer_mtl.mm

@@ -4,8 +4,13 @@
 
 #include "impeller/renderer/backend/metal/command_buffer_mtl.h"
 
+#include "flutter/fml/make_copyable.h"
+#include "flutter/fml/synchronization/semaphore.h"
+#include "flutter/fml/trace_event.h"
+
 #include "impeller/renderer/backend/metal/blit_pass_mtl.h"
 #include "impeller/renderer/backend/metal/compute_pass_mtl.h"
+#include "impeller/renderer/backend/metal/context_mtl.h"
 #include "impeller/renderer/backend/metal/render_pass_mtl.h"
 
 namespace impeller {
@@ -171,6 +176,53 @@ static bool LogMTLCommandBufferErrorIfPresent(id<MTLCommandBuffer> buffer) {
   return true;
 }
 
+bool CommandBufferMTL::SubmitCommandsAsync(
+    std::shared_ptr<RenderPass> render_pass) {
+  TRACE_EVENT0("impeller", "CommandBufferMTL::SubmitCommandsAsync");
+  if (!IsValid() || !render_pass->IsValid()) {
+    return false;
+  }
+  auto context = context_.lock();
+  if (!context) {
+    return false;
+  }
+  [buffer_ enqueue];
+  auto buffer = buffer_;
+  buffer_ = nil;
+
+  auto worker_task_runner = ContextMTL::Cast(*context).GetWorkerTaskRunner();
+
+  auto mtl_render_pass = static_cast<RenderPassMTL*>(render_pass.get());
+
+  // Render command encoder creation has been observed to exceed the stack size
+  // limit for worker threads, and therefore is intentionally constructed on the
+  // raster thread.
+  auto render_command_encoder =
+      [buffer renderCommandEncoderWithDescriptor:mtl_render_pass->desc_];
+  if (!render_command_encoder) {
+    return false;
+  }
+
+  auto task = fml::MakeCopyable(
+      [render_pass, buffer, render_command_encoder, context]() {
+        auto mtl_render_pass = static_cast<RenderPassMTL*>(render_pass.get());
+        if (!mtl_render_pass->label_.empty()) {
+          [render_command_encoder setLabel:@(mtl_render_pass->label_.c_str())];
+        }
+
+        auto result = mtl_render_pass->EncodeCommands(
+            context->GetResourceAllocator(), render_command_encoder);
+        [render_command_encoder endEncoding];
+        if (result) {
+          [buffer commit];
+        } else {
+          VALIDATION_LOG << "Failed to encode command buffer";
+        }
+      });
+  worker_task_runner->PostTask(task);
+  return true;
+}
+
 void CommandBufferMTL::OnWaitUntilScheduled() {}
 
 std::shared_ptr<RenderPass> CommandBufferMTL::OnCreateRenderPass(

impeller/renderer/backend/metal/context_mtl.h

@@ -9,6 +9,7 @@
 #include <string>
 #include <vector>
 
+#include "flutter/fml/concurrent_message_loop.h"
 #include "flutter/fml/macros.h"
 #include "impeller/base/backend_cast.h"
 #include "impeller/core/sampler.h"
@@ -26,10 +27,12 @@ class ContextMTL final : public Context,
                          public std::enable_shared_from_this<ContextMTL> {
  public:
   static std::shared_ptr<ContextMTL> Create(
-      const std::vector<std::string>& shader_library_paths);
+      const std::vector<std::string>& shader_library_paths,
+      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner);
 
   static std::shared_ptr<ContextMTL> Create(
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries_data,
+      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner,
       const std::string& label);
 
   // |Context|
@@ -66,6 +69,8 @@ class ContextMTL final : public Context,
 
   id<MTLCommandBuffer> CreateMTLCommandBuffer() const;
 
+  const std::shared_ptr<fml::ConcurrentTaskRunner>& GetWorkerTaskRunner() const;
+
  private:
   id<MTLDevice> device_ = nullptr;
   id<MTLCommandQueue> command_queue_ = nullptr;
@@ -74,9 +79,12 @@ class ContextMTL final : public Context,
   std::shared_ptr<SamplerLibrary> sampler_library_;
   std::shared_ptr<AllocatorMTL> resource_allocator_;
   std::shared_ptr<const Capabilities> device_capabilities_;
+  std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner_;
   bool is_valid_ = false;
 
-  ContextMTL(id<MTLDevice> device, NSArray<id<MTLLibrary>>* shader_libraries);
+  ContextMTL(id<MTLDevice> device,
+             NSArray<id<MTLLibrary>>* shader_libraries,
+             std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner);
 
   std::shared_ptr<CommandBuffer> CreateCommandBufferInQueue(
       id<MTLCommandQueue> queue) const;

impeller/renderer/backend/metal/context_mtl.mm

@@ -65,9 +65,11 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
       .Build();
 }
 
-ContextMTL::ContextMTL(id<MTLDevice> device,
-                       NSArray<id<MTLLibrary>>* shader_libraries)
-    : device_(device) {
+ContextMTL::ContextMTL(
+    id<MTLDevice> device,
+    NSArray<id<MTLLibrary>>* shader_libraries,
+    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner)
+    : device_(device), worker_task_runner_(std::move(worker_task_runner)) {
   // Validate device.
   if (!device_) {
     VALIDATION_LOG << "Could not setup valid Metal device.";
@@ -200,10 +202,12 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
 }
 
 std::shared_ptr<ContextMTL> ContextMTL::Create(
-    const std::vector<std::string>& shader_library_paths) {
+    const std::vector<std::string>& shader_library_paths,
+    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner) {
   auto device = CreateMetalDevice();
   auto context = std::shared_ptr<ContextMTL>(new ContextMTL(
-      device, MTLShaderLibraryFromFilePaths(device, shader_library_paths)));
+      device, MTLShaderLibraryFromFilePaths(device, shader_library_paths),
+      std::move(worker_task_runner)));
   if (!context->IsValid()) {
     FML_LOG(ERROR) << "Could not create Metal context.";
     return nullptr;
@@ -213,11 +217,13 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
 
 std::shared_ptr<ContextMTL> ContextMTL::Create(
     const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries_data,
+    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner,
     const std::string& label) {
   auto device = CreateMetalDevice();
   auto context = std::shared_ptr<ContextMTL>(new ContextMTL(
       device,
-      MTLShaderLibraryFromFileData(device, shader_libraries_data, label)));
+      MTLShaderLibraryFromFileData(device, shader_libraries_data, label),
+      worker_task_runner));
   if (!context->IsValid()) {
     FML_LOG(ERROR) << "Could not create Metal context.";
     return nullptr;
@@ -257,6 +263,11 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
   return CreateCommandBufferInQueue(command_queue_);
 }
 
+const std::shared_ptr<fml::ConcurrentTaskRunner>&
+ContextMTL::GetWorkerTaskRunner() const {
+  return worker_task_runner_;
+}
+
 std::shared_ptr<CommandBuffer> ContextMTL::CreateCommandBufferInQueue(
     id<MTLCommandQueue> queue) const {
   if (!IsValid()) {

impeller/renderer/backend/metal/render_pass_mtl.mm

@@ -6,11 +6,13 @@
 
 #include "flutter/fml/closure.h"
 #include "flutter/fml/logging.h"
+#include "flutter/fml/make_copyable.h"
 #include "flutter/fml/trace_event.h"
 #include "impeller/base/backend_cast.h"
 #include "impeller/core/formats.h"
 #include "impeller/core/host_buffer.h"
 #include "impeller/core/shader_types.h"
+#include "impeller/renderer/backend/metal/context_mtl.h"
 #include "impeller/renderer/backend/metal/device_buffer_mtl.h"
 #include "impeller/renderer/backend/metal/formats_mtl.h"
 #include "impeller/renderer/backend/metal/pipeline_mtl.h"

impeller/renderer/backend/metal/surface_mtl.mm

@@ -179,6 +179,7 @@
     }
   }
 
+#if ((FML_OS_MACOSX && !FML_OS_IOS) || FML_OS_IOS_SIMULATOR)
   // If a transaction is present, `presentDrawable` will present too early. And
   // so we wait on an empty command buffer to get scheduled instead, which
   // forces us to also wait for all of the previous command buffers in the queue
@@ -187,6 +188,8 @@
       ContextMTL::Cast(context.get())->CreateMTLCommandBuffer();
   [command_buffer commit];
   [command_buffer waitUntilScheduled];
+#endif  // (FML_OS_MACOSX && !FML_OS_IOS) || FML_OS_IOS_SIMULATOR) (not iPhone)
+
   [drawable_ present];
 
   return true;

impeller/renderer/command_buffer.cc

@@ -36,6 +36,21 @@ void CommandBuffer::WaitUntilScheduled() {
   return OnWaitUntilScheduled();
 }
 
+bool CommandBuffer::SubmitCommandsAsync(
+    std::shared_ptr<RenderPass>
+        render_pass  // NOLINT(performance-unnecessary-value-param)
+) {
+  TRACE_EVENT0("impeller", "CommandBuffer::SubmitCommandsAsync");
+  if (!render_pass->IsValid() || !IsValid()) {
+    return false;
+  }
+  if (!render_pass->EncodeCommands()) {
+    return false;
+  }
+
+  return SubmitCommands(nullptr);
+}
+
 std::shared_ptr<RenderPass> CommandBuffer::CreateRenderPass(
     const RenderTarget& render_target) {
   auto pass = OnCreateRenderPass(render_target);

impeller/renderer/command_buffer.h

@@ -55,7 +55,8 @@ class CommandBuffer {
 
   //----------------------------------------------------------------------------
   /// @brief      Schedule the command encoded by render passes within this
-  ///             command buffer on the GPU.
+  ///             command buffer on the GPU. The encoding of these commnands is
+  ///             performed immediately on the calling thread.
   ///
   ///             A command buffer may only be committed once.
   ///
@@ -65,6 +66,17 @@ class CommandBuffer {
 
   [[nodiscard]] bool SubmitCommands();
 
+  //----------------------------------------------------------------------------
+  /// @brief      Schedule the command encoded by render passes within this
+  ///             command buffer on the GPU. The enqueing of this buffer is
+  ///             performed immediately but encoding is pushed to a worker
+  ///             thread if possible.
+  ///
+  ///             A command buffer may only be committed once.
+  ///
+  [[nodiscard]] virtual bool SubmitCommandsAsync(
+      std::shared_ptr<RenderPass> render_pass);
+
   //----------------------------------------------------------------------------
   /// @brief      Force execution of pending GPU commands.
   ///

impeller/renderer/render_pass.h

@@ -7,6 +7,7 @@
 #include <string>
 
 #include "impeller/renderer/command.h"
+#include "impeller/renderer/command_buffer.h"
 #include "impeller/renderer/render_target.h"
 
 namespace impeller {

shell/platform/darwin/graphics/FlutterDarwinContextMetalImpeller.h

@@ -9,6 +9,7 @@
 #import <Foundation/Foundation.h>
 #import <Metal/Metal.h>
 
+#include "flutter/fml/concurrent_message_loop.h"
 #include "flutter/fml/platform/darwin/cf_utils.h"
 #import "flutter/shell/platform/darwin/common/framework/Headers/FlutterTexture.h"
 #import "flutter/shell/platform/darwin/graphics/FlutterDarwinExternalTextureMetal.h"
@@ -34,10 +35,15 @@ NS_ASSUME_NONNULL_BEGIN
                                 texture:(NSObject<FlutterTexture>*)texture;
 
 /**
- * Impeller context;
+ * Impeller context.
  */
 @property(nonatomic, readonly) std::shared_ptr<impeller::ContextMTL> context;
 
+/**
+ * Concurrent message loop.
+ */
+@property(nonatomic, readonly) std::shared_ptr<fml::ConcurrentMessageLoop> workers;
+
 /*
  * Texture cache for external textures.
  */

shell/platform/darwin/graphics/FlutterDarwinContextMetalImpeller.mm

@@ -16,7 +16,8 @@
 
 FLUTTER_ASSERT_ARC
 
-static std::shared_ptr<impeller::ContextMTL> CreateImpellerContext() {
+static std::shared_ptr<impeller::ContextMTL> CreateImpellerContext(
+    const std::shared_ptr<fml::ConcurrentMessageLoop>& concurrent_loop) {
   std::vector<std::shared_ptr<fml::Mapping>> shader_mappings = {
       std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_data,
                                              impeller_entity_shaders_length),
@@ -27,7 +28,9 @@
       std::make_shared<fml::NonOwnedMapping>(impeller_framebuffer_blend_shaders_data,
                                              impeller_framebuffer_blend_shaders_length),
   };
-  auto context = impeller::ContextMTL::Create(shader_mappings, "Impeller Library");
+  auto worker_task_runner = concurrent_loop->GetTaskRunner();
+  auto context =
+      impeller::ContextMTL::Create(shader_mappings, worker_task_runner, "Impeller Library");
   if (!context) {
     FML_LOG(ERROR) << "Could not create Metal Impeller Context.";
     return nullptr;
@@ -42,7 +45,8 @@ @implementation FlutterDarwinContextMetalImpeller
 - (instancetype)init {
   self = [super init];
   if (self != nil) {
-    _context = CreateImpellerContext();
+    _workers = fml::ConcurrentMessageLoop::Create();
+    _context = CreateImpellerContext(_workers);
     id<MTLDevice> device = _context->GetMTLDevice();
     if (!device) {
       FML_DLOG(ERROR) << "Could not acquire Metal device.";