Home | History | Annotate | Download | only in bench 
      1 
      2 /*
      3  * Copyright 2011 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 #ifndef SkBenchmark_DEFINED
      9 #define SkBenchmark_DEFINED
     10 
     11 #include "SkRefCnt.h"
     12 #include "SkPoint.h"
     13 #include "SkTDict.h"
     14 #include "SkTRegistry.h"
     15 
     16 #define DEF_BENCH(code) \
     17 static SkBenchmark* SK_MACRO_APPEND_LINE(F_)(void* p) { code; } \
     18 static BenchRegistry SK_MACRO_APPEND_LINE(R_)(SK_MACRO_APPEND_LINE(F_));
     19 
     20 /*
     21  *  With the above macros, you can register benches as follows (at the bottom
     22  *  of your .cpp)
     23  *
     24  *  DEF_BENCH(new MyBenchmark(p, ...))
     25  *  DEF_BENCH(new MyBenchmark(p, ...))
     26  *  DEF_BENCH(new MyBenchmark(p, ...))
     27  */
     28 
     29 
     30 #ifdef SK_DEBUG
     31     #define SkBENCHLOOP(n) 1
     32 #else
     33     #define SkBENCHLOOP(n) n
     34 #endif
     35 
     36 class SkCanvas;
     37 class SkPaint;
     38 
     39 class SkTriState {
     40 public:
     41     enum State {
     42         kDefault,
     43         kTrue,
     44         kFalse
     45     };
     46 };
     47 
     48 class SkBenchmark : public SkRefCnt {
     49 public:
     50     SK_DECLARE_INST_COUNT(SkBenchmark)
     51 
     52     SkBenchmark(void* defineDict);
     53 
     54     const char* getName();
     55     SkIPoint getSize();
     56 
     57     // Call before draw, allows the benchmark to do setup work outside of the
     58     // timer. When a benchmark is repeatedly drawn, this should be called once
     59     // before the initial draw.
     60     void preDraw();
     61 
     62     void draw(SkCanvas*);
     63 
     64     // Call after draw, allows the benchmark to do cleanup work outside of the
     65     // timer. When a benchmark is repeatedly drawn, this is only called once
     66     // after the last draw.
     67     void postDraw();
     68 
     69     void setForceAlpha(int alpha) {
     70         fForceAlpha = alpha;
     71     }
     72 
     73     void setForceAA(bool aa) {
     74         fForceAA = aa;
     75     }
     76 
     77     void setForceFilter(bool filter) {
     78         fForceFilter = filter;
     79     }
     80 
     81     void setDither(SkTriState::State state) {
     82         fDither = state;
     83     }
     84 
     85     void setStrokeWidth(SkScalar width) {
     86       strokeWidth = width;
     87       fHasStrokeWidth = true;
     88     }
     89 
     90     SkScalar getStrokeWidth() {
     91       return strokeWidth;
     92     }
     93 
     94     bool hasStrokeWidth() {
     95       return fHasStrokeWidth;
     96     }
     97 
     98     /** If true; the benchmark does rendering; if false, the benchmark
     99         doesn't, and so need not be re-run in every different rendering
    100         mode. */
    101     bool isRendering() {
    102         return fIsRendering;
    103     }
    104 
    105     const char* findDefine(const char* key) const;
    106     bool findDefine32(const char* key, int32_t* value) const;
    107     bool findDefineScalar(const char* key, SkScalar* value) const;
    108 
    109     /** Assign masks for paint-flags. These will be applied when setupPaint()
    110      *  is called.
    111      *
    112      *  Performs the following on the paint:
    113      *      uint32_t flags = paint.getFlags();
    114      *      flags &= ~clearMask;
    115      *      flags |= orMask;
    116      *      paint.setFlags(flags);
    117      */
    118     void setPaintMasks(uint32_t orMask, uint32_t clearMask) {
    119         fOrMask = orMask;
    120         fClearMask = clearMask;
    121     }
    122 
    123     float getDurationScale() { return this->onGetDurationScale(); }
    124 
    125 protected:
    126     virtual void setupPaint(SkPaint* paint);
    127 
    128     virtual const char* onGetName() = 0;
    129     virtual void onPreDraw() {}
    130     virtual void onDraw(SkCanvas*) = 0;
    131     virtual void onPostDraw() {}
    132     // the caller will scale the computed duration by this value. It allows a
    133     // slow bench to run fewer inner loops, but return the corresponding scale
    134     // so that its reported duration can be compared against other benches.
    135     // e.g.
    136     //      if I run 10x slower, I can run 1/10 the number of inner-loops, but
    137     //      return 10.0 for my durationScale, so I "report" the honest duration.
    138     virtual float onGetDurationScale() { return 1; }
    139 
    140     virtual SkIPoint onGetSize();
    141     /// Defaults to true.
    142     bool    fIsRendering;
    143 
    144 private:
    145     const SkTDict<const char*>* fDict;
    146     int     fForceAlpha;
    147     bool    fForceAA;
    148     bool    fForceFilter;
    149     SkTriState::State  fDither;
    150     bool    fHasStrokeWidth;
    151     SkScalar strokeWidth;
    152     uint32_t    fOrMask, fClearMask;
    153 
    154     typedef SkRefCnt INHERITED;
    155 };
    156 
    157 typedef SkTRegistry<SkBenchmark*, void*> BenchRegistry;
    158 
    159 #endif
    160