DrawArc

Author: George Wright

flow/display_list_benchmarks.cc

@@ -263,6 +263,45 @@ void BM_DrawRRect(benchmark::State& state,
   canvas_provider->Snapshot(filename);
 }
 
+void BM_DrawArc(benchmark::State& state,
+                std::unique_ptr<CanvasProvider> canvas_provider) {
+  DisplayListBuilder builder;
+  size_t length = state.range(0);
+  canvas_provider->InitializeSurface(length, length);
+  auto canvas = canvas_provider->GetSurface()->getCanvas();
+
+  SkScalar startingAngle = 0.0f;
+  SkScalar scalarLength = length;
+
+  // Just some random sweeps that will mostly circumnavigate the circle
+  std::vector<SkScalar> segmentSweeps = {5.5f,  -10.0f, 42.0f, 71.7f, 90.0f,
+                                         37.5f, 17.9f,  32.0f, 379.4f};
+
+  SkRect bounds = SkRect::MakeLTRB(0, 0, length, length);
+
+  for (size_t i = 0; i < 1000; i++) {
+    SkScalar inset = std::fmod(i * 0.5, scalarLength);
+    bounds.setLTRB(0, inset, scalarLength, scalarLength - inset);
+    for (SkScalar sweep : segmentSweeps) {
+      builder.drawArc(bounds, startingAngle, sweep, false);
+      startingAngle += sweep + 5.0f;
+    }
+  }
+
+  auto displaylist = builder.Build();
+
+  // We only want to time the actual rasterization.
+  for (auto _ : state) {
+    canvas->discard();
+    displaylist->RenderTo(canvas);
+    canvas_provider->GetSurface()->flushAndSubmit(true);
+  }
+
+  auto filename = canvas_provider->BackendName() + "-DrawArc-" +
+                  std::to_string(state.range(0)) + ".png";
+  canvas_provider->Snapshot(filename);
+}
+
 std::vector<SkPoint> GetPolygonPoints(size_t n, SkPoint center, SkScalar r) {
   std::vector<SkPoint> points;
   SkScalar x, y;
@@ -421,8 +460,6 @@ sk_sp<SkVertices> GetTestVertices(SkPoint center,
   size_t outerVertexCount = vertexCount / 2;
   std::vector<SkPoint> outerPoints =
       GetPolygonPoints(outerVertexCount, center, radius * 1.5f);
-  std::vector<SkPoint> innerPoints =
-      GetPolygonPoints(outerVertexCount * 2, center, radius * 0.75f);
 
   std::vector<SkPoint> vertices;
   std::vector<SkColor> colors;
@@ -446,7 +483,7 @@ sk_sp<SkVertices> GetTestVertices(SkPoint center,
       for (size_t i = 0; i <= outerVertexCount; i++) {
         vertices.push_back(outerPoints[i % outerPoints.size()]);
         colors.push_back(i % 2 ? SK_ColorRED : SK_ColorGREEN);
-        vertices.push_back(innerPoints[(2 * i + 1) % innerPoints.size()]);
+        vertices.push_back(center);
         colors.push_back(i % 2 ? SK_ColorBLUE : SK_ColorCYAN);
       }
       break;
@@ -511,6 +548,10 @@ void BM_DrawVertices(benchmark::State& state,
   canvas_provider->Snapshot(filename);
 }
 
+void BM_DrawPoints(benchmark::State& state,
+                   std::unique_ptr<CanvasProvider> canvas_provider,
+                   SkCanvas::PointMode mode) {}
+
 // clang-format off
 
 BENCHMARK_CAPTURE(BM_DrawLine,
@@ -541,6 +582,13 @@ BENCHMARK_CAPTURE(BM_DrawCircle,
     ->Range(16, 2048)
     ->Unit(benchmark::kMillisecond);
 
+BENCHMARK_CAPTURE(BM_DrawArc,
+                  Software,
+                  std::make_unique<SoftwareCanvasProvider>())
+    ->RangeMultiplier(2)
+    ->Range(128, 2048)
+    ->Unit(benchmark::kMillisecond);
+
 BENCHMARK_CAPTURE(BM_DrawRRect,
                   Symmetric/Software,
                   std::make_unique<SoftwareCanvasProvider>(),

flow/display_list_benchmarks.h

@@ -54,6 +54,8 @@ void BM_DrawCircle(benchmark::State& state,
                    std::unique_ptr<CanvasProvider> canvas_provider);
 void BM_DrawOval(benchmark::State& state,
                  std::unique_ptr<CanvasProvider> canvas_provider);
+void BM_DrawArc(benchmark::State& state,
+                std::unique_ptr<CanvasProvider> canvas_provider);
 void BM_DrawRRect(benchmark::State& state,
                   std::unique_ptr<CanvasProvider> canvas_provider,
                   SkRRect::Type type);

flow/display_list_benchmarks_metal.cc

@@ -59,6 +59,12 @@ BENCHMARK_CAPTURE(BM_DrawCircle, Metal, std::make_unique<MetalCanvasProvider>())
     ->UseRealTime()
     ->Unit(benchmark::kMillisecond);
 
+BENCHMARK_CAPTURE(BM_DrawArc, Metal, std::make_unique<MetalCanvasProvider>())
+    ->RangeMultiplier(2)
+    ->Range(16, 2048)
+    ->UseRealTime()
+    ->Unit(benchmark::kMillisecond);
+
 BENCHMARK_CAPTURE(BM_DrawRRect,
                   Symmetric/Metal,
                   std::make_unique<MetalCanvasProvider>(),