try to speed-up maprect + round2i + contains

include/core/SkRect.h

 /*
  * 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.
  */
 
 #ifndef SkRect_DEFINED
 #define SkRect_DEFINED
 
 #include "SkPoint.h"
 #include "SkSize.h"
+#include "../private/SkNx.h"
 
 struct SkRect;
 
 /** \struct SkIRect
 
     SkIRect holds four 32 bit integer coordinates for a rectangle
 */
 struct SK_API SkIRect {
     int32_t fLeft, fTop, fRight, fBottom;
 
@@ skipping 839 matching lines @@
         this->round(&ir);
         return ir;
     }
     
     //! Returns the result of calling roundOut(&dst)
     SkIRect roundOut() const {
         SkIRect ir;
         this->roundOut(&ir);
         return ir;
     }
-    
+
+    SkIRect round2i() const {

[msarett, 2016/07/11 12:50:06]

On Intel this disassembles to roundps and cvtt?

There is a single Intel instruction to convert float->int with rounding.  I made
an attempt to expose that here:
https://codereview.chromium.org/2134753006/

+        SkIRect dst;
+        Sk4s rd = (Sk4s::Load(&fLeft) + Sk4s(0.5)).floor();

[msarett, 2016/07/11 12:50:06]

Why call floor when the cast will floor anyway?

[mtklein, 2016/07/11 13:39:13]

We've got to make sure we're careful to distinguish the behavior of floor(),
ceil(), round(), and trunc() when dealing with these spatial types which may
contain negative values.  I think it's probably best that we add round(),
ceil(), and floor() calls to Sk4f, so that we're not left wondering whether
implementations in terms of each other are correct.

For what it's  worth, truncating from float->int is cheap and available
everywhere.  Anything else is more complicated.  Generally floor() and ceil()
and round() are going to be about this expensive and error prone:
  - truncate to integer
  - convert back to float
  - see if that result is too small or big
  - add back (wrong ? kFixupConstant : 0) to fix it up

The main caveat is that we cannot round floats to values that are representable
as floats but not integers.  The safest thing might be to never expose an API
that does float -> float rounding.

When we have SSE 4.1 or better on Intel, roundps lifts the
roundtrip-through-ints limitation, and is considerably faster.  We check
dynamically for this today, but it's unclear whether that approach is reliably
faster than the slow caveated SSE2 version.

ARMv8 added similar instructions to NEON.  On ARMv7 we always do the slow
caveated thing.

+        SkNx_cast<int32_t>(rd).store(&dst.fLeft);
+        return dst;
+    }
+
+    SkRect round2s() const {
+        SkRect dst;
+        (Sk4s::Load(&fLeft) + Sk4s(0.5)).floor().store(&dst.fLeft);
+        return dst;
+    }
+
     /**
      *  Swap top/bottom or left/right if there are flipped (i.e. if width()
      *  or height() would have returned a negative value.) This should be called
      *  if the edges are computed separately, and may have crossed over each
      *  other. When this returns, left <= right && top <= bottom
      */
     void sort() {
         if (fLeft > fRight) {
             SkTSwap<SkScalar>(fLeft, fRight);
         }
@@ skipping 13 matching lines @@
     void dumpHex() const { this->dump(true); }
 };
 
 inline bool SkIRect::contains(const SkRect& r) const {
     return  !r.isEmpty() && !this->isEmpty() &&     // check for empties
             (SkScalar)fLeft <= r.fLeft && (SkScalar)fTop <= r.fTop &&
             (SkScalar)fRight >= r.fRight && (SkScalar)fBottom >= r.fBottom;
 }
 
 #endif