RefCntBench.cpp revision 62a69c26b3a34c259918d6c97b4dea76b6285b67 
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
13enum {
14    M = 2
15};
16
17class AtomicInc32 : public Benchmark {
18public:
19    AtomicInc32() : fX(0) {}
20
21    bool isSuitableFor(Backend backend) override {
22        return backend == kNonRendering_Backend;
23    }
24
25protected:
26    const char* onGetName() override {
27        return "atomic_inc_32";
28    }
29
30    void onDraw(const int loops, SkCanvas*) override {
31        for (int i = 0; i < loops; ++i) {
32            sk_atomic_inc(&fX);
33        }
34    }
35
36private:
37    int32_t fX;
38    typedef Benchmark INHERITED;
39};
40
41class AtomicInc64 : public Benchmark {
42public:
43    AtomicInc64() : fX(0) {}
44
45    bool isSuitableFor(Backend backend) override {
46        return backend == kNonRendering_Backend;
47    }
48
49protected:
50    const char* onGetName() override {
51        return "atomic_inc_64";
52    }
53
54    void onDraw(const int loops, SkCanvas*) override {
55        for (int i = 0; i < loops; ++i) {
56            sk_atomic_inc(&fX);
57        }
58    }
59
60private:
61    int64_t fX;
62    typedef Benchmark INHERITED;
63};
64
65class RefCntBench_Stack : public Benchmark {
66public:
67    bool isSuitableFor(Backend backend) override {
68        return backend == kNonRendering_Backend;
69    }
70
71protected:
72    const char* onGetName() override {
73        return "ref_cnt_stack";
74    }
75
76    void onDraw(const 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
86private:
87    typedef Benchmark INHERITED;
88};
89
90class PlacedRefCnt : public SkRefCnt {
91public:
92    PlacedRefCnt() : SkRefCnt() { }
93    void operator delete(void*) { }
94
95private:
96    typedef SkRefCnt INHERITED;
97};
98
99class RefCntBench_Heap : public Benchmark {
100public:
101    bool isSuitableFor(Backend backend) override {
102        return backend == kNonRendering_Backend;
103    }
104
105protected:
106    const char* onGetName() override {
107        return "ref_cnt_heap";
108    }
109
110    void onDraw(const 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
122private:
123    typedef Benchmark INHERITED;
124};
125
126class RefCntBench_New : public Benchmark {
127public:
128    bool isSuitableFor(Backend backend) override {
129        return backend == kNonRendering_Backend;
130    }
131
132protected:
133    const char* onGetName() override {
134        return "ref_cnt_new";
135    }
136
137    void onDraw(const 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
148private:
149    typedef Benchmark INHERITED;
150};
151
152///////////////////////////////////////////////////////////////////////////////
153
154class WeakRefCntBench_Stack : public Benchmark {
155public:
156    bool isSuitableFor(Backend backend) override {
157        return backend == kNonRendering_Backend;
158    }
159
160protected:
161    const char* onGetName() override {
162        return "ref_cnt_stack_weak";
163    }
164
165    void onDraw(const 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
175private:
176    typedef Benchmark INHERITED;
177};
178
179class PlacedWeakRefCnt : public SkWeakRefCnt {
180public:
181    PlacedWeakRefCnt() : SkWeakRefCnt() { }
182    void operator delete(void*) { }
183};
184
185class WeakRefCntBench_Heap : public Benchmark {
186public:
187    bool isSuitableFor(Backend backend) override {
188        return backend == kNonRendering_Backend;
189    }
190
191protected:
192    const char* onGetName() override {
193        return "ref_cnt_heap_weak";
194    }
195
196    void onDraw(const 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
208private:
209    typedef Benchmark INHERITED;
210};
211
212class WeakRefCntBench_New : public Benchmark {
213public:
214    bool isSuitableFor(Backend backend) override {
215        return backend == kNonRendering_Backend;
216    }
217
218protected:
219    const char* onGetName() override {
220        return "ref_cnt_new_weak";
221    }
222
223    void onDraw(const 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
234private:
235    typedef Benchmark INHERITED;
236};
237
238///////////////////////////////////////////////////////////////////////////////
239
240DEF_BENCH( return new AtomicInc32(); )
241DEF_BENCH( return new AtomicInc64(); )
242
243DEF_BENCH( return new RefCntBench_Stack(); )
244DEF_BENCH( return new RefCntBench_Heap(); )
245DEF_BENCH( return new RefCntBench_New(); )
246
247DEF_BENCH( return new WeakRefCntBench_Stack(); )
248DEF_BENCH( return new WeakRefCntBench_Heap(); )
249DEF_BENCH( return new WeakRefCntBench_New(); )
250