Home | History | Annotate | Download | only in bench 
      1 /*
      2  * Copyright 2013 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 "SkCanvas.h"
     10 #include "SkString.h"
     11 #include "SkUtils.h"
     12 
     13 class MemsetBench : public Benchmark {
     14     SkString    fName;
     15 
     16 protected:
     17     size_t      fMinSize;
     18     size_t      fMaxSize;
     19     enum {
     20         kBufferSize = 10000,
     21         VALUE32 = 0x12345678,
     22         VALUE16 = 0x1234
     23     };
     24 
     25     enum MemsetType {
     26         MEMSET16 = 16,
     27         MEMSET32 = 32
     28     };
     29 
     30 public:
     31     MemsetBench(MemsetType type, size_t minSize, size_t maxSize)  {
     32         SkASSERT((minSize < maxSize) && (maxSize <= kBufferSize));
     33         fMinSize = minSize;
     34         fMaxSize = maxSize;
     35         fName.printf("memset%d_" SK_SIZE_T_SPECIFIER "_" SK_SIZE_T_SPECIFIER,
     36                      type, minSize, maxSize);
     37     }
     38 
     39     virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
     40         return backend == kNonRendering_Backend;
     41     }
     42 
     43     virtual void performTest() = 0;
     44 
     45 protected:
     46     virtual const char* onGetName() SK_OVERRIDE {
     47         return fName.c_str();
     48     }
     49 
     50     virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
     51         for (int i = 0; i < loops; ++i) {
     52             this->performTest();
     53         }
     54     }
     55 
     56 private:
     57     typedef Benchmark INHERITED;
     58 };
     59 
     60 class Memset32Bench : public MemsetBench {
     61     uint32_t kBuffer[kBufferSize + 3];
     62 public:
     63     Memset32Bench(size_t minSize, size_t maxSize)
     64         : INHERITED(MEMSET32, minSize, maxSize) {}
     65 
     66 protected:
     67     virtual void performTest() SK_OVERRIDE {
     68         for(size_t j = fMinSize; j < fMaxSize; ++j){
     69             sk_memset32(kBuffer, VALUE32, j);
     70             sk_memset32(kBuffer + 1, VALUE32, j);
     71             sk_memset32(kBuffer + 2, VALUE32, j);
     72             sk_memset32(kBuffer + 3, VALUE32, j);
     73         }
     74     }
     75 private:
     76     typedef MemsetBench INHERITED;
     77 };
     78 
     79 class Memset16Bench : public MemsetBench {
     80     uint16_t kBuffer[kBufferSize + 7];
     81 public:
     82     Memset16Bench(size_t minSize, size_t maxSize)
     83         : INHERITED(MEMSET16, minSize, maxSize) {}
     84 
     85 protected:
     86     virtual void performTest() SK_OVERRIDE {
     87         for(size_t j = fMinSize; j < fMaxSize; ++j){
     88             sk_memset16(kBuffer, VALUE16, j);
     89             sk_memset16(kBuffer + 1, VALUE16, j);
     90             sk_memset16(kBuffer + 2, VALUE16, j);
     91             sk_memset16(kBuffer + 3, VALUE16, j);
     92             sk_memset16(kBuffer + 4, VALUE16, j);
     93             sk_memset16(kBuffer + 5, VALUE16, j);
     94             sk_memset16(kBuffer + 6, VALUE16, j);
     95             sk_memset16(kBuffer + 7, VALUE16, j);
     96         }
     97     }
     98 private:
     99     typedef MemsetBench INHERITED;
    100 };
    101 
    102 DEF_BENCH(return new Memset32Bench(1, 600);)
    103 DEF_BENCH(return new Memset32Bench(600, 800);)
    104 DEF_BENCH(return new Memset32Bench(800, 1000);)
    105 DEF_BENCH(return new Memset32Bench(1000, 2000);)
    106 DEF_BENCH(return new Memset32Bench(2000, 3000);)
    107 DEF_BENCH(return new Memset32Bench(3000, 4000);)
    108 DEF_BENCH(return new Memset32Bench(4000, 5000);)
    109 
    110 DEF_BENCH(return new Memset16Bench(1, 600);)
    111 DEF_BENCH(return new Memset16Bench(600, 800);)
    112 DEF_BENCH(return new Memset16Bench(800, 1000);)
    113 DEF_BENCH(return new Memset16Bench(1000, 2000);)
    114 DEF_BENCH(return new Memset16Bench(2000, 3000);)
    115 DEF_BENCH(return new Memset16Bench(3000, 4000);)
    116 DEF_BENCH(return new Memset16Bench(4000, 5000);)
    117