extend SkBenchmark to allow a bench to return a durationScale, which allows it to perform fewer act…

bench/BitmapBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkPaint.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkRandom.h"
 #include "SkString.h"
 
-static const char* gTileName[] = {
-    "clamp", "repeat", "mirror"
-};
-
 static const char* gConfigName[] = {
     "ERROR", "a1", "a8", "index8", "565", "4444", "8888"
 };
 
 static int conv6ToByte(int x) {
     return x * 0xFF / 5;
 }
 
 static int convByteTo6(int x) {
     return x * 5 / 255;
@@ skipping 45 matching lines @@
     - matrix options: translate, scale, rotate, persp
     - tiling: none, repeat, mirror, clamp
 
  */
 
 class BitmapBench : public SkBenchmark {
     SkBitmap    fBitmap;
     SkPaint     fPaint;
     bool        fIsOpaque;
     bool        fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
-    int         fTileX, fTileY; // -1 means don't use shader
     bool        fIsVolatile;
     SkBitmap::Config fConfig;
     SkString    fName;
-    enum { N = SkBENCHLOOP(300) };
+    enum { BICUBIC_DUR_SCALE = 20 };
+    enum { N = SkBENCHLOOP(15 * BICUBIC_DUR_SCALE) };
     enum { W = 128 };
     enum { H = 128 };
 public:
     BitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
-                bool forceUpdate = false, bool bitmapVolatile = false,
-                int tx = -1, int ty = -1)
+                bool forceUpdate = false, bool bitmapVolatile = false)
         : INHERITED(param)
         , fIsOpaque(isOpaque)
         , fForceUpdate(forceUpdate)
-        , fTileX(tx)
-        , fTileY(ty)
         , fIsVolatile(bitmapVolatile)
         , fConfig(c) {
     }
 
 protected:
     virtual const char* onGetName() {
         fName.set("bitmap");
-        if (fTileX >= 0) {
-            fName.appendf("_%s", gTileName[fTileX]);
-            if (fTileY != fTileX) {
-                fName.appendf("_%s", gTileName[fTileY]);
-            }
-        }
         fName.appendf("_%s%s", gConfigName[fConfig],
                       fIsOpaque ? "" : "_A");
         if (fForceUpdate)
             fName.append("_update");
         if (fIsVolatile)
             fName.append("_volatile");
 
         return fName.c_str();
     }
 
@@ skipping 28 matching lines @@
         SkIPoint dim = this->getSize();
         SkRandom rand;
 
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
         const SkBitmap& bitmap = fBitmap;
         const SkScalar x0 = SkIntToScalar(-bitmap.width() / 2);
         const SkScalar y0 = SkIntToScalar(-bitmap.height() / 2);
 
-        for (int i = 0; i < N; i++) {
+        int count = N;
+#ifdef SK_RELEASE
+        // in DEBUG, N is always 1
+        if (paint.getFlags() & SkPaint::kBicubicFilterBitmap_Flag) {
+            count /= BICUBIC_DUR_SCALE;
+        }
+#endif
+        for (int i = 0; i < count; i++) {
             SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
             SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
 
             if (fForceUpdate)
                 bitmap.notifyPixelsChanged();
 
             canvas->drawBitmap(bitmap, x, y, &paint);
         }
     }
 
+    virtual float onGetDurationScale() SK_OVERRIDE {
+        SkPaint paint;
+        this->setupPaint(&paint);
+#ifdef SK_DEBUG
+        return 1;
+#else
+        return (paint.getFlags() & SkPaint::kBicubicFilterBitmap_Flag) ?
+                BICUBIC_DUR_SCALE : 1;
+#endif
+    }
+
     virtual void onDrawIntoBitmap(const SkBitmap& bm) {
         const int w = bm.width();
         const int h = bm.height();
 
         SkCanvas canvas(bm);
         SkPaint p;
         p.setAntiAlias(true);
         p.setColor(SK_ColorRED);
         canvas.drawCircle(SkIntToScalar(w)/2, SkIntToScalar(h)/2,
                           SkIntToScalar(SkMin32(w, h))*3/8, p);
 
         SkRect r;
         r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h));
         p.setStyle(SkPaint::kStroke_Style);
         p.setStrokeWidth(SkIntToScalar(4));
         p.setColor(SK_ColorBLUE);
         canvas.drawRect(r, p);
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 /** Explicitly invoke some filter types to improve coverage of acceleration
     procs. */
 
+enum Flags {
+    kScale_Flag             = 1 << 0,
+    kRotate_Flag            = 1 << 1,
+    kBilerp_Flag            = 1 << 2,
+    kBicubic_Flag           = 1 << 3,
+};
+
+static bool isBilerp(uint32_t flags) {
+    return (flags & (kBilerp_Flag | kBicubic_Flag)) == (kBilerp_Flag);
+}
+
+static bool isBicubic(uint32_t flags) {
+    return (flags & (kBilerp_Flag | kBicubic_Flag)) == (kBilerp_Flag | kBicubic_Flag);
+}
+
 class FilterBitmapBench : public BitmapBench {
-    bool        fScale;
-    bool        fRotate;
-    bool        fFilter;
+    uint32_t    fFlags;
     SkString    fFullName;
     enum { N = SkBENCHLOOP(300) };
 public:
     FilterBitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
-                bool forceUpdate = false, bool bitmapVolatile = false,
-                int tx = -1, int ty = -1, bool addScale = false,
-                bool addRotate = false, bool addFilter = false)
-        : INHERITED(param, isOpaque, c, forceUpdate, bitmapVolatile, tx, ty)
-        , fScale(addScale), fRotate(addRotate), fFilter(addFilter) {
-
+                      bool forceUpdate, bool isVolitile, uint32_t flags)
+        : INHERITED(param, isOpaque, c, forceUpdate, isVolitile)
+        , fFlags(flags) {
     }
 
 protected:
     virtual const char* onGetName() {
         fFullName.set(INHERITED::onGetName());
-        if (fScale)
+        if (fFlags & kScale_Flag) {
             fFullName.append("_scale");
-        if (fRotate)
+        }
+        if (fFlags & kRotate_Flag) {
             fFullName.append("_rotate");
-        if (fFilter)
-            fFullName.append("_filter");
+        }
+        if (isBilerp(fFlags)) {
+            fFullName.append("_bilerp");
+        } else if (isBicubic(fFlags)) {
+            fFullName.append("_bicubic");
+        }
 
         return fFullName.c_str();
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         SkISize dim = canvas->getDeviceSize();
-        if (fScale) {
+        if (fFlags & kScale_Flag) {
             const SkScalar x = SkIntToScalar(dim.fWidth) / 2;
             const SkScalar y = SkIntToScalar(dim.fHeight) / 2;
 
             canvas->translate(x, y);
             // just enough so we can't take the sprite case
             canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
             canvas->translate(-x, -y);
         }
-        if (fRotate) {
+        if (fFlags & kRotate_Flag) {
             const SkScalar x = SkIntToScalar(dim.fWidth) / 2;
             const SkScalar y = SkIntToScalar(dim.fHeight) / 2;
 
             canvas->translate(x, y);
             canvas->rotate(SkIntToScalar(35));
             canvas->translate(-x, -y);
         }
 
-        this->setForceFilter(fFilter);
+        uint32_t orMask = 0;
+        uint32_t clearMask = SkPaint::kFilterBitmap_Flag | SkPaint::kBicubicFilterBitmap_Flag;
+        if (fFlags & kBilerp_Flag) {
+            orMask |= SkPaint::kFilterBitmap_Flag;
+        }
+        if (fFlags & kBicubic_Flag) {
+            orMask |= SkPaint::kBicubicFilterBitmap_Flag;
+        }
+        this->setPaintMasks(orMask, clearMask);
+
         INHERITED::onDraw(canvas);
     }
 
 private:
     typedef BitmapBench INHERITED;
 };
 
 /** Verify optimizations that test source alpha values. */
 
 class SourceAlphaBitmapBench : public BitmapBench {
 public:
     enum SourceAlpha { kOpaque_SourceAlpha, kTransparent_SourceAlpha,
                        kTwoStripes_SourceAlpha, kThreeStripes_SourceAlpha};
 private:
     SkString    fFullName;
     SourceAlpha fSourceAlpha;
 public:
     SourceAlphaBitmapBench(void* param, SourceAlpha alpha, SkBitmap::Config c,
-                bool forceUpdate = false, bool bitmapVolatile = false,
-                int tx = -1, int ty = -1)
-        : INHERITED(param, false, c, forceUpdate, bitmapVolatile, tx, ty)
+                bool forceUpdate = false, bool bitmapVolatile = false)
+        : INHERITED(param, false, c, forceUpdate, bitmapVolatile)
         , fSourceAlpha(alpha) {
     }
 
 protected:
     virtual const char* onGetName() {
         fFullName.set(INHERITED::onGetName());
 
         if (fSourceAlpha == kOpaque_SourceAlpha) {
                 fFullName.append("_source_opaque");
         } else if (fSourceAlpha == kTransparent_SourceAlpha) {
@@ skipping 67 matching lines @@
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config); )
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kRGB_565_Config); )
 DEF_BENCH( return new BitmapBench(p, false, SkBitmap::kARGB_4444_Config); )
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_4444_Config); )
 DEF_BENCH( return new BitmapBench(p, false, SkBitmap::kIndex8_Config); )
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kIndex8_Config); )
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true); )
 DEF_BENCH( return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false); )
 
 // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, -1, -1, true, false, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, -1, -1, true, false, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, -1, -1, true, false, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, -1, -1, true, false, true); )
+DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kBilerp_Flag); )
 
 // scale rotate filter -> S32_opaque_D32_filter_DXDY_{SSE2,SSSE3}
-DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, -1, -1, true, true, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, -1, -1, true, true, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, -1, -1, true, true, true); )
-DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, -1, -1, true, true, true); )
+DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+
+DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(p, false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
 
 // source alpha tests -> S32A_Opaque_BlitRow32_{arm,neon}
 DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kOpaque_SourceAlpha, SkBitmap::kARGB_8888_Config); )
 DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kTransparent_SourceAlpha, SkBitmap::kARGB_8888_Config); )
 DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
 DEF_BENCH( return new SourceAlphaBitmapBench(p, SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )