[Impeller] Use the IO context for OpenGL program setup (#37)

Fix flutter-tizen/embedder#157
Impeller eagerly sets up the entire set of pipeline state objects (PSOs)
it may need during renderer setup. This works fine on mid to high-end
devices as the setup completes well before the first frame is rendered.

However on low-end devices, not all PSOs may be ready before the first
frame is rendered. Low-end device usually don't have as much available
concurrency and are slower to boot. On these devices, the rendering
thread had to wait for the background compile job to be completed. It
was also observed that the relatively higher priority render thread was
waiting on a background thread to finish a PSO compile job. The PSO
compile job could also be stuck behind another job that was not
immediately needed. This made the situation on low end devices less than
ideal.

flutter#180022, this PR fix PSO stuck
issue for Vulkan on low end devices.
Current PR can fix the PSO stuck issue for GLES on low end devices.
Related issue : flutter#176657

This PR can improve app startup time for impeller+GLES on low-end
devices.
flutter#180022 has provided solution for
impeller + vulkan.

Impeller+GLES has a special case: resource loading cannot be arbitrarily
placed on other threads; it needs to be done on the I/O thread because
this thread shares the context with the GPU thread. Therefore, this PR
introduces the I/O task runner into PipelineCompileQueueGLES. However,
since the I/O task runner may handle other tasks, we cannot put all jobs
into the I/O thread at once. My current solution is to wait for the
previous job to finish before putting the next one into the I/O thread.

Main changes:

Introduce fml::RefPtrfml::TaskRunner into PipelineCompileQueueGLES.
Extract new class PipelineCompileQueueVulkan for vulkan, because the
runners are on different threads.

(cherry picked from commit 92a8430)

Author: xiaowei-guan

engine/src/flutter/impeller/renderer/BUILD.gn

@@ -104,6 +104,7 @@ template("renderer_unittests_component") {
     "blit_pass_unittests.cc",
     "capabilities_unittests.cc",
     "device_buffer_unittests.cc",
+    "pipeline_compile_queue_unittests.cc",
     "pipeline_descriptor_unittests.cc",
     "pipeline_library_unittests.cc",
     "pool_unittests.cc",

engine/src/flutter/impeller/renderer/backend/gles/BUILD.gn

@@ -24,6 +24,7 @@ impeller_component("gles_unittests") {
     "test/mock_gles.cc",
     "test/mock_gles.h",
     "test/mock_gles_unittests.cc",
+    "test/pipeline_compile_queue_gles_unittests.cc",
     "test/pipeline_library_gles_unittests.cc",
     "test/proc_table_gles_unittests.cc",
     "test/reactor_unittests.cc",
@@ -34,6 +35,7 @@ impeller_component("gles_unittests") {
   ]
   deps = [
     ":gles",
+    "//flutter/fml",
     "//flutter/impeller/playground:playground_test",
     "//flutter/testing:testing_lib",
   ]
@@ -68,6 +70,8 @@ impeller_component("gles") {
     "gpu_tracer_gles.h",
     "handle_gles.cc",
     "handle_gles.h",
+    "pipeline_compile_queue_gles.cc",
+    "pipeline_compile_queue_gles.h",
     "pipeline_gles.cc",
     "pipeline_gles.h",
     "pipeline_library_gles.cc",

engine/src/flutter/impeller/renderer/backend/gles/context_gles.cc

@@ -22,16 +22,19 @@ std::shared_ptr<ContextGLES> ContextGLES::Create(
     const Flags& flags,
     std::unique_ptr<ProcTableGLES> gl,
     const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-    bool enable_gpu_tracing) {
-  return std::shared_ptr<ContextGLES>(new ContextGLES(
-      flags, std::move(gl), shader_libraries, enable_gpu_tracing));
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner) {
+  return std::shared_ptr<ContextGLES>(
+      new ContextGLES(flags, std::move(gl), shader_libraries,
+                      enable_gpu_tracing, std::move(io_task_runner)));
 }
 
 ContextGLES::ContextGLES(
     const Flags& flags,
     std::unique_ptr<ProcTableGLES> gl,
     const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries_mappings,
-    bool enable_gpu_tracing)
+    bool enable_gpu_tracing,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
     : Context(flags) {
   reactor_ = std::make_shared<ReactorGLES>(std::move(gl));
   if (!reactor_->IsValid()) {
@@ -52,8 +55,8 @@ ContextGLES::ContextGLES(
 
   // Create the pipeline library.
   {
-    pipeline_library_ =
-        std::shared_ptr<PipelineLibraryGLES>(new PipelineLibraryGLES(reactor_));
+    pipeline_library_ = std::shared_ptr<PipelineLibraryGLES>(
+        new PipelineLibraryGLES(reactor_, std::move(io_task_runner)));
   }
 
   // Create allocators.

engine/src/flutter/impeller/renderer/backend/gles/context_gles.h

@@ -28,7 +28,8 @@ class ContextGLES final : public Context,
       const Flags& flags,
       std::unique_ptr<ProcTableGLES> gl,
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-      bool enable_gpu_tracing);
+      bool enable_gpu_tracing,
+      fml::RefPtr<fml::TaskRunner> io_task_runner = nullptr);
 
   // |Context|
   ~ContextGLES() override;
@@ -64,7 +65,8 @@ class ContextGLES final : public Context,
       const Flags& flags,
       std::unique_ptr<ProcTableGLES> gl,
       const std::vector<std::shared_ptr<fml::Mapping>>& shader_libraries,
-      bool enable_gpu_tracing);
+      bool enable_gpu_tracing,
+      fml::RefPtr<fml::TaskRunner> io_task_runner = nullptr);
 
   // |Context|
   std::string DescribeGpuModel() const override;

engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.cc

@@ -0,0 +1,72 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/gles/pipeline_compile_queue_gles.h"
+
+#include "flutter/fml/logging.h"
+#include "flutter/fml/trace_event.h"
+#include "impeller/base/validation.h"
+
+namespace impeller {
+
+std::shared_ptr<PipelineCompileQueueGLES> PipelineCompileQueueGLES::Create(
+    fml::RefPtr<fml::TaskRunner> worker_task_runner) {
+  if (!worker_task_runner) {
+    return nullptr;
+  }
+  return std::shared_ptr<PipelineCompileQueueGLES>(
+      new PipelineCompileQueueGLES(std::move(worker_task_runner)));
+}
+
+PipelineCompileQueueGLES::PipelineCompileQueueGLES(
+    fml::RefPtr<fml::TaskRunner> worker_task_runner)
+    : worker_task_runner_(std::move(worker_task_runner)) {}
+
+PipelineCompileQueueGLES::~PipelineCompileQueueGLES() = default;
+
+void PipelineCompileQueueGLES::OnJobAdded() {
+  // To prevent potential deadlocks and reduce lock contention, avoid calling
+  // external or virtual methods (such as DrainPendingJobs, which posts tasks
+  // to the task runner) while holding a mutex. Instead, minimize the scope of
+  // the lock by using a local boolean flag to trigger the draining process
+  // outside the lock block.
+  bool should_drain = false;
+  {
+    Lock lock(processing_mutex_);
+    if (!is_processing_) {
+      is_processing_ = true;
+      should_drain = true;
+    }
+  }
+  if (should_drain) {
+    DrainPendingJobs();
+  }
+}
+
+void PipelineCompileQueueGLES::PostJob(const fml::closure& job) {
+  if (!job) {
+    return;
+  }
+
+  worker_task_runner_->PostTask(job);
+}
+
+void PipelineCompileQueueGLES::DrainPendingJobs() {
+  PostJob([weak_queue = weak_from_this()]() {
+    if (auto queue = std::static_pointer_cast<PipelineCompileQueueGLES>(
+            weak_queue.lock())) {
+      queue->DoOneJob();
+      {
+        Lock lock(queue->processing_mutex_);
+        if (!queue->HasPendingJobs()) {
+          queue->is_processing_ = false;
+          return;
+        }
+      }
+      queue->DrainPendingJobs();
+    }
+  });
+}
+
+}  // namespace impeller

engine/src/flutter/impeller/renderer/backend/gles/pipeline_compile_queue_gles.h

@@ -0,0 +1,63 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_
+#define FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_
+
+#include "flutter/fml/closure.h"
+#include "flutter/fml/task_runner.h"
+#include "impeller/base/thread.h"
+#include "impeller/renderer/pipeline_compile_queue.h"
+
+namespace impeller {
+
+//------------------------------------------------------------------------------
+/// @brief      A task queue designed for managing compilation of pipeline state
+///             objects for OpenGL ES backend.
+///
+///             This subclass uses a fml::TaskRunner as the worker task runner
+///             and implements a sequential job processing mechanism to prevent
+///             blocking the IO task runner.
+///
+///             Key characteristics:
+///             - Uses fml::RefPtr<fml::TaskRunner> for worker_task_runner_
+///             - Processes jobs sequentially: loads one job at a time before
+///               proceeding to the next, preventing IO task runner blocking
+///             - Uses DrainPendingJobs() to recursively process jobs one by one
+///             - Employs is_processing_ flag and processing_mutex_ to control
+///               sequential processing
+///
+///             The sequential processing ensures that pipeline compilation jobs
+///             do not overwhelm the task runner, which is particularly
+///             important for GLES backend where resource loading patterns
+///             differ from Vulkan.
+///
+class PipelineCompileQueueGLES : public PipelineCompileQueue {
+ public:
+  static std::shared_ptr<PipelineCompileQueueGLES> Create(
+      fml::RefPtr<fml::TaskRunner> worker_task_runner);
+
+  ~PipelineCompileQueueGLES() override;
+
+  PipelineCompileQueueGLES(const PipelineCompileQueueGLES&) = delete;
+
+  PipelineCompileQueueGLES& operator=(const PipelineCompileQueueGLES&) = delete;
+
+  void PostJob(const fml::closure& job) override;
+
+  void OnJobAdded() override;
+
+ private:
+  explicit PipelineCompileQueueGLES(
+      fml::RefPtr<fml::TaskRunner> worker_task_runner);
+  void DrainPendingJobs();
+
+  fml::RefPtr<fml::TaskRunner> worker_task_runner_;
+  Mutex processing_mutex_;
+  bool is_processing_ IPLR_GUARDED_BY(processing_mutex_) = false;
+};
+
+}  // namespace impeller
+
+#endif  // FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_PIPELINE_COMPILE_QUEUE_GLES_H_

engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.cc

@@ -16,8 +16,12 @@
 
 namespace impeller {
 
-PipelineLibraryGLES::PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor)
-    : reactor_(std::move(reactor)) {}
+PipelineLibraryGLES::PipelineLibraryGLES(
+    std::shared_ptr<ReactorGLES> reactor,
+    fml::RefPtr<fml::TaskRunner> io_task_runner)
+    : reactor_(std::move(reactor)),
+      compile_queue_(
+          PipelineCompileQueueGLES::Create(std::move(io_task_runner))) {}
 
 static std::string GetShaderInfoLog(const ProcTableGLES& gl, GLuint shader) {
   GLint log_length = 0;
@@ -296,17 +300,34 @@ PipelineFuture<PipelineDescriptor> PipelineLibraryGLES::GetPipeline(
       PipelineFuture<PipelineDescriptor>{descriptor, promise->get_future()};
   pipelines_[descriptor] = pipeline_future;
 
-  const auto result = reactor_->AddOperation([promise,                       //
-                                              weak_this = weak_from_this(),  //
-                                              descriptor,                    //
-                                              vert_function,                 //
-                                              frag_function,                 //
-                                              threadsafe                     //
-  ](const ReactorGLES& reactor) {
-    promise->set_value(CreatePipeline(weak_this, descriptor, vert_function,
-                                      frag_function, threadsafe));
-  });
-  FML_CHECK(result);
+  auto weak_this = weak_from_this();
+  auto reactor = reactor_;
+  auto generation_task = [promise, weak_this, descriptor, vert_function,
+                          frag_function, threadsafe, reactor]() {
+    auto thiz = weak_this.lock();
+    if (!thiz) {
+      promise->set_value(nullptr);
+      return;
+    }
+    const auto result = reactor->AddOperation([promise,        //
+                                               weak_this,      //
+                                               descriptor,     //
+                                               vert_function,  //
+                                               frag_function,  //
+                                               threadsafe      //
+    ](const ReactorGLES& reactor) {
+      promise->set_value(CreatePipeline(weak_this, descriptor, vert_function,
+                                        frag_function, threadsafe));
+    });
+    FML_CHECK(result);
+  };
+
+  if (async && compile_queue_) {
+    compile_queue_->PostJobForDescriptor(descriptor,
+                                         std::move(generation_task));
+  } else {
+    generation_task();
+  }
 
   return pipeline_future;
 }
@@ -373,4 +394,8 @@ void PipelineLibraryGLES::SetProgramForKey(
   programs_[key] = std::move(program);
 }
 
+PipelineCompileQueue* PipelineLibraryGLES::GetPipelineCompileQueue() const {
+  return compile_queue_.get();
+}
+
 }  // namespace impeller

engine/src/flutter/impeller/renderer/backend/gles/pipeline_library_gles.h

@@ -9,7 +9,9 @@
 #include <vector>
 
 #include "flutter/fml/hash_combine.h"
+#include "flutter/fml/task_runner.h"
 #include "impeller/base/thread.h"
+#include "impeller/renderer/backend/gles/pipeline_compile_queue_gles.h"
 #include "impeller/renderer/backend/gles/reactor_gles.h"
 #include "impeller/renderer/backend/gles/unique_handle_gles.h"
 #include "impeller/renderer/pipeline_library.h"
@@ -91,8 +93,10 @@ class PipelineLibraryGLES final
   PipelineMap pipelines_;
   Mutex programs_mutex_;
   ProgramMap programs_ IPLR_GUARDED_BY(programs_mutex_);
+  std::shared_ptr<PipelineCompileQueueGLES> compile_queue_;
 
-  explicit PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor);
+  explicit PipelineLibraryGLES(std::shared_ptr<ReactorGLES> reactor,
+                               fml::RefPtr<fml::TaskRunner> io_task_runner);
 
   // |PipelineLibrary|
   bool IsValid() const override;
@@ -127,6 +131,8 @@ class PipelineLibraryGLES final
 
   void SetProgramForKey(const ProgramKey& key,
                         std::shared_ptr<UniqueHandleGLES> program);
+  // |PipelineLibrary|
+  PipelineCompileQueue* GetPipelineCompileQueue() const override;
 };
 
 }  // namespace impeller