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 | 7 |
8 #include "SkBenchmark.h" | 8 #include "SkBenchmark.h" |
9 #include "SkMatrix44.h" | 9 #include "SkMatrix44.h" |
10 #include "SkRandom.h" | 10 #include "SkRandom.h" |
11 #include "SkString.h" | 11 #include "SkString.h" |
12 | 12 |
13 class Matrix44Bench : public SkBenchmark { | 13 class Matrix44Bench : public SkBenchmark { |
14 SkString fName; | 14 SkString fName; |
15 public: | 15 public: |
16 Matrix44Bench(const char name[]) { | 16 Matrix44Bench(const char name[]) { |
17 fName.printf("matrix44_%s", name); | 17 fName.printf("matrix44_%s", name); |
18 fIsRendering = false; | 18 fIsRendering = false; |
19 } | 19 } |
20 | 20 |
21 virtual void performTest() = 0; | 21 virtual void performTest() = 0; |
22 | 22 |
23 protected: | 23 protected: |
24 virtual int mulLoopCount() const { return 1; } | 24 virtual int mulLoopCount() const { return 1; } |
25 | 25 |
26 virtual const char* onGetName() { | 26 virtual const char* onGetName() { |
27 return fName.c_str(); | 27 return fName.c_str(); |
28 } | 28 } |
29 | 29 |
30 virtual void onDraw(SkCanvas*) { | 30 virtual void onDraw(SkCanvas*) { |
31 for (int i = 0; i < this->getLoops(); i++) { | 31 for (int i = 0; i < this->getLoops(); i++) { |
32 this->performTest(); | 32 this->performTest(); |
33 } | 33 } |
34 } | 34 } |
35 | 35 |
36 private: | 36 private: |
37 typedef SkBenchmark INHERITED; | 37 typedef SkBenchmark INHERITED; |
38 }; | 38 }; |
39 | 39 |
40 class EqualsMatrix44Bench : public Matrix44Bench { | 40 class EqualsMatrix44Bench : public Matrix44Bench { |
41 public: | 41 public: |
42 EqualsMatrix44Bench() : INHERITED("equals") { | 42 EqualsMatrix44Bench() |
| 43 : INHERITED("equals") |
| 44 , fM0(SkMatrix44::kIdentity_Constructor) |
| 45 , fM1(SkMatrix44::kIdentity_Constructor) |
| 46 , fM2(SkMatrix44::kIdentity_Constructor) |
| 47 { |
43 fM1.set(0, 0, 0); | 48 fM1.set(0, 0, 0); |
44 fM2.set(3, 3, 0); | 49 fM2.set(3, 3, 0); |
45 } | 50 } |
46 protected: | 51 protected: |
47 virtual void performTest() { | 52 virtual void performTest() { |
48 for (int i = 0; i < 10; ++i) { | 53 for (int i = 0; i < 10; ++i) { |
49 (void) (fM0 == fM1); | 54 (void) (fM0 == fM1); |
50 (void) (fM1 == fM2); | 55 (void) (fM1 == fM2); |
51 (void) (fM2 == fM0); | 56 (void) (fM2 == fM0); |
52 } | 57 } |
53 } | 58 } |
54 private: | 59 private: |
55 SkMatrix44 fM0, fM1, fM2; | 60 SkMatrix44 fM0, fM1, fM2; |
56 typedef Matrix44Bench INHERITED; | 61 typedef Matrix44Bench INHERITED; |
57 }; | 62 }; |
58 | 63 |
59 class SetIdentityMatrix44Bench : public Matrix44Bench { | 64 class SetIdentityMatrix44Bench : public Matrix44Bench { |
60 public: | 65 public: |
61 SetIdentityMatrix44Bench() : INHERITED("setidentity") { | 66 SetIdentityMatrix44Bench() |
| 67 : INHERITED("setidentity") |
| 68 , mat(SkMatrix44::kIdentity_Constructor) |
| 69 { |
62 double rowMajor[16] = | 70 double rowMajor[16] = |
63 { 1, 2, 3, 4, | 71 { 1, 2, 3, 4, |
64 5, 6, 7, 8, | 72 5, 6, 7, 8, |
65 9, 10, 11, 12, | 73 9, 10, 11, 12, |
66 13, 14, 15, 16}; | 74 13, 14, 15, 16}; |
67 mat.setRowMajord(rowMajor); | 75 mat.setRowMajord(rowMajor); |
68 } | 76 } |
69 protected: | 77 protected: |
70 virtual void performTest() { | 78 virtual void performTest() { |
71 for (int i = 0; i < 10; ++i) { | 79 for (int i = 0; i < 10; ++i) { |
72 mat.setIdentity(); | 80 mat.setIdentity(); |
73 } | 81 } |
74 } | 82 } |
75 private: | 83 private: |
76 SkMatrix44 mat; | 84 SkMatrix44 mat; |
77 typedef Matrix44Bench INHERITED; | 85 typedef Matrix44Bench INHERITED; |
78 }; | 86 }; |
79 | 87 |
80 class PreScaleMatrix44Bench : public Matrix44Bench { | 88 class PreScaleMatrix44Bench : public Matrix44Bench { |
81 public: | 89 public: |
82 PreScaleMatrix44Bench() : INHERITED("prescale") { | 90 PreScaleMatrix44Bench() |
| 91 : INHERITED("prescale") |
| 92 , fM0(SkMatrix44::kUninitialized_Constructor) |
| 93 { |
83 fX = fY = fZ = SkDoubleToMScalar(1.5); | 94 fX = fY = fZ = SkDoubleToMScalar(1.5); |
84 } | 95 } |
85 protected: | 96 protected: |
86 virtual void performTest() { | 97 virtual void performTest() { |
87 fM0.reset(); | 98 fM0.reset(); |
88 for (int i = 0; i < 10; ++i) { | 99 for (int i = 0; i < 10; ++i) { |
89 fM0.preScale(fX, fY, fZ); | 100 fM0.preScale(fX, fY, fZ); |
90 } | 101 } |
91 } | 102 } |
92 private: | 103 private: |
93 SkMatrix44 fM0; | 104 SkMatrix44 fM0; |
94 SkMScalar fX, fY, fZ; | 105 SkMScalar fX, fY, fZ; |
95 typedef Matrix44Bench INHERITED; | 106 typedef Matrix44Bench INHERITED; |
96 }; | 107 }; |
97 | 108 |
98 class InvertMatrix44Bench : public Matrix44Bench { | 109 class InvertMatrix44Bench : public Matrix44Bench { |
99 public: | 110 public: |
100 InvertMatrix44Bench() : INHERITED("invert") { | 111 InvertMatrix44Bench() |
| 112 : INHERITED("invert") |
| 113 , fM0(SkMatrix44::kUninitialized_Constructor) |
| 114 , fM1(SkMatrix44::kUninitialized_Constructor) |
| 115 { |
101 fM0.set(0, 0, -1.1); | 116 fM0.set(0, 0, -1.1); |
102 fM0.set(0, 1, 2.1); | 117 fM0.set(0, 1, 2.1); |
103 fM0.set(0, 2, -3.1); | 118 fM0.set(0, 2, -3.1); |
104 fM0.set(0, 3, 4.1); | 119 fM0.set(0, 3, 4.1); |
105 fM0.set(1, 0, 5.1); | 120 fM0.set(1, 0, 5.1); |
106 fM0.set(1, 1, -6.1); | 121 fM0.set(1, 1, -6.1); |
107 fM0.set(1, 2, 7.1); | 122 fM0.set(1, 2, 7.1); |
108 fM0.set(1, 3, 8.1); | 123 fM0.set(1, 3, 8.1); |
109 fM0.set(2, 0, -9.1); | 124 fM0.set(2, 0, -9.1); |
110 fM0.set(2, 1, 10.1); | 125 fM0.set(2, 1, 10.1); |
(...skipping 10 matching lines...) Expand all Loading... |
121 fM0.invert(&fM1); | 136 fM0.invert(&fM1); |
122 } | 137 } |
123 } | 138 } |
124 private: | 139 private: |
125 SkMatrix44 fM0, fM1; | 140 SkMatrix44 fM0, fM1; |
126 typedef Matrix44Bench INHERITED; | 141 typedef Matrix44Bench INHERITED; |
127 }; | 142 }; |
128 | 143 |
129 class InvertAffineMatrix44Bench : public Matrix44Bench { | 144 class InvertAffineMatrix44Bench : public Matrix44Bench { |
130 public: | 145 public: |
131 InvertAffineMatrix44Bench() : INHERITED("invertaffine") { | 146 InvertAffineMatrix44Bench() |
| 147 : INHERITED("invertaffine") |
| 148 , fM0(SkMatrix44::kIdentity_Constructor) |
| 149 , fM1(SkMatrix44::kUninitialized_Constructor) |
| 150 { |
132 fM0.set(0, 0, -1.1); | 151 fM0.set(0, 0, -1.1); |
133 fM0.set(0, 1, 2.1); | 152 fM0.set(0, 1, 2.1); |
134 fM0.set(0, 2, -3.1); | 153 fM0.set(0, 2, -3.1); |
135 fM0.set(0, 3, 4.1); | 154 fM0.set(0, 3, 4.1); |
136 fM0.set(1, 0, 5.1); | 155 fM0.set(1, 0, 5.1); |
137 fM0.set(1, 1, -6.1); | 156 fM0.set(1, 1, -6.1); |
138 fM0.set(1, 2, 7.1); | 157 fM0.set(1, 2, 7.1); |
139 fM0.set(1, 3, 8.1); | 158 fM0.set(1, 3, 8.1); |
140 fM0.set(2, 0, -9.1); | 159 fM0.set(2, 0, -9.1); |
141 fM0.set(2, 1, 10.1); | 160 fM0.set(2, 1, 10.1); |
142 fM0.set(2, 2, 11.1); | 161 fM0.set(2, 2, 11.1); |
143 fM0.set(2, 3, -12.1); | 162 fM0.set(2, 3, -12.1); |
144 // bottom row (perspective component) remains (0, 0, 0, 1). | 163 // bottom row (perspective component) remains (0, 0, 0, 1). |
145 } | 164 } |
146 protected: | 165 protected: |
147 virtual void performTest() { | 166 virtual void performTest() { |
148 for (int i = 0; i < 10; ++i) { | 167 for (int i = 0; i < 10; ++i) { |
149 fM0.invert(&fM1); | 168 fM0.invert(&fM1); |
150 } | 169 } |
151 } | 170 } |
152 private: | 171 private: |
153 SkMatrix44 fM0, fM1; | 172 SkMatrix44 fM0, fM1; |
154 typedef Matrix44Bench INHERITED; | 173 typedef Matrix44Bench INHERITED; |
155 }; | 174 }; |
156 | 175 |
157 class InvertScaleTranslateMatrix44Bench : public Matrix44Bench { | 176 class InvertScaleTranslateMatrix44Bench : public Matrix44Bench { |
158 public: | 177 public: |
159 InvertScaleTranslateMatrix44Bench() : INHERITED("invertscaletranslate") { | 178 InvertScaleTranslateMatrix44Bench() |
| 179 : INHERITED("invertscaletranslate") |
| 180 , fM0(SkMatrix44::kIdentity_Constructor) |
| 181 , fM1(SkMatrix44::kUninitialized_Constructor) |
| 182 { |
160 fM0.set(0, 0, -1.1); | 183 fM0.set(0, 0, -1.1); |
161 fM0.set(0, 3, 4.1); | 184 fM0.set(0, 3, 4.1); |
162 | 185 |
163 fM0.set(1, 1, -6.1); | 186 fM0.set(1, 1, -6.1); |
164 fM0.set(1, 3, 8.1); | 187 fM0.set(1, 3, 8.1); |
165 | 188 |
166 fM0.set(2, 2, 11.1); | 189 fM0.set(2, 2, 11.1); |
167 fM0.set(2, 3, -12.1); | 190 fM0.set(2, 3, -12.1); |
168 } | 191 } |
169 protected: | 192 protected: |
170 virtual void performTest() { | 193 virtual void performTest() { |
171 for (int i = 0; i < 10; ++i) { | 194 for (int i = 0; i < 10; ++i) { |
172 fM0.invert(&fM1); | 195 fM0.invert(&fM1); |
173 } | 196 } |
174 } | 197 } |
175 private: | 198 private: |
176 SkMatrix44 fM0, fM1; | 199 SkMatrix44 fM0, fM1; |
177 typedef Matrix44Bench INHERITED; | 200 typedef Matrix44Bench INHERITED; |
178 }; | 201 }; |
179 | 202 |
180 class InvertTranslateMatrix44Bench : public Matrix44Bench { | 203 class InvertTranslateMatrix44Bench : public Matrix44Bench { |
181 public: | 204 public: |
182 InvertTranslateMatrix44Bench() : INHERITED("inverttranslate") { | 205 InvertTranslateMatrix44Bench() |
| 206 : INHERITED("inverttranslate") |
| 207 , fM0(SkMatrix44::kIdentity_Constructor) |
| 208 , fM1(SkMatrix44::kUninitialized_Constructor) |
| 209 { |
183 fM0.set(0, 3, 4.1); | 210 fM0.set(0, 3, 4.1); |
184 fM0.set(1, 3, 8.1); | 211 fM0.set(1, 3, 8.1); |
185 fM0.set(2, 3, -12.1); | 212 fM0.set(2, 3, -12.1); |
186 } | 213 } |
187 protected: | 214 protected: |
188 virtual void performTest() { | 215 virtual void performTest() { |
189 for (int i = 0; i < 10; ++i) { | 216 for (int i = 0; i < 10; ++i) { |
190 fM0.invert(&fM1); | 217 fM0.invert(&fM1); |
191 } | 218 } |
192 } | 219 } |
193 private: | 220 private: |
194 SkMatrix44 fM0, fM1; | 221 SkMatrix44 fM0, fM1; |
195 typedef Matrix44Bench INHERITED; | 222 typedef Matrix44Bench INHERITED; |
196 }; | 223 }; |
197 | 224 |
198 class PostScaleMatrix44Bench : public Matrix44Bench { | 225 class PostScaleMatrix44Bench : public Matrix44Bench { |
199 public: | 226 public: |
200 PostScaleMatrix44Bench() : INHERITED("postscale") { | 227 PostScaleMatrix44Bench() |
| 228 : INHERITED("postscale") |
| 229 , fM0(SkMatrix44::kUninitialized_Constructor) |
| 230 { |
201 fX = fY = fZ = SkDoubleToMScalar(1.5); | 231 fX = fY = fZ = SkDoubleToMScalar(1.5); |
202 } | 232 } |
203 protected: | 233 protected: |
204 virtual void performTest() { | 234 virtual void performTest() { |
205 fM0.reset(); | 235 fM0.reset(); |
206 for (int i = 0; i < 10; ++i) { | 236 for (int i = 0; i < 10; ++i) { |
207 fM0.postScale(fX, fY, fZ); | 237 fM0.postScale(fX, fY, fZ); |
208 } | 238 } |
209 } | 239 } |
210 private: | 240 private: |
211 SkMatrix44 fM0; | 241 SkMatrix44 fM0; |
212 SkMScalar fX, fY, fZ; | 242 SkMScalar fX, fY, fZ; |
213 typedef Matrix44Bench INHERITED; | 243 typedef Matrix44Bench INHERITED; |
214 }; | 244 }; |
215 | 245 |
216 class SetConcatMatrix44Bench : public Matrix44Bench { | 246 class SetConcatMatrix44Bench : public Matrix44Bench { |
217 public: | 247 public: |
218 SetConcatMatrix44Bench() : INHERITED("setconcat") { | 248 SetConcatMatrix44Bench() |
| 249 : INHERITED("setconcat") |
| 250 , fM0(SkMatrix44::kUninitialized_Constructor) |
| 251 , fM1(SkMatrix44::kUninitialized_Constructor) |
| 252 , fM2(SkMatrix44::kUninitialized_Constructor) |
| 253 { |
219 fX = fY = fZ = SkDoubleToMScalar(1.5); | 254 fX = fY = fZ = SkDoubleToMScalar(1.5); |
220 fM1.setScale(fX, fY, fZ); | 255 fM1.setScale(fX, fY, fZ); |
221 fM2.setTranslate(fX, fY, fZ); | 256 fM2.setTranslate(fX, fY, fZ); |
222 } | 257 } |
223 protected: | 258 protected: |
224 virtual void performTest() { | 259 virtual void performTest() { |
225 fM0.reset(); // just to normalize this test with prescale/postscale | 260 fM0.reset(); // just to normalize this test with prescale/postscale |
226 for (int i = 0; i < 10; ++i) { | 261 for (int i = 0; i < 10; ++i) { |
227 fM0.setConcat(fM1, fM2); | 262 fM0.setConcat(fM1, fM2); |
228 } | 263 } |
229 } | 264 } |
230 private: | 265 private: |
231 SkMatrix44 fM0, fM1, fM2; | 266 SkMatrix44 fM0, fM1, fM2; |
232 SkMScalar fX, fY, fZ; | 267 SkMScalar fX, fY, fZ; |
233 typedef Matrix44Bench INHERITED; | 268 typedef Matrix44Bench INHERITED; |
234 }; | 269 }; |
235 | 270 |
236 class GetTypeMatrix44Bench : public Matrix44Bench { | 271 class GetTypeMatrix44Bench : public Matrix44Bench { |
237 public: | 272 public: |
238 GetTypeMatrix44Bench() : INHERITED("gettype") {} | 273 GetTypeMatrix44Bench() |
| 274 : INHERITED("gettype") |
| 275 , fMatrix(SkMatrix44::kIdentity_Constructor) |
| 276 {} |
239 protected: | 277 protected: |
240 // Putting random generation of the matrix inside performTest() | 278 // Putting random generation of the matrix inside performTest() |
241 // would help us avoid anomalous runs, but takes up 25% or | 279 // would help us avoid anomalous runs, but takes up 25% or |
242 // more of the function time. | 280 // more of the function time. |
243 virtual void performTest() { | 281 virtual void performTest() { |
244 for (int i = 0; i < 20; ++i) { | 282 for (int i = 0; i < 20; ++i) { |
245 fMatrix.set(1, 2, 1); // to invalidate the type-cache | 283 fMatrix.set(1, 2, 1); // to invalidate the type-cache |
246 fMatrix.getType(); | 284 fMatrix.getType(); |
247 } | 285 } |
248 } | 286 } |
249 private: | 287 private: |
250 SkMatrix44 fMatrix; | 288 SkMatrix44 fMatrix; |
251 typedef Matrix44Bench INHERITED; | 289 typedef Matrix44Bench INHERITED; |
252 }; | 290 }; |
253 | 291 |
254 DEF_BENCH( return new SetIdentityMatrix44Bench(); ) | 292 DEF_BENCH( return new SetIdentityMatrix44Bench(); ) |
255 DEF_BENCH( return new EqualsMatrix44Bench(); ) | 293 DEF_BENCH( return new EqualsMatrix44Bench(); ) |
256 DEF_BENCH( return new PreScaleMatrix44Bench(); ) | 294 DEF_BENCH( return new PreScaleMatrix44Bench(); ) |
257 DEF_BENCH( return new PostScaleMatrix44Bench(); ) | 295 DEF_BENCH( return new PostScaleMatrix44Bench(); ) |
258 DEF_BENCH( return new InvertMatrix44Bench(); ) | 296 DEF_BENCH( return new InvertMatrix44Bench(); ) |
259 DEF_BENCH( return new InvertAffineMatrix44Bench(); ) | 297 DEF_BENCH( return new InvertAffineMatrix44Bench(); ) |
260 DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(); ) | 298 DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(); ) |
261 DEF_BENCH( return new InvertTranslateMatrix44Bench(); ) | 299 DEF_BENCH( return new InvertTranslateMatrix44Bench(); ) |
262 DEF_BENCH( return new SetConcatMatrix44Bench(); ) | 300 DEF_BENCH( return new SetConcatMatrix44Bench(); ) |
263 DEF_BENCH( return new GetTypeMatrix44Bench(); ) | 301 DEF_BENCH( return new GetTypeMatrix44Bench(); ) |
OLD | NEW |