PathBench.cpp 36 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244
  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/SkColorPriv.h"
  11. #include "include/core/SkPaint.h"
  12. #include "include/core/SkPath.h"
  13. #include "include/core/SkShader.h"
  14. #include "include/core/SkString.h"
  15. #include "include/private/SkTArray.h"
  16. #include "include/utils/SkRandom.h"
  17. enum Flags {
  18. kStroke_Flag = 1 << 0,
  19. kBig_Flag = 1 << 1
  20. };
  21. #define FLAGS00 Flags(0)
  22. #define FLAGS01 Flags(kStroke_Flag)
  23. #define FLAGS10 Flags(kBig_Flag)
  24. #define FLAGS11 Flags(kStroke_Flag | kBig_Flag)
  25. class PathBench : public Benchmark {
  26. SkPaint fPaint;
  27. SkString fName;
  28. Flags fFlags;
  29. public:
  30. PathBench(Flags flags) : fFlags(flags) {
  31. fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style :
  32. SkPaint::kFill_Style);
  33. fPaint.setStrokeWidth(SkIntToScalar(5));
  34. fPaint.setStrokeJoin(SkPaint::kBevel_Join);
  35. }
  36. virtual void appendName(SkString*) = 0;
  37. virtual void makePath(SkPath*) = 0;
  38. virtual int complexity() { return 0; }
  39. protected:
  40. const char* onGetName() override {
  41. fName.printf("path_%s_%s_",
  42. fFlags & kStroke_Flag ? "stroke" : "fill",
  43. fFlags & kBig_Flag ? "big" : "small");
  44. this->appendName(&fName);
  45. return fName.c_str();
  46. }
  47. void onDraw(int loops, SkCanvas* canvas) override {
  48. SkPaint paint(fPaint);
  49. this->setupPaint(&paint);
  50. SkPath path;
  51. this->makePath(&path);
  52. if (fFlags & kBig_Flag) {
  53. const SkMatrix m = SkMatrix::MakeScale(SkIntToScalar(10), SkIntToScalar(10));
  54. path.transform(m);
  55. }
  56. for (int i = 0; i < loops; i++) {
  57. canvas->drawPath(path, paint);
  58. }
  59. }
  60. private:
  61. typedef Benchmark INHERITED;
  62. };
  63. class TrianglePathBench : public PathBench {
  64. public:
  65. TrianglePathBench(Flags flags) : INHERITED(flags) {}
  66. void appendName(SkString* name) override {
  67. name->append("triangle");
  68. }
  69. void makePath(SkPath* path) override {
  70. static const int gCoord[] = {
  71. 10, 10, 15, 5, 20, 20
  72. };
  73. path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
  74. path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
  75. path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
  76. path->close();
  77. }
  78. private:
  79. typedef PathBench INHERITED;
  80. };
  81. class RectPathBench : public PathBench {
  82. public:
  83. RectPathBench(Flags flags) : INHERITED(flags) {}
  84. void appendName(SkString* name) override {
  85. name->append("rect");
  86. }
  87. void makePath(SkPath* path) override {
  88. SkRect r = { 10, 10, 20, 20 };
  89. path->addRect(r);
  90. }
  91. private:
  92. typedef PathBench INHERITED;
  93. };
  94. class RotatedRectBench : public PathBench {
  95. public:
  96. RotatedRectBench(Flags flags, bool aa, int degrees) : INHERITED(flags) {
  97. fAA = aa;
  98. fDegrees = degrees;
  99. }
  100. void appendName(SkString* name) override {
  101. SkString suffix;
  102. suffix.printf("rotated_rect_%s_%d", fAA ? "aa" : "noaa", fDegrees);
  103. name->append(suffix);
  104. }
  105. void makePath(SkPath* path) override {
  106. SkRect r = { 10, 10, 20, 20 };
  107. path->addRect(r);
  108. SkMatrix rotateMatrix;
  109. rotateMatrix.setRotate((SkScalar)fDegrees);
  110. path->transform(rotateMatrix);
  111. }
  112. virtual void setupPaint(SkPaint* paint) override {
  113. PathBench::setupPaint(paint);
  114. paint->setAntiAlias(fAA);
  115. }
  116. private:
  117. typedef PathBench INHERITED;
  118. int fDegrees;
  119. bool fAA;
  120. };
  121. class OvalPathBench : public PathBench {
  122. public:
  123. OvalPathBench(Flags flags) : INHERITED(flags) {}
  124. void appendName(SkString* name) override {
  125. name->append("oval");
  126. }
  127. void makePath(SkPath* path) override {
  128. SkRect r = { 10, 10, 23, 20 };
  129. path->addOval(r);
  130. }
  131. private:
  132. typedef PathBench INHERITED;
  133. };
  134. class CirclePathBench: public PathBench {
  135. public:
  136. CirclePathBench(Flags flags) : INHERITED(flags) {}
  137. void appendName(SkString* name) override {
  138. name->append("circle");
  139. }
  140. void makePath(SkPath* path) override {
  141. path->addCircle(SkIntToScalar(20), SkIntToScalar(20),
  142. SkIntToScalar(10));
  143. }
  144. private:
  145. typedef PathBench INHERITED;
  146. };
  147. class NonAACirclePathBench: public CirclePathBench {
  148. public:
  149. NonAACirclePathBench(Flags flags) : INHERITED(flags) {}
  150. void appendName(SkString* name) override {
  151. name->append("nonaacircle");
  152. }
  153. void setupPaint(SkPaint* paint) override {
  154. CirclePathBench::setupPaint(paint);
  155. paint->setAntiAlias(false);
  156. }
  157. private:
  158. typedef CirclePathBench INHERITED;
  159. };
  160. // Test max speedup of Analytic AA for concave paths
  161. class AAAConcavePathBench : public PathBench {
  162. public:
  163. AAAConcavePathBench(Flags flags) : INHERITED(flags) {}
  164. void appendName(SkString* name) override {
  165. name->append("concave_aaa");
  166. }
  167. void makePath(SkPath* path) override {
  168. path->moveTo(10, 10);
  169. path->lineTo(15, 10);
  170. path->lineTo(15, 5);
  171. path->lineTo(40, 40);
  172. path->close();
  173. }
  174. private:
  175. typedef PathBench INHERITED;
  176. };
  177. // Test max speedup of Analytic AA for convex paths
  178. class AAAConvexPathBench : public PathBench {
  179. public:
  180. AAAConvexPathBench(Flags flags) : INHERITED(flags) {}
  181. void appendName(SkString* name) override {
  182. name->append("convex_aaa");
  183. }
  184. void makePath(SkPath* path) override {
  185. path->moveTo(10, 10);
  186. path->lineTo(15, 10);
  187. path->lineTo(40, 50);
  188. path->close();
  189. }
  190. private:
  191. typedef PathBench INHERITED;
  192. };
  193. class SawToothPathBench : public PathBench {
  194. public:
  195. SawToothPathBench(Flags flags) : INHERITED(flags) {}
  196. void appendName(SkString* name) override {
  197. name->append("sawtooth");
  198. }
  199. void makePath(SkPath* path) override {
  200. SkScalar x = SkIntToScalar(20);
  201. SkScalar y = SkIntToScalar(20);
  202. const SkScalar x0 = x;
  203. const SkScalar dx = SK_Scalar1 * 5;
  204. const SkScalar dy = SK_Scalar1 * 10;
  205. path->moveTo(x, y);
  206. for (int i = 0; i < 32; i++) {
  207. x += dx;
  208. path->lineTo(x, y - dy);
  209. x += dx;
  210. path->lineTo(x, y + dy);
  211. }
  212. path->lineTo(x, y + 2 * dy);
  213. path->lineTo(x0, y + 2 * dy);
  214. path->close();
  215. }
  216. int complexity() override { return 1; }
  217. private:
  218. typedef PathBench INHERITED;
  219. };
  220. class LongCurvedPathBench : public PathBench {
  221. public:
  222. LongCurvedPathBench(Flags flags) : INHERITED(flags) {}
  223. void appendName(SkString* name) override {
  224. name->append("long_curved");
  225. }
  226. void makePath(SkPath* path) override {
  227. SkRandom rand (12);
  228. int i;
  229. for (i = 0; i < 100; i++) {
  230. path->quadTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480,
  231. rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
  232. }
  233. path->close();
  234. }
  235. int complexity() override { return 2; }
  236. private:
  237. typedef PathBench INHERITED;
  238. };
  239. class LongLinePathBench : public PathBench {
  240. public:
  241. LongLinePathBench(Flags flags) : INHERITED(flags) {}
  242. void appendName(SkString* name) override {
  243. name->append("long_line");
  244. }
  245. void makePath(SkPath* path) override {
  246. SkRandom rand;
  247. path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
  248. for (size_t i = 1; i < 100; i++) {
  249. path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
  250. }
  251. }
  252. int complexity() override { return 2; }
  253. private:
  254. typedef PathBench INHERITED;
  255. };
  256. class RandomPathBench : public Benchmark {
  257. public:
  258. bool isSuitableFor(Backend backend) override {
  259. return backend == kNonRendering_Backend;
  260. }
  261. protected:
  262. void createData(int minVerbs,
  263. int maxVerbs,
  264. bool allowMoves = true,
  265. SkRect* bounds = nullptr) {
  266. SkRect tempBounds;
  267. if (nullptr == bounds) {
  268. tempBounds.setXYWH(0, 0, SK_Scalar1, SK_Scalar1);
  269. bounds = &tempBounds;
  270. }
  271. fVerbCnts.reset(kNumVerbCnts);
  272. for (int i = 0; i < kNumVerbCnts; ++i) {
  273. fVerbCnts[i] = fRandom.nextRangeU(minVerbs, maxVerbs + 1);
  274. }
  275. fVerbs.reset(kNumVerbs);
  276. for (int i = 0; i < kNumVerbs; ++i) {
  277. do {
  278. fVerbs[i] = static_cast<SkPath::Verb>(fRandom.nextULessThan(SkPath::kDone_Verb));
  279. } while (!allowMoves && SkPath::kMove_Verb == fVerbs[i]);
  280. }
  281. fPoints.reset(kNumPoints);
  282. for (int i = 0; i < kNumPoints; ++i) {
  283. fPoints[i].set(fRandom.nextRangeScalar(bounds->fLeft, bounds->fRight),
  284. fRandom.nextRangeScalar(bounds->fTop, bounds->fBottom));
  285. }
  286. this->restartMakingPaths();
  287. }
  288. void restartMakingPaths() {
  289. fCurrPath = 0;
  290. fCurrVerb = 0;
  291. fCurrPoint = 0;
  292. }
  293. void makePath(SkPath* path) {
  294. int vCount = fVerbCnts[(fCurrPath++) & (kNumVerbCnts - 1)];
  295. for (int v = 0; v < vCount; ++v) {
  296. int verb = fVerbs[(fCurrVerb++) & (kNumVerbs - 1)];
  297. switch (verb) {
  298. case SkPath::kMove_Verb:
  299. path->moveTo(fPoints[(fCurrPoint++) & (kNumPoints - 1)]);
  300. break;
  301. case SkPath::kLine_Verb:
  302. path->lineTo(fPoints[(fCurrPoint++) & (kNumPoints - 1)]);
  303. break;
  304. case SkPath::kQuad_Verb:
  305. path->quadTo(fPoints[(fCurrPoint + 0) & (kNumPoints - 1)],
  306. fPoints[(fCurrPoint + 1) & (kNumPoints - 1)]);
  307. fCurrPoint += 2;
  308. break;
  309. case SkPath::kConic_Verb:
  310. path->conicTo(fPoints[(fCurrPoint + 0) & (kNumPoints - 1)],
  311. fPoints[(fCurrPoint + 1) & (kNumPoints - 1)],
  312. SK_ScalarHalf);
  313. fCurrPoint += 2;
  314. break;
  315. case SkPath::kCubic_Verb:
  316. path->cubicTo(fPoints[(fCurrPoint + 0) & (kNumPoints - 1)],
  317. fPoints[(fCurrPoint + 1) & (kNumPoints - 1)],
  318. fPoints[(fCurrPoint + 2) & (kNumPoints - 1)]);
  319. fCurrPoint += 3;
  320. break;
  321. case SkPath::kClose_Verb:
  322. path->close();
  323. break;
  324. default:
  325. SkDEBUGFAIL("Unexpected path verb");
  326. break;
  327. }
  328. }
  329. }
  330. void finishedMakingPaths() {
  331. fVerbCnts.reset(0);
  332. fVerbs.reset(0);
  333. fPoints.reset(0);
  334. }
  335. private:
  336. enum {
  337. // these should all be pow 2
  338. kNumVerbCnts = 1 << 5,
  339. kNumVerbs = 1 << 5,
  340. kNumPoints = 1 << 5,
  341. };
  342. SkAutoTArray<int> fVerbCnts;
  343. SkAutoTArray<SkPath::Verb> fVerbs;
  344. SkAutoTArray<SkPoint> fPoints;
  345. int fCurrPath;
  346. int fCurrVerb;
  347. int fCurrPoint;
  348. SkRandom fRandom;
  349. typedef Benchmark INHERITED;
  350. };
  351. class PathCreateBench : public RandomPathBench {
  352. public:
  353. PathCreateBench() {
  354. }
  355. protected:
  356. const char* onGetName() override {
  357. return "path_create";
  358. }
  359. void onDelayedSetup() override {
  360. this->createData(10, 100);
  361. }
  362. void onDraw(int loops, SkCanvas*) override {
  363. for (int i = 0; i < loops; ++i) {
  364. if (i % 1000 == 0) {
  365. fPath.reset(); // PathRef memory can grow without bound otherwise.
  366. }
  367. this->makePath(&fPath);
  368. }
  369. this->restartMakingPaths();
  370. }
  371. private:
  372. SkPath fPath;
  373. typedef RandomPathBench INHERITED;
  374. };
  375. class PathCopyBench : public RandomPathBench {
  376. public:
  377. PathCopyBench() {
  378. }
  379. protected:
  380. const char* onGetName() override {
  381. return "path_copy";
  382. }
  383. void onDelayedSetup() override {
  384. this->createData(10, 100);
  385. fPaths.reset(kPathCnt);
  386. fCopies.reset(kPathCnt);
  387. for (int i = 0; i < kPathCnt; ++i) {
  388. this->makePath(&fPaths[i]);
  389. }
  390. this->finishedMakingPaths();
  391. }
  392. void onDraw(int loops, SkCanvas*) override {
  393. for (int i = 0; i < loops; ++i) {
  394. int idx = i & (kPathCnt - 1);
  395. fCopies[idx] = fPaths[idx];
  396. }
  397. }
  398. private:
  399. enum {
  400. // must be a pow 2
  401. kPathCnt = 1 << 5,
  402. };
  403. SkAutoTArray<SkPath> fPaths;
  404. SkAutoTArray<SkPath> fCopies;
  405. typedef RandomPathBench INHERITED;
  406. };
  407. class PathTransformBench : public RandomPathBench {
  408. public:
  409. PathTransformBench(bool inPlace) : fInPlace(inPlace) {}
  410. protected:
  411. const char* onGetName() override {
  412. return fInPlace ? "path_transform_in_place" : "path_transform_copy";
  413. }
  414. void onDelayedSetup() override {
  415. fMatrix.setScale(5 * SK_Scalar1, 6 * SK_Scalar1);
  416. this->createData(10, 100);
  417. fPaths.reset(kPathCnt);
  418. for (int i = 0; i < kPathCnt; ++i) {
  419. this->makePath(&fPaths[i]);
  420. }
  421. this->finishedMakingPaths();
  422. if (!fInPlace) {
  423. fTransformed.reset(kPathCnt);
  424. }
  425. }
  426. void onDraw(int loops, SkCanvas*) override {
  427. if (fInPlace) {
  428. for (int i = 0; i < loops; ++i) {
  429. fPaths[i & (kPathCnt - 1)].transform(fMatrix);
  430. }
  431. } else {
  432. for (int i = 0; i < loops; ++i) {
  433. int idx = i & (kPathCnt - 1);
  434. fPaths[idx].transform(fMatrix, &fTransformed[idx]);
  435. }
  436. }
  437. }
  438. private:
  439. enum {
  440. // must be a pow 2
  441. kPathCnt = 1 << 5,
  442. };
  443. SkAutoTArray<SkPath> fPaths;
  444. SkAutoTArray<SkPath> fTransformed;
  445. SkMatrix fMatrix;
  446. bool fInPlace;
  447. typedef RandomPathBench INHERITED;
  448. };
  449. class PathEqualityBench : public RandomPathBench {
  450. public:
  451. PathEqualityBench() { }
  452. protected:
  453. const char* onGetName() override {
  454. return "path_equality_50%";
  455. }
  456. void onDelayedSetup() override {
  457. fParity = 0;
  458. this->createData(10, 100);
  459. fPaths.reset(kPathCnt);
  460. fCopies.reset(kPathCnt);
  461. for (int i = 0; i < kPathCnt; ++i) {
  462. this->makePath(&fPaths[i]);
  463. fCopies[i] = fPaths[i];
  464. }
  465. this->finishedMakingPaths();
  466. }
  467. void onDraw(int loops, SkCanvas*) override {
  468. for (int i = 0; i < loops; ++i) {
  469. int idx = i & (kPathCnt - 1);
  470. fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
  471. }
  472. }
  473. private:
  474. bool fParity; // attempt to keep compiler from optimizing out the ==
  475. enum {
  476. // must be a pow 2
  477. kPathCnt = 1 << 5,
  478. };
  479. SkAutoTArray<SkPath> fPaths;
  480. SkAutoTArray<SkPath> fCopies;
  481. typedef RandomPathBench INHERITED;
  482. };
  483. class SkBench_AddPathTest : public RandomPathBench {
  484. public:
  485. enum AddType {
  486. kAdd_AddType,
  487. kAddTrans_AddType,
  488. kAddMatrix_AddType,
  489. kReverseAdd_AddType,
  490. kReversePathTo_AddType,
  491. };
  492. SkBench_AddPathTest(AddType type) : fType(type) {
  493. fMatrix.setRotate(60 * SK_Scalar1);
  494. }
  495. protected:
  496. const char* onGetName() override {
  497. switch (fType) {
  498. case kAdd_AddType:
  499. return "path_add_path";
  500. case kAddTrans_AddType:
  501. return "path_add_path_trans";
  502. case kAddMatrix_AddType:
  503. return "path_add_path_matrix";
  504. case kReverseAdd_AddType:
  505. return "path_reverse_add_path";
  506. case kReversePathTo_AddType:
  507. return "path_reverse_path_to";
  508. default:
  509. SkDEBUGFAIL("Bad add type");
  510. return "";
  511. }
  512. }
  513. void onDelayedSetup() override {
  514. // reversePathTo assumes a single contour path.
  515. bool allowMoves = kReversePathTo_AddType != fType;
  516. this->createData(10, 100, allowMoves);
  517. fPaths0.reset(kPathCnt);
  518. fPaths1.reset(kPathCnt);
  519. for (int i = 0; i < kPathCnt; ++i) {
  520. this->makePath(&fPaths0[i]);
  521. this->makePath(&fPaths1[i]);
  522. }
  523. this->finishedMakingPaths();
  524. }
  525. void onDraw(int loops, SkCanvas*) override {
  526. switch (fType) {
  527. case kAdd_AddType:
  528. for (int i = 0; i < loops; ++i) {
  529. int idx = i & (kPathCnt - 1);
  530. SkPath result = fPaths0[idx];
  531. result.addPath(fPaths1[idx]);
  532. }
  533. break;
  534. case kAddTrans_AddType:
  535. for (int i = 0; i < loops; ++i) {
  536. int idx = i & (kPathCnt - 1);
  537. SkPath result = fPaths0[idx];
  538. result.addPath(fPaths1[idx], 2 * SK_Scalar1, 5 * SK_Scalar1);
  539. }
  540. break;
  541. case kAddMatrix_AddType:
  542. for (int i = 0; i < loops; ++i) {
  543. int idx = i & (kPathCnt - 1);
  544. SkPath result = fPaths0[idx];
  545. result.addPath(fPaths1[idx], fMatrix);
  546. }
  547. break;
  548. case kReverseAdd_AddType:
  549. for (int i = 0; i < loops; ++i) {
  550. int idx = i & (kPathCnt - 1);
  551. SkPath result = fPaths0[idx];
  552. result.reverseAddPath(fPaths1[idx]);
  553. }
  554. break;
  555. case kReversePathTo_AddType:
  556. for (int i = 0; i < loops; ++i) {
  557. int idx = i & (kPathCnt - 1);
  558. SkPath result = fPaths0[idx];
  559. result.reversePathTo(fPaths1[idx]);
  560. }
  561. break;
  562. }
  563. }
  564. private:
  565. AddType fType; // or reverseAddPath
  566. enum {
  567. // must be a pow 2
  568. kPathCnt = 1 << 5,
  569. };
  570. SkAutoTArray<SkPath> fPaths0;
  571. SkAutoTArray<SkPath> fPaths1;
  572. SkMatrix fMatrix;
  573. typedef RandomPathBench INHERITED;
  574. };
  575. class CirclesBench : public Benchmark {
  576. protected:
  577. SkString fName;
  578. Flags fFlags;
  579. public:
  580. CirclesBench(Flags flags) : fFlags(flags) {
  581. fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill");
  582. }
  583. protected:
  584. const char* onGetName() override {
  585. return fName.c_str();
  586. }
  587. void onDraw(int loops, SkCanvas* canvas) override {
  588. SkPaint paint;
  589. paint.setColor(SK_ColorBLACK);
  590. paint.setAntiAlias(true);
  591. if (fFlags & kStroke_Flag) {
  592. paint.setStyle(SkPaint::kStroke_Style);
  593. }
  594. SkRandom rand;
  595. SkRect r;
  596. for (int i = 0; i < loops; ++i) {
  597. SkScalar radius = rand.nextUScalar1() * 3;
  598. r.fLeft = rand.nextUScalar1() * 300;
  599. r.fTop = rand.nextUScalar1() * 300;
  600. r.fRight = r.fLeft + 2 * radius;
  601. r.fBottom = r.fTop + 2 * radius;
  602. if (fFlags & kStroke_Flag) {
  603. paint.setStrokeWidth(rand.nextUScalar1() * 5.0f);
  604. }
  605. SkPath temp;
  606. // mimic how Chrome does circles
  607. temp.arcTo(r, 0, 0, false);
  608. temp.addOval(r, SkPath::kCCW_Direction);
  609. temp.arcTo(r, 360, 0, true);
  610. temp.close();
  611. canvas->drawPath(temp, paint);
  612. }
  613. }
  614. private:
  615. typedef Benchmark INHERITED;
  616. };
  617. // Chrome creates its own round rects with each corner possibly being different.
  618. // In its "zero radius" incarnation it creates degenerate round rects.
  619. // Note: PathTest::test_arb_round_rect_is_convex and
  620. // test_arb_zero_rad_round_rect_is_rect perform almost exactly
  621. // the same test (but with no drawing)
  622. class ArbRoundRectBench : public Benchmark {
  623. protected:
  624. SkString fName;
  625. public:
  626. ArbRoundRectBench(bool zeroRad) : fZeroRad(zeroRad) {
  627. if (zeroRad) {
  628. fName.printf("zeroradroundrect");
  629. } else {
  630. fName.printf("arbroundrect");
  631. }
  632. }
  633. protected:
  634. const char* onGetName() override {
  635. return fName.c_str();
  636. }
  637. static void add_corner_arc(SkPath* path, const SkRect& rect,
  638. SkScalar xIn, SkScalar yIn,
  639. int startAngle)
  640. {
  641. SkScalar rx = SkMinScalar(rect.width(), xIn);
  642. SkScalar ry = SkMinScalar(rect.height(), yIn);
  643. SkRect arcRect;
  644. arcRect.set(-rx, -ry, rx, ry);
  645. switch (startAngle) {
  646. case 0:
  647. arcRect.offset(rect.fRight - arcRect.fRight, rect.fBottom - arcRect.fBottom);
  648. break;
  649. case 90:
  650. arcRect.offset(rect.fLeft - arcRect.fLeft, rect.fBottom - arcRect.fBottom);
  651. break;
  652. case 180:
  653. arcRect.offset(rect.fLeft - arcRect.fLeft, rect.fTop - arcRect.fTop);
  654. break;
  655. case 270:
  656. arcRect.offset(rect.fRight - arcRect.fRight, rect.fTop - arcRect.fTop);
  657. break;
  658. default:
  659. break;
  660. }
  661. path->arcTo(arcRect, SkIntToScalar(startAngle), SkIntToScalar(90), false);
  662. }
  663. static void make_arb_round_rect(SkPath* path, const SkRect& r,
  664. SkScalar xCorner, SkScalar yCorner) {
  665. // we are lazy here and use the same x & y for each corner
  666. add_corner_arc(path, r, xCorner, yCorner, 270);
  667. add_corner_arc(path, r, xCorner, yCorner, 0);
  668. add_corner_arc(path, r, xCorner, yCorner, 90);
  669. add_corner_arc(path, r, xCorner, yCorner, 180);
  670. path->close();
  671. SkASSERT(path->isConvex());
  672. }
  673. void onDraw(int loops, SkCanvas* canvas) override {
  674. SkRandom rand;
  675. SkRect r;
  676. for (int i = 0; i < loops; ++i) {
  677. SkPaint paint;
  678. paint.setColor(0xff000000 | rand.nextU());
  679. paint.setAntiAlias(true);
  680. SkScalar size = rand.nextUScalar1() * 30;
  681. if (size < SK_Scalar1) {
  682. continue;
  683. }
  684. r.fLeft = rand.nextUScalar1() * 300;
  685. r.fTop = rand.nextUScalar1() * 300;
  686. r.fRight = r.fLeft + 2 * size;
  687. r.fBottom = r.fTop + 2 * size;
  688. SkPath temp;
  689. if (fZeroRad) {
  690. make_arb_round_rect(&temp, r, 0, 0);
  691. SkASSERT(temp.isRect(nullptr));
  692. } else {
  693. make_arb_round_rect(&temp, r, r.width() / 10, r.height() / 15);
  694. }
  695. canvas->drawPath(temp, paint);
  696. }
  697. }
  698. private:
  699. bool fZeroRad; // should 0 radius rounds rects be tested?
  700. typedef Benchmark INHERITED;
  701. };
  702. class ConservativelyContainsBench : public Benchmark {
  703. public:
  704. enum Type {
  705. kRect_Type,
  706. kRoundRect_Type,
  707. kOval_Type,
  708. };
  709. ConservativelyContainsBench(Type type) {
  710. fParity = false;
  711. fName = "conservatively_contains_";
  712. switch (type) {
  713. case kRect_Type:
  714. fName.append("rect");
  715. fPath.addRect(kBaseRect);
  716. break;
  717. case kRoundRect_Type:
  718. fName.append("round_rect");
  719. fPath.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1]);
  720. break;
  721. case kOval_Type:
  722. fName.append("oval");
  723. fPath.addOval(kBaseRect);
  724. break;
  725. }
  726. }
  727. bool isSuitableFor(Backend backend) override {
  728. return backend == kNonRendering_Backend;
  729. }
  730. private:
  731. const char* onGetName() override {
  732. return fName.c_str();
  733. }
  734. void onDraw(int loops, SkCanvas*) override {
  735. for (int i = 0; i < loops; ++i) {
  736. const SkRect& rect = fQueryRects[i % kQueryRectCnt];
  737. fParity = fParity != fPath.conservativelyContainsRect(rect);
  738. }
  739. }
  740. void onDelayedSetup() override {
  741. fQueryRects.setCount(kQueryRectCnt);
  742. SkRandom rand;
  743. for (int i = 0; i < kQueryRectCnt; ++i) {
  744. SkSize size;
  745. SkPoint xy;
  746. size.fWidth = rand.nextRangeScalar(kQueryMin.fWidth, kQueryMax.fWidth);
  747. size.fHeight = rand.nextRangeScalar(kQueryMin.fHeight, kQueryMax.fHeight);
  748. xy.fX = rand.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth);
  749. xy.fY = rand.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight);
  750. fQueryRects[i] = SkRect::MakeXYWH(xy.fX, xy.fY, size.fWidth, size.fHeight);
  751. }
  752. }
  753. enum {
  754. kQueryRectCnt = 400,
  755. };
  756. static const SkRect kBounds; // bounds for all random query rects
  757. static const SkSize kQueryMin; // minimum query rect size, should be <= kQueryMax
  758. static const SkSize kQueryMax; // max query rect size, should < kBounds
  759. static const SkRect kBaseRect; // rect that is used to construct the path
  760. static const SkScalar kRRRadii[2]; // x and y radii for round rect
  761. SkString fName;
  762. SkPath fPath;
  763. bool fParity;
  764. SkTDArray<SkRect> fQueryRects;
  765. typedef Benchmark INHERITED;
  766. };
  767. ///////////////////////////////////////////////////////////////////////////////
  768. #include "src/core/SkGeometry.h"
  769. class ConicBench_Chop : public Benchmark {
  770. protected:
  771. SkConic fRQ, fDst[2];
  772. SkString fName;
  773. public:
  774. ConicBench_Chop() : fName("conic-chop") {
  775. fRQ.fPts[0].set(0, 0);
  776. fRQ.fPts[1].set(100, 0);
  777. fRQ.fPts[2].set(100, 100);
  778. fRQ.fW = SkScalarCos(SK_ScalarPI/4);
  779. }
  780. bool isSuitableFor(Backend backend) override {
  781. return backend == kNonRendering_Backend;
  782. }
  783. private:
  784. const char* onGetName() override { return fName.c_str(); }
  785. void onDraw(int loops, SkCanvas*) override {
  786. for (int i = 0; i < loops; ++i) {
  787. fRQ.chop(fDst);
  788. }
  789. }
  790. typedef Benchmark INHERITED;
  791. };
  792. DEF_BENCH( return new ConicBench_Chop; )
  793. class ConicBench_EvalPos : public ConicBench_Chop {
  794. const bool fUseV2;
  795. public:
  796. ConicBench_EvalPos(bool useV2) : fUseV2(useV2) {
  797. fName.printf("conic-eval-pos%d", useV2);
  798. }
  799. void onDraw(int loops, SkCanvas*) override {
  800. if (fUseV2) {
  801. for (int i = 0; i < loops; ++i) {
  802. for (int j = 0; j < 1000; ++j) {
  803. fDst[0].fPts[0] = fRQ.evalAt(0.4f);
  804. }
  805. }
  806. } else {
  807. for (int i = 0; i < loops; ++i) {
  808. for (int j = 0; j < 1000; ++j) {
  809. fRQ.evalAt(0.4f, &fDst[0].fPts[0], nullptr);
  810. }
  811. }
  812. }
  813. }
  814. };
  815. DEF_BENCH( return new ConicBench_EvalPos(false); )
  816. DEF_BENCH( return new ConicBench_EvalPos(true); )
  817. class ConicBench_EvalTan : public ConicBench_Chop {
  818. const bool fUseV2;
  819. public:
  820. ConicBench_EvalTan(bool useV2) : fUseV2(useV2) {
  821. fName.printf("conic-eval-tan%d", useV2);
  822. }
  823. void onDraw(int loops, SkCanvas*) override {
  824. if (fUseV2) {
  825. for (int i = 0; i < loops; ++i) {
  826. for (int j = 0; j < 1000; ++j) {
  827. fDst[0].fPts[0] = fRQ.evalTangentAt(0.4f);
  828. }
  829. }
  830. } else {
  831. for (int i = 0; i < loops; ++i) {
  832. for (int j = 0; j < 1000; ++j) {
  833. fRQ.evalAt(0.4f, nullptr, &fDst[0].fPts[0]);
  834. }
  835. }
  836. }
  837. }
  838. };
  839. DEF_BENCH( return new ConicBench_EvalTan(false); )
  840. DEF_BENCH( return new ConicBench_EvalTan(true); )
  841. ///////////////////////////////////////////////////////////////////////////////
  842. static void rand_conic(SkConic* conic, SkRandom& rand) {
  843. for (int i = 0; i < 3; ++i) {
  844. conic->fPts[i].set(rand.nextUScalar1() * 100, rand.nextUScalar1() * 100);
  845. }
  846. if (rand.nextUScalar1() > 0.5f) {
  847. conic->fW = rand.nextUScalar1();
  848. } else {
  849. conic->fW = 1 + rand.nextUScalar1() * 4;
  850. }
  851. }
  852. class ConicBench : public Benchmark {
  853. public:
  854. ConicBench() {
  855. SkRandom rand;
  856. for (int i = 0; i < CONICS; ++i) {
  857. rand_conic(&fConics[i], rand);
  858. }
  859. }
  860. bool isSuitableFor(Backend backend) override {
  861. return backend == kNonRendering_Backend;
  862. }
  863. protected:
  864. enum {
  865. CONICS = 100
  866. };
  867. SkConic fConics[CONICS];
  868. private:
  869. typedef Benchmark INHERITED;
  870. };
  871. class ConicBench_ComputeError : public ConicBench {
  872. public:
  873. ConicBench_ComputeError() {}
  874. protected:
  875. const char* onGetName() override {
  876. return "conic-compute-error";
  877. }
  878. void onDraw(int loops, SkCanvas*) override {
  879. SkVector err;
  880. for (int i = 0; i < loops; ++i) {
  881. for (int j = 0; j < CONICS; ++j) {
  882. fConics[j].computeAsQuadError(&err);
  883. }
  884. }
  885. }
  886. private:
  887. typedef ConicBench INHERITED;
  888. };
  889. class ConicBench_asQuadTol : public ConicBench {
  890. public:
  891. ConicBench_asQuadTol() {}
  892. protected:
  893. const char* onGetName() override {
  894. return "conic-asQuadTol";
  895. }
  896. void onDraw(int loops, SkCanvas*) override {
  897. for (int i = 0; i < loops; ++i) {
  898. for (int j = 0; j < CONICS; ++j) {
  899. fConics[j].asQuadTol(SK_ScalarHalf);
  900. }
  901. }
  902. }
  903. private:
  904. typedef ConicBench INHERITED;
  905. };
  906. class ConicBench_quadPow2 : public ConicBench {
  907. public:
  908. ConicBench_quadPow2() {}
  909. protected:
  910. const char* onGetName() override {
  911. return "conic-quadPow2";
  912. }
  913. void onDraw(int loops, SkCanvas*) override {
  914. for (int i = 0; i < loops; ++i) {
  915. for (int j = 0; j < CONICS; ++j) {
  916. fConics[j].computeQuadPOW2(SK_ScalarHalf);
  917. }
  918. }
  919. }
  920. private:
  921. typedef ConicBench INHERITED;
  922. };
  923. ///////////////////////////////////////////////////////////////////////////////
  924. class TightBoundsBench : public Benchmark {
  925. SkPath fPath;
  926. SkString fName;
  927. SkRect (*fProc)(const SkPath&);
  928. public:
  929. TightBoundsBench(SkRect (*proc)(const SkPath&), const char suffix[]) : fProc(proc) {
  930. fName.printf("tight_bounds_%s", suffix);
  931. const int N = 100;
  932. SkRandom rand;
  933. for (int i = 0; i < N; ++i) {
  934. fPath.moveTo(rand.nextF()*100, rand.nextF()*100);
  935. fPath.lineTo(rand.nextF()*100, rand.nextF()*100);
  936. fPath.quadTo(rand.nextF()*100, rand.nextF()*100, rand.nextF()*100, rand.nextF()*100);
  937. fPath.conicTo(rand.nextF()*100, rand.nextF()*100, rand.nextF()*100, rand.nextF()*100,
  938. rand.nextF()*10);
  939. fPath.cubicTo(rand.nextF()*100, rand.nextF()*100, rand.nextF()*100, rand.nextF()*100,
  940. rand.nextF()*100, rand.nextF()*100);
  941. }
  942. }
  943. protected:
  944. bool isSuitableFor(Backend backend) override {
  945. return backend == kNonRendering_Backend;
  946. }
  947. const char* onGetName() override { return fName.c_str(); }
  948. void onDraw(int loops, SkCanvas* canvas) override {
  949. for (int i = 0; i < loops*100; ++i) {
  950. fProc(fPath);
  951. }
  952. }
  953. private:
  954. typedef Benchmark INHERITED;
  955. };
  956. const SkRect ConservativelyContainsBench::kBounds = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
  957. const SkSize ConservativelyContainsBench::kQueryMin = {SkIntToScalar(1), SkIntToScalar(1)};
  958. const SkSize ConservativelyContainsBench::kQueryMax = {SkIntToScalar(40), SkIntToScalar(40)};
  959. const SkRect ConservativelyContainsBench::kBaseRect = SkRect::MakeXYWH(SkIntToScalar(25), SkIntToScalar(25), SkIntToScalar(50), SkIntToScalar(50));
  960. const SkScalar ConservativelyContainsBench::kRRRadii[2] = {SkIntToScalar(5), SkIntToScalar(10)};
  961. DEF_BENCH( return new TrianglePathBench(FLAGS00); )
  962. DEF_BENCH( return new TrianglePathBench(FLAGS01); )
  963. DEF_BENCH( return new TrianglePathBench(FLAGS10); )
  964. DEF_BENCH( return new TrianglePathBench(FLAGS11); )
  965. DEF_BENCH( return new RectPathBench(FLAGS00); )
  966. DEF_BENCH( return new RectPathBench(FLAGS01); )
  967. DEF_BENCH( return new RectPathBench(FLAGS10); )
  968. DEF_BENCH( return new RectPathBench(FLAGS11); )
  969. DEF_BENCH( return new RotatedRectBench(FLAGS00, false, 45));
  970. DEF_BENCH( return new RotatedRectBench(FLAGS10, false, 45));
  971. DEF_BENCH( return new RotatedRectBench(FLAGS00, true, 45));
  972. DEF_BENCH( return new RotatedRectBench(FLAGS10, true, 45));
  973. DEF_BENCH( return new OvalPathBench(FLAGS00); )
  974. DEF_BENCH( return new OvalPathBench(FLAGS01); )
  975. DEF_BENCH( return new OvalPathBench(FLAGS10); )
  976. DEF_BENCH( return new OvalPathBench(FLAGS11); )
  977. DEF_BENCH( return new CirclePathBench(FLAGS00); )
  978. DEF_BENCH( return new CirclePathBench(FLAGS01); )
  979. DEF_BENCH( return new CirclePathBench(FLAGS10); )
  980. DEF_BENCH( return new CirclePathBench(FLAGS11); )
  981. DEF_BENCH( return new NonAACirclePathBench(FLAGS00); )
  982. DEF_BENCH( return new NonAACirclePathBench(FLAGS10); )
  983. DEF_BENCH( return new AAAConcavePathBench(FLAGS00); )
  984. DEF_BENCH( return new AAAConcavePathBench(FLAGS10); )
  985. DEF_BENCH( return new AAAConvexPathBench(FLAGS00); )
  986. DEF_BENCH( return new AAAConvexPathBench(FLAGS10); )
  987. DEF_BENCH( return new SawToothPathBench(FLAGS00); )
  988. DEF_BENCH( return new SawToothPathBench(FLAGS01); )
  989. DEF_BENCH( return new LongCurvedPathBench(FLAGS00); )
  990. DEF_BENCH( return new LongCurvedPathBench(FLAGS01); )
  991. DEF_BENCH( return new LongLinePathBench(FLAGS00); )
  992. DEF_BENCH( return new LongLinePathBench(FLAGS01); )
  993. DEF_BENCH( return new PathCreateBench(); )
  994. DEF_BENCH( return new PathCopyBench(); )
  995. DEF_BENCH( return new PathTransformBench(true); )
  996. DEF_BENCH( return new PathTransformBench(false); )
  997. DEF_BENCH( return new PathEqualityBench(); )
  998. DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAdd_AddType); )
  999. DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddTrans_AddType); )
  1000. DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kAddMatrix_AddType); )
  1001. DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReverseAdd_AddType); )
  1002. DEF_BENCH( return new SkBench_AddPathTest(SkBench_AddPathTest::kReversePathTo_AddType); )
  1003. DEF_BENCH( return new CirclesBench(FLAGS00); )
  1004. DEF_BENCH( return new CirclesBench(FLAGS01); )
  1005. DEF_BENCH( return new ArbRoundRectBench(false); )
  1006. DEF_BENCH( return new ArbRoundRectBench(true); )
  1007. DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kRect_Type); )
  1008. DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kRoundRect_Type); )
  1009. DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kOval_Type); )
  1010. #include "include/pathops/SkPathOps.h"
  1011. #include "src/core/SkPathPriv.h"
  1012. DEF_BENCH( return new TightBoundsBench([](const SkPath& path){ return path.computeTightBounds();},
  1013. "priv"); )
  1014. DEF_BENCH( return new TightBoundsBench([](const SkPath& path) {
  1015. SkRect bounds; TightBounds(path, &bounds); return bounds;
  1016. }, "pathops"); )
  1017. // These seem to be optimized away, which is troublesome for timing.
  1018. /*
  1019. DEF_BENCH( return new ConicBench_Chop5() )
  1020. DEF_BENCH( return new ConicBench_ComputeError() )
  1021. DEF_BENCH( return new ConicBench_asQuadTol() )
  1022. DEF_BENCH( return new ConicBench_quadPow2() )
  1023. */
  1024. class CommonConvexBench : public Benchmark {
  1025. protected:
  1026. SkString fName;
  1027. SkPath fPath;
  1028. const bool fAA;
  1029. public:
  1030. CommonConvexBench(int w, int h, bool forceConcave, bool aa) : fAA(aa) {
  1031. fName.printf("convex_path_%d_%d_%d_%d", w, h, forceConcave, aa);
  1032. SkRect r = SkRect::MakeXYWH(10, 10, w*1.0f, h*1.0f);
  1033. fPath.addRRect(SkRRect::MakeRectXY(r, w/8.0f, h/8.0f));
  1034. if (forceConcave) {
  1035. fPath.setConvexity(SkPath::kConcave_Convexity);
  1036. SkASSERT(!fPath.isConvex());
  1037. } else {
  1038. SkASSERT(fPath.isConvex());
  1039. }
  1040. }
  1041. protected:
  1042. const char* onGetName() override {
  1043. return fName.c_str();
  1044. }
  1045. void onDraw(int loops, SkCanvas* canvas) override {
  1046. SkPaint paint;
  1047. paint.setAntiAlias(fAA);
  1048. for (int i = 0; i < loops; ++i) {
  1049. for (int inner = 0; inner < 100; ++inner) {
  1050. canvas->drawPath(fPath, paint);
  1051. }
  1052. }
  1053. }
  1054. private:
  1055. typedef Benchmark INHERITED;
  1056. };
  1057. DEF_BENCH( return new CommonConvexBench( 16, 16, false, false); )
  1058. DEF_BENCH( return new CommonConvexBench( 16, 16, true, false); )
  1059. DEF_BENCH( return new CommonConvexBench( 16, 16, false, true); )
  1060. DEF_BENCH( return new CommonConvexBench( 16, 16, true, true); )
  1061. DEF_BENCH( return new CommonConvexBench(200, 16, false, false); )
  1062. DEF_BENCH( return new CommonConvexBench(200, 16, true, false); )
  1063. DEF_BENCH( return new CommonConvexBench(200, 16, false, true); )
  1064. DEF_BENCH( return new CommonConvexBench(200, 16, true, true); )