1 /*
2  * Copyright 2011 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 #ifndef Benchmark_DEFINED
9 #define Benchmark_DEFINED
10 
11 #include "SkPoint.h"
12 #include "SkRefCnt.h"
13 #include "SkString.h"
14 #include "SkTRegistry.h"
15 
16 #define DEF_BENCH3(code, N) \
17     static BenchRegistry gBench##N([](void*) -> Benchmark* { code; });
18 #define DEF_BENCH2(code, N) DEF_BENCH3(code, N)
19 #define DEF_BENCH(code) DEF_BENCH2(code, __COUNTER__)
20 
21 /*
22  *  With the above macros, you can register benches as follows (at the bottom
23  *  of your .cpp)
24  *
25  *  DEF_BENCH(return new MyBenchmark(...))
26  *  DEF_BENCH(return new MyBenchmark(...))
27  *  DEF_BENCH(return new MyBenchmark(...))
28  */
29 
30 
31 class SkCanvas;
32 class SkPaint;
33 
34 class SkTriState {
35 public:
36     enum State {
37         kDefault,
38         kTrue,
39         kFalse
40     };
41     static const char* Name[];
42 };
43 
44 class Benchmark : public SkRefCnt {
45 public:
46     Benchmark();
47 
48     const char* getName();
49     const char* getUniqueName();
50     SkIPoint getSize();
51 
52     enum Backend {
53         kNonRendering_Backend,
54         kRaster_Backend,
55         kGPU_Backend,
56         kPDF_Backend,
57         kHWUI_Backend,
58     };
59 
60     // Call to determine whether the benchmark is intended for
61     // the rendering mode.
isSuitableFor(Backend backend)62     virtual bool isSuitableFor(Backend backend) {
63         return backend != kNonRendering_Backend;
64     }
65 
calculateLoops(int defaultLoops)66     virtual int calculateLoops(int defaultLoops) const {
67         return defaultLoops;
68     }
69 
70     // Call before draw, allows the benchmark to do setup work outside of the
71     // timer. When a benchmark is repeatedly drawn, this should be called once
72     // before the initial draw.
73     void delayedSetup();
74 
75     // Called once before and after a series of draw calls to a single canvas.
76     // The setup/break down in these calls is not timed.
77     void perCanvasPreDraw(SkCanvas*);
78     void perCanvasPostDraw(SkCanvas*);
79 
80     // Called just before and after each call to draw().  Not timed.
81     void preDraw(SkCanvas*);
82     void postDraw(SkCanvas*);
83 
84     // Bench framework can tune loops to be large enough for stable timing.
85     void draw(int loops, SkCanvas*);
86 
setForceAlpha(int alpha)87     void setForceAlpha(int alpha) {
88         fForceAlpha = alpha;
89     }
90 
setDither(SkTriState::State state)91     void setDither(SkTriState::State state) {
92         fDither = state;
93     }
94 
95     /** Assign masks for paint-flags. These will be applied when setupPaint()
96      *  is called.
97      *
98      *  Performs the following on the paint:
99      *      uint32_t flags = paint.getFlags();
100      *      flags &= ~clearMask;
101      *      flags |= orMask;
102      *      paint.setFlags(flags);
103      */
setPaintMasks(uint32_t orMask,uint32_t clearMask)104     void setPaintMasks(uint32_t orMask, uint32_t clearMask) {
105         fOrMask = orMask;
106         fClearMask = clearMask;
107     }
108 
109     /*
110      * Benches which support running in a visual mode can advertise this functionality
111      */
isVisual()112     virtual bool isVisual() { return false; }
113 
114     /*
115      * VisualBench frequently resets the canvas.  As a result we need to bulk call all of the hooks
116      */
preTimingHooks(SkCanvas * canvas)117     void preTimingHooks(SkCanvas* canvas) {
118         this->perCanvasPreDraw(canvas);
119         this->preDraw(canvas);
120     }
121 
postTimingHooks(SkCanvas * canvas)122     void postTimingHooks(SkCanvas* canvas)  {
123         this->postDraw(canvas);
124         this->perCanvasPostDraw(canvas);
125     }
126 
getGpuStats(SkCanvas *,SkTArray<SkString> * keys,SkTArray<double> * values)127     virtual void getGpuStats(SkCanvas*, SkTArray<SkString>* keys, SkTArray<double>* values) {}
128 
129 protected:
130     virtual void setupPaint(SkPaint* paint);
131 
132     virtual const char* onGetName() = 0;
onGetUniqueName()133     virtual const char* onGetUniqueName() { return this->onGetName(); }
onDelayedSetup()134     virtual void onDelayedSetup() {}
onPerCanvasPreDraw(SkCanvas *)135     virtual void onPerCanvasPreDraw(SkCanvas*) {}
onPerCanvasPostDraw(SkCanvas *)136     virtual void onPerCanvasPostDraw(SkCanvas*) {}
onPreDraw(SkCanvas *)137     virtual void onPreDraw(SkCanvas*) {}
onPostDraw(SkCanvas *)138     virtual void onPostDraw(SkCanvas*) {}
139     // Each bench should do its main work in a loop like this:
140     //   for (int i = 0; i < loops; i++) { <work here> }
141     virtual void onDraw(int loops, SkCanvas*) = 0;
142 
143     virtual SkIPoint onGetSize();
144 
145 private:
146     int     fForceAlpha;
147     SkTriState::State  fDither;
148     uint32_t    fOrMask, fClearMask;
149 
150     typedef SkRefCnt INHERITED;
151 };
152 
153 typedef SkTRegistry<Benchmark*(*)(void*)> BenchRegistry;
154 
155 #endif
156