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
13class MemsetBench : public Benchmark {
14    SkString    fName;
15
16protected:
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
30public:
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
45protected:
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
56private:
57    typedef Benchmark INHERITED;
58};
59
60class Memset32Bench : public MemsetBench {
61    uint32_t kBuffer[kBufferSize + 3];
62public:
63    Memset32Bench(size_t minSize, size_t maxSize)
64        : INHERITED(MEMSET32, minSize, maxSize) {}
65
66protected:
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    }
75private:
76    typedef MemsetBench INHERITED;
77};
78
79class Memset16Bench : public MemsetBench {
80    uint16_t kBuffer[kBufferSize + 7];
81public:
82    Memset16Bench(size_t minSize, size_t maxSize)
83        : INHERITED(MEMSET16, minSize, maxSize) {}
84
85protected:
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    }
98private:
99    typedef MemsetBench INHERITED;
100};
101
102DEF_BENCH(return new Memset32Bench(1, 600);)
103DEF_BENCH(return new Memset32Bench(600, 800);)
104DEF_BENCH(return new Memset32Bench(800, 1000);)
105DEF_BENCH(return new Memset32Bench(1000, 2000);)
106DEF_BENCH(return new Memset32Bench(2000, 3000);)
107DEF_BENCH(return new Memset32Bench(3000, 4000);)
108DEF_BENCH(return new Memset32Bench(4000, 5000);)
109
110DEF_BENCH(return new Memset16Bench(1, 600);)
111DEF_BENCH(return new Memset16Bench(600, 800);)
112DEF_BENCH(return new Memset16Bench(800, 1000);)
113DEF_BENCH(return new Memset16Bench(1000, 2000);)
114DEF_BENCH(return new Memset16Bench(2000, 3000);)
115DEF_BENCH(return new Memset16Bench(3000, 4000);)
116DEF_BENCH(return new Memset16Bench(4000, 5000);)
117