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