1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkBenchmark_DEFINED
#define SkBenchmark_DEFINED
#include "SkRefCnt.h"
#include "SkPoint.h"
#include "SkString.h"
#include "SkTRegistry.h"
#define DEF_BENCH(code) \
namespace { \
static SkBenchmark* SK_MACRO_APPEND_LINE(factory)(void*) { code; } \
BenchRegistry SK_MACRO_APPEND_LINE(g_R_)(SK_MACRO_APPEND_LINE(factory)); \
}
/*
* With the above macros, you can register benches as follows (at the bottom
* of your .cpp)
*
* DEF_BENCH(return new MyBenchmark(...))
* DEF_BENCH(return new MyBenchmark(...))
* DEF_BENCH(return new MyBenchmark(...))
*/
class SkCanvas;
class SkPaint;
class SkTriState {
public:
enum State {
kDefault,
kTrue,
kFalse
};
static const char* Name[];
};
class SkBenchmark : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(SkBenchmark)
SkBenchmark();
const char* getName();
SkIPoint getSize();
enum Backend {
kNonRendering_Backend,
kRaster_Backend,
kGPU_Backend,
kPDF_Backend,
};
// Call to determine whether the benchmark is intended for
// the rendering mode.
virtual bool isSuitableFor(Backend backend) {
return backend != kNonRendering_Backend;
}
// Call before draw, allows the benchmark to do setup work outside of the
// timer. When a benchmark is repeatedly drawn, this should be called once
// before the initial draw.
void preDraw();
// Bench framework can tune loops to be large enough for stable timing.
void draw(const int loops, SkCanvas*);
// Call after draw, allows the benchmark to do cleanup work outside of the
// timer. When a benchmark is repeatedly drawn, this is only called once
// after the last draw.
void postDraw();
void setForceAlpha(int alpha) {
fForceAlpha = alpha;
}
void setForceAA(bool aa) {
fForceAA = aa;
}
void setForceFilter(bool filter) {
fForceFilter = filter;
}
void setDither(SkTriState::State state) {
fDither = state;
}
/** Assign masks for paint-flags. These will be applied when setupPaint()
* is called.
*
* Performs the following on the paint:
* uint32_t flags = paint.getFlags();
* flags &= ~clearMask;
* flags |= orMask;
* paint.setFlags(flags);
*/
void setPaintMasks(uint32_t orMask, uint32_t clearMask) {
fOrMask = orMask;
fClearMask = clearMask;
}
static void SetResourcePath(const char* resPath) { gResourcePath.set(resPath); }
static SkString& GetResourcePath() { return gResourcePath; }
protected:
virtual void setupPaint(SkPaint* paint);
virtual const char* onGetName() = 0;
virtual void onPreDraw() {}
// Each bench should do its main work in a loop like this:
// for (int i = 0; i < loops; i++) { <work here> }
virtual void onDraw(const int loops, SkCanvas*) = 0;
virtual void onPostDraw() {}
virtual SkIPoint onGetSize();
private:
int fForceAlpha;
bool fForceAA;
bool fForceFilter;
SkTriState::State fDither;
uint32_t fOrMask, fClearMask;
static SkString gResourcePath;
typedef SkRefCnt INHERITED;
};
typedef SkTRegistry<SkBenchmark*(*)(void*)> BenchRegistry;
#endif
|
