Home | History | Annotate | Download | only in bench 
      1 /*
      2  * Copyright 2015 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 "SkColor.h"
     10 #include "SkNx.h"
     11 
     12 // Writing into this array prevents the loops from being compiled away.
     13 static volatile float blackhole[4];
     14 
     15 template <typename T>
     16 struct Sk4fRoundtripBench : public Benchmark {
     17     Sk4fRoundtripBench() {}
     18 
     19     const char* onGetName() override {
     20         switch (sizeof(T)) {
     21             case 1: return "Sk4f_roundtrip_u8";
     22             case 2: return "Sk4f_roundtrip_u16";
     23             case 4: return "Sk4f_roundtrip_int";
     24         }
     25         SkASSERT(false);
     26         return "";
     27     }
     28 
     29     bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
     30 
     31     void onDraw(int loops, SkCanvas* canvas) override {
     32         Sk4f fs(1,2,3,4);
     33         while (loops --> 0) {
     34             fs = SkNx_cast<float>(SkNx_cast<T>(fs));
     35         }
     36         fs.store((float*)blackhole);
     37     }
     38 };
     39 DEF_BENCH(return new Sk4fRoundtripBench<uint8_t>;)
     40 DEF_BENCH(return new Sk4fRoundtripBench<uint16_t>;)
     41 DEF_BENCH(return new Sk4fRoundtripBench<int>;)
     42 
     43 struct Sk4fFloorBench : public Benchmark {
     44     Sk4fFloorBench() {}
     45 
     46     const char* onGetName() override { return "Sk4f_floor"; }
     47     bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
     48 
     49     void onDraw(int loops, SkCanvas* canvas) override {
     50         Sk4f fs(1,2,3,4);
     51         while (loops --> 0) {
     52             fs = fs.floor();
     53         }
     54         fs.store((float*)blackhole);
     55     }
     56 };
     57 DEF_BENCH(return new Sk4fFloorBench;)
     58 
     59 struct Sk4fGradientBench : public Benchmark {
     60     const char* onGetName() override { return "Sk4f_gradient"; }
     61     bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
     62 
     63     SkPMColor fDevice[100];
     64     void onDraw(int loops, SkCanvas*) override {
     65         Sk4f c0(0,0,255,255),
     66              c1(255,0,0,255),
     67              dc = c1 - c0,
     68              fx(0.1f),
     69              dx(0.002f),
     70              dcdx(dc*dx),
     71              dcdx4(dcdx+dcdx+dcdx+dcdx);
     72 
     73         for (int n = 0; n < loops; n++) {
     74             Sk4f a = c0 + dc*fx + Sk4f(0.5f),  // add an extra 0.5f to get rounding for free.
     75                  b = a + dcdx,
     76                  c = b + dcdx,
     77                  d = c + dcdx;
     78             for (size_t i = 0; i < SK_ARRAY_COUNT(fDevice); i += 4) {
     79                 Sk4f_ToBytes((uint8_t*)(fDevice+i), a, b, c, d);
     80                 a = a + dcdx4;
     81                 b = b + dcdx4;
     82                 c = c + dcdx4;
     83                 d = d + dcdx4;
     84             }
     85         }
     86     }
     87 };
     88 DEF_BENCH(return new Sk4fGradientBench;)
     89