bench/RefCntBench.cpp

   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 "SkRefCnt.h"
  10 #include "SkThread.h"
  11 #include "SkWeakRefCnt.h"
  12
  13 enum {
  14     M = 2
  15 };
  16
  17 class AtomicInc32 : public Benchmark {
  18 public:
  19     AtomicInc32() : fX(0) {}
  20
  21     bool isSuitableFor(Backend backend) override {
  22         return backend == kNonRendering_Backend;
  23     }
  24
  25 protected:
  26     virtual const char* onGetName() {
  27         return "atomic_inc_32";
  28     }
  29
  30     virtual void onDraw(const int loops, SkCanvas*) {
  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 AtomicInc64 : public Benchmark {
  42 public:
  43     AtomicInc64() : fX(0) {}
  44
  45     bool isSuitableFor(Backend backend) override {
  46         return backend == kNonRendering_Backend;
  47     }
  48
  49 protected:
  50     virtual const char* onGetName() {
  51         return "atomic_inc_64";
  52     }
  53
  54     virtual void onDraw(const int loops, SkCanvas*) {
  55         for (int i = 0; i < loops; ++i) {
  56             sk_atomic_inc(&fX);
  57         }
  58     }
  59
  60 private:
  61     int64_t fX;
  62     typedef Benchmark INHERITED;
  63 };
  64
  65 class RefCntBench_Stack : public Benchmark {
  66 public:
  67     bool isSuitableFor(Backend backend) override {
  68         return backend == kNonRendering_Backend;
  69     }
  70
  71 protected:
  72     virtual const char* onGetName() {
  73         return "ref_cnt_stack";
  74     }
  75
  76     virtual void onDraw(const int loops, SkCanvas*) {
  77         for (int i = 0; i < loops; ++i) {
  78             SkRefCnt ref;
  79             for (int j = 0; j < M; ++j) {
  80                 ref.ref();
  81                 ref.unref();
  82             }
  83         }
  84     }
  85
  86 private:
  87     typedef Benchmark INHERITED;
  88 };
  89
  90 class PlacedRefCnt : public SkRefCnt {
  91 public:
  92     SK_DECLARE_INST_COUNT(PlacedRefCnt)
  93
  94     PlacedRefCnt() : SkRefCnt() { }
  95     void operator delete(void*) { }
  96
  97 private:
  98     typedef SkRefCnt INHERITED;
  99 };
 100
 101 class RefCntBench_Heap : public Benchmark {
 102 public:
 103     bool isSuitableFor(Backend backend) override {
 104         return backend == kNonRendering_Backend;
 105     }
 106
 107 protected:
 108     virtual const char* onGetName() {
 109         return "ref_cnt_heap";
 110     }
 111
 112     virtual void onDraw(const int loops, SkCanvas*) {
 113         char memory[sizeof(PlacedRefCnt)];
 114         for (int i = 0; i < loops; ++i) {
 115             PlacedRefCnt* ref = new (memory) PlacedRefCnt();
 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 class RefCntBench_New : public Benchmark {
 129 public:
 130     bool isSuitableFor(Backend backend) override {
 131         return backend == kNonRendering_Backend;
 132     }
 133
 134 protected:
 135     virtual const char* onGetName() {
 136         return "ref_cnt_new";
 137     }
 138
 139     virtual void onDraw(const int loops, SkCanvas*) {
 140         for (int i = 0; i < loops; ++i) {
 141             SkRefCnt* ref = new SkRefCnt();
 142             for (int j = 0; j < M; ++j) {
 143                 ref->ref();
 144                 ref->unref();
 145             }
 146             ref->unref();
 147         }
 148     }
 149
 150 private:
 151     typedef Benchmark INHERITED;
 152 };
 153
 154 ///////////////////////////////////////////////////////////////////////////////
 155
 156 class WeakRefCntBench_Stack : public Benchmark {
 157 public:
 158     bool isSuitableFor(Backend backend) override {
 159         return backend == kNonRendering_Backend;
 160     }
 161
 162 protected:
 163     virtual const char* onGetName() {
 164         return "ref_cnt_stack_weak";
 165     }
 166
 167     virtual void onDraw(const int loops, SkCanvas*) {
 168         for (int i = 0; i < loops; ++i) {
 169             SkWeakRefCnt ref;
 170             for (int j = 0; j < M; ++j) {
 171                 ref.ref();
 172                 ref.unref();
 173             }
 174         }
 175     }
 176
 177 private:
 178     typedef Benchmark INHERITED;
 179 };
 180
 181 class PlacedWeakRefCnt : public SkWeakRefCnt {
 182 public:
 183     PlacedWeakRefCnt() : SkWeakRefCnt() { }
 184     void operator delete(void*) { }
 185 };
 186
 187 class WeakRefCntBench_Heap : public Benchmark {
 188 public:
 189     bool isSuitableFor(Backend backend) override {
 190         return backend == kNonRendering_Backend;
 191     }
 192
 193 protected:
 194     const char* onGetName() override {
 195         return "ref_cnt_heap_weak";
 196     }
 197
 198     void onDraw(const int loops, SkCanvas*) override {
 199         char memory[sizeof(PlacedWeakRefCnt)];
 200         for (int i = 0; i < loops; ++i) {
 201             PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
 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 class WeakRefCntBench_New : public Benchmark {
 215 public:
 216     bool isSuitableFor(Backend backend) override {
 217         return backend == kNonRendering_Backend;
 218     }
 219
 220 protected:
 221     const char* onGetName() override {
 222         return "ref_cnt_new_weak";
 223     }
 224
 225     void onDraw(const int loops, SkCanvas*) override {
 226         for (int i = 0; i < loops; ++i) {
 227             SkWeakRefCnt* ref = new SkWeakRefCnt();
 228             for (int j = 0; j < M; ++j) {
 229                 ref->ref();
 230                 ref->unref();
 231             }
 232             ref->unref();
 233         }
 234     }
 235
 236 private:
 237     typedef Benchmark INHERITED;
 238 };
 239
 240 ///////////////////////////////////////////////////////////////////////////////
 241
 242 DEF_BENCH( return new AtomicInc32(); )
 243 DEF_BENCH( return new AtomicInc64(); )
 244
 245 DEF_BENCH( return new RefCntBench_Stack(); )
 246 DEF_BENCH( return new RefCntBench_Heap(); )
 247 DEF_BENCH( return new RefCntBench_New(); )
 248
 249 DEF_BENCH( return new WeakRefCntBench_Stack(); )
 250 DEF_BENCH( return new WeakRefCntBench_Heap(); )
 251 DEF_BENCH( return new WeakRefCntBench_New(); )