add DrawPath benchmark

Author: George Wright

flow/display_list_benchmarks.cc

@@ -269,99 +269,199 @@ BENCHMARK_TEMPLATE(DrawCircle, MetalCanvasProvider)
     ->UseRealTime()
     ->Unit(benchmark::kMillisecond);
 
-static SkRRect CreateSymmetricRRect(int width, int height) {
-  SkScalar xRadius = width / 5.0f;
-  SkScalar yRadius = height / 5.0f;
-  return SkRRect::MakeRectXY(SkRect::MakeWH(width, height), xRadius, yRadius);
+// static SkRRect CreateSymmetricRRect(int width, int height) {
+//   SkScalar xRadius = width / 5.0f;
+//   SkScalar yRadius = height / 5.0f;
+//   return SkRRect::MakeRectXY(SkRect::MakeWH(width, height), xRadius,
+//   yRadius);
+// }
+
+// static SkRRect CreateNinePatchRRect(int width, int height) {
+//   SkScalar xRadius = width / 5.0f;
+//   SkScalar yRadius = height / 5.0f;
+//   return SkRRect::MakeRectXY(SkRect::MakeWH(width, height), xRadius,
+//   yRadius);
+// }
+
+// template <class T>
+// void DrawRRect(benchmark::State& state) {
+//   DisplayListBuilder builder;
+//   size_t length = state.range(0);
+//   T canvas_provider(length, length);
+//   auto canvas = canvas_provider.GetSurface()->getCanvas();
+
+//   float multiplier = length / 16;
+//   SkVector radii[4];
+//   switch (state.range(1)) {
+//     // Symmetric in both x and y
+//     case 0:
+//       radii[0] = SkVector::Make(5.0f, 5.0f);
+//       radii[1] = SkVector::Make(5.0f, 5.0f);
+//       radii[2] = SkVector::Make(5.0f, 5.0f);
+//       radii[3] = SkVector::Make(5.0f, 5.0f);
+//       state.SetLabel("Symmetric");
+//       break;
+//     // "nine patch" type
+//     case 1:
+//       radii[0] = SkVector::Make(5.0f, 2.0f);
+//       radii[1] = SkVector::Make(3.0f, 2.0f);
+//       radii[2] = SkVector::Make(3.0f, 4.0f);
+//       radii[3] = SkVector::Make(5.0f, 4.0f);
+//       state.SetLabel("Nine patch");
+//       break;
+//     // Not symmetric at all
+//     case 2:
+//       radii[0] = SkVector::Make(5.0f, 4.0f);
+//       radii[1] = SkVector::Make(4.0f, 5.0f);
+//       radii[2] = SkVector::Make(3.0f, 6.0f);
+//       radii[3] = SkVector::Make(2.0f, 7.0f);
+//       state.SetLabel("Complex");
+//       break;
+//   }
+
+//   // The rects will shrink by the inset constant for each iteration. The
+//   // inset constant is 0.5 to test non-axis-aligned rasterisation.
+//   const SkScalar inset = 0.5;
+//   SkRect rect = SkRect::MakeLTRB(0, 0, length, length);
+//   SkRRect rrect;
+//   SkVector setRadii[4];
+
+//   // Always draw 5000 rects regardless of the rect size requested
+//   for (size_t i = 0; i < 15000; i++) {
+//     for (int i = 0; i < 4; i++) {
+//       setRadii[i] = radii[i] * multiplier;
+//     }
+//     // As rects have SkScalar dimensions, we want to ensure that we also
+//     // draw non-axis-aligned rects with scalar position and size
+//     rrect.setRectRadii(rect, setRadii);
+//     builder.drawRRect(rrect);
+//     rect.inset(inset, inset);
+//     if (rect.width() == 0) {
+//       rect = SkRect::MakeLTRB(0, 0, length, length);
+//     }
+//     multiplier = rrect.width() / 16.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() + "-DrawRRect-" +
+//                   std::to_string(state.range(0)) + ".png";
+//   canvas_provider.Snapshot(filename);
+// }
+
+// BENCHMARK_TEMPLATE(DrawRRect, SoftwareCanvasProvider)
+// //     ->Args({16, 0})
+// //     ->Args({16, 1})
+// //     ->Args({16, 2})
+// //     ->Args({128, 0})
+// //     ->Args({128, 1})
+// //     ->Args({128, 2})
+// //     ->Args({512, 0})
+// //     ->Args({512, 1})
+// //     ->Args({512, 2})
+//     ->Args({1024, 0})
+//     ->Args({1024, 1})
+//     ->Args({1024, 2})
+//     ->Unit(benchmark::kMillisecond);
+
+void GetLinesPath(SkPath& path, size_t length) {
+  for (int i = 0; i < 100000; i++) {
+    path.lineTo(i % length, 0);
+    path.lineTo(length - i % length, length);
+  }
+}
+
+void GetQuadsPath(SkPath& path, size_t length) {
+  for (int i = 0; i < 100000; i++) {
+    path.quadTo(i % length, length / 2.0, i % length, 0);
+    path.quadTo(i % length, length / 2.0, length - i % length, length);
+  }
+}
+
+void GetConicsPath(SkPath& path, size_t length) {
+  for (int i = 0; i < 100000; i++) {
+    path.conicTo(i % length, length / 2.0, i % length, 0, (SkScalar)i / length);
+    path.conicTo(i % length, length / 2.0, length - i % length, length,
+                 (SkScalar)i / length);
+  }
 }
 
+void GetCubicsPath(SkPath& path, size_t length) {
+  for (int i = 0; i < 100000; i++) {
+    path.cubicTo(i / 3 % length, length / 3.0, (2 * i / 3) % length,
+                 length / 3.0 * 2.0, length - i % length, length);
+    path.cubicTo(i / 3 % length, length / 3.0, (2 * i / 3) % length,
+                 length / 3.0 * 2.0, length - i % length, length);
+  }
+}
 
 template <class T>
-void DrawRRect(benchmark::State& state) {
+void DrawPath(benchmark::State& state) {
   DisplayListBuilder builder;
   size_t length = state.range(0);
   T canvas_provider(length, length);
   auto canvas = canvas_provider.GetSurface()->getCanvas();
 
-  float multiplier = length / 16;
-  SkVector radii[4];
+  SkPath path;
+  builder.setAntiAlias(true);
+  builder.setStyle(SkPaint::kStroke_Style);
+
+  std::string label;
+
   switch (state.range(1)) {
-    // Symmetric in both x and y
     case 0:
-      radii[0] = SkVector::Make(5.0f, 5.0f);
-      radii[1] = SkVector::Make(5.0f, 5.0f);
-      radii[2] = SkVector::Make(5.0f, 5.0f);
-      radii[3] = SkVector::Make(5.0f, 5.0f);
-      state.SetLabel("Symmetric");
+      GetLinesPath(path, length);
+      label = "Lines";
       break;
-    // "nine patch" type
     case 1:
-      radii[0] = SkVector::Make(5.0f, 2.0f);
-      radii[1] = SkVector::Make(3.0f, 2.0f);
-      radii[2] = SkVector::Make(3.0f, 4.0f);
-      radii[3] = SkVector::Make(5.0f, 4.0f);
-      state.SetLabel("Nine patch");
+      GetQuadsPath(path, length);
+      label = "Quads";
       break;
-    // Not symmetric at all
     case 2:
-      radii[0] = SkVector::Make(5.0f, 4.0f);
-      radii[1] = SkVector::Make(4.0f, 5.0f);
-      radii[2] = SkVector::Make(3.0f, 6.0f);
-      radii[3] = SkVector::Make(2.0f, 7.0f);
-      state.SetLabel("Complex");
+      GetConicsPath(path, length);
+      label = "Conics";
+      break;
+    case 3:
+      GetCubicsPath(path, length);
+      label = "Cubics";
       break;
   }
 
-  // The rects will shrink by the inset constant for each iteration. The
-  // inset constant is 0.5 to test non-axis-aligned rasterisation.
-  const SkScalar inset = 0.5;
-  SkRect rect = SkRect::MakeLTRB(0, 0, length, length);
-  SkRRect rrect;
-  SkVector setRadii[4];
-  
-  // Always draw 5000 rects regardless of the rect size requested
-  for (size_t i = 0; i < 15000; i++) {
-    for (int i = 0; i < 4; i++) {
-      setRadii[i] = radii[i] * multiplier;
-    }
-    // As rects have SkScalar dimensions, we want to ensure that we also
-    // draw non-axis-aligned rects with scalar position and size
-    rrect.setRectRadii(rect, setRadii);
-    builder.drawRRect(rrect);
-    rect.inset(inset, inset);
-    if (rect.width() == 0) {
-      rect = SkRect::MakeLTRB(0, 0, length, length);
-    }
-    multiplier = rrect.width() / 16.0f;
-  }
+  state.SetLabel(label);
 
+  builder.drawPath(path);
   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() + "-DrawRRect-" +
+  auto filename = canvas_provider.BackendName() + "-DrawPath-" + label + "-" +
                   std::to_string(state.range(0)) + ".png";
   canvas_provider.Snapshot(filename);
 }
 
-BENCHMARK_TEMPLATE(DrawRRect, SoftwareCanvasProvider)
-//     ->Args({16, 0})
-//     ->Args({16, 1})
-//     ->Args({16, 2})
-//     ->Args({128, 0})
-//     ->Args({128, 1})
-//     ->Args({128, 2})    
-//     ->Args({512, 0})
-//     ->Args({512, 1})
-//     ->Args({512, 2})    
+BENCHMARK_TEMPLATE(DrawPath, SoftwareCanvasProvider)
+    ->Args({1024, 0})
+    ->Args({1024, 1})
+    ->Args({1024, 2})
+    ->Args({1024, 3})
+    ->Unit(benchmark::kMillisecond);
+
+BENCHMARK_TEMPLATE(DrawPath, MetalCanvasProvider)
     ->Args({1024, 0})
     ->Args({1024, 1})
     ->Args({1024, 2})
+    ->Args({1024, 3})
     ->Unit(benchmark::kMillisecond);
 
 }  // namespace testing