[WIP] integrated skp shader warmup

freiling · freiling · commit 8cd322f63a62 · 2020-08-13T06:27:08.000Z
diff --git a/assets/asset_manager.cc b/assets/asset_manager.cc
@@ -47,6 +47,24 @@ std::unique_ptr<fml::Mapping> AssetManager::GetAsMapping(
   return nullptr;
 }
 
+// |AssetResolver|
+std::vector<std::unique_ptr<fml::Mapping>> AssetManager::GetAsMappings(
+    const std::string& asset_pattern) const {
+  std::vector<std::unique_ptr<fml::Mapping>> mappings;
+  if (asset_pattern.size() == 0) {
+    return mappings;
+  }
+  TRACE_EVENT1("flutter", "AssetManager::GetAsMappings", "pattern",
+               asset_pattern.c_str());
+  for (const auto& resolver : resolvers_) {
+    auto resolver_mappings = resolver->GetAsMappings(asset_pattern);
+    mappings.insert(mappings.end(),
+                    std::make_move_iterator(resolver_mappings.begin()),
+                    std::make_move_iterator(resolver_mappings.end()));
+  }
+  return mappings;
+}
+
 // |AssetResolver|
 bool AssetManager::IsValid() const {
   return resolvers_.size() > 0;
diff --git a/assets/asset_manager.h b/assets/asset_manager.h
@@ -32,6 +32,10 @@ class AssetManager final : public AssetResolver {
   std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const override;
 
+  // |AssetResolver|
+  std::vector<std::unique_ptr<fml::Mapping>> GetAsMappings(
+      const std::string& asset_pattern) const override;
+
  private:
   std::deque<std::unique_ptr<AssetResolver>> resolvers_;
 
diff --git a/assets/asset_resolver.h b/assets/asset_resolver.h
@@ -24,6 +24,11 @@ class AssetResolver {
   [[nodiscard]] virtual std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const = 0;
 
+  // Same as GetAsMapping() but returns mappings for all files who's name
+  // matches |pattern|. Returns empty vector if no matching assets are found
+  [[nodiscard]] virtual std::vector<std::unique_ptr<fml::Mapping>>
+  GetAsMappings(const std::string& asset_pattern) const = 0;
+
  private:
   FML_DISALLOW_COPY_AND_ASSIGN(AssetResolver);
 };
diff --git a/assets/directory_asset_bundle.cc b/assets/directory_asset_bundle.cc
@@ -4,6 +4,7 @@
 
 #include "flutter/assets/directory_asset_bundle.h"
 
+#include <regex>
 #include <utility>
 
 #include "flutter/fml/eintr_wrapper.h"
@@ -45,4 +46,32 @@ std::unique_ptr<fml::Mapping> DirectoryAssetBundle::GetAsMapping(
   return mapping;
 }
 
+std::vector<std::unique_ptr<fml::Mapping>> DirectoryAssetBundle::GetAsMappings(
+    const std::string& asset_pattern) const {
+  std::vector<std::unique_ptr<fml::Mapping>> mappings;
+  if (!is_valid_) {
+    FML_DLOG(WARNING) << "Asset bundle was not valid.";
+    return mappings;
+  }
+
+  std::regex asset_regex(asset_pattern);
+  fml::FileVisitor visitor = [&](const fml::UniqueFD& directory,
+                                 const std::string& filename) {
+    if (std::regex_match(filename, asset_regex)) {
+      auto mapping = std::make_unique<fml::FileMapping>(fml::OpenFile(
+          directory, filename.c_str(), false, fml::FilePermission::kRead));
+
+      if (mapping && mapping->IsValid()) {
+        mappings.push_back(std::move(mapping));
+      } else {
+        FML_LOG(ERROR) << "Mapping " << filename << " failed";
+      }
+    }
+    return true;
+  };
+  fml::VisitFilesRecursively(descriptor_, visitor);
+
+  return mappings;
+}
+
 }  // namespace flutter
diff --git a/assets/directory_asset_bundle.h b/assets/directory_asset_bundle.h
@@ -29,6 +29,10 @@ class DirectoryAssetBundle : public AssetResolver {
   std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const override;
 
+  // |AssetResolver|
+  std::vector<std::unique_ptr<fml::Mapping>> GetAsMappings(
+      const std::string& asset_pattern) const override;
+
   FML_DISALLOW_COPY_AND_ASSIGN(DirectoryAssetBundle);
 };
 
diff --git a/shell/common/persistent_cache.cc b/shell/common/persistent_cache.cc
@@ -361,4 +361,14 @@ void PersistentCache::SetAssetManager(std::shared_ptr<AssetManager> value) {
   asset_manager_ = value;
 }
 
+std::vector<std::unique_ptr<fml::Mapping>>
+PersistentCache::GetSkpsFromAssetManager() const {
+  if (!asset_manager_) {
+    FML_LOG(ERROR)
+        << "PersistentCache::GetSkpsFromAssetManager: Asset manager not set!";
+    return std::vector<std::unique_ptr<fml::Mapping>>();
+  }
+  return asset_manager_->GetAsMappings(".*\\.skp$");
+}
+
 }  // namespace flutter
diff --git a/shell/common/persistent_cache.h b/shell/common/persistent_cache.h
@@ -66,6 +66,9 @@ class PersistentCache : public GrContextOptions::PersistentCache {
   /// Load all the SkSL shader caches in the right directory.
   std::vector<SkSLCache> LoadSkSLs();
 
+  // Return mappings for all skp's accessible through the AssetManager
+  std::vector<std::unique_ptr<fml::Mapping>> GetSkpsFromAssetManager() const;
+
   /// Set the asset manager from which PersistentCache can load SkLSs. A nullptr
   /// can be provided to clear the asset manager.
   static void SetAssetManager(std::shared_ptr<AssetManager> value);
diff --git a/shell/platform/fuchsia/flutter/compositor_context.cc b/shell/platform/fuchsia/flutter/compositor_context.cc
@@ -78,7 +78,13 @@ CompositorContext::CompositorContext(
           std::move(session),
           session_error_callback,
           [](auto) {},
-          vsync_event_handle) {}
+          vsync_event_handle) {
+  SkISize size = SkISize::Make(1024, 600);
+  skp_warmup_surface_ = session_connection_.vulkan_surface_producer()->ProduceOffscreenSurface(size);
+  if (!skp_warmup_surface_) {
+    FML_LOG(ERROR) << "SkSurface::MakeRenderTarget returned null";
+  }
+}
 
 void CompositorContext::OnSessionMetricsDidChange(
     const fuchsia::ui::gfx::Metrics& metrics) {
@@ -131,4 +137,9 @@ CompositorContext::AcquireFrame(
   );
 }
 
+void CompositorContext::WarmupSkp(const sk_sp<SkPicture> picture) {
+  skp_warmup_surface_->getCanvas()->drawPicture(picture);
+  session_connection_.vulkan_surface_producer()->gr_context()->flush();
+}
+
 }  // namespace flutter_runner
diff --git a/shell/platform/fuchsia/flutter/compositor_context.h b/shell/platform/fuchsia/flutter/compositor_context.h
@@ -38,6 +38,8 @@ class CompositorContext final : public flutter::CompositorContext {
   void OnCreateView(int64_t view_id, bool hit_testable, bool focusable);
   void OnDestroyView(int64_t view_id);
 
+  void WarmupSkp(sk_sp<SkPicture> picture);
+
   flutter::ExternalViewEmbedder* GetViewEmbedder() {
     return &session_connection_.scene_update_context();
   }
@@ -46,6 +48,7 @@ class CompositorContext final : public flutter::CompositorContext {
   const std::string debug_label_;
   scenic::ViewRefPair view_ref_pair_;
   SessionConnection session_connection_;
+  sk_sp<SkSurface> skp_warmup_surface_;
 
   // |flutter::CompositorContext|
   std::unique_ptr<ScopedFrame> AcquireFrame(
diff --git a/shell/platform/fuchsia/flutter/engine.cc b/shell/platform/fuchsia/flutter/engine.cc
@@ -15,10 +15,14 @@
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/fml/task_runner.h"
 #include "flutter/runtime/dart_vm_lifecycle.h"
+#include "flutter/shell/common/persistent_cache.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/run_configuration.h"
+#include "flutter/shell/common/serialization_callbacks.h"
 #include "flutter_runner_product_configuration.h"
 #include "fuchsia_intl.h"
+#include "include/core/SkPicture.h"
+#include "include/core/SkSerialProcs.h"
 #include "platform_view.h"
 #include "runtime/dart/utils/files.h"
 #include "task_runner_adapter.h"
@@ -198,34 +202,6 @@ Engine::Engine(Delegate& delegate,
       CreateFMLTaskRunner(threads_[2]->dispatcher())        // io
   );
 
-  // Setup the callback that will instantiate the rasterizer.
-  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer =
-      fml::MakeCopyable([thread_label = thread_label_,              //
-                         view_token = std::move(view_token),        //
-                         view_ref_pair = std::move(view_ref_pair),  //
-                         session = std::move(session),              //
-                         on_session_error_callback,                 //
-                         vsync_event = vsync_event_.get()           //
-  ](flutter::Shell& shell) mutable {
-        std::unique_ptr<flutter_runner::CompositorContext> compositor_context;
-        {
-          TRACE_DURATION("flutter", "CreateCompositorContext");
-          compositor_context =
-              std::make_unique<flutter_runner::CompositorContext>(
-                  thread_label,           // debug label
-                  std::move(view_token),  // scenic view we attach our tree to
-                  std::move(view_ref_pair),  // scenic view ref/view ref control
-                  std::move(session),        // scenic session
-                  on_session_error_callback,  // session did encounter error
-                  vsync_event);               // vsync event handle
-        }
-
-        return std::make_unique<flutter::Rasterizer>(
-            /*task_runners=*/shell.GetTaskRunners(),
-            /*compositor_context=*/std::move(compositor_context),
-            /*is_gpu_disabled_sync_switch=*/shell.GetIsGpuDisabledSyncSwitch());
-      });
-
   UpdateNativeThreadLabelNames(thread_label_, task_runners);
 
   settings_.verbose_logging = true;
@@ -247,6 +223,76 @@ Engine::Engine(Delegate& delegate,
         });
       });
 
+  // Launch the engine in the appropriate configuration.
+  auto run_configuration = flutter::RunConfiguration::InferFromSettings(
+      settings_, task_runners.GetIOTaskRunner());
+
+  // Setup the callback that will instantiate the rasterizer.
+  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer =
+      fml::MakeCopyable([thread_label = thread_label_,              //
+                         view_token = std::move(view_token),        //
+                         view_ref_pair = std::move(view_ref_pair),  //
+                         session = std::move(session),              //
+                         on_session_error_callback,                 //
+                         vsync_event = vsync_event_.get()           //
+  ](flutter::Shell& shell) mutable {
+        std::unique_ptr<flutter_runner::CompositorContext> compositor_context;
+        {
+          {
+            TRACE_DURATION("flutter", "CreateCompositorContext");
+            compositor_context =
+                std::make_unique<flutter_runner::CompositorContext>(
+                    thread_label,           // debug label
+                    std::move(view_token),  // scenic view we attach our tree to
+                    std::move(view_ref_pair),  // scenic view ref/view ref control
+                    std::move(session),        // scenic session
+                    on_session_error_callback,  // session did encounter error
+                    vsync_event);               // vsync event handle
+          }
+
+
+          // tell concurrent task runner to deserialize all skps available from
+          // the asset manager
+          shell.GetDartVM()->GetConcurrentMessageLoop()->GetTaskRunner()->PostTask([raster_task_runner =
+                          shell.GetTaskRunners().GetRasterTaskRunner(),
+                      compositor_context = compositor_context.get()]() {
+            TRACE_DURATION("flutter", "DeserializeSkps");
+            std::vector<std::unique_ptr<fml::Mapping>> skp_mappings =
+                flutter::PersistentCache::GetCacheForProcess()
+                    ->GetSkpsFromAssetManager();
+            std::vector<sk_sp<SkPicture>> pictures;
+            int i = 0;
+            for (auto& mapping : skp_mappings) {
+              
+              std::unique_ptr<SkMemoryStream> stream =
+                  SkMemoryStream::MakeDirect(mapping->GetMapping(),
+                                             mapping->GetSize());
+              SkDeserialProcs procs = {0};
+              procs.fImageProc = flutter::DeserializeImageWithoutData;
+              procs.fTypefaceProc = flutter::DeserializeTypefaceWithoutData;
+              sk_sp<SkPicture> picture =
+                  SkPicture::MakeFromStream(stream.get(), &procs);
+              if (!picture) {
+                FML_LOG(ERROR) << "Failed to deserialize picture " << i++;
+                continue;
+              }
+
+              // Tell raster task runner to warmup have the compositor
+              // context warm up the newly deserialized picture
+              raster_task_runner->PostTask([compositor_context, picture] {
+                TRACE_DURATION("flutter", "WarmupSkp");
+                compositor_context->WarmupSkp(picture);
+              });
+            }
+          });
+        }
+
+        return std::make_unique<flutter::Rasterizer>(
+            /*task_runners=*/shell.GetTaskRunners(),
+            /*compositor_context=*/std::move(compositor_context),
+            /*is_gpu_disabled_sync_switch=*/shell.GetIsGpuDisabledSyncSwitch());
+      });
+
   auto vm = flutter::DartVMRef::Create(settings_);
 
   if (!isolate_snapshot) {
@@ -337,10 +383,6 @@ Engine::Engine(Delegate& delegate,
     };
   }
 
-  // Launch the engine in the appropriate configuration.
-  auto run_configuration = flutter::RunConfiguration::InferFromSettings(
-      settings_, task_runners.GetIOTaskRunner());
-
   auto on_run_failure = [weak = weak_factory_.GetWeakPtr()]() {
     // The engine could have been killed by the caller right after the
     // constructor was called but before it could run on the UI thread.
diff --git a/shell/platform/fuchsia/flutter/vulkan_surface_pool.h b/shell/platform/fuchsia/flutter/vulkan_surface_pool.h
@@ -26,6 +26,7 @@ class VulkanSurfacePool final {
 
   ~VulkanSurfacePool();
 
+  std::unique_ptr<VulkanSurface> CreateSurface(const SkISize& size);
   std::unique_ptr<VulkanSurface> AcquireSurface(const SkISize& size);
 
   void SubmitSurface(
@@ -73,7 +74,6 @@ class VulkanSurfacePool final {
 
   std::unique_ptr<VulkanSurface> GetCachedOrCreateSurface(const SkISize& size);
 
-  std::unique_ptr<VulkanSurface> CreateSurface(const SkISize& size);
 
   void RecycleSurface(std::unique_ptr<VulkanSurface> surface);
 
diff --git a/shell/platform/fuchsia/flutter/vulkan_surface_producer.cc b/shell/platform/fuchsia/flutter/vulkan_surface_producer.cc
@@ -278,4 +278,9 @@ void VulkanSurfaceProducer::SubmitSurface(
   surface_pool_->SubmitSurface(std::move(surface));
 }
 
+sk_sp<SkSurface> VulkanSurfaceProducer::ProduceOffscreenSurface(const SkISize& size){
+  return urface_pool_->CreateSurface(size)->CreateSurface(size);
+}
+
+
 }  // namespace flutter_runner
diff --git a/shell/platform/fuchsia/flutter/vulkan_surface_producer.h b/shell/platform/fuchsia/flutter/vulkan_surface_producer.h
@@ -38,6 +38,8 @@ class VulkanSurfaceProducer final
                  const flutter::LayerRasterCacheKey& layer_key,
                  std::unique_ptr<scenic::EntityNode> entity_node) override;
 
+  sk_sp<SkSurface> ProduceOffscreenSurface(const SkISize& size);
+
   // |flutter::SceneUpdateContext::SurfaceProducer|
   void SubmitSurface(
       std::unique_ptr<flutter::SceneUpdateContext::SurfaceProducerSurface>
