Add a new flow_benchmarks test suite that will allow us to microbenchmark all the rasterops defined in

our DisplayList format on both CPU and GPU canvases.

Author: George Wright

BUILD.gn

@@ -106,6 +106,7 @@ group("flutter") {
   # Compile all benchmark targets if enabled.
   if (enable_unittests && !is_win) {
     public_deps += [
+      "//flutter/flow:flow_benchmarks",
       "//flutter/fml:fml_benchmarks",
       "//flutter/lib/ui:ui_benchmarks",
       "//flutter/shell/common:shell_benchmarks",

flow/BUILD.gn

@@ -192,4 +192,31 @@ if (enable_unittests) {
       defines += [ "_USE_MATH_DEFINES" ]
     }
   }
+
+  fixtures_location("flow_benchmarks_fixtures") {
+    assets_dir = "$target_gen_dir/"
+  }
+
+  executable("flow_benchmarks") {
+    testonly = true
+
+    sources = [ "display_list_benchmarks.cc" ]
+
+    deps = [
+      ":flow",
+      ":flow_benchmarks_fixtures",
+      ":flow_testing",
+      "//flutter/benchmarking",
+      "//flutter/common/graphics",
+      "//flutter/fml",
+      "//flutter/testing:skia",
+      "//flutter/testing:testing_lib",
+      "//third_party/dart/runtime:libdart_jit",  # for tracing
+      "//third_party/skia",
+    ]
+
+    if (is_mac) {
+      deps += [ "//flutter/testing:metal" ]
+    }
+  }
 }

flow/display_list_benchmarks.cc

@@ -0,0 +1,120 @@
+// 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 "flutter/benchmarking/benchmarking.h"
+#include "flutter/flow/display_list.h"
+#include "flutter/fml/mapping.h"
+#include "flutter/testing/test_metal_context.h"
+#include "flutter/testing/test_metal_surface.h"
+#include "flutter/testing/testing.h"
+
+#include "third_party/skia/include/core/SkPoint.h"
+#include "third_party/skia/include/core/SkSurface.h"
+
+namespace flutter {
+
+namespace testing {
+
+class CanvasProvider {
+ public:
+  virtual const std::string BackendName() = 0;
+  virtual sk_sp<SkSurface> GetSurface() = 0;
+
+  virtual bool Snapshot(std::string filename) {
+    auto image = GetSurface()->makeImageSnapshot();
+    if (!image) {
+      return false;
+    }
+    auto raster = image->makeRasterImage();
+    if (!raster) {
+      return false;
+    }
+    auto data = raster->encodeToData();
+    if (!data) {
+      return false;
+    }
+    fml::NonOwnedMapping mapping(static_cast<const uint8_t*>(data->data()),
+                                 data->size());
+    return WriteAtomically(OpenFixturesDirectory(), filename.c_str(), mapping);
+  }
+};
+
+class SoftwareCanvasProvider : public CanvasProvider {
+ public:
+  SoftwareCanvasProvider(const size_t width, const size_t height) {
+    surface_ = SkSurface::MakeRasterN32Premul(width, height);
+    surface_->getCanvas()->clear(SK_ColorTRANSPARENT);
+  }
+
+  sk_sp<SkSurface> GetSurface() override { return surface_; }
+
+  const std::string BackendName() override { return "Software"; }
+
+ private:
+  sk_sp<SkSurface> surface_;
+};
+
+class MetalCanvasProvider : public CanvasProvider {
+ public:
+  MetalCanvasProvider(const size_t width, const size_t height) {
+    metal_context_ = std::make_unique<TestMetalContext>();
+    metal_surface_ =
+        TestMetalSurface::Create(*metal_context_, SkISize::Make(width, height));
+    metal_surface_->GetSurface()->getCanvas()->clear(SK_ColorTRANSPARENT);
+  }
+
+  sk_sp<SkSurface> GetSurface() override {
+    return metal_surface_->GetSurface();
+  }
+
+  const std::string BackendName() override { return "Metal"; }
+
+ private:
+  std::unique_ptr<TestMetalContext> metal_context_;
+  std::unique_ptr<TestMetalSurface> metal_surface_;
+};
+
+template <class T>
+void DrawLine(benchmark::State& state) {
+  DisplayListBuilder builder;
+  T canvas_provider(state.range(0), state.range(0));
+
+  auto canvas = canvas_provider.GetSurface()->getCanvas();
+
+  // Always draw 10k lines regardless of the line length requested
+  size_t length = state.range(0);
+  for (size_t i = 0; i < 10000; i++) {
+    // The (approximate) line lengths are passed to us via the benchmark state
+    // object, so that we can benchmark the performance of drawLine and how it
+    // differs based on line length
+    builder.drawLine(SkPoint::Make(i % length, 0),
+                     SkPoint::Make(length - i % length, length));
+  }
+
+  auto displaylist = builder.Build();
+
+  // We only want to time the actual rasterization.
+  while (state.KeepRunning()) {
+    displaylist->RenderTo(canvas);
+    canvas->flush();
+  }
+
+  auto filename = canvas_provider.BackendName() + "-DrawLine-" +
+                  std::to_string(state.range(0)) + ".png";
+  canvas_provider.Snapshot(filename);
+}
+
+BENCHMARK_TEMPLATE(DrawLine, SoftwareCanvasProvider)
+    ->RangeMultiplier(2)
+    ->Range(16, 2048)
+    ->Unit(benchmark::kMillisecond);
+
+BENCHMARK_TEMPLATE(DrawLine, MetalCanvasProvider)
+    ->RangeMultiplier(2)
+    ->Range(16, 2048)
+    ->UseRealTime()
+    ->Unit(benchmark::kMillisecond);
+
+}  // namespace testing
+}  // namespace flutter