1 /* 2 * Copyright 2012 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 <memory> 8 #include "Benchmark.h" 9 #include "SkAtomics.h" 10 #include "SkRefCnt.h" 11 #include "SkWeakRefCnt.h" 12 13 enum { 14 M = 2 15 }; 16 17 class AtomicInc32 : public Benchmark { 18 public: AtomicInc32()19 AtomicInc32() : fX(0) {} 20 isSuitableFor(Backend backend)21 bool isSuitableFor(Backend backend) override { 22 return backend == kNonRendering_Backend; 23 } 24 25 protected: onGetName()26 const char* onGetName() override { 27 return "atomic_inc_32"; 28 } 29 onDraw(int loops,SkCanvas *)30 void onDraw(int loops, SkCanvas*) override { 31 for (int i = 0; i < loops; ++i) { 32 sk_atomic_inc(&fX); 33 } 34 } 35 36 private: 37 int32_t fX; 38 typedef Benchmark INHERITED; 39 }; 40 41 class RefCntBench_Stack : public Benchmark { 42 public: isSuitableFor(Backend backend)43 bool isSuitableFor(Backend backend) override { 44 return backend == kNonRendering_Backend; 45 } 46 47 protected: onGetName()48 const char* onGetName() override { 49 return "ref_cnt_stack"; 50 } 51 onDraw(int loops,SkCanvas *)52 void onDraw(int loops, SkCanvas*) override { 53 for (int i = 0; i < loops; ++i) { 54 SkRefCnt ref; 55 for (int j = 0; j < M; ++j) { 56 ref.ref(); 57 ref.unref(); 58 } 59 } 60 } 61 62 private: 63 typedef Benchmark INHERITED; 64 }; 65 66 class PlacedRefCnt : public SkRefCnt { 67 public: PlacedRefCnt()68 PlacedRefCnt() : SkRefCnt() { } operator delete(void *)69 void operator delete(void*) { } 70 71 private: 72 typedef SkRefCnt INHERITED; 73 }; 74 75 class RefCntBench_Heap : public Benchmark { 76 public: isSuitableFor(Backend backend)77 bool isSuitableFor(Backend backend) override { 78 return backend == kNonRendering_Backend; 79 } 80 81 protected: onGetName()82 const char* onGetName() override { 83 return "ref_cnt_heap"; 84 } 85 onDraw(int loops,SkCanvas *)86 void onDraw(int loops, SkCanvas*) override { 87 char memory[sizeof(PlacedRefCnt)]; 88 for (int i = 0; i < loops; ++i) { 89 PlacedRefCnt* ref = new (memory) PlacedRefCnt(); 90 for (int j = 0; j < M; ++j) { 91 ref->ref(); 92 ref->unref(); 93 } 94 ref->unref(); 95 } 96 } 97 98 private: 99 typedef Benchmark INHERITED; 100 }; 101 102 class RefCntBench_New : public Benchmark { 103 public: isSuitableFor(Backend backend)104 bool isSuitableFor(Backend backend) override { 105 return backend == kNonRendering_Backend; 106 } 107 108 protected: onGetName()109 const char* onGetName() override { 110 return "ref_cnt_new"; 111 } 112 onDraw(int loops,SkCanvas *)113 void onDraw(int loops, SkCanvas*) override { 114 for (int i = 0; i < loops; ++i) { 115 SkRefCnt* ref = new SkRefCnt(); 116 for (int j = 0; j < M; ++j) { 117 ref->ref(); 118 ref->unref(); 119 } 120 ref->unref(); 121 } 122 } 123 124 private: 125 typedef Benchmark INHERITED; 126 }; 127 128 /////////////////////////////////////////////////////////////////////////////// 129 130 class WeakRefCntBench_Stack : public Benchmark { 131 public: isSuitableFor(Backend backend)132 bool isSuitableFor(Backend backend) override { 133 return backend == kNonRendering_Backend; 134 } 135 136 protected: onGetName()137 const char* onGetName() override { 138 return "ref_cnt_stack_weak"; 139 } 140 onDraw(int loops,SkCanvas *)141 void onDraw(int loops, SkCanvas*) override { 142 for (int i = 0; i < loops; ++i) { 143 SkWeakRefCnt ref; 144 for (int j = 0; j < M; ++j) { 145 ref.ref(); 146 ref.unref(); 147 } 148 } 149 } 150 151 private: 152 typedef Benchmark INHERITED; 153 }; 154 155 class PlacedWeakRefCnt : public SkWeakRefCnt { 156 public: PlacedWeakRefCnt()157 PlacedWeakRefCnt() : SkWeakRefCnt() { } operator delete(void *)158 void operator delete(void*) { } 159 }; 160 161 class WeakRefCntBench_Heap : public Benchmark { 162 public: isSuitableFor(Backend backend)163 bool isSuitableFor(Backend backend) override { 164 return backend == kNonRendering_Backend; 165 } 166 167 protected: onGetName()168 const char* onGetName() override { 169 return "ref_cnt_heap_weak"; 170 } 171 onDraw(int loops,SkCanvas *)172 void onDraw(int loops, SkCanvas*) override { 173 char memory[sizeof(PlacedWeakRefCnt)]; 174 for (int i = 0; i < loops; ++i) { 175 PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt(); 176 for (int j = 0; j < M; ++j) { 177 ref->ref(); 178 ref->unref(); 179 } 180 ref->unref(); 181 } 182 } 183 184 private: 185 typedef Benchmark INHERITED; 186 }; 187 188 class WeakRefCntBench_New : public Benchmark { 189 public: isSuitableFor(Backend backend)190 bool isSuitableFor(Backend backend) override { 191 return backend == kNonRendering_Backend; 192 } 193 194 protected: onGetName()195 const char* onGetName() override { 196 return "ref_cnt_new_weak"; 197 } 198 onDraw(int loops,SkCanvas *)199 void onDraw(int loops, SkCanvas*) override { 200 for (int i = 0; i < loops; ++i) { 201 SkWeakRefCnt* ref = new SkWeakRefCnt(); 202 for (int j = 0; j < M; ++j) { 203 ref->ref(); 204 ref->unref(); 205 } 206 ref->unref(); 207 } 208 } 209 210 private: 211 typedef Benchmark INHERITED; 212 }; 213 214 /////////////////////////////////////////////////////////////////////////////// 215 216 DEF_BENCH( return new AtomicInc32(); ) 217 218 DEF_BENCH( return new RefCntBench_Stack(); ) 219 DEF_BENCH( return new RefCntBench_Heap(); ) 220 DEF_BENCH( return new RefCntBench_New(); ) 221 222 DEF_BENCH( return new WeakRefCntBench_Stack(); ) 223 DEF_BENCH( return new WeakRefCntBench_Heap(); ) 224 DEF_BENCH( return new WeakRefCntBench_New(); ) 225