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(void* param, const char name[]) : INHERITED(param) { | 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(void* param) : INHERITED(param, "equals") { | 42 EqualsMatrix44Bench() : INHERITED("equals") { |
43 fM1.set(0, 0, 0); | 43 fM1.set(0, 0, 0); |
44 fM2.set(3, 3, 0); | 44 fM2.set(3, 3, 0); |
45 } | 45 } |
46 protected: | 46 protected: |
47 virtual void performTest() { | 47 virtual void performTest() { |
48 for (int i = 0; i < 10; ++i) { | 48 for (int i = 0; i < 10; ++i) { |
49 (void) (fM0 == fM1); | 49 (void) (fM0 == fM1); |
50 (void) (fM1 == fM2); | 50 (void) (fM1 == fM2); |
51 (void) (fM2 == fM0); | 51 (void) (fM2 == fM0); |
52 } | 52 } |
53 } | 53 } |
54 private: | 54 private: |
55 SkMatrix44 fM0, fM1, fM2; | 55 SkMatrix44 fM0, fM1, fM2; |
56 typedef Matrix44Bench INHERITED; | 56 typedef Matrix44Bench INHERITED; |
57 }; | 57 }; |
58 | 58 |
59 class SetIdentityMatrix44Bench : public Matrix44Bench { | 59 class SetIdentityMatrix44Bench : public Matrix44Bench { |
60 public: | 60 public: |
61 SetIdentityMatrix44Bench(void* param) : INHERITED(param, "setidentity") { | 61 SetIdentityMatrix44Bench() : INHERITED("setidentity") { |
62 double rowMajor[16] = | 62 double rowMajor[16] = |
63 { 1, 2, 3, 4, | 63 { 1, 2, 3, 4, |
64 5, 6, 7, 8, | 64 5, 6, 7, 8, |
65 9, 10, 11, 12, | 65 9, 10, 11, 12, |
66 13, 14, 15, 16}; | 66 13, 14, 15, 16}; |
67 mat.setRowMajord(rowMajor); | 67 mat.setRowMajord(rowMajor); |
68 } | 68 } |
69 protected: | 69 protected: |
70 virtual void performTest() { | 70 virtual void performTest() { |
71 for (int i = 0; i < 10; ++i) { | 71 for (int i = 0; i < 10; ++i) { |
72 mat.setIdentity(); | 72 mat.setIdentity(); |
73 } | 73 } |
74 } | 74 } |
75 private: | 75 private: |
76 SkMatrix44 mat; | 76 SkMatrix44 mat; |
77 typedef Matrix44Bench INHERITED; | 77 typedef Matrix44Bench INHERITED; |
78 }; | 78 }; |
79 | 79 |
80 class PreScaleMatrix44Bench : public Matrix44Bench { | 80 class PreScaleMatrix44Bench : public Matrix44Bench { |
81 public: | 81 public: |
82 PreScaleMatrix44Bench(void* param) : INHERITED(param, "prescale") { | 82 PreScaleMatrix44Bench() : INHERITED("prescale") { |
83 fX = fY = fZ = SkDoubleToMScalar(1.5); | 83 fX = fY = fZ = SkDoubleToMScalar(1.5); |
84 } | 84 } |
85 protected: | 85 protected: |
86 virtual void performTest() { | 86 virtual void performTest() { |
87 fM0.reset(); | 87 fM0.reset(); |
88 for (int i = 0; i < 10; ++i) { | 88 for (int i = 0; i < 10; ++i) { |
89 fM0.preScale(fX, fY, fZ); | 89 fM0.preScale(fX, fY, fZ); |
90 } | 90 } |
91 } | 91 } |
92 private: | 92 private: |
93 SkMatrix44 fM0; | 93 SkMatrix44 fM0; |
94 SkMScalar fX, fY, fZ; | 94 SkMScalar fX, fY, fZ; |
95 typedef Matrix44Bench INHERITED; | 95 typedef Matrix44Bench INHERITED; |
96 }; | 96 }; |
97 | 97 |
98 class InvertMatrix44Bench : public Matrix44Bench { | 98 class InvertMatrix44Bench : public Matrix44Bench { |
99 public: | 99 public: |
100 InvertMatrix44Bench(void* param) : INHERITED(param, "invert") { | 100 InvertMatrix44Bench() : INHERITED("invert") { |
101 fM0.set(0, 0, -1.1); | 101 fM0.set(0, 0, -1.1); |
102 fM0.set(0, 1, 2.1); | 102 fM0.set(0, 1, 2.1); |
103 fM0.set(0, 2, -3.1); | 103 fM0.set(0, 2, -3.1); |
104 fM0.set(0, 3, 4.1); | 104 fM0.set(0, 3, 4.1); |
105 fM0.set(1, 0, 5.1); | 105 fM0.set(1, 0, 5.1); |
106 fM0.set(1, 1, -6.1); | 106 fM0.set(1, 1, -6.1); |
107 fM0.set(1, 2, 7.1); | 107 fM0.set(1, 2, 7.1); |
108 fM0.set(1, 3, 8.1); | 108 fM0.set(1, 3, 8.1); |
109 fM0.set(2, 0, -9.1); | 109 fM0.set(2, 0, -9.1); |
110 fM0.set(2, 1, 10.1); | 110 fM0.set(2, 1, 10.1); |
(...skipping 10 matching lines...) Expand all Loading... |
121 fM0.invert(&fM1); | 121 fM0.invert(&fM1); |
122 } | 122 } |
123 } | 123 } |
124 private: | 124 private: |
125 SkMatrix44 fM0, fM1; | 125 SkMatrix44 fM0, fM1; |
126 typedef Matrix44Bench INHERITED; | 126 typedef Matrix44Bench INHERITED; |
127 }; | 127 }; |
128 | 128 |
129 class InvertAffineMatrix44Bench : public Matrix44Bench { | 129 class InvertAffineMatrix44Bench : public Matrix44Bench { |
130 public: | 130 public: |
131 InvertAffineMatrix44Bench(void* param) : INHERITED(param, "invertaffine") { | 131 InvertAffineMatrix44Bench() : INHERITED("invertaffine") { |
132 fM0.set(0, 0, -1.1); | 132 fM0.set(0, 0, -1.1); |
133 fM0.set(0, 1, 2.1); | 133 fM0.set(0, 1, 2.1); |
134 fM0.set(0, 2, -3.1); | 134 fM0.set(0, 2, -3.1); |
135 fM0.set(0, 3, 4.1); | 135 fM0.set(0, 3, 4.1); |
136 fM0.set(1, 0, 5.1); | 136 fM0.set(1, 0, 5.1); |
137 fM0.set(1, 1, -6.1); | 137 fM0.set(1, 1, -6.1); |
138 fM0.set(1, 2, 7.1); | 138 fM0.set(1, 2, 7.1); |
139 fM0.set(1, 3, 8.1); | 139 fM0.set(1, 3, 8.1); |
140 fM0.set(2, 0, -9.1); | 140 fM0.set(2, 0, -9.1); |
141 fM0.set(2, 1, 10.1); | 141 fM0.set(2, 1, 10.1); |
142 fM0.set(2, 2, 11.1); | 142 fM0.set(2, 2, 11.1); |
143 fM0.set(2, 3, -12.1); | 143 fM0.set(2, 3, -12.1); |
144 // bottom row (perspective component) remains (0, 0, 0, 1). | 144 // bottom row (perspective component) remains (0, 0, 0, 1). |
145 } | 145 } |
146 protected: | 146 protected: |
147 virtual void performTest() { | 147 virtual void performTest() { |
148 for (int i = 0; i < 10; ++i) { | 148 for (int i = 0; i < 10; ++i) { |
149 fM0.invert(&fM1); | 149 fM0.invert(&fM1); |
150 } | 150 } |
151 } | 151 } |
152 private: | 152 private: |
153 SkMatrix44 fM0, fM1; | 153 SkMatrix44 fM0, fM1; |
154 typedef Matrix44Bench INHERITED; | 154 typedef Matrix44Bench INHERITED; |
155 }; | 155 }; |
156 | 156 |
157 class InvertScaleTranslateMatrix44Bench : public Matrix44Bench { | 157 class InvertScaleTranslateMatrix44Bench : public Matrix44Bench { |
158 public: | 158 public: |
159 InvertScaleTranslateMatrix44Bench(void* param) : INHERITED(param, "invertsca
letranslate") { | 159 InvertScaleTranslateMatrix44Bench() : INHERITED("invertscaletranslate") { |
160 fM0.set(0, 0, -1.1); | 160 fM0.set(0, 0, -1.1); |
161 fM0.set(0, 3, 4.1); | 161 fM0.set(0, 3, 4.1); |
162 | 162 |
163 fM0.set(1, 1, -6.1); | 163 fM0.set(1, 1, -6.1); |
164 fM0.set(1, 3, 8.1); | 164 fM0.set(1, 3, 8.1); |
165 | 165 |
166 fM0.set(2, 2, 11.1); | 166 fM0.set(2, 2, 11.1); |
167 fM0.set(2, 3, -12.1); | 167 fM0.set(2, 3, -12.1); |
168 } | 168 } |
169 protected: | 169 protected: |
170 virtual void performTest() { | 170 virtual void performTest() { |
171 for (int i = 0; i < 10; ++i) { | 171 for (int i = 0; i < 10; ++i) { |
172 fM0.invert(&fM1); | 172 fM0.invert(&fM1); |
173 } | 173 } |
174 } | 174 } |
175 private: | 175 private: |
176 SkMatrix44 fM0, fM1; | 176 SkMatrix44 fM0, fM1; |
177 typedef Matrix44Bench INHERITED; | 177 typedef Matrix44Bench INHERITED; |
178 }; | 178 }; |
179 | 179 |
180 class InvertTranslateMatrix44Bench : public Matrix44Bench { | 180 class InvertTranslateMatrix44Bench : public Matrix44Bench { |
181 public: | 181 public: |
182 InvertTranslateMatrix44Bench(void* param) : INHERITED(param, "inverttranslat
e") { | 182 InvertTranslateMatrix44Bench() : INHERITED("inverttranslate") { |
183 fM0.set(0, 3, 4.1); | 183 fM0.set(0, 3, 4.1); |
184 fM0.set(1, 3, 8.1); | 184 fM0.set(1, 3, 8.1); |
185 fM0.set(2, 3, -12.1); | 185 fM0.set(2, 3, -12.1); |
186 } | 186 } |
187 protected: | 187 protected: |
188 virtual void performTest() { | 188 virtual void performTest() { |
189 for (int i = 0; i < 10; ++i) { | 189 for (int i = 0; i < 10; ++i) { |
190 fM0.invert(&fM1); | 190 fM0.invert(&fM1); |
191 } | 191 } |
192 } | 192 } |
193 private: | 193 private: |
194 SkMatrix44 fM0, fM1; | 194 SkMatrix44 fM0, fM1; |
195 typedef Matrix44Bench INHERITED; | 195 typedef Matrix44Bench INHERITED; |
196 }; | 196 }; |
197 | 197 |
198 class PostScaleMatrix44Bench : public Matrix44Bench { | 198 class PostScaleMatrix44Bench : public Matrix44Bench { |
199 public: | 199 public: |
200 PostScaleMatrix44Bench(void* param) : INHERITED(param, "postscale") { | 200 PostScaleMatrix44Bench() : INHERITED("postscale") { |
201 fX = fY = fZ = SkDoubleToMScalar(1.5); | 201 fX = fY = fZ = SkDoubleToMScalar(1.5); |
202 } | 202 } |
203 protected: | 203 protected: |
204 virtual void performTest() { | 204 virtual void performTest() { |
205 fM0.reset(); | 205 fM0.reset(); |
206 for (int i = 0; i < 10; ++i) { | 206 for (int i = 0; i < 10; ++i) { |
207 fM0.postScale(fX, fY, fZ); | 207 fM0.postScale(fX, fY, fZ); |
208 } | 208 } |
209 } | 209 } |
210 private: | 210 private: |
211 SkMatrix44 fM0; | 211 SkMatrix44 fM0; |
212 SkMScalar fX, fY, fZ; | 212 SkMScalar fX, fY, fZ; |
213 typedef Matrix44Bench INHERITED; | 213 typedef Matrix44Bench INHERITED; |
214 }; | 214 }; |
215 | 215 |
216 class SetConcatMatrix44Bench : public Matrix44Bench { | 216 class SetConcatMatrix44Bench : public Matrix44Bench { |
217 public: | 217 public: |
218 SetConcatMatrix44Bench(void* param) : INHERITED(param, "setconcat") { | 218 SetConcatMatrix44Bench() : INHERITED("setconcat") { |
219 fX = fY = fZ = SkDoubleToMScalar(1.5); | 219 fX = fY = fZ = SkDoubleToMScalar(1.5); |
220 fM1.setScale(fX, fY, fZ); | 220 fM1.setScale(fX, fY, fZ); |
221 fM2.setTranslate(fX, fY, fZ); | 221 fM2.setTranslate(fX, fY, fZ); |
222 } | 222 } |
223 protected: | 223 protected: |
224 virtual void performTest() { | 224 virtual void performTest() { |
225 fM0.reset(); // just to normalize this test with prescale/postscale | 225 fM0.reset(); // just to normalize this test with prescale/postscale |
226 for (int i = 0; i < 10; ++i) { | 226 for (int i = 0; i < 10; ++i) { |
227 fM0.setConcat(fM1, fM2); | 227 fM0.setConcat(fM1, fM2); |
228 } | 228 } |
229 } | 229 } |
230 private: | 230 private: |
231 SkMatrix44 fM0, fM1, fM2; | 231 SkMatrix44 fM0, fM1, fM2; |
232 SkMScalar fX, fY, fZ; | 232 SkMScalar fX, fY, fZ; |
233 typedef Matrix44Bench INHERITED; | 233 typedef Matrix44Bench INHERITED; |
234 }; | 234 }; |
235 | 235 |
236 class GetTypeMatrix44Bench : public Matrix44Bench { | 236 class GetTypeMatrix44Bench : public Matrix44Bench { |
237 public: | 237 public: |
238 GetTypeMatrix44Bench(void* param) : INHERITED(param, "gettype") {} | 238 GetTypeMatrix44Bench() : INHERITED("gettype") {} |
239 protected: | 239 protected: |
240 // Putting random generation of the matrix inside performTest() | 240 // Putting random generation of the matrix inside performTest() |
241 // would help us avoid anomalous runs, but takes up 25% or | 241 // would help us avoid anomalous runs, but takes up 25% or |
242 // more of the function time. | 242 // more of the function time. |
243 virtual void performTest() { | 243 virtual void performTest() { |
244 for (int i = 0; i < 20; ++i) { | 244 for (int i = 0; i < 20; ++i) { |
245 fMatrix.set(1, 2, 1); // to invalidate the type-cache | 245 fMatrix.set(1, 2, 1); // to invalidate the type-cache |
246 fMatrix.getType(); | 246 fMatrix.getType(); |
247 } | 247 } |
248 } | 248 } |
249 private: | 249 private: |
250 SkMatrix44 fMatrix; | 250 SkMatrix44 fMatrix; |
251 typedef Matrix44Bench INHERITED; | 251 typedef Matrix44Bench INHERITED; |
252 }; | 252 }; |
253 | 253 |
254 DEF_BENCH( return new SetIdentityMatrix44Bench(p); ) | 254 DEF_BENCH( return new SetIdentityMatrix44Bench(); ) |
255 DEF_BENCH( return new EqualsMatrix44Bench(p); ) | 255 DEF_BENCH( return new EqualsMatrix44Bench(); ) |
256 DEF_BENCH( return new PreScaleMatrix44Bench(p); ) | 256 DEF_BENCH( return new PreScaleMatrix44Bench(); ) |
257 DEF_BENCH( return new PostScaleMatrix44Bench(p); ) | 257 DEF_BENCH( return new PostScaleMatrix44Bench(); ) |
258 DEF_BENCH( return new InvertMatrix44Bench(p); ) | 258 DEF_BENCH( return new InvertMatrix44Bench(); ) |
259 DEF_BENCH( return new InvertAffineMatrix44Bench(p); ) | 259 DEF_BENCH( return new InvertAffineMatrix44Bench(); ) |
260 DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(p); ) | 260 DEF_BENCH( return new InvertScaleTranslateMatrix44Bench(); ) |
261 DEF_BENCH( return new InvertTranslateMatrix44Bench(p); ) | 261 DEF_BENCH( return new InvertTranslateMatrix44Bench(); ) |
262 DEF_BENCH( return new SetConcatMatrix44Bench(p); ) | 262 DEF_BENCH( return new SetConcatMatrix44Bench(); ) |
263 DEF_BENCH( return new GetTypeMatrix44Bench(p); ) | 263 DEF_BENCH( return new GetTypeMatrix44Bench(); ) |
OLD | NEW |