GeometryBench.cpp 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294
  1. /*
  2. * Copyright 2014 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/SkRect.h"
  9. #include "include/utils/SkRandom.h"
  10. #include "src/core/SkGeometry.h"
  11. class GeometryBench : public Benchmark {
  12. public:
  13. GeometryBench(const char suffix[]) : fVolatileInt(0) {
  14. fName.printf("geo_%s", suffix);
  15. }
  16. const char* onGetName() override {
  17. return fName.c_str();
  18. }
  19. bool isSuitableFor(Backend backend) override {
  20. return kNonRendering_Backend == backend;
  21. }
  22. protected:
  23. volatile int fVolatileInt;
  24. /**
  25. * Subclasses can call this to try to defeat the optimizer (with some result of their
  26. * inner loop), since it will fool the compiler into assuming that "n" is actually
  27. * needed somewhere, and since this method is not const, the member fields cannot
  28. * be assumed to be const before and after the call.
  29. */
  30. virtual void virtualCallToFoilOptimizers(int n) { fVolatileInt += n; }
  31. private:
  32. SkString fName;
  33. };
  34. class GeoRectBench : public GeometryBench {
  35. public:
  36. GeoRectBench(const char suffix[]) : GeometryBench(suffix) {}
  37. protected:
  38. SkRect fRects[2048];
  39. virtual void onDelayedSetup() {
  40. const SkScalar min = -100;
  41. const SkScalar max = 100;
  42. SkRandom rand;
  43. for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
  44. SkScalar x = rand.nextRangeScalar(min, max);
  45. SkScalar y = rand.nextRangeScalar(min, max);
  46. SkScalar w = rand.nextRangeScalar(min, max);
  47. SkScalar h = rand.nextRangeScalar(min, max);
  48. fRects[i].setXYWH(x, y, w, h);
  49. }
  50. }
  51. };
  52. class GeoRectBench_intersect : public GeoRectBench {
  53. public:
  54. GeoRectBench_intersect() : GeoRectBench("rect_intersect") {}
  55. protected:
  56. void onDraw(int loops, SkCanvas* canvas) override {
  57. for (int outer = 0; outer < loops; ++outer) {
  58. int count = 0;
  59. for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
  60. SkRect r = fRects[0];
  61. count += r.intersect(fRects[i]);
  62. }
  63. this->virtualCallToFoilOptimizers(count);
  64. }
  65. }
  66. };
  67. class GeoRectBench_intersect_rect : public GeoRectBench {
  68. public:
  69. GeoRectBench_intersect_rect() : GeoRectBench("rect_intersect_rect") {}
  70. protected:
  71. void onDraw(int loops, SkCanvas* canvas) override {
  72. for (int outer = 0; outer < loops; ++outer) {
  73. int count = 0;
  74. SkRect r;
  75. for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
  76. count += r.intersect(fRects[0], fRects[i]);
  77. }
  78. this->virtualCallToFoilOptimizers(count);
  79. }
  80. }
  81. };
  82. class GeoRectBench_Intersects : public GeoRectBench {
  83. public:
  84. GeoRectBench_Intersects() : GeoRectBench("rect_Intersects") {}
  85. protected:
  86. void onDraw(int loops, SkCanvas* canvas) override {
  87. for (int outer = 0; outer < loops; ++outer) {
  88. int count = 0;
  89. for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
  90. count += SkRect::Intersects(fRects[0], fRects[i]);
  91. }
  92. this->virtualCallToFoilOptimizers(count);
  93. }
  94. }
  95. };
  96. class GeoRectBench_sort : public GeoRectBench {
  97. public:
  98. GeoRectBench_sort() : GeoRectBench("rect_sort") {}
  99. protected:
  100. void onDraw(int loops, SkCanvas* canvas) override {
  101. for (int outer = 0; outer < loops; ++outer) {
  102. for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
  103. fRects[i].sort();
  104. }
  105. }
  106. }
  107. };
  108. DEF_BENCH( return new GeoRectBench_intersect; )
  109. DEF_BENCH( return new GeoRectBench_intersect_rect; )
  110. DEF_BENCH( return new GeoRectBench_Intersects; )
  111. DEF_BENCH( return new GeoRectBench_sort; )
  112. ///////////////////////////////////////////////////////////////////////////////////////////////////
  113. class QuadBenchBase : public GeometryBench {
  114. protected:
  115. SkPoint fPts[4];
  116. public:
  117. QuadBenchBase(const char name[]) : GeometryBench(name) {
  118. SkRandom rand;
  119. for (int i = 0; i < 4; ++i) {
  120. fPts[i].set(rand.nextUScalar1(), rand.nextUScalar1());
  121. }
  122. }
  123. };
  124. class EvalQuadAt0 : public QuadBenchBase {
  125. public:
  126. EvalQuadAt0() : QuadBenchBase("evalquadat0") {}
  127. protected:
  128. void onDraw(int loops, SkCanvas* canvas) override {
  129. SkPoint result;
  130. for (int outer = 0; outer < loops; ++outer) {
  131. SkEvalQuadAt(fPts, 0.5f, &result);
  132. SkEvalQuadAt(fPts, 0.5f, &result);
  133. SkEvalQuadAt(fPts, 0.5f, &result);
  134. SkEvalQuadAt(fPts, 0.5f, &result);
  135. }
  136. }
  137. };
  138. DEF_BENCH( return new EvalQuadAt0; )
  139. class EvalQuadAt1 : public QuadBenchBase {
  140. public:
  141. EvalQuadAt1() : QuadBenchBase("evalquadat1") {}
  142. protected:
  143. void onDraw(int loops, SkCanvas* canvas) override {
  144. SkPoint result;
  145. for (int outer = 0; outer < loops; ++outer) {
  146. result = SkEvalQuadAt(fPts, 0.5f);
  147. result = SkEvalQuadAt(fPts, 0.5f);
  148. result = SkEvalQuadAt(fPts, 0.5f);
  149. result = SkEvalQuadAt(fPts, 0.5f);
  150. }
  151. }
  152. };
  153. DEF_BENCH( return new EvalQuadAt1; )
  154. ////////
  155. class EvalQuadTangentAt0 : public QuadBenchBase {
  156. public:
  157. EvalQuadTangentAt0() : QuadBenchBase("evalquadtangentat0") {}
  158. protected:
  159. void onDraw(int loops, SkCanvas* canvas) override {
  160. SkPoint result;
  161. for (int outer = 0; outer < loops; ++outer) {
  162. SkEvalQuadAt(fPts, 0.5f, nullptr, &result);
  163. SkEvalQuadAt(fPts, 0.5f, nullptr, &result);
  164. SkEvalQuadAt(fPts, 0.5f, nullptr, &result);
  165. SkEvalQuadAt(fPts, 0.5f, nullptr, &result);
  166. }
  167. }
  168. };
  169. DEF_BENCH( return new EvalQuadTangentAt0; )
  170. class EvalQuadTangentAt1 : public QuadBenchBase {
  171. public:
  172. EvalQuadTangentAt1() : QuadBenchBase("evalquadtangentat1") {}
  173. protected:
  174. void onDraw(int loops, SkCanvas* canvas) override {
  175. SkPoint result;
  176. for (int outer = 0; outer < loops; ++outer) {
  177. result = SkEvalQuadTangentAt(fPts, 0.5f);
  178. result = SkEvalQuadTangentAt(fPts, 0.5f);
  179. result = SkEvalQuadTangentAt(fPts, 0.5f);
  180. result = SkEvalQuadTangentAt(fPts, 0.5f);
  181. }
  182. }
  183. };
  184. DEF_BENCH( return new EvalQuadTangentAt1; )
  185. ////////
  186. class ChopQuadAt : public QuadBenchBase {
  187. public:
  188. ChopQuadAt() : QuadBenchBase("chopquadat") {}
  189. protected:
  190. void onDraw(int loops, SkCanvas* canvas) override {
  191. SkPoint dst[5];
  192. for (int outer = 0; outer < loops; ++outer) {
  193. SkChopQuadAt(fPts, dst, 0.5f);
  194. SkChopQuadAt(fPts, dst, 0.5f);
  195. SkChopQuadAt(fPts, dst, 0.5f);
  196. SkChopQuadAt(fPts, dst, 0.5f);
  197. }
  198. }
  199. };
  200. DEF_BENCH( return new ChopQuadAt; )
  201. class ChopCubicAt : public QuadBenchBase {
  202. public:
  203. ChopCubicAt() : QuadBenchBase("chopcubicat0") {}
  204. protected:
  205. void onDraw(int loops, SkCanvas* canvas) override {
  206. SkPoint dst[7];
  207. for (int outer = 0; outer < loops; ++outer) {
  208. SkChopCubicAt(fPts, dst, 0.5f);
  209. SkChopCubicAt(fPts, dst, 0.5f);
  210. SkChopCubicAt(fPts, dst, 0.5f);
  211. SkChopCubicAt(fPts, dst, 0.5f);
  212. }
  213. }
  214. };
  215. DEF_BENCH( return new ChopCubicAt; )
  216. #include "include/core/SkPath.h"
  217. class ConvexityBench : public Benchmark {
  218. SkPath fPath;
  219. public:
  220. ConvexityBench(const char suffix[]) {
  221. fName.printf("convexity_%s", suffix);
  222. }
  223. const char* onGetName() override {
  224. return fName.c_str();
  225. }
  226. bool isSuitableFor(Backend backend) override {
  227. return kNonRendering_Backend == backend;
  228. }
  229. virtual void preparePath(SkPath*) = 0;
  230. protected:
  231. void onPreDraw(SkCanvas*) override {
  232. this->preparePath(&fPath);
  233. }
  234. void onDraw(int loops, SkCanvas* canvas) override {
  235. for (int i = 0; i < loops; ++i) {
  236. fPath.setConvexity(SkPath::kUnknown_Convexity);
  237. (void)fPath.isConvex();
  238. }
  239. }
  240. private:
  241. SkString fName;
  242. };
  243. class RRectConvexityBench : public ConvexityBench {
  244. public:
  245. RRectConvexityBench() : ConvexityBench("rrect") {}
  246. void preparePath(SkPath* path) override {
  247. SkRRect rr;
  248. rr.setRectXY({0, 0, 100, 100}, 20, 30);
  249. path->addRRect(rr);
  250. }
  251. };
  252. DEF_BENCH( return new RRectConvexityBench; )