[Impeller] Give Impeller a dedicated raster priority level worker loop.

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(

impeller/renderer/backend/metal/context_mtl.mm

@@ -71,18 +71,34 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
     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)
     : device_(device),
       command_queue_(command_queue),
-      worker_task_runner_(std::move(worker_task_runner)),
       is_gpu_disabled_sync_switch_(std::move(is_gpu_disabled_sync_switch)) {
   // Validate device.
   if (!device_) {
     VALIDATION_LOG << "Could not setup valid Metal device.";
     return;
   }
 
+  // Worker task runner.
+  {
+    raster_message_loop_ = fml::ConcurrentMessageLoop::Create(
+        std::min(4u, std::thread::hardware_concurrency()));
+    raster_message_loop_->PostTaskToAllWorkers([]() {
+      // See https://github.com/flutter/flutter/issues/65752
+      // Intentionally opt out of QoS for raster task workloads.
+      [[NSThread currentThread] setThreadPriority:1.0];
+      sched_param param;
+      int policy;
+      pthread_t thread = pthread_self();
+      if (!pthread_getschedparam(thread, &policy, &param)) {
+        param.sched_priority = 50;
+        pthread_setschedparam(thread, policy, &param);
+      }
+    });
+  }
+
   // Setup the shader library.
   {
     if (shader_libraries == nil) {
@@ -210,7 +226,6 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
 
 std::shared_ptr<ContextMTL> 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) {
   auto device = CreateMetalDevice();
   auto command_queue = CreateMetalCommandQueue(device);
@@ -220,7 +235,7 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
   auto context = std::shared_ptr<ContextMTL>(new ContextMTL(
       device, command_queue,
       MTLShaderLibraryFromFilePaths(device, shader_library_paths),
-      std::move(worker_task_runner), std::move(is_gpu_disabled_sync_switch)));
+      std::move(is_gpu_disabled_sync_switch)));
   if (!context->IsValid()) {
     FML_LOG(ERROR) << "Could not create Metal context.";
     return nullptr;
@@ -230,19 +245,18 @@ 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,
     std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch,
     const std::string& library_label) {
   auto device = CreateMetalDevice();
   auto command_queue = CreateMetalCommandQueue(device);
   if (!command_queue) {
     return nullptr;
   }
-  auto context = std::shared_ptr<ContextMTL>(new ContextMTL(
-      device, command_queue,
-      MTLShaderLibraryFromFileData(device, shader_libraries_data,
-                                   library_label),
-      std::move(worker_task_runner), std::move(is_gpu_disabled_sync_switch)));
+  auto context = std::shared_ptr<ContextMTL>(
+      new ContextMTL(device, command_queue,
+                     MTLShaderLibraryFromFileData(device, shader_libraries_data,
+                                                  library_label),
+                     std::move(is_gpu_disabled_sync_switch)));
   if (!context->IsValid()) {
     FML_LOG(ERROR) << "Could not create Metal context.";
     return nullptr;
@@ -254,14 +268,13 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
     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& library_label) {
-  auto context = std::shared_ptr<ContextMTL>(new ContextMTL(
-      device, command_queue,
-      MTLShaderLibraryFromFileData(device, shader_libraries_data,
-                                   library_label),
-      std::move(worker_task_runner), std::move(is_gpu_disabled_sync_switch)));
+  auto context = std::shared_ptr<ContextMTL>(
+      new ContextMTL(device, command_queue,
+                     MTLShaderLibraryFromFileData(device, shader_libraries_data,
+                                                  library_label),
+                     std::move(is_gpu_disabled_sync_switch)));
   if (!context->IsValid()) {
     FML_LOG(ERROR) << "Could not create Metal context.";
     return nullptr;
@@ -301,9 +314,14 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
   return CreateCommandBufferInQueue(command_queue_);
 }
 
-const std::shared_ptr<fml::ConcurrentTaskRunner>&
+// |Context|
+void ContextMTL::Shutdown() {
+  raster_message_loop_.reset();
+}
+
+const std::shared_ptr<fml::ConcurrentTaskRunner>
 ContextMTL::GetWorkerTaskRunner() const {
-  return worker_task_runner_;
+  return raster_message_loop_->GetTaskRunner();
 }
 
 std::shared_ptr<const fml::SyncSwitch> ContextMTL::GetIsGpuDisabledSyncSwitch()

impeller/renderer/backend/vulkan/context_vk.cc

@@ -4,6 +4,12 @@
 
 #include "impeller/renderer/backend/vulkan/context_vk.h"
 
+#ifdef FML_OS_ANDROID
+#include <pthread.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#endif  // FML_OS_ANDROID
+
 #include <map>
 #include <memory>
 #include <optional>
@@ -120,12 +126,15 @@ void ContextVK::Setup(Settings settings) {
     return;
   }
 
-  if (!settings.worker_task_runner) {
-    VALIDATION_LOG
-        << "Cannot set up a Vulkan context without a worker task runner.";
-    return;
-  }
-  worker_task_runner_ = settings.worker_task_runner;
+  raster_message_loop_ = fml::ConcurrentMessageLoop::Create(
+      std::min(4u, std::thread::hardware_concurrency()));
+#ifdef FML_OS_ANDROID
+  raster_message_loop_->PostTaskToAllWorkers([]() {
+    if (::setpriority(PRIO_PROCESS, gettid(), -5) != 0) {
+      FML_LOG(ERROR) << "Failed to set Workers task runner priority";
+    }
+  });
+#endif  // FML_OS_ANDROID
 
   auto& dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER;
   dispatcher.init(settings.proc_address_callback);
@@ -335,10 +344,10 @@ void ContextVK::Setup(Settings settings) {
   /// Setup the pipeline library.
   ///
   auto pipeline_library = std::shared_ptr<PipelineLibraryVK>(
-      new PipelineLibraryVK(device_holder,                        //
-                            caps,                                 //
-                            std::move(settings.cache_directory),  //
-                            worker_task_runner_                   //
+      new PipelineLibraryVK(device_holder,                         //
+                            caps,                                  //
+                            std::move(settings.cache_directory),   //
+                            raster_message_loop_->GetTaskRunner()  //
                             ));
 
   if (!pipeline_library->IsValid()) {
@@ -458,7 +467,11 @@ const vk::Device& ContextVK::GetDevice() const {
 
 const std::shared_ptr<fml::ConcurrentTaskRunner>
 ContextVK::GetConcurrentWorkerTaskRunner() const {
-  return worker_task_runner_;
+  return raster_message_loop_->GetTaskRunner();
+}
+
+void ContextVK::Shutdown() {
+  raster_message_loop_->Terminate();
 }
 
 std::unique_ptr<Surface> ContextVK::AcquireNextSurface() {