Add SK_PREFETCH and use in SkBlurImageFilter.

src/effects/SkBlurImageFilter.cpp

 /*
  * Copyright 2011 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBlurImageFilter.h"
 #include "SkColorPriv.h"
@@ skipping 83 matching lines @@
         SkColor* p = src.getAddr32(bounds.fLeft + x, bounds.fTop);
         for (int i = 0; i < bottomBorder; ++i) {
             sumA += SkGetPackedA32(*p);
             sumR += SkGetPackedR32(*p);
             sumG += SkGetPackedG32(*p);
             sumB += SkGetPackedB32(*p);
             p += srcStride;
         }
 
         const SkColor* sptr = src.getAddr32(bounds.fLeft + x, bounds.fTop);
+        const SkColor* back  = sptr - topOffset * srcStride;
+        const SkColor* front = sptr + (bottomOffset + 1) * srcStride;
         SkColor* dptr = dst->getAddr32(x, 0);
         for (int y = 0; y < height; ++y) {
             *dptr = SkPackARGB32(sumA / kernelSize,
                                  sumR / kernelSize,
                                  sumG / kernelSize,
                                  sumB / kernelSize);
             if (y >= topOffset) {
-                SkColor l = *(sptr - topOffset * srcStride);
+                SkColor l = *back;
                 sumA -= SkGetPackedA32(l);
                 sumR -= SkGetPackedR32(l);
                 sumG -= SkGetPackedG32(l);
                 sumB -= SkGetPackedB32(l);
             }
             if (y + bottomOffset + 1 < height) {
-                SkColor r = *(sptr + (bottomOffset + 1) * srcStride);
+                SkColor r = *front;
                 sumA += SkGetPackedA32(r);
                 sumR += SkGetPackedR32(r);
                 sumG += SkGetPackedG32(r);
                 sumB += SkGetPackedB32(r);
             }
-            sptr += srcStride;
-            dptr += dstStride;
+            front += srcStride;
+            SK_PREFETCH(front);  // This step by srcStride seems to be hard to predict.

[Stephen White, 2013/11/04 16:24:17]

I'm a little leery of prefetch instructions, due to this Intel lore: "On some
older processors, under very bandwidth-sensitive workloads, ineffective hardware
prefetches can hurt the system by actually using bandwidth that is needed by
your application." But I don't have any hard data.

Could you characterize the impact of this change with and without the prefetch?

+            back  += srcStride;  // back will probably still be cached, so no hint needed.
+            dptr  += dstStride;
         }
     }
 }
 
 static void getBox3Params(SkScalar s, int *kernelSize, int* kernelSize3, int *lowOffset,
                           int *highOffset)
 {
     float pi = SkScalarToFloat(SK_ScalarPI);
     int d = static_cast<int>(floorf(SkScalarToFloat(s) * 3.0f * sqrtf(2.0f * pi) / 4.0f + 0.5f));
     *kernelSize = d;
@@ skipping 95 matching lines @@
                                                              fSigma.width(),
                                                              fSigma.height()));
     offset->fX += rect.fLeft;
     offset->fY += rect.fTop;
     return SkImageFilterUtils::WrapTexture(tex, rect.width(), rect.height(), result);
 #else
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 #endif
 }