Sk2x

This adds an API, an SSE impl, a portable impl, and some tests for Sk2f/Sk2d/Sk2s.

BUG=skia:

Review URL: https://codereview.chromium.org/1025463002

diff --git a/gyp/tests.gypi b/gyp/tests.gypi
index f03488d..43179d3 100644 (file)
--- a/gyp/tests.gypi
+++ b/gyp/tests.gypi
@@ -195,6 +195,7 @@
     '../tests/ShaderImageFilterTest.cpp',
     '../tests/ShaderOpacityTest.cpp',
     '../tests/SizeTest.cpp',
+    '../tests/Sk2xTest.cpp',
     '../tests/Sk4xTest.cpp',
     '../tests/SkBase64Test.cpp',
     '../tests/SkImageTest.cpp',

diff --git a/src/core/Sk2x.h b/src/core/Sk2x.h
new file mode 100644 (file)
index 0000000..6b3fd86
--- /dev/null
+++ b/src/core/Sk2x.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Sk2x_DEFINED
+#define Sk2x_DEFINED
+
+#include "SkTypes.h"
+
+#define SK2X_PREAMBLE 1
+    #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+        #include "../opts/Sk2x_sse.h"
+    #else
+        #include "../opts/Sk2x_none.h"
+    #endif
+#undef SK2X_PREAMBLE
+
+template <typename T> class Sk2x;
+typedef Sk2x<float>  Sk2f;
+typedef Sk2x<double> Sk2d;
+
+#if SK_SCALAR_IS_FLOAT
+    typedef Sk2f Sk2s;
+#elif SK_SCALAR_IS_DOUBLE
+    typedef Sk2d Sk2s;
+#endif
+
+// This API is meant to be manageably small, not comprehensive.
+// Please talk to mtklein if you find yourself wanting more.
+template <typename T> class Sk2x {
+public:
+    Sk2x();  // Uninitialized; use Sk2x(0) for zero.
+    explicit Sk2x(T);  // Same as Sk2x(T,T);
+    Sk2x(T, T);
+
+    Sk2x(const Sk2x& o) { *this = o; }
+    Sk2x& operator=(const Sk2x&);
+
+    // These assume no particular alignment.
+    static Sk2x Load(const T[2]);
+    void store(T[2]) const;
+
+    Sk2x      add(const Sk2x&) const;
+    Sk2x subtract(const Sk2x&) const;
+    Sk2x multiply(const Sk2x&) const;
+
+    Sk2x rsqrt() const;   // Approximate 1/this->sqrt().
+    Sk2x  sqrt() const;   // this->multiply(this->rsqrt()) may be faster, but less precise.
+
+    static Sk2x Min(const Sk2x&, const Sk2x&);
+    static Sk2x Max(const Sk2x&, const Sk2x&);
+
+private:
+#define SK2X_PRIVATE 1
+    #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+        #include "../opts/Sk2x_sse.h"
+    #else
+        #include "../opts/Sk2x_none.h"
+    #endif
+#undef SK2X_PRIVATE
+};
+
+#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+    #include "../opts/Sk2x_sse.h"
+#else
+    #include "../opts/Sk2x_none.h"
+#endif
+
+#endif//Sk2x_DEFINED

diff --git a/src/opts/Sk2x_none.h b/src/opts/Sk2x_none.h
new file mode 100644 (file)
index 0000000..12daffd
--- /dev/null
+++ b/src/opts/Sk2x_none.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// It is important _not_ to put header guards here.
+// This file will be intentionally included three times.
+
+#include "SkTypes.h"  // Keep this before any #ifdef for skbug.com/3362
+
+#if defined(SK2X_PREAMBLE)
+    #include "SkFloatingPoint.h"
+    #include <math.h>
+
+#elif defined(SK2X_PRIVATE)
+    T fVec[2];
+
+#else
+
+#define M(...) template <typename T> __VA_ARGS__ Sk2x<T>::
+
+M() Sk2x() {}
+M() Sk2x(T val) { fVec[0] = fVec[1] = val; }
+M() Sk2x(T a, T b) { fVec[0] = a; fVec[1] = b; }
+
+M(Sk2x<T>&) operator=(const Sk2x<T>& o) {
+    fVec[0] = o.fVec[0];
+    fVec[1] = o.fVec[1];
+    return *this;
+}
+
+M(Sk2x<T>) Load(const T vals[2]) { return Sk2x<T>(vals[0], vals[1]); }
+M(void) store(T vals[2]) const { vals[0] = fVec[0]; vals[1] = fVec[1]; }
+
+M(Sk2x<T>) add(const Sk2x<T>& o) const {
+    return Sk2x<T>(fVec[0] + o.fVec[0], fVec[1] + o.fVec[1]);
+}
+M(Sk2x<T>) subtract(const Sk2x<T>& o) const {
+    return Sk2x<T>(fVec[0] - o.fVec[0], fVec[1] - o.fVec[1]);
+}
+M(Sk2x<T>) multiply(const Sk2x<T>& o) const {
+    return Sk2x<T>(fVec[0] * o.fVec[0], fVec[1] * o.fVec[1]);
+}
+
+M(Sk2x<T>) Min(const Sk2x<T>& a, const Sk2x<T>& b) {
+    return Sk2x<T>(SkTMin(a.fVec[0], b.fVec[0]), SkTMin(a.fVec[1], b.fVec[1]));
+}
+M(Sk2x<T>) Max(const Sk2x<T>& a, const Sk2x<T>& b) {
+    return Sk2x<T>(SkTMax(a.fVec[0], b.fVec[0]), SkTMax(a.fVec[1], b.fVec[1]));
+}
+
+#undef M
+
+#define M template <> inline
+
+M Sk2f Sk2f::rsqrt() const { return Sk2f(sk_float_rsqrt(fVec[0]), sk_float_rsqrt(fVec[1])); }
+M Sk2f Sk2f:: sqrt() const { return Sk2f(         sqrtf(fVec[0]),          sqrtf(fVec[1])); }
+
+M Sk2d Sk2d::rsqrt() const { return Sk2d(1.0/::sqrt(fVec[0]), 1.0/::sqrt(fVec[1])); }
+M Sk2d Sk2d:: sqrt() const { return Sk2d(    ::sqrt(fVec[0]),     ::sqrt(fVec[1])); }
+
+#undef M
+
+#endif

diff --git a/src/opts/Sk2x_sse.h b/src/opts/Sk2x_sse.h
new file mode 100644 (file)
index 0000000..71071c0
--- /dev/null
+++ b/src/opts/Sk2x_sse.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// It is important _not_ to put header guards here.
+// This file will be intentionally included three times.
+
+#include "SkTypes.h"  // Keep this before any #ifdef for skbug.com/3362
+
+#if defined(SK2X_PREAMBLE)
+    #include <immintrin.h>
+    template <typename T> struct SkScalarToSIMD;
+    template <> struct SkScalarToSIMD< float> { typedef __m128  Type; };
+    template <> struct SkScalarToSIMD<double> { typedef __m128d Type; };
+
+
+#elif defined(SK2X_PRIVATE)
+    typename SkScalarToSIMD<T>::Type fVec;
+    /*implicit*/ Sk2x(const typename SkScalarToSIMD<T>::Type vec) { fVec = vec; }
+
+#else
+
+#define M(...) template <> inline __VA_ARGS__ Sk2x<float>::
+
+M() Sk2x() {}
+M() Sk2x(float val)        { fVec = _mm_set1_ps(val);    }
+M() Sk2x(float a, float b) { fVec = _mm_set_ps(b,a,b,a); }
+M(Sk2f&) operator=(const Sk2f& o) { fVec = o.fVec; return *this; }
+
+M(Sk2f) Load(const float vals[2]) {
+    return _mm_castsi128_ps(_mm_loadl_epi64((const __m128i*)vals));
+}
+M(void) store(float vals[2]) const { _mm_storel_pi((__m64*)vals, fVec); }
+
+M(Sk2f)      add(const Sk2f& o) const { return _mm_add_ps(fVec, o.fVec); }
+M(Sk2f) subtract(const Sk2f& o) const { return _mm_sub_ps(fVec, o.fVec); }
+M(Sk2f) multiply(const Sk2f& o) const { return _mm_mul_ps(fVec, o.fVec); }
+
+M(Sk2f) Min(const Sk2f& a, const Sk2f& b) { return _mm_min_ps(a.fVec, b.fVec); }
+M(Sk2f) Max(const Sk2f& a, const Sk2f& b) { return _mm_max_ps(a.fVec, b.fVec); }
+
+M(Sk2f) rsqrt() const { return _mm_rsqrt_ps(fVec); }
+M(Sk2f)  sqrt() const { return _mm_sqrt_ps (fVec); }
+
+#undef M
+
+#define M(...) template <> inline __VA_ARGS__ Sk2x<double>::
+
+M() Sk2x() {}
+M() Sk2x(double val)         { fVec = _mm_set1_pd(val);    }
+M() Sk2x(double a, double b) { fVec = _mm_set_pd(b, a);    }
+M(Sk2d&) operator=(const Sk2d& o) { fVec = o.fVec; return *this; }
+
+M(Sk2d) Load(const double vals[2]) { return _mm_loadu_pd(vals); }
+M(void) store(double vals[2]) const { _mm_storeu_pd(vals, fVec); }
+
+M(Sk2d)      add(const Sk2d& o) const { return _mm_add_pd(fVec, o.fVec); }
+M(Sk2d) subtract(const Sk2d& o) const { return _mm_sub_pd(fVec, o.fVec); }
+M(Sk2d) multiply(const Sk2d& o) const { return _mm_mul_pd(fVec, o.fVec); }
+
+M(Sk2d) Min(const Sk2d& a, const Sk2d& b) { return _mm_min_pd(a.fVec, b.fVec); }
+M(Sk2d) Max(const Sk2d& a, const Sk2d& b) { return _mm_max_pd(a.fVec, b.fVec); }
+
+// There is no _mm_rsqrt_pd, so we do Sk2d::rsqrt() in floats.
+M(Sk2d) rsqrt() const { return _mm_cvtps_pd(_mm_rsqrt_ps(_mm_cvtpd_ps(fVec))); }
+M(Sk2d)  sqrt() const { return _mm_sqrt_pd(fVec); }
+
+#undef M
+
+#endif

diff --git a/tests/Sk2xTest.cpp b/tests/Sk2xTest.cpp
new file mode 100644 (file)
index 0000000..5f7bf68
--- /dev/null
+++ b/tests/Sk2xTest.cpp
@@ -0,0 +1,56 @@
+/*
+ * 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 "Test.h"
+#include "Sk2x.h"
+
+template <typename T>
+static bool nearly_eq(double eps, const Sk2x<T>& v, double x, double y) {
+    T vals[2];
+    v.store(vals);
+    return fabs(vals[0] - (T)x) <= eps && fabs(vals[1] - (T)y) <= eps;
+}
+
+template <typename T>
+static bool eq(const Sk2x<T>& v, double x, double y) { return nearly_eq(0, v, x, y); }
+
+template <typename T>
+static void test(skiatest::Reporter* r) {
+    // Constructors, assignment, etc.
+    Sk2x<T> a(4),
+            b = a,
+            c(a);
+    REPORTER_ASSERT(r, eq(a, 4, 4));
+    REPORTER_ASSERT(r, eq(b, 4, 4));
+    REPORTER_ASSERT(r, eq(c, 4, 4));
+
+    Sk2x<T> d(2, 5);
+    Sk2x<T> e;
+    e = d;
+    T vals[] = { 2, 5 };
+    Sk2x<T> f = Sk2x<T>::Load(vals);
+    REPORTER_ASSERT(r, eq(d, 2, 5));
+    REPORTER_ASSERT(r, eq(e, 2, 5));
+    REPORTER_ASSERT(r, eq(f, 2, 5));
+
+    a.store(vals);
+    REPORTER_ASSERT(r, vals[0] == 4 && vals[1] == 4);
+
+    // Math
+    REPORTER_ASSERT(r, eq(a.add(d),      6,   9));
+    REPORTER_ASSERT(r, eq(a.subtract(d), 2,  -1));
+    REPORTER_ASSERT(r, eq(a.multiply(d), 8,  20));
+
+    REPORTER_ASSERT(r, nearly_eq(0.001, a.rsqrt(), 0.5, 0.5));
+    REPORTER_ASSERT(r, eq(a.sqrt(), 2, 2));
+
+    REPORTER_ASSERT(r, eq(Sk2x<T>::Min(a, d), 2, 4));
+    REPORTER_ASSERT(r, eq(Sk2x<T>::Max(a, d), 4, 5));
+}
+
+DEF_TEST(Sk2f, r) { test< float>(r); }
+DEF_TEST(Sk2d, r) { test<double>(r); }