[Impeller] Give Impeller a dedicated raster priority level worker loop. (#43166)

We'd like to (or already are) using the concurrent message loop for high priority rendering tasks like PSO construction and render pass encoding. The default priority level for the engine managed concurrent message loop is 2, which is a significantly lower priority than the raster thread at -5. This is almost certainly causing priority inversion.

We must move back to dedicated runners so we can adjust thread priorities.

Author: Jonah Williams

ci/licenses_golden/excluded_files

@@ -230,7 +230,6 @@
 ../../../flutter/shell/platform/android/.gitignore
 ../../../flutter/shell/platform/android/android_context_gl_impeller_unittests.cc
 ../../../flutter/shell/platform/android/android_context_gl_unittests.cc
-../../../flutter/shell/platform/android/android_context_vulkan_impeller_unittests.cc
 ../../../flutter/shell/platform/android/android_shell_holder_unittests.cc
 ../../../flutter/shell/platform/android/apk_asset_provider_unittests.cc
 ../../../flutter/shell/platform/android/external_view_embedder/external_view_embedder_unittests.cc

fml/concurrent_message_loop.cc

@@ -29,6 +29,7 @@ ConcurrentMessageLoop::ConcurrentMessageLoop(size_t worker_count)
 ConcurrentMessageLoop::~ConcurrentMessageLoop() {
   Terminate();
   for (auto& worker : workers_) {
+    FML_DCHECK(worker.joinable());
     worker.join();
   }
 }

impeller/playground/backend/metal/playground_impl_mtl.mm

@@ -73,10 +73,9 @@
   if (!window) {
     return;
   }
-  auto worker_task_runner = concurrent_loop_->GetTaskRunner();
-  auto context = ContextMTL::Create(
-      ShaderLibraryMappingsForPlayground(), worker_task_runner,
-      is_gpu_disabled_sync_switch_, "Playground Library");
+  auto context =
+      ContextMTL::Create(ShaderLibraryMappingsForPlayground(),
+                         is_gpu_disabled_sync_switch_, "Playground Library");
   if (!context) {
     return;
   }

impeller/playground/backend/vulkan/playground_impl_vk.cc

@@ -52,9 +52,7 @@ void PlaygroundImplVK::DestroyWindowHandle(WindowHandle handle) {
 }
 
 PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
-    : PlaygroundImpl(switches),
-      concurrent_loop_(fml::ConcurrentMessageLoop::Create()),
-      handle_(nullptr, &DestroyWindowHandle) {
+    : PlaygroundImpl(switches), handle_(nullptr, &DestroyWindowHandle) {
   if (!::glfwVulkanSupported()) {
 #ifdef TARGET_OS_MAC
     VALIDATION_LOG << "Attempted to initialize a Vulkan playground on macOS "
@@ -86,7 +84,6 @@ PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
           &::glfwGetInstanceProcAddress);
   context_settings.shader_libraries_data = ShaderLibraryMappingsForPlayground();
   context_settings.cache_directory = fml::paths::GetCachesDirectory();
-  context_settings.worker_task_runner = concurrent_loop_->GetTaskRunner();
   context_settings.enable_validation = switches_.enable_vulkan_validation;
 
   auto context = ContextVK::Create(std::move(context_settings));

impeller/playground/backend/vulkan/playground_impl_vk.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "flutter/fml/concurrent_message_loop.h"
 #include "flutter/fml/macros.h"
 #include "impeller/playground/playground_impl.h"
 #include "impeller/renderer/backend/vulkan/vk.h"
@@ -18,7 +17,6 @@ class PlaygroundImplVK final : public PlaygroundImpl {
   ~PlaygroundImplVK();
 
  private:
-  std::shared_ptr<fml::ConcurrentMessageLoop> concurrent_loop_;
   std::shared_ptr<Context> context_;
 
   // Windows management.

impeller/playground/playground.cc

@@ -139,6 +139,9 @@ void Playground::SetupWindow() {
 }
 
 void Playground::TeardownWindow() {
+  if (context_) {
+    context_->Shutdown();
+  }
   context_.reset();
   renderer_.reset();
   impl_.reset();

impeller/renderer/backend/gles/context_gles.cc

@@ -107,6 +107,8 @@ bool ContextGLES::IsValid() const {
   return is_valid_;
 }
 
+void ContextGLES::Shutdown() {}
+
 // |Context|
 std::string ContextGLES::DescribeGpuModel() const {
   return reactor_->GetProcTable().GetDescription()->GetString();

impeller/renderer/backend/gles/context_gles.h

@@ -72,6 +72,9 @@ class ContextGLES final : public Context,
   // |Context|
   const std::shared_ptr<const Capabilities>& GetCapabilities() const override;
 
+  // |Context|
+  void Shutdown() override;
+
   FML_DISALLOW_COPY_AND_ASSIGN(ContextGLES);
 };
 

impeller/renderer/backend/metal/command_buffer_mtl.mm

@@ -202,32 +202,39 @@ static bool LogMTLCommandBufferErrorIfPresent(id<MTLCommandBuffer> buffer) {
     return false;
   }
 
-  auto task = fml::MakeCopyable([render_pass, buffer, render_command_encoder,
-                                 weak_context = context_]() {
-    auto context = weak_context.lock();
-    if (!context) {
-      return;
-    }
-    auto is_gpu_disabled_sync_switch =
-        ContextMTL::Cast(*context).GetIsGpuDisabledSyncSwitch();
-    is_gpu_disabled_sync_switch->Execute(fml::SyncSwitch::Handlers().SetIfFalse(
-        [&render_pass, &render_command_encoder, &buffer, &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);
+  auto task = fml::MakeCopyable(
+      [render_pass, buffer, render_command_encoder, weak_context = context_]() {
+        auto context = weak_context.lock();
+        if (!context) {
           [render_command_encoder endEncoding];
-          if (result) {
-            [buffer commit];
-          } else {
-            VALIDATION_LOG << "Failed to encode command buffer";
-          }
-        }));
-  });
+          return;
+        }
+        auto is_gpu_disabled_sync_switch =
+            ContextMTL::Cast(*context).GetIsGpuDisabledSyncSwitch();
+        is_gpu_disabled_sync_switch->Execute(
+            fml::SyncSwitch::Handlers()
+                .SetIfFalse([&render_pass, &render_command_encoder, &buffer,
+                             &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";
+                  }
+                })
+                .SetIfTrue([&render_command_encoder] {
+                  [render_command_encoder endEncoding];
+                }));
+      });
   worker_task_runner->PostTask(task);
   return true;
 }

impeller/renderer/backend/metal/context_mtl.h

@@ -35,20 +35,17 @@ class ContextMTL final : public Context,
  public:
   static std::shared_ptr<ContextMTL> Create(
       const std::vector<std::string>& shader_library_paths,
-      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner,
       std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch);
 
   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,
       std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch,
       const std::string& label);
 
   static std::shared_ptr<ContextMTL> Create(
       id<MTLDevice> device,
       id<MTLCommandQueue> command_queue,
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries_data,
-      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner,
       std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch,
       const std::string& label);
 
@@ -84,9 +81,12 @@ class ContextMTL final : public Context,
   // |Context|
   bool UpdateOffscreenLayerPixelFormat(PixelFormat format) override;
 
+  // |Context|
+  void Shutdown() override;
+
   id<MTLCommandBuffer> CreateMTLCommandBuffer(const std::string& label) const;
 
-  const std::shared_ptr<fml::ConcurrentTaskRunner>& GetWorkerTaskRunner() const;
+  const std::shared_ptr<fml::ConcurrentTaskRunner> GetWorkerTaskRunner() const;
 
   std::shared_ptr<const fml::SyncSwitch> GetIsGpuDisabledSyncSwitch() const;
 
@@ -98,15 +98,14 @@ 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_;
+  std::shared_ptr<fml::ConcurrentMessageLoop> raster_message_loop_;
   std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch_;
   bool is_valid_ = false;
 
   ContextMTL(
       id<MTLDevice> device,
       id<MTLCommandQueue> command_queue,
       NSArray<id<MTLLibrary>>* shader_libraries,
-      std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner,
       std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch);
 
   std::shared_ptr<CommandBuffer> CreateCommandBufferInQueue(