• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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