1 2 /* 3 * Copyright 2011 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 #ifndef SkBenchmark_DEFINED 9 #define SkBenchmark_DEFINED 10 11 #include "SkRefCnt.h" 12 #include "SkPoint.h" 13 #include "SkTDict.h" 14 #include "SkTRegistry.h" 15 16 #define DEF_BENCH(code) \ 17 static SkBenchmark* SK_MACRO_APPEND_LINE(F_)(void* p) { code; } \ 18 static BenchRegistry SK_MACRO_APPEND_LINE(R_)(SK_MACRO_APPEND_LINE(F_)); 19 20 /* 21 * With the above macros, you can register benches as follows (at the bottom 22 * of your .cpp) 23 * 24 * DEF_BENCH(new MyBenchmark(p, ...)) 25 * DEF_BENCH(new MyBenchmark(p, ...)) 26 * DEF_BENCH(new MyBenchmark(p, ...)) 27 */ 28 29 30 #ifdef SK_DEBUG 31 #define SkBENCHLOOP(n) 1 32 #else 33 #define SkBENCHLOOP(n) n 34 #endif 35 36 class SkCanvas; 37 class SkPaint; 38 39 class SkTriState { 40 public: 41 enum State { 42 kDefault, 43 kTrue, 44 kFalse 45 }; 46 }; 47 48 class SkBenchmark : public SkRefCnt { 49 public: 50 SK_DECLARE_INST_COUNT(SkBenchmark) 51 52 SkBenchmark(void* defineDict); 53 54 const char* getName(); 55 SkIPoint getSize(); 56 57 // Call before draw, allows the benchmark to do setup work outside of the 58 // timer. When a benchmark is repeatedly drawn, this should be called once 59 // before the initial draw. 60 void preDraw(); 61 62 void draw(SkCanvas*); 63 64 // Call after draw, allows the benchmark to do cleanup work outside of the 65 // timer. When a benchmark is repeatedly drawn, this is only called once 66 // after the last draw. 67 void postDraw(); 68 69 void setForceAlpha(int alpha) { 70 fForceAlpha = alpha; 71 } 72 73 void setForceAA(bool aa) { 74 fForceAA = aa; 75 } 76 77 void setForceFilter(bool filter) { 78 fForceFilter = filter; 79 } 80 81 void setDither(SkTriState::State state) { 82 fDither = state; 83 } 84 85 void setStrokeWidth(SkScalar width) { 86 strokeWidth = width; 87 fHasStrokeWidth = true; 88 } 89 90 SkScalar getStrokeWidth() { 91 return strokeWidth; 92 } 93 94 bool hasStrokeWidth() { 95 return fHasStrokeWidth; 96 } 97 98 /** If true; the benchmark does rendering; if false, the benchmark 99 doesn't, and so need not be re-run in every different rendering 100 mode. */ 101 bool isRendering() { 102 return fIsRendering; 103 } 104 105 const char* findDefine(const char* key) const; 106 bool findDefine32(const char* key, int32_t* value) const; 107 bool findDefineScalar(const char* key, SkScalar* value) const; 108 109 /** Assign masks for paint-flags. These will be applied when setupPaint() 110 * is called. 111 * 112 * Performs the following on the paint: 113 * uint32_t flags = paint.getFlags(); 114 * flags &= ~clearMask; 115 * flags |= orMask; 116 * paint.setFlags(flags); 117 */ 118 void setPaintMasks(uint32_t orMask, uint32_t clearMask) { 119 fOrMask = orMask; 120 fClearMask = clearMask; 121 } 122 123 float getDurationScale() { return this->onGetDurationScale(); } 124 125 protected: 126 virtual void setupPaint(SkPaint* paint); 127 128 virtual const char* onGetName() = 0; 129 virtual void onPreDraw() {} 130 virtual void onDraw(SkCanvas*) = 0; 131 virtual void onPostDraw() {} 132 // the caller will scale the computed duration by this value. It allows a 133 // slow bench to run fewer inner loops, but return the corresponding scale 134 // so that its reported duration can be compared against other benches. 135 // e.g. 136 // if I run 10x slower, I can run 1/10 the number of inner-loops, but 137 // return 10.0 for my durationScale, so I "report" the honest duration. 138 virtual float onGetDurationScale() { return 1; } 139 140 virtual SkIPoint onGetSize(); 141 /// Defaults to true. 142 bool fIsRendering; 143 144 private: 145 const SkTDict<const char*>* fDict; 146 int fForceAlpha; 147 bool fForceAA; 148 bool fForceFilter; 149 SkTriState::State fDither; 150 bool fHasStrokeWidth; 151 SkScalar strokeWidth; 152 uint32_t fOrMask, fClearMask; 153 154 typedef SkRefCnt INHERITED; 155 }; 156 157 typedef SkTRegistry<SkBenchmark*, void*> BenchRegistry; 158 159 #endif 160