Implement a benchmark for GrResourceCache

bench/MathBench.cpp

 #include "SkBenchmark.h"
 #include "SkColorPriv.h"
 #include "SkMatrix.h"
 #include "SkRandom.h"
 #include "SkString.h"
 #include "SkPaint.h"
 
 static float sk_fsel(float pred, float result_ge, float result_lt) {
     return pred >= 0 ? result_ge : result_lt;
 }
@@ skipping 11 matching lines @@
     SkString    fName;
     float       fSrc[kBuffer], fDst[kBuffer];
 public:
     MathBench(const char name[])  {
         fName.printf("math_%s", name);
 
         SkRandom rand;
         for (int i = 0; i < kBuffer; ++i) {
             fSrc[i] = rand.nextSScalar1();
         }
+    }
 
-        fIsRendering = false;
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) = 0;
 
 protected:
     virtual int mulLoopCount() const { return 1; }
 
     virtual const char* onGetName() {
@@ skipping 230 matching lines @@
             fData[i] = rand.nextSScalar1();
         }
 
         if (index < 0) {
             fProc = NULL;
             fName = "isfinite_rect";
         } else {
             fProc = gRec[index].fProc;
             fName = gRec[index].fName;
         }
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
 protected:
     virtual void onDraw(SkCanvas*) {
         IsFiniteProc proc = fProc;
         const float* data = fData;
         // do this so the compiler won't throw away the function call
         int counter = 0;
 
         if (proc) {
@@ skipping 44 matching lines @@
 
         for (int i = 0; i < ARRAY; ++i) {
             fData[i] = rand.nextSScalar1();
         }
 
         if (fast) {
             fName = "floor_fast";
         } else {
             fName = "floor_std";
         }
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
     virtual void process(float) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         SkRandom rand;
         float accum = 0;
         const float* data = fData;
 
@@ skipping 37 matching lines @@
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fData[i] = rand.nextU();
         }
 
         if (fUsePortable) {
             fName = "clz_portable";
         } else {
             fName = "clz_intrinsic";
         }
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         int accum = 0;
 
         if (fUsePortable) {
@@ skipping 32 matching lines @@
     SkVector fVec[ARRAY];
 
 public:
     NormalizeBench() {
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fVec[i].set(rand.nextSScalar1(), rand.nextSScalar1());
         }
 
         fName = "point_normalize";
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         int accum = 0;
 
         for (int j = 0; j < this->getLoops(); ++j) {
@@ skipping 23 matching lines @@
     float fData[N];
     SkFixed fResult[N];
 public:
 
     FixedMathBench()  {
         SkRandom rand;
         for (int i = 0; i < this->getLoops(); ++i) {
             fData[i%N] = rand.nextSScalar1();
         }
 
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
 protected:
     virtual void onDraw(SkCanvas*) {
         for (int j = 0; j < this->getLoops(); ++j) {
             for (int i = 0; i < N - 4; ++i) {
                 fResult[i] = SkFloatToFixed(fData[i]);
             }
         }
 
@@ skipping 12 matching lines @@
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
 class DivModBench : public SkBenchmark {
     SkString fName;
 public:
     explicit DivModBench(const char* name) {
         fName.printf("divmod_%s", name);
-        fIsRendering = false;
+    }
+
+    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+        return backend == kNonRendering_Backend;
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas*) {
         volatile T a = 0, b = 0;
         T div = 0, mod = 0;
@@ skipping 34 matching lines @@
 
 DEF_BENCH( return new FloorBench(false); )
 DEF_BENCH( return new FloorBench(true); )
 
 DEF_BENCH( return new CLZBench(false); )
 DEF_BENCH( return new CLZBench(true); )
 
 DEF_BENCH( return new NormalizeBench(); )
 
 DEF_BENCH( return new FixedMathBench(); )