[Impeller] Affinity adjustments for Vulkan backend.

fml/cpu_affinity.cc

@@ -61,7 +61,6 @@ const std::vector<size_t>& CPUSpeedTracker::GetIndices(
 // required because files under /proc do not always return a valid size
 // when using fseek(0, SEEK_END) + ftell(). Nor can they be mmap()-ed.
 std::optional<int64_t> ReadIntFromFile(const std::string& path) {
-  // size_t data_length = 0u;
   std::ifstream file;
   file.open(path.c_str());
 

fml/platform/android/cpu_affinity.cc

@@ -11,6 +11,7 @@
 #include <mutex>
 #include <optional>
 #include <thread>
+#include "flutter/fml/logging.h"
 
 namespace fml {
 
@@ -36,15 +37,27 @@ void InitCPUInfo(size_t cpu_count) {
   gCPUTracker = new CPUSpeedTracker(cpu_speeds);
 }
 
-bool RequestAffinity(CpuAffinity affinity) {
+bool SetUpCPUTracker() {
   // Populate CPU Info if uninitialized.
   auto count = std::thread::hardware_concurrency();
   std::call_once(gCPUTrackerFlag, [count]() { InitCPUInfo(count); });
-  if (gCPUTracker == nullptr) {
+  if (gCPUTracker == nullptr || !gCPUTracker->IsValid()) {
+    return false;
+  }
+  return true;
+}
+
+std::optional<size_t> EfficiencyCoreCount() {
+  if (!SetUpCPUTracker()) {
     return true;
   }
+  auto result = gCPUTracker->GetIndices(CpuAffinity::kEfficiency).size();
+  FML_DCHECK(result > 0);
+  return result;
+}
 
-  if (!gCPUTracker->IsValid()) {
+bool RequestAffinity(CpuAffinity affinity) {
+  if (!SetUpCPUTracker()) {
     return true;
   }
 

fml/platform/android/cpu_affinity.h

@@ -8,6 +8,14 @@
 
 namespace fml {
 
+/// @brief Request count of efficiency cores.
+///
+///        Efficiency cores are defined as those with the lowest reported
+///        cpu_max_freq. If the CPU speed could not be determined, or if all
+///        cores have the same reported speed then this returns std::nullopt.
+///        That is, the result will never be 0.
+std::optional<size_t> EfficiencyCoreCount();
+
 /// @brief Request the given affinity for the current thread.
 ///
 ///        Returns true if successfull, or if it was a no-op. This function is

impeller/renderer/backend/vulkan/context_vk.cc

@@ -8,6 +8,7 @@
 #include <pthread.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include "flutter/fml/platform/android/cpu_affinity.h"
 #endif  // FML_OS_ANDROID
 
 #include <map>
@@ -132,6 +133,9 @@ void ContextVK::Setup(Settings settings) {
       std::min(4u, std::thread::hardware_concurrency()));
 #ifdef FML_OS_ANDROID
   raster_message_loop_->PostTaskToAllWorkers([]() {
+    // Currently we only use the worker task pool for small parts of a frame
+    // workload, if this changes this setting may need to be adjusted.
+    fml::RequestAffinity(fml::CpuAffinity::kNotPerformance);
     if (::setpriority(PRIO_PROCESS, gettid(), -5) != 0) {
       FML_LOG(ERROR) << "Failed to set Workers task runner priority";
     }

impeller/renderer/backend/vulkan/fence_waiter_vk.cc

@@ -8,6 +8,11 @@
 #include <chrono>
 #include <utility>
 
+#ifdef FML_OS_ANDROID
+#include "flutter/fml/platform/android/cpu_affinity.h"
+#include "fml/cpu_affinity.h"
+#endif  // FML_OS_ANDROID
+
 #include "flutter/fml/thread.h"
 #include "flutter/fml/trace_event.h"
 #include "impeller/base/validation.h"
@@ -86,8 +91,11 @@ static std::vector<vk::Fence> GetFencesForWaitSet(const WaitSet& set) {
 void FenceWaiterVK::Main() {
   fml::Thread::SetCurrentThreadName(
       fml::Thread::ThreadConfig{"io.flutter.impeller.fence_waiter"});
-
+#ifdef FML_OS_ANDROID
+  // Since this thread mostly waits on fences, it doesn't need to be fast.
+  fml::RequestAffinity(fml::CpuAffinity::kEfficiency);
   using namespace std::literals::chrono_literals;
+#endif  // FML_OS_ANDROID
 
   while (true) {
     // We'll read the terminate_ flag within the lock below.

impeller/renderer/backend/vulkan/resource_manager_vk.cc

@@ -8,6 +8,11 @@
 #include "flutter/fml/trace_event.h"
 #include "fml/logging.h"
 
+#ifdef FML_OS_ANDROID
+#include "flutter/fml/platform/android/cpu_affinity.h"
+#include "fml/cpu_affinity.h"
+#endif  // FML_OS_ANDROID
+
 namespace impeller {
 
 std::shared_ptr<ResourceManagerVK> ResourceManagerVK::Create() {
@@ -39,6 +44,11 @@ void ResourceManagerVK::Start() {
 
   fml::Thread::SetCurrentThreadName(
       fml::Thread::ThreadConfig{"io.flutter.impeller.resource_manager"});
+#ifdef FML_OS_ANDROID
+  // While this code calls destructors it doesn't need to be particularly fast
+  // with them, as long as it doesn't interrupt raster thread.
+  fml::RequestAffinity(fml::CpuAffinity::kEfficiency);
+#endif  // FML_OS_ANDROID
 
   bool should_exit = false;
   while (!should_exit) {

runtime/dart_vm.cc

@@ -29,6 +29,10 @@
 #include "third_party/tonic/logging/dart_error.h"
 #include "third_party/tonic/typed_data/typed_list.h"
 
+#ifdef FML_OS_ANDROID
+#include "flutter/fml/platform/android/cpu_affinity.h"
+#endif  // FML_OS_ANDROID
+
 namespace dart {
 namespace observatory {
 
@@ -285,7 +289,13 @@ size_t DartVM::GetVMLaunchCount() {
 DartVM::DartVM(const std::shared_ptr<const DartVMData>& vm_data,
                std::shared_ptr<IsolateNameServer> isolate_name_server)
     : settings_(vm_data->GetSettings()),
+#ifdef FML_OS_ANDROID
+      concurrent_message_loop_(fml::ConcurrentMessageLoop::Create(
+          fml::EfficiencyCoreCount().value_or(
+              std::thread::hardware_concurrency()))),
+#else
       concurrent_message_loop_(fml::ConcurrentMessageLoop::Create()),
+#endif  // FML_OS_ANDROID
       skia_concurrent_executor_(
           [runner = concurrent_message_loop_->GetTaskRunner()](
               const fml::closure& work) { runner->PostTask(work); }),