From bbecae0832996b72d1f6e7d39d2754651300d31e Mon Sep 17 00:00:00 2001 From: mtklein Date: Thu, 19 Mar 2015 10:44:27 -0700 Subject: 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 --- src/core/Sk2x.h | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/opts/Sk2x_none.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++ src/opts/Sk2x_sse.h | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 211 insertions(+) create mode 100644 src/core/Sk2x.h create mode 100644 src/opts/Sk2x_none.h create mode 100644 src/opts/Sk2x_sse.h (limited to 'src') diff --git a/src/core/Sk2x.h b/src/core/Sk2x.h new file mode 100644 index 0000000000..6b3fd86b27 --- /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 class Sk2x; +typedef Sk2x Sk2f; +typedef Sk2x 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 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 index 0000000000..12daffd72f --- /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 + +#elif defined(SK2X_PRIVATE) + T fVec[2]; + +#else + +#define M(...) template __VA_ARGS__ Sk2x:: + +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&) operator=(const Sk2x& o) { + fVec[0] = o.fVec[0]; + fVec[1] = o.fVec[1]; + return *this; +} + +M(Sk2x) Load(const T vals[2]) { return Sk2x(vals[0], vals[1]); } +M(void) store(T vals[2]) const { vals[0] = fVec[0]; vals[1] = fVec[1]; } + +M(Sk2x) add(const Sk2x& o) const { + return Sk2x(fVec[0] + o.fVec[0], fVec[1] + o.fVec[1]); +} +M(Sk2x) subtract(const Sk2x& o) const { + return Sk2x(fVec[0] - o.fVec[0], fVec[1] - o.fVec[1]); +} +M(Sk2x) multiply(const Sk2x& o) const { + return Sk2x(fVec[0] * o.fVec[0], fVec[1] * o.fVec[1]); +} + +M(Sk2x) Min(const Sk2x& a, const Sk2x& b) { + return Sk2x(SkTMin(a.fVec[0], b.fVec[0]), SkTMin(a.fVec[1], b.fVec[1])); +} +M(Sk2x) Max(const Sk2x& a, const Sk2x& b) { + return Sk2x(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 index 0000000000..71071c08c7 --- /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 + template struct SkScalarToSIMD; + template <> struct SkScalarToSIMD< float> { typedef __m128 Type; }; + template <> struct SkScalarToSIMD { typedef __m128d Type; }; + + +#elif defined(SK2X_PRIVATE) + typename SkScalarToSIMD::Type fVec; + /*implicit*/ Sk2x(const typename SkScalarToSIMD::Type vec) { fVec = vec; } + +#else + +#define M(...) template <> inline __VA_ARGS__ Sk2x:: + +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:: + +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 -- cgit v1.2.3