OLD | NEW |
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(); ) |
OLD | NEW |