DashBench.cpp 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485
  1. /*
  2. * Copyright 2011 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "bench/Benchmark.h"
  8. #include "include/core/SkBitmap.h"
  9. #include "include/core/SkCanvas.h"
  10. #include "include/core/SkPaint.h"
  11. #include "include/core/SkPath.h"
  12. #include "include/core/SkString.h"
  13. #include "include/core/SkStrokeRec.h"
  14. #include "include/effects/SkDashPathEffect.h"
  15. #include "include/private/SkTDArray.h"
  16. #include "include/utils/SkRandom.h"
  17. /*
  18. * Cases to consider:
  19. *
  20. * 1. antialiasing on/off (esp. width <= 1)
  21. * 2. strokewidth == 0, 1, 2
  22. * 3. hline, vline, diagonal, rect, oval
  23. * 4. dots [1,1] ([N,N] where N=strokeWidth?) or arbitrary (e.g. [2,1] or [1,2,3,2])
  24. */
  25. static void path_hline(SkPath* path) {
  26. path->moveTo(SkIntToScalar(10), SkIntToScalar(10));
  27. path->lineTo(SkIntToScalar(600), SkIntToScalar(10));
  28. }
  29. class DashBench : public Benchmark {
  30. protected:
  31. SkString fName;
  32. SkTDArray<SkScalar> fIntervals;
  33. int fWidth;
  34. SkPoint fPts[2];
  35. bool fDoClip;
  36. public:
  37. DashBench(const SkScalar intervals[], int count, int width,
  38. bool doClip = false) {
  39. fIntervals.append(count, intervals);
  40. for (int i = 0; i < count; ++i) {
  41. fIntervals[i] *= width;
  42. }
  43. fWidth = width;
  44. fName.printf("dash_%d_%s", width, doClip ? "clipped" : "noclip");
  45. fDoClip = doClip;
  46. fPts[0].set(SkIntToScalar(10), SkIntToScalar(10));
  47. fPts[1].set(SkIntToScalar(600), SkIntToScalar(10));
  48. }
  49. virtual void makePath(SkPath* path) {
  50. path_hline(path);
  51. }
  52. protected:
  53. const char* onGetName() override {
  54. return fName.c_str();
  55. }
  56. void onDraw(int loops, SkCanvas* canvas) override {
  57. SkPaint paint;
  58. this->setupPaint(&paint);
  59. paint.setStyle(SkPaint::kStroke_Style);
  60. paint.setStrokeWidth(SkIntToScalar(fWidth));
  61. paint.setAntiAlias(false);
  62. SkPath path;
  63. this->makePath(&path);
  64. paint.setPathEffect(SkDashPathEffect::Make(fIntervals.begin(), fIntervals.count(), 0));
  65. if (fDoClip) {
  66. SkRect r = path.getBounds();
  67. r.inset(-SkIntToScalar(20), -SkIntToScalar(20));
  68. // now move it so we don't intersect
  69. r.offset(0, r.height() * 3 / 2);
  70. canvas->clipRect(r);
  71. }
  72. this->handlePath(canvas, path, paint, loops);
  73. }
  74. virtual void handlePath(SkCanvas* canvas, const SkPath& path,
  75. const SkPaint& paint, int N) {
  76. for (int i = 0; i < N; ++i) {
  77. // canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, paint);
  78. canvas->drawPath(path, paint);
  79. }
  80. }
  81. private:
  82. typedef Benchmark INHERITED;
  83. };
  84. class RectDashBench : public DashBench {
  85. public:
  86. RectDashBench(const SkScalar intervals[], int count, int width)
  87. : INHERITED(intervals, count, width) {
  88. fName.append("_rect");
  89. }
  90. protected:
  91. virtual void handlePath(SkCanvas* canvas, const SkPath& path,
  92. const SkPaint& paint, int N) override {
  93. SkPoint pts[2];
  94. if (!path.isLine(pts) || pts[0].fY != pts[1].fY) {
  95. this->INHERITED::handlePath(canvas, path, paint, N);
  96. } else {
  97. SkRect rect;
  98. rect.fLeft = pts[0].fX;
  99. rect.fTop = pts[0].fY - paint.getStrokeWidth() / 2;
  100. rect.fRight = rect.fLeft + SkIntToScalar(fWidth);
  101. rect.fBottom = rect.fTop + paint.getStrokeWidth();
  102. SkPaint p(paint);
  103. p.setStyle(SkPaint::kFill_Style);
  104. p.setPathEffect(nullptr);
  105. int count = SkScalarRoundToInt((pts[1].fX - pts[0].fX) / (2*fWidth));
  106. SkScalar dx = SkIntToScalar(2 * fWidth);
  107. for (int i = 0; i < N*10; ++i) {
  108. SkRect r = rect;
  109. for (int j = 0; j < count; ++j) {
  110. canvas->drawRect(r, p);
  111. r.offset(dx, 0);
  112. }
  113. }
  114. }
  115. }
  116. private:
  117. typedef DashBench INHERITED;
  118. };
  119. static void make_unit_star(SkPath* path, int n) {
  120. SkScalar rad = -SK_ScalarPI / 2;
  121. const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
  122. path->moveTo(0, -SK_Scalar1);
  123. for (int i = 1; i < n; i++) {
  124. rad += drad;
  125. path->lineTo(SkScalarCos(rad), SkScalarSin(rad));
  126. }
  127. path->close();
  128. }
  129. static void make_poly(SkPath* path) {
  130. make_unit_star(path, 9);
  131. const SkMatrix matrix = SkMatrix::MakeScale(SkIntToScalar(100), SkIntToScalar(100));
  132. path->transform(matrix);
  133. }
  134. static void make_quad(SkPath* path) {
  135. SkScalar x0 = SkIntToScalar(10);
  136. SkScalar y0 = SkIntToScalar(10);
  137. path->moveTo(x0, y0);
  138. path->quadTo(x0, y0 + 400 * SK_Scalar1,
  139. x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1);
  140. }
  141. static void make_cubic(SkPath* path) {
  142. SkScalar x0 = SkIntToScalar(10);
  143. SkScalar y0 = SkIntToScalar(10);
  144. path->moveTo(x0, y0);
  145. path->cubicTo(x0, y0 + 400 * SK_Scalar1,
  146. x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1,
  147. x0 + 600 * SK_Scalar1, y0);
  148. }
  149. class MakeDashBench : public Benchmark {
  150. SkString fName;
  151. SkPath fPath;
  152. sk_sp<SkPathEffect> fPE;
  153. public:
  154. MakeDashBench(void (*proc)(SkPath*), const char name[]) {
  155. fName.printf("makedash_%s", name);
  156. proc(&fPath);
  157. SkScalar vals[] = { SkIntToScalar(4), SkIntToScalar(4) };
  158. fPE = SkDashPathEffect::Make(vals, 2, 0);
  159. }
  160. protected:
  161. const char* onGetName() override {
  162. return fName.c_str();
  163. }
  164. void onDraw(int loops, SkCanvas*) override {
  165. SkPath dst;
  166. for (int i = 0; i < loops; ++i) {
  167. SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
  168. fPE->filterPath(&dst, fPath, &rec, nullptr);
  169. dst.rewind();
  170. }
  171. }
  172. private:
  173. typedef Benchmark INHERITED;
  174. };
  175. /*
  176. * We try to special case square dashes (intervals are equal to strokewidth).
  177. */
  178. class DashLineBench : public Benchmark {
  179. SkString fName;
  180. SkScalar fStrokeWidth;
  181. bool fIsRound;
  182. sk_sp<SkPathEffect> fPE;
  183. public:
  184. DashLineBench(SkScalar width, bool isRound) {
  185. fName.printf("dashline_%g_%s", SkScalarToFloat(width), isRound ? "circle" : "square");
  186. fStrokeWidth = width;
  187. fIsRound = isRound;
  188. SkScalar vals[] = { SK_Scalar1, SK_Scalar1 };
  189. fPE = SkDashPathEffect::Make(vals, 2, 0);
  190. }
  191. protected:
  192. const char* onGetName() override {
  193. return fName.c_str();
  194. }
  195. void onDraw(int loops, SkCanvas* canvas) override {
  196. SkPaint paint;
  197. this->setupPaint(&paint);
  198. paint.setStrokeWidth(fStrokeWidth);
  199. paint.setStrokeCap(fIsRound ? SkPaint::kRound_Cap : SkPaint::kSquare_Cap);
  200. paint.setPathEffect(fPE);
  201. for (int i = 0; i < loops; ++i) {
  202. canvas->drawLine(10 * SK_Scalar1, 10 * SK_Scalar1,
  203. 640 * SK_Scalar1, 10 * SK_Scalar1, paint);
  204. }
  205. }
  206. private:
  207. typedef Benchmark INHERITED;
  208. };
  209. class DrawPointsDashingBench : public Benchmark {
  210. SkString fName;
  211. int fStrokeWidth;
  212. bool fDoAA;
  213. sk_sp<SkPathEffect> fPathEffect;
  214. public:
  215. DrawPointsDashingBench(int dashLength, int strokeWidth, bool doAA)
  216. {
  217. fName.printf("drawpointsdash_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
  218. fStrokeWidth = strokeWidth;
  219. fDoAA = doAA;
  220. SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) };
  221. fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1);
  222. }
  223. protected:
  224. const char* onGetName() override {
  225. return fName.c_str();
  226. }
  227. void onDraw(int loops, SkCanvas* canvas) override {
  228. SkPaint p;
  229. this->setupPaint(&p);
  230. p.setColor(SK_ColorBLACK);
  231. p.setStyle(SkPaint::kStroke_Style);
  232. p.setStrokeWidth(SkIntToScalar(fStrokeWidth));
  233. p.setPathEffect(fPathEffect);
  234. p.setAntiAlias(fDoAA);
  235. SkPoint pts[2] = {
  236. { SkIntToScalar(10), 0 },
  237. { SkIntToScalar(640), 0 }
  238. };
  239. for (int i = 0; i < loops; ++i) {
  240. pts[0].fY = pts[1].fY = SkIntToScalar(i % 480);
  241. canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
  242. }
  243. }
  244. private:
  245. typedef Benchmark INHERITED;
  246. };
  247. // Want to test how we handle dashing when 99% of the dash is clipped out
  248. class GiantDashBench : public Benchmark {
  249. SkString fName;
  250. SkScalar fStrokeWidth;
  251. SkPoint fPts[2];
  252. sk_sp<SkPathEffect> fPathEffect;
  253. public:
  254. enum LineType {
  255. kHori_LineType,
  256. kVert_LineType,
  257. kDiag_LineType,
  258. kLineTypeCount
  259. };
  260. static const char* LineTypeName(LineType lt) {
  261. static const char* gNames[] = { "hori", "vert", "diag" };
  262. static_assert(kLineTypeCount == SK_ARRAY_COUNT(gNames), "names_wrong_size");
  263. return gNames[lt];
  264. }
  265. GiantDashBench(LineType lt, SkScalar width) {
  266. fName.printf("giantdashline_%s_%g", LineTypeName(lt), width);
  267. fStrokeWidth = width;
  268. // deliberately pick intervals that won't be caught by asPoints(), so
  269. // we can test the filterPath code-path.
  270. const SkScalar intervals[] = { 20, 10, 10, 10 };
  271. fPathEffect = SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0);
  272. SkScalar cx = 640 / 2; // center X
  273. SkScalar cy = 480 / 2; // center Y
  274. SkMatrix matrix;
  275. switch (lt) {
  276. case kHori_LineType:
  277. matrix.setIdentity();
  278. break;
  279. case kVert_LineType:
  280. matrix.setRotate(90, cx, cy);
  281. break;
  282. case kDiag_LineType:
  283. matrix.setRotate(45, cx, cy);
  284. break;
  285. case kLineTypeCount:
  286. // Not a real enum value.
  287. break;
  288. }
  289. const SkScalar overshoot = 100*1000;
  290. const SkPoint pts[2] = {
  291. { -overshoot, cy }, { 640 + overshoot, cy }
  292. };
  293. matrix.mapPoints(fPts, pts, 2);
  294. }
  295. protected:
  296. const char* onGetName() override {
  297. return fName.c_str();
  298. }
  299. void onDraw(int loops, SkCanvas* canvas) override {
  300. SkPaint p;
  301. this->setupPaint(&p);
  302. p.setStyle(SkPaint::kStroke_Style);
  303. p.setStrokeWidth(fStrokeWidth);
  304. p.setPathEffect(fPathEffect);
  305. for (int i = 0; i < loops; i++) {
  306. canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, p);
  307. }
  308. }
  309. private:
  310. typedef Benchmark INHERITED;
  311. };
  312. // Want to test how we draw a dashed grid (like what is used in spreadsheets) of many
  313. // small dashed lines switching back and forth between horizontal and vertical
  314. class DashGridBench : public Benchmark {
  315. SkString fName;
  316. int fStrokeWidth;
  317. bool fDoAA;
  318. sk_sp<SkPathEffect> fPathEffect;
  319. public:
  320. DashGridBench(int dashLength, int strokeWidth, bool doAA) {
  321. fName.printf("dashgrid_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
  322. fStrokeWidth = strokeWidth;
  323. fDoAA = doAA;
  324. SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) };
  325. fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1);
  326. }
  327. protected:
  328. const char* onGetName() override {
  329. return fName.c_str();
  330. }
  331. void onDraw(int loops, SkCanvas* canvas) override {
  332. SkPaint p;
  333. this->setupPaint(&p);
  334. p.setColor(SK_ColorBLACK);
  335. p.setStyle(SkPaint::kStroke_Style);
  336. p.setStrokeWidth(SkIntToScalar(fStrokeWidth));
  337. p.setPathEffect(fPathEffect);
  338. p.setAntiAlias(fDoAA);
  339. SkPoint pts[4] = {
  340. { SkIntToScalar(0), 20.5f },
  341. { SkIntToScalar(20), 20.5f },
  342. { 20.5f, SkIntToScalar(0) },
  343. { 20.5f, SkIntToScalar(20) }
  344. };
  345. for (int i = 0; i < loops; ++i) {
  346. for (int j = 0; j < 10; ++j) {
  347. for (int k = 0; k < 10; ++k) {
  348. // Horizontal line
  349. SkPoint horPts[2];
  350. horPts[0].fX = pts[0].fX + k * 22.f;
  351. horPts[0].fY = pts[0].fY + j * 22.f;
  352. horPts[1].fX = pts[1].fX + k * 22.f;
  353. horPts[1].fY = pts[1].fY + j * 22.f;
  354. canvas->drawPoints(SkCanvas::kLines_PointMode, 2, horPts, p);
  355. // Vertical line
  356. SkPoint vertPts[2];
  357. vertPts[0].fX = pts[2].fX + k * 22.f;
  358. vertPts[0].fY = pts[2].fY + j * 22.f;
  359. vertPts[1].fX = pts[3].fX + k * 22.f;
  360. vertPts[1].fY = pts[3].fY + j * 22.f;
  361. canvas->drawPoints(SkCanvas::kLines_PointMode, 2, vertPts, p);
  362. }
  363. }
  364. }
  365. }
  366. private:
  367. typedef Benchmark INHERITED;
  368. };
  369. ///////////////////////////////////////////////////////////////////////////////
  370. static const SkScalar gDots[] = { SK_Scalar1, SK_Scalar1 };
  371. #define PARAM(array) array, SK_ARRAY_COUNT(array)
  372. DEF_BENCH( return new DashBench(PARAM(gDots), 0); )
  373. DEF_BENCH( return new DashBench(PARAM(gDots), 1); )
  374. DEF_BENCH( return new DashBench(PARAM(gDots), 1, true); )
  375. DEF_BENCH( return new DashBench(PARAM(gDots), 4); )
  376. DEF_BENCH( return new MakeDashBench(make_poly, "poly"); )
  377. DEF_BENCH( return new MakeDashBench(make_quad, "quad"); )
  378. DEF_BENCH( return new MakeDashBench(make_cubic, "cubic"); )
  379. DEF_BENCH( return new DashLineBench(0, false); )
  380. DEF_BENCH( return new DashLineBench(SK_Scalar1, false); )
  381. DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, false); )
  382. DEF_BENCH( return new DashLineBench(0, true); )
  383. DEF_BENCH( return new DashLineBench(SK_Scalar1, true); )
  384. DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, true); )
  385. DEF_BENCH( return new DrawPointsDashingBench(1, 1, false); )
  386. DEF_BENCH( return new DrawPointsDashingBench(1, 1, true); )
  387. DEF_BENCH( return new DrawPointsDashingBench(3, 1, false); )
  388. DEF_BENCH( return new DrawPointsDashingBench(3, 1, true); )
  389. DEF_BENCH( return new DrawPointsDashingBench(5, 5, false); )
  390. DEF_BENCH( return new DrawPointsDashingBench(5, 5, true); )
  391. /* Disable the GiantDashBench for Android devices until we can better control
  392. * the memory usage. (https://code.google.com/p/skia/issues/detail?id=1430)
  393. */
  394. #ifndef SK_BUILD_FOR_ANDROID
  395. DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 0); )
  396. DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 0); )
  397. DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 0); )
  398. // pass 2 to explicitly avoid any 1-is-the-same-as-hairline special casing
  399. // hori_2 is just too slow to enable at the moment
  400. DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 2); )
  401. DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 2); )
  402. DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 2); )
  403. DEF_BENCH( return new DashGridBench(1, 1, true); )
  404. DEF_BENCH( return new DashGridBench(1, 1, false); )
  405. DEF_BENCH( return new DashGridBench(3, 1, true); )
  406. DEF_BENCH( return new DashGridBench(3, 1, false); )
  407. #endif