speed up rgn building by inlining memcmp for 32bit values

src/core/SkRegion_path.cpp

Index: src/core/SkRegion_path.cpp
diff --git a/src/core/SkRegion_path.cpp b/src/core/SkRegion_path.cpp
index 03830e6ce542a1864f5a6ad144ad8b027c8090b7..0c97eb9ce9f6879716e64b77154e69e23b53d37f 100644
--- a/src/core/SkRegion_path.cpp
+++ b/src/core/SkRegion_path.cpp
@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -6,13 +5,38 @@
  * found in the LICENSE file.
  */
 
-
 #include "SkRegionPriv.h"
 #include "SkBlitter.h"
 #include "SkScan.h"
 #include "SkTDArray.h"
 #include "SkPath.h"
 
+#define SK_USE_INLINE_MEMEQ32
+
+static bool sk_memeq32(const int32_t* SK_RESTRICT a, const int32_t* SK_RESTRICT b, int count) {
+#ifdef SK_USE_INLINE_MEMEQ32
+#if 0

[Tom Hudson, 2014/06/20 18:50:05]

Nit: would we want to replace 10 lines of dead code by a one-line comment ala
// grouping 4-at-a-time doesn't seem to speed this up

(But if it's ints, why were we expecting 4-at-a-time to speed this up? Automatic
SSE magic somewhere in the compiler? But there's not an alignment guarantee for
that, is there?)

[mtklein, 2014/06/20 19:20:38]

We _could_ write this with SSE or Neon, and SSE wouldn't even strictly require
an alignment step.  E.g.
        __m128i a4 = _mm_loadu_si128(a);
        __m128i b4 = _mm_loadu_si128(b);
        __m128i eq = _mm_xor_si128(a4, b4);
        if (!_mm_testz_si128(eq, eq)) {
            return false;
        }
        a += 4;
        b += 4;

and I imagine the platform memcmp must be written that way.  That said, I can't
get either of Mike's implementations (#if 0 or #if 1) to auto vectorize.

This might make a good candidate to move to SkUtils so we can give it platform
versions.  Conceivably we could be memcmp, given that we only need to return
equal/not-equal, not the direction of the inequality.

+    const int count4 = count >> 2;
+    for (int i = 0; i < count4; ++i) {
+        if ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2]) | (a[3] ^ b[3])) {
+            return false;
+        }
+        a += 4;
+        b += 4;
+    }
+    count &= 3;
+#endif
+    for (int i = 0; i < count; ++i) {
+        if (a[i] != b[i]) {
+            return false;
+        }
+    }
+    return true;
+#else
+    return !memcmp(a, b, count << 2);

[Tom Hudson, 2014/06/20 18:50:05]

Nit: * sizeof(int32_t) is a little more intelligible than << 2 ?

+#endif
+}
+
 class SkRgnBuilder : public SkBlitter {
 public:
     SkRgnBuilder();
@@ -87,9 +111,7 @@ private:
         if (fPrevScanline != NULL &&
             fPrevScanline->fLastY + 1 == fCurrScanline->fLastY &&
             fPrevScanline->fXCount == fCurrScanline->fXCount &&
-            !memcmp(fPrevScanline->firstX(),
-                    fCurrScanline->firstX(),
-                    fCurrScanline->fXCount * sizeof(SkRegion::RunType)))
+            sk_memeq32(fPrevScanline->firstX(), fCurrScanline->firstX(), fCurrScanline->fXCount))
         {
             // update the height of fPrevScanline
             fPrevScanline->fLastY = fCurrScanline->fLastY;