Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(33)

Side by Side Diff: bench/RefCntBench.cpp

Issue 347823004: Remove Sk prefix from some bench classes. (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: SkGMBench -> GMBench Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « bench/RectoriBench.cpp ('k') | bench/RegionBench.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2012 Google Inc. 2 * Copyright 2012 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 5 * found in the LICENSE file.
6 */ 6 */
7 #include "SkBenchmark.h" 7 #include <memory>
8 #include "Benchmark.h"
8 #include "SkRefCnt.h" 9 #include "SkRefCnt.h"
9 #include "SkThread.h" 10 #include "SkThread.h"
10 #include "SkWeakRefCnt.h" 11 #include "SkWeakRefCnt.h"
11 #include <memory>
12 12
13 enum { 13 enum {
14 M = 2 14 M = 2
15 }; 15 };
16 16
17 class RefCntBench_Stack : public SkBenchmark { 17 class RefCntBench_Stack : public Benchmark {
18 public: 18 public:
19 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 19 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
20 return backend == kNonRendering_Backend; 20 return backend == kNonRendering_Backend;
21 } 21 }
22 22
23 protected: 23 protected:
24 virtual const char* onGetName() { 24 virtual const char* onGetName() {
25 return "ref_cnt_stack"; 25 return "ref_cnt_stack";
26 } 26 }
27 27
28 virtual void onDraw(const int loops, SkCanvas*) { 28 virtual void onDraw(const int loops, SkCanvas*) {
29 for (int i = 0; i < loops; ++i) { 29 for (int i = 0; i < loops; ++i) {
30 SkRefCnt ref; 30 SkRefCnt ref;
31 for (int j = 0; j < M; ++j) { 31 for (int j = 0; j < M; ++j) {
32 ref.ref(); 32 ref.ref();
33 ref.unref(); 33 ref.unref();
34 } 34 }
35 } 35 }
36 } 36 }
37 37
38 private: 38 private:
39 typedef SkBenchmark INHERITED; 39 typedef Benchmark INHERITED;
40 }; 40 };
41 41
42 class PlacedRefCnt : public SkRefCnt { 42 class PlacedRefCnt : public SkRefCnt {
43 public: 43 public:
44 SK_DECLARE_INST_COUNT(PlacedRefCnt) 44 SK_DECLARE_INST_COUNT(PlacedRefCnt)
45 45
46 PlacedRefCnt() : SkRefCnt() { } 46 PlacedRefCnt() : SkRefCnt() { }
47 void operator delete(void*) { } 47 void operator delete(void*) { }
48 48
49 private: 49 private:
50 typedef SkRefCnt INHERITED; 50 typedef SkRefCnt INHERITED;
51 }; 51 };
52 52
53 class RefCntBench_Heap : public SkBenchmark { 53 class RefCntBench_Heap : public Benchmark {
54 public: 54 public:
55 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 55 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
56 return backend == kNonRendering_Backend; 56 return backend == kNonRendering_Backend;
57 } 57 }
58 58
59 protected: 59 protected:
60 virtual const char* onGetName() { 60 virtual const char* onGetName() {
61 return "ref_cnt_heap"; 61 return "ref_cnt_heap";
62 } 62 }
63 63
64 virtual void onDraw(const int loops, SkCanvas*) { 64 virtual void onDraw(const int loops, SkCanvas*) {
65 char memory[sizeof(PlacedRefCnt)]; 65 char memory[sizeof(PlacedRefCnt)];
66 for (int i = 0; i < loops; ++i) { 66 for (int i = 0; i < loops; ++i) {
67 PlacedRefCnt* ref = new (memory) PlacedRefCnt(); 67 PlacedRefCnt* ref = new (memory) PlacedRefCnt();
68 for (int j = 0; j < M; ++j) { 68 for (int j = 0; j < M; ++j) {
69 ref->ref(); 69 ref->ref();
70 ref->unref(); 70 ref->unref();
71 } 71 }
72 ref->unref(); 72 ref->unref();
73 } 73 }
74 } 74 }
75 75
76 private: 76 private:
77 typedef SkBenchmark INHERITED; 77 typedef Benchmark INHERITED;
78 }; 78 };
79 79
80 class RefCntBench_New : public SkBenchmark { 80 class RefCntBench_New : public Benchmark {
81 public: 81 public:
82 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 82 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
83 return backend == kNonRendering_Backend; 83 return backend == kNonRendering_Backend;
84 } 84 }
85 85
86 protected: 86 protected:
87 virtual const char* onGetName() { 87 virtual const char* onGetName() {
88 return "ref_cnt_new"; 88 return "ref_cnt_new";
89 } 89 }
90 90
91 virtual void onDraw(const int loops, SkCanvas*) { 91 virtual void onDraw(const int loops, SkCanvas*) {
92 for (int i = 0; i < loops; ++i) { 92 for (int i = 0; i < loops; ++i) {
93 SkRefCnt* ref = new SkRefCnt(); 93 SkRefCnt* ref = new SkRefCnt();
94 for (int j = 0; j < M; ++j) { 94 for (int j = 0; j < M; ++j) {
95 ref->ref(); 95 ref->ref();
96 ref->unref(); 96 ref->unref();
97 } 97 }
98 ref->unref(); 98 ref->unref();
99 } 99 }
100 } 100 }
101 101
102 private: 102 private:
103 typedef SkBenchmark INHERITED; 103 typedef Benchmark INHERITED;
104 }; 104 };
105 105
106 /////////////////////////////////////////////////////////////////////////////// 106 ///////////////////////////////////////////////////////////////////////////////
107 107
108 class WeakRefCntBench_Stack : public SkBenchmark { 108 class WeakRefCntBench_Stack : public Benchmark {
109 public: 109 public:
110 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 110 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
111 return backend == kNonRendering_Backend; 111 return backend == kNonRendering_Backend;
112 } 112 }
113 113
114 protected: 114 protected:
115 virtual const char* onGetName() { 115 virtual const char* onGetName() {
116 return "ref_cnt_stack_weak"; 116 return "ref_cnt_stack_weak";
117 } 117 }
118 118
119 virtual void onDraw(const int loops, SkCanvas*) { 119 virtual void onDraw(const int loops, SkCanvas*) {
120 for (int i = 0; i < loops; ++i) { 120 for (int i = 0; i < loops; ++i) {
121 SkWeakRefCnt ref; 121 SkWeakRefCnt ref;
122 for (int j = 0; j < M; ++j) { 122 for (int j = 0; j < M; ++j) {
123 ref.ref(); 123 ref.ref();
124 ref.unref(); 124 ref.unref();
125 } 125 }
126 } 126 }
127 } 127 }
128 128
129 private: 129 private:
130 typedef SkBenchmark INHERITED; 130 typedef Benchmark INHERITED;
131 }; 131 };
132 132
133 class PlacedWeakRefCnt : public SkWeakRefCnt { 133 class PlacedWeakRefCnt : public SkWeakRefCnt {
134 public: 134 public:
135 PlacedWeakRefCnt() : SkWeakRefCnt() { } 135 PlacedWeakRefCnt() : SkWeakRefCnt() { }
136 void operator delete(void*) { } 136 void operator delete(void*) { }
137 }; 137 };
138 138
139 class WeakRefCntBench_Heap : public SkBenchmark { 139 class WeakRefCntBench_Heap : public Benchmark {
140 public: 140 public:
141 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 141 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
142 return backend == kNonRendering_Backend; 142 return backend == kNonRendering_Backend;
143 } 143 }
144 144
145 protected: 145 protected:
146 virtual const char* onGetName() { 146 virtual const char* onGetName() {
147 return "ref_cnt_heap_weak"; 147 return "ref_cnt_heap_weak";
148 } 148 }
149 149
150 virtual void onDraw(const int loops, SkCanvas*) { 150 virtual void onDraw(const int loops, SkCanvas*) {
151 char memory[sizeof(PlacedWeakRefCnt)]; 151 char memory[sizeof(PlacedWeakRefCnt)];
152 for (int i = 0; i < loops; ++i) { 152 for (int i = 0; i < loops; ++i) {
153 PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt(); 153 PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
154 for (int j = 0; j < M; ++j) { 154 for (int j = 0; j < M; ++j) {
155 ref->ref(); 155 ref->ref();
156 ref->unref(); 156 ref->unref();
157 } 157 }
158 ref->unref(); 158 ref->unref();
159 } 159 }
160 } 160 }
161 161
162 private: 162 private:
163 typedef SkBenchmark INHERITED; 163 typedef Benchmark INHERITED;
164 }; 164 };
165 165
166 class WeakRefCntBench_New : public SkBenchmark { 166 class WeakRefCntBench_New : public Benchmark {
167 public: 167 public:
168 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { 168 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
169 return backend == kNonRendering_Backend; 169 return backend == kNonRendering_Backend;
170 } 170 }
171 171
172 protected: 172 protected:
173 virtual const char* onGetName() { 173 virtual const char* onGetName() {
174 return "ref_cnt_new_weak"; 174 return "ref_cnt_new_weak";
175 } 175 }
176 176
177 virtual void onDraw(const int loops, SkCanvas*) { 177 virtual void onDraw(const int loops, SkCanvas*) {
178 for (int i = 0; i < loops; ++i) { 178 for (int i = 0; i < loops; ++i) {
179 SkWeakRefCnt* ref = new SkWeakRefCnt(); 179 SkWeakRefCnt* ref = new SkWeakRefCnt();
180 for (int j = 0; j < M; ++j) { 180 for (int j = 0; j < M; ++j) {
181 ref->ref(); 181 ref->ref();
182 ref->unref(); 182 ref->unref();
183 } 183 }
184 ref->unref(); 184 ref->unref();
185 } 185 }
186 } 186 }
187 187
188 private: 188 private:
189 typedef SkBenchmark INHERITED; 189 typedef Benchmark INHERITED;
190 }; 190 };
191 191
192 /////////////////////////////////////////////////////////////////////////////// 192 ///////////////////////////////////////////////////////////////////////////////
193 193
194 DEF_BENCH( return new RefCntBench_Stack(); ) 194 DEF_BENCH( return new RefCntBench_Stack(); )
195 DEF_BENCH( return new RefCntBench_Heap(); ) 195 DEF_BENCH( return new RefCntBench_Heap(); )
196 DEF_BENCH( return new RefCntBench_New(); ) 196 DEF_BENCH( return new RefCntBench_New(); )
197 197
198 DEF_BENCH( return new WeakRefCntBench_Stack(); ) 198 DEF_BENCH( return new WeakRefCntBench_Stack(); )
199 DEF_BENCH( return new WeakRefCntBench_Heap(); ) 199 DEF_BENCH( return new WeakRefCntBench_Heap(); )
200 DEF_BENCH( return new WeakRefCntBench_New(); ) 200 DEF_BENCH( return new WeakRefCntBench_New(); )
OLDNEW
« no previous file with comments | « bench/RectoriBench.cpp ('k') | bench/RegionBench.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698