[fuchsia] Add shell test for skp based shader warmup

Author: freiling

shell/common/BUILD.gn

@@ -264,6 +264,7 @@ if (enable_unittests) {
       "persistent_cache_unittests.cc",
       "pipeline_unittests.cc",
       "shell_unittests.cc",
+      "skp_shader_warmup_unittests.cc",
     ]
 
     deps = [

shell/common/skp_shader_warmup_unittests.cc

@@ -0,0 +1,200 @@
+// 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 <memory>
+
+#include "flutter/assets/directory_asset_bundle.h"
+#include "flutter/flow/layers/container_layer.h"
+#include "flutter/flow/layers/layer.h"
+#include "flutter/flow/layers/physical_shape_layer.h"
+#include "flutter/flow/layers/picture_layer.h"
+#include "flutter/fml/command_line.h"
+#include "flutter/fml/file.h"
+#include "flutter/fml/log_settings.h"
+#include "flutter/fml/unique_fd.h"
+#include "flutter/shell/common/persistent_cache.h"
+#include "flutter/shell/common/shell_test.h"
+#include "flutter/shell/common/switches.h"
+#include "flutter/shell/version/version.h"
+#include "flutter/testing/testing.h"
+#include "include/core/SkPicture.h"
+
+namespace flutter {
+namespace testing {
+
+#if defined(OS_FUCHSIA)
+
+static void WaitForIO(Shell* shell) {
+  std::promise<bool> io_task_finished;
+  shell->GetTaskRunners().GetIOTaskRunner()->PostTask(
+      [&io_task_finished]() { io_task_finished.set_value(true); });
+  io_task_finished.get_future().wait();
+}
+
+class SkpWarmupTest : public ShellTest {
+ public:
+  SkpWarmupTest() {}
+
+  void TestWarmup(const LayerTreeBuilder& builder) {
+    // Create a temp dir to store the persistent cache
+    fml::ScopedTemporaryDirectory dir;
+    PersistentCache::SetCacheDirectoryPath(dir.path());
+    PersistentCache::ResetCacheForProcess();
+
+    auto settings = CreateSettingsForFixture();
+    settings.cache_sksl = true;
+    settings.dump_skp_on_shader_compilation = true;
+
+    fml::AutoResetWaitableEvent firstFrameLatch;
+    settings.frame_rasterized_callback =
+        [&firstFrameLatch](const FrameTiming& t) { firstFrameLatch.Signal(); };
+
+    auto config = RunConfiguration::InferFromSettings(settings);
+    config.SetEntrypoint("emptyMain");
+    std::unique_ptr<Shell> shell = CreateShell(settings);
+    PlatformViewNotifyCreated(shell.get());
+    RunEngine(shell.get(), std::move(config));
+
+    // Initially, we should have no SkSL cache
+    auto cache = PersistentCache::GetCacheForProcess()->LoadSkSLs();
+    ASSERT_EQ(cache.size(), 0u);
+
+    PumpOneFrame(shell.get(), 100, 100, builder);
+    firstFrameLatch.Wait();
+    WaitForIO(shell.get());
+
+    // Count the number of shaders this builder generated. We use this as a
+    // proxy for whether new shaders were generated, since skia will dump an skp
+    // any time a new shader is compiled.
+    int skp_count = 0;
+    fml::FileVisitor skp_count_visitor = [&skp_count](
+                                             const fml::UniqueFD& directory,
+                                             const std::string& filename) {
+      if (filename.size() >= 4 &&
+          filename.substr(filename.size() - 4, 4) == ".skp") {
+        skp_count += 1;
+      }
+      return true;
+    };
+    fml::VisitFilesRecursively(dir.fd(), skp_count_visitor);
+    int first_skp_count = skp_count;
+    skp_count = 0;
+    ASSERT_GT(first_skp_count, 0);
+
+    // Deserialize all skps into memory
+    std::vector<sk_sp<SkPicture>> pictures;
+    fml::FileVisitor skp_deserialize_visitor =
+        [&pictures](const fml::UniqueFD& directory,
+                    const std::string& filename) {
+          if (filename.size() >= 4 &&
+              filename.substr(filename.size() - 4, 4) == ".skp") {
+            auto fd = fml::OpenFileReadOnly(directory, filename.c_str());
+            if (fd.get() < 0) {
+              FML_LOG(ERROR) << "Failed to open " << filename;
+              return true;
+            }
+            // Deserialize
+            sk_sp<SkData> data = SkData::MakeFromFD(fd.get());
+            std::unique_ptr<SkMemoryStream> stream = SkMemoryStream::Make(data);
+            sk_sp<SkPicture> picture = SkPicture::MakeFromStream(
+                stream.get(), /*const SkDeserialProcs* */ nullptr);
+            pictures.push_back(std::move(picture));
+            fd.reset();
+          }
+          return true;
+        };
+    fml::VisitFilesRecursively(dir.fd(), skp_deserialize_visitor);
+    ASSERT_GT(pictures.size(), 0ul);
+
+    // Reinitialize shell with clean cache and verify that drawing again dumps
+    // the same number of shaders
+    fml::RemoveFilesInDirectory(dir.fd());
+    PersistentCache::ResetCacheForProcess();
+    DestroyShell(std::move(shell));
+    auto config2 = RunConfiguration::InferFromSettings(settings);
+    config2.SetEntrypoint("emptyMain");
+    shell = CreateShell(settings);
+    PlatformViewNotifyCreated(shell.get());
+    RunEngine(shell.get(), std::move(config2));
+    firstFrameLatch.Reset();
+    PumpOneFrame(shell.get(), 100, 100, builder);
+    firstFrameLatch.Wait();
+    WaitForIO(shell.get());
+
+    // Verify same number of shaders dumped
+    fml::VisitFilesRecursively(dir.fd(), skp_count_visitor);
+    int second_skp_count = skp_count;
+    skp_count = 0;
+    ASSERT_EQ(second_skp_count, first_skp_count);
+
+    // Reinitialize shell and draw deserialized skps to warm up shaders
+    fml::RemoveFilesInDirectory(dir.fd());
+    PersistentCache::ResetCacheForProcess();
+    DestroyShell(std::move(shell));
+    auto config3 = RunConfiguration::InferFromSettings(settings);
+    config3.SetEntrypoint("emptyMain");
+    shell = CreateShell(settings);
+    PlatformViewNotifyCreated(shell.get());
+    RunEngine(shell.get(), std::move(config3));
+    firstFrameLatch.Reset();
+
+    for (auto& picture : pictures) {
+      fml::RefPtr<SkiaUnrefQueue> queue = fml::MakeRefCounted<SkiaUnrefQueue>(
+          this->GetCurrentTaskRunner(), fml::TimeDelta::FromSeconds(0));
+      LayerTreeBuilder picture_builder =
+          [picture, queue](std::shared_ptr<ContainerLayer> root) {
+            auto picture_layer = std::make_shared<PictureLayer>(
+                SkPoint::Make(0, 0), SkiaGPUObject<SkPicture>(picture, queue),
+                /* is_complex */ false,
+                /* will_change */ false);
+            root->Add(picture_layer);
+          };
+      PumpOneFrame(shell.get(), picture->cullRect().width(),
+                   picture->cullRect().height(), picture_builder);
+    }
+    firstFrameLatch.Wait();
+    WaitForIO(shell.get());
+
+    // Verify same number of shaders dumped
+    fml::VisitFilesRecursively(dir.fd(), skp_count_visitor);
+    int third_skp_count = skp_count;
+    skp_count = 0;
+    ASSERT_EQ(third_skp_count, first_skp_count);
+
+    // Remove files generated
+    fml::RemoveFilesInDirectory(dir.fd());
+
+    // Draw orignal material again
+    firstFrameLatch.Reset();
+    PumpOneFrame(shell.get(), 100, 100, builder);
+    firstFrameLatch.Wait();
+    WaitForIO(shell.get());
+
+    // Verify no new shaders dumped
+    fml::VisitFilesRecursively(dir.fd(), skp_count_visitor);
+    int fourth_skp_count = skp_count;
+    skp_count = 0;
+    ASSERT_EQ(fourth_skp_count, 0);
+
+    // Clean Up
+    fml::RemoveFilesInDirectory(dir.fd());
+  }
+};
+
+TEST_F(SkpWarmupTest, Basic) {
+  // Draw something to trigger shader compilations.
+  LayerTreeBuilder builder = [](std::shared_ptr<ContainerLayer> root) {
+    SkPath path;
+    path.addCircle(50, 50, 20);
+    auto physical_shape_layer = std::make_shared<PhysicalShapeLayer>(
+        SK_ColorRED, SK_ColorBLUE, 1.0f, path, Clip::antiAlias);
+    root->Add(physical_shape_layer);
+  };
+  TestWarmup(builder);
+}
+
+#endif
+
+}  // namespace testing
+}  // namespace flutter