speed up rgn building by inlining memcmp for 32bit values

src/core/SkRegion_path.cpp

-
 /*
  * Copyright 2006 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 "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();
     virtual ~SkRgnBuilder();
 
     // returns true if it could allocate the working storage needed
     bool init(int maxHeight, int maxTransitions, bool pathIsInverse);
 
     void done() {
         if (fCurrScanline != NULL) {
@@ skipping 54 matching lines @@
     //  points at next avialable x[] in fCurrScanline
     SkRegion::RunType*  fCurrXPtr;
     SkRegion::RunType   fTop;           // first Y value
 
     int fStorageCount;
 
     bool collapsWithPrev() {
         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;
             return true;
         }
         return false;
     }
 };
 
 SkRgnBuilder::SkRgnBuilder()
@@ skipping 408 matching lines @@
 #endif
 
     path->incReserve(count << 1);
     do {
         SkASSERT(count > 1);
         count -= extract_path(start, stop, path);
     } while (count > 0);
 
     return true;
 }