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