hack on linear gradient

bench/PMFloatBench.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Benchmark.h"
 #include "SkPMFloat.h"
 
 // Used to prevent the compiler from optimizing away the whole loop.
 volatile uint32_t blackhole = 0;
 
 // Not a great random number generator, but it's very fast.
 // The code we're measuring is quite fast, so low overhead is essential.
 static uint32_t lcg_rand(uint32_t* seed) {
     *seed *= 1664525;
     *seed += 1013904223;
     return *seed;
 }
 
 // I'm having better luck getting these to constant-propagate away as template parameters.
 template <bool kClamp, bool kWide>
-struct PMFloatBench : public Benchmark {
-    PMFloatBench() {}
+struct PMFloatGetSetBench : public Benchmark {
+    PMFloatGetSetBench() {}
 
     const char* onGetName() SK_OVERRIDE {
         switch (kClamp << 1 | kWide) {
             case 0: return "SkPMFloat_get_1x";
             case 1: return "SkPMFloat_get_4x";
             case 2: return "SkPMFloat_clamp_1x";
             case 3: return "SkPMFloat_clamp_4x";
         }
         SkFAIL("unreachable");
         return "oh bother";
@@ skipping 49 matching lines @@
             }
             for (int i = 0; i < 4; i++) {
                 junk ^= back[i];
             }
         }
         blackhole ^= junk;
     }
 };
 
 // Extra () help DEF_BENCH not get confused by the comma inside the <>.
-DEF_BENCH(return (new PMFloatBench< true,  true>);)
-DEF_BENCH(return (new PMFloatBench<false,  true>);)
-DEF_BENCH(return (new PMFloatBench< true, false>);)
-DEF_BENCH(return (new PMFloatBench<false, false>);)
+DEF_BENCH(return (new PMFloatGetSetBench< true,  true>);)
+DEF_BENCH(return (new PMFloatGetSetBench<false,  true>);)
+DEF_BENCH(return (new PMFloatGetSetBench< true, false>);)
+DEF_BENCH(return (new PMFloatGetSetBench<false, false>);)
+
+struct PMFloatGradientBench : public Benchmark {
+    const char* onGetName() override { return "PMFloat_gradient"; }
+    bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
+
+    SkPMColor fDevice[100];
+    void onDraw(const int loops, SkCanvas*) override {
+        Sk4f c0 = SkPMFloat::FromARGB(255, 255, 0, 0),
+             c1 = SkPMFloat::FromARGB(255, 0, 0, 255),
+             dc = c1 - c0,
+             fx(0.1f),
+             dx(0.002f),
+             dcdx(dc*dx),
+             dcdx4(dcdx+dcdx+dcdx+dcdx);
+
+        for (int n = 0; n < loops; n++) {
+            Sk4f a = c0 + dc*fx,  // TODO: add 0.5f, here call trunc() instead of get().
+                 b = a + dcdx,
+                 c = b + dcdx,
+                 d = c + dcdx;
+            for (size_t i = 0; i < SK_ARRAY_COUNT(fDevice); i += 4) {
+                fDevice[i+0] = SkPMFloat(a).get();
+                fDevice[i+1] = SkPMFloat(b).get();
+                fDevice[i+2] = SkPMFloat(c).get();
+                fDevice[i+3] = SkPMFloat(d).get();
+                a += dcdx4;
+                b += dcdx4;
+                c += dcdx4;
+                d += dcdx4;
+            }
+        }
+    }
+};
+
+DEF_BENCH(return new PMFloatGradientBench;)