• 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 AtomicInc64 : public Benchmark {
42 public:
AtomicInc64()43     AtomicInc64() : fX(0) {}
44 
isSuitableFor(Backend backend)45     bool isSuitableFor(Backend backend) override {
46         return backend == kNonRendering_Backend;
47     }
48 
49 protected:
onGetName()50     const char* onGetName() override {
51         return "atomic_inc_64";
52     }
53 
onDraw(int loops,SkCanvas *)54     void onDraw(int loops, SkCanvas*) override {
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:
isSuitableFor(Backend backend)67     bool isSuitableFor(Backend backend) override {
68         return backend == kNonRendering_Backend;
69     }
70 
71 protected:
onGetName()72     const char* onGetName() override {
73         return "ref_cnt_stack";
74     }
75 
onDraw(int loops,SkCanvas *)76     void onDraw(int loops, SkCanvas*) override {
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:
PlacedRefCnt()92     PlacedRefCnt() : SkRefCnt() { }
operator delete(void *)93     void operator delete(void*) { }
94 
95 private:
96     typedef SkRefCnt INHERITED;
97 };
98 
99 class RefCntBench_Heap : public Benchmark {
100 public:
isSuitableFor(Backend backend)101     bool isSuitableFor(Backend backend) override {
102         return backend == kNonRendering_Backend;
103     }
104 
105 protected:
onGetName()106     const char* onGetName() override {
107         return "ref_cnt_heap";
108     }
109 
onDraw(int loops,SkCanvas *)110     void onDraw(int loops, SkCanvas*) override {
111         char memory[sizeof(PlacedRefCnt)];
112         for (int i = 0; i < loops; ++i) {
113             PlacedRefCnt* ref = new (memory) PlacedRefCnt();
114             for (int j = 0; j < M; ++j) {
115                 ref->ref();
116                 ref->unref();
117             }
118             ref->unref();
119         }
120     }
121 
122 private:
123     typedef Benchmark INHERITED;
124 };
125 
126 class RefCntBench_New : public Benchmark {
127 public:
isSuitableFor(Backend backend)128     bool isSuitableFor(Backend backend) override {
129         return backend == kNonRendering_Backend;
130     }
131 
132 protected:
onGetName()133     const char* onGetName() override {
134         return "ref_cnt_new";
135     }
136 
onDraw(int loops,SkCanvas *)137     void onDraw(int loops, SkCanvas*) override {
138         for (int i = 0; i < loops; ++i) {
139             SkRefCnt* ref = new SkRefCnt();
140             for (int j = 0; j < M; ++j) {
141                 ref->ref();
142                 ref->unref();
143             }
144             ref->unref();
145         }
146     }
147 
148 private:
149     typedef Benchmark INHERITED;
150 };
151 
152 ///////////////////////////////////////////////////////////////////////////////
153 
154 class WeakRefCntBench_Stack : public Benchmark {
155 public:
isSuitableFor(Backend backend)156     bool isSuitableFor(Backend backend) override {
157         return backend == kNonRendering_Backend;
158     }
159 
160 protected:
onGetName()161     const char* onGetName() override {
162         return "ref_cnt_stack_weak";
163     }
164 
onDraw(int loops,SkCanvas *)165     void onDraw(int loops, SkCanvas*) override {
166         for (int i = 0; i < loops; ++i) {
167             SkWeakRefCnt ref;
168             for (int j = 0; j < M; ++j) {
169                 ref.ref();
170                 ref.unref();
171             }
172         }
173     }
174 
175 private:
176     typedef Benchmark INHERITED;
177 };
178 
179 class PlacedWeakRefCnt : public SkWeakRefCnt {
180 public:
PlacedWeakRefCnt()181     PlacedWeakRefCnt() : SkWeakRefCnt() { }
operator delete(void *)182     void operator delete(void*) { }
183 };
184 
185 class WeakRefCntBench_Heap : public Benchmark {
186 public:
isSuitableFor(Backend backend)187     bool isSuitableFor(Backend backend) override {
188         return backend == kNonRendering_Backend;
189     }
190 
191 protected:
onGetName()192     const char* onGetName() override {
193         return "ref_cnt_heap_weak";
194     }
195 
onDraw(int loops,SkCanvas *)196     void onDraw(int loops, SkCanvas*) override {
197         char memory[sizeof(PlacedWeakRefCnt)];
198         for (int i = 0; i < loops; ++i) {
199             PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
200             for (int j = 0; j < M; ++j) {
201                 ref->ref();
202                 ref->unref();
203             }
204             ref->unref();
205         }
206     }
207 
208 private:
209     typedef Benchmark INHERITED;
210 };
211 
212 class WeakRefCntBench_New : public Benchmark {
213 public:
isSuitableFor(Backend backend)214     bool isSuitableFor(Backend backend) override {
215         return backend == kNonRendering_Backend;
216     }
217 
218 protected:
onGetName()219     const char* onGetName() override {
220         return "ref_cnt_new_weak";
221     }
222 
onDraw(int loops,SkCanvas *)223     void onDraw(int loops, SkCanvas*) override {
224         for (int i = 0; i < loops; ++i) {
225             SkWeakRefCnt* ref = new SkWeakRefCnt();
226             for (int j = 0; j < M; ++j) {
227                 ref->ref();
228                 ref->unref();
229             }
230             ref->unref();
231         }
232     }
233 
234 private:
235     typedef Benchmark INHERITED;
236 };
237 
238 ///////////////////////////////////////////////////////////////////////////////
239 
240 DEF_BENCH( return new AtomicInc32(); )
241 DEF_BENCH( return new AtomicInc64(); )
242 
243 DEF_BENCH( return new RefCntBench_Stack(); )
244 DEF_BENCH( return new RefCntBench_Heap(); )
245 DEF_BENCH( return new RefCntBench_New(); )
246 
247 DEF_BENCH( return new WeakRefCntBench_Stack(); )
248 DEF_BENCH( return new WeakRefCntBench_Heap(); )
249 DEF_BENCH( return new WeakRefCntBench_New(); )
250