AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Specialize Sk2d for ARM64

Browse Source 
The implementation is nearly identical to Sk2f, with these changes:
  - float32x2_t -> float64x2_t
  - vfoo -> vfooq
  - one extra Newton's method step in sqrt().

Also, generally fix NEON detection to be defined(SK_ARM_HAS_NEON).
SK_ARM_HAS_NEON is not being set on ARM64 bots right now (nor does the compiler
seem to set __ARM_NEON__), so this CL fixes everything up.

BUG=skia:

Review URL: https://codereview.chromium.org/1020963002
This commit is contained in:
mtklein 2015-03-20 08:32:35 -07:00 committed by Commit bot
parent b502ee3ace
commit e57b5cab26
5 changed files with 72 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/core/SkPreConfig.h
View File

@ -197,6 +197,11 @@
#define SK_CPU_ARM64 #define SK_CPU_ARM64
#endif #endif
// All 64-bit ARM chips have NEON. Many 32-bit ARM chips do too.
#if !defined(SK_ARM_HAS_NEON) && (defined(SK_CPU_ARM64) || defined(__ARM_NEON__))
#define SK_ARM_HAS_NEON
#endif
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
#if !defined(SKIA_IMPLEMENTATION) #if !defined(SKIA_IMPLEMENTATION)

6
src/core/Sk2x.h
View File

@ -14,7 +14,7 @@
#define SK2X_PREAMBLE 1 #define SK2X_PREAMBLE 1
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD) #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_sse.h" #include "../opts/Sk2x_sse.h"
#elif defined(__ARM_NEON__) && !defined(SKNX_NO_SIMD) #elif defined(SK_ARM_HAS_NEON) && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_neon.h" #include "../opts/Sk2x_neon.h"
#else #else
#include "../opts/Sk2x_none.h" #include "../opts/Sk2x_none.h"
@ -71,7 +71,7 @@ private:
#define SK2X_PRIVATE 1 #define SK2X_PRIVATE 1
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD) #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_sse.h" #include "../opts/Sk2x_sse.h"
#elif defined(__ARM_NEON__) && !defined(SKNX_NO_SIMD) #elif defined(SK_ARM_HAS_NEON) && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_neon.h" #include "../opts/Sk2x_neon.h"
#else #else
#include "../opts/Sk2x_none.h" #include "../opts/Sk2x_none.h"
@ -81,7 +81,7 @@ private:
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD) #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_sse.h" #include "../opts/Sk2x_sse.h"
#elif defined(__ARM_NEON__) && !defined(SKNX_NO_SIMD) #elif defined(SK_ARM_HAS_NEON) && !defined(SKNX_NO_SIMD)
#include "../opts/Sk2x_neon.h" #include "../opts/Sk2x_neon.h"
#else #else
#include "../opts/Sk2x_none.h" #include "../opts/Sk2x_none.h"

6
src/core/SkPMFloat.h
View File

@ -8,7 +8,7 @@
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
#include <immintrin.h> #include <immintrin.h>
#elif defined(__ARM_NEON__) #elif defined(SK_ARM_HAS_NEON)
#include <arm_neon.h> #include <arm_neon.h>
#endif #endif
@ -66,7 +66,7 @@ private:
float fColor[4]; float fColor[4];
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
__m128 fColors; __m128 fColors;
#elif defined(__ARM_NEON__) #elif defined(SK_ARM_HAS_NEON)
float32x4_t fColors; float32x4_t fColors;
#endif #endif
}; };
@ -76,7 +76,7 @@ private:
#include "../opts/SkPMFloat_SSSE3.h" #include "../opts/SkPMFloat_SSSE3.h"
#elif SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2 #elif SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
#include "../opts/SkPMFloat_SSE2.h" #include "../opts/SkPMFloat_SSE2.h"
#elif defined(__ARM_NEON__) #elif defined(SK_ARM_HAS_NEON)
#include "../opts/SkPMFloat_neon.h" #include "../opts/SkPMFloat_neon.h"
#else #else
#include "../opts/SkPMFloat_none.h" #include "../opts/SkPMFloat_none.h"

4
src/core/SkUtilsArm.h
View File

@ -21,9 +21,9 @@
#define SK_ARM_NEON_MODE_ALWAYS 1 #define SK_ARM_NEON_MODE_ALWAYS 1
#define SK_ARM_NEON_MODE_DYNAMIC 2 #define SK_ARM_NEON_MODE_DYNAMIC 2
#if defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_OPTIONAL_NEON) #if defined(SK_ARM_HAS_OPTIONAL_NEON)
# define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_DYNAMIC # define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_DYNAMIC
#elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON) || defined(SK_CPU_ARM64) #elif defined(SK_ARM_HAS_NEON)
# define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_ALWAYS # define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_ALWAYS
#else #else
# define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_NONE # define SK_ARM_NEON_MODE SK_ARM_NEON_MODE_NONE

82
src/opts/Sk2x_neon.h
View File

@ -15,7 +15,11 @@
#include <math.h> #include <math.h>
template <typename T> struct SkScalarToSIMD; template <typename T> struct SkScalarToSIMD;
template <> struct SkScalarToSIMD< float> { typedef float32x2_t Type; }; template <> struct SkScalarToSIMD< float> { typedef float32x2_t Type; };
template <> struct SkScalarToSIMD<double> { typedef double Type[2]; }; #if defined(SK_CPU_ARM64)
template <> struct SkScalarToSIMD<double> { typedef float64x2_t Type; };
#else
template <> struct SkScalarToSIMD<double> { typedef double Type[2]; };
#endif
#elif defined(SK2X_PRIVATE) #elif defined(SK2X_PRIVATE)
@ -60,33 +64,65 @@ M(Sk2f) sqrt() const {
#define M(...) template <> inline __VA_ARGS__ Sk2x<double>:: #define M(...) template <> inline __VA_ARGS__ Sk2x<double>::
// TODO: #ifdef SK_CPU_ARM64 use float64x2_t for Sk2d. #if defined(SK_CPU_ARM64)
M() Sk2x() {}
M() Sk2x(double val) { fVec = vdupq_n_f64(val); }
M() Sk2x(double a, double b) {
fVec = vsetq_lane_f64(a, fVec, 0);
fVec = vsetq_lane_f64(b, fVec, 1);
}
M(Sk2d&) operator=(const Sk2d& o) { fVec = o.fVec; return *this; }
M() Sk2x() {} M(Sk2d) Load(const double vals[2]) { return vld1q_f64(vals); }
M() Sk2x(double val) { fVec[0] = fVec[1] = val; } M(void) store(double vals[2]) const { vst1q_f64(vals, fVec); }
M() Sk2x(double a, double b) { fVec[0] = a; fVec[1] = b; }
M(Sk2d&) operator=(const Sk2d& o) {
fVec[0] = o.fVec[0];
fVec[1] = o.fVec[1];
return *this;
}
M(Sk2d) Load(const double vals[2]) { return Sk2d(vals[0], vals[1]); } M(Sk2d) add(const Sk2d& o) const { return vaddq_f64(fVec, o.fVec); }
M(void) store(double vals[2]) const { vals[0] = fVec[0]; vals[1] = fVec[1]; } M(Sk2d) subtract(const Sk2d& o) const { return vsubq_f64(fVec, o.fVec); }
M(Sk2d) multiply(const Sk2d& o) const { return vmulq_f64(fVec, o.fVec); }
M(Sk2d) add(const Sk2d& o) const { return Sk2d(fVec[0] + o.fVec[0], fVec[1] + o.fVec[1]); } M(Sk2d) Min(const Sk2d& a, const Sk2d& b) { return vminq_f64(a.fVec, b.fVec); }
M(Sk2d) subtract(const Sk2d& o) const { return Sk2d(fVec[0] - o.fVec[0], fVec[1] - o.fVec[1]); } M(Sk2d) Max(const Sk2d& a, const Sk2d& b) { return vmaxq_f64(a.fVec, b.fVec); }
M(Sk2d) multiply(const Sk2d& o) const { return Sk2d(fVec[0] * o.fVec[0], fVec[1] * o.fVec[1]); }
M(Sk2d) Min(const Sk2d& a, const Sk2d& b) { M(Sk2d) rsqrt() const {
return Sk2d(SkTMin(a.fVec[0], b.fVec[0]), SkTMin(a.fVec[1], b.fVec[1])); float64x2_t est0 = vrsqrteq_f64(fVec),
} est1 = vmulq_f64(vrsqrtsq_f64(fVec, vmulq_f64(est0, est0)), est0);
M(Sk2d) Max(const Sk2d& a, const Sk2d& b) { return est1;
return Sk2d(SkTMax(a.fVec[0], b.fVec[0]), SkTMax(a.fVec[1], b.fVec[1])); }
} M(Sk2d) sqrt() const {
float64x2_t est1 = this->rsqrt().fVec,
// Two extra steps of Newton's method to refine the estimate of 1/sqrt(this).
est2 = vmulq_f64(vrsqrtsq_f64(fVec, vmulq_f64(est1, est1)), est1),
est3 = vmulq_f64(vrsqrtsq_f64(fVec, vmulq_f64(est2, est2)), est2);
return vmulq_f64(fVec, est3);
}
M(Sk2d) rsqrt() const { return Sk2d(1.0/::sqrt(fVec[0]), 1.0/::sqrt(fVec[1])); } #else // Scalar implementation for 32-bit chips, which don't have float64x2_t.
M(Sk2d) sqrt() const { return Sk2d( ::sqrt(fVec[0]), ::sqrt(fVec[1])); } M() Sk2x() {}
M() Sk2x(double val) { fVec[0] = fVec[1] = val; }
M() Sk2x(double a, double b) { fVec[0] = a; fVec[1] = b; }
M(Sk2d&) operator=(const Sk2d& o) {
fVec[0] = o.fVec[0];
fVec[1] = o.fVec[1];
return *this;
}
M(Sk2d) Load(const double vals[2]) { return Sk2d(vals[0], vals[1]); }
M(void) store(double vals[2]) const { vals[0] = fVec[0]; vals[1] = fVec[1]; }
M(Sk2d) add(const Sk2d& o) const { return Sk2d(fVec[0] + o.fVec[0], fVec[1] + o.fVec[1]); }
M(Sk2d) subtract(const Sk2d& o) const { return Sk2d(fVec[0] - o.fVec[0], fVec[1] - o.fVec[1]); }
M(Sk2d) multiply(const Sk2d& o) const { return Sk2d(fVec[0] * o.fVec[0], fVec[1] * o.fVec[1]); }
M(Sk2d) Min(const Sk2d& a, const Sk2d& b) {
return Sk2d(SkTMin(a.fVec[0], b.fVec[0]), SkTMin(a.fVec[1], b.fVec[1]));
}
M(Sk2d) Max(const Sk2d& a, const Sk2d& b) {
return Sk2d(SkTMax(a.fVec[0], b.fVec[0]), SkTMax(a.fVec[1], b.fVec[1]));
}
M(Sk2d) rsqrt() const { return Sk2d(1.0/::sqrt(fVec[0]), 1.0/::sqrt(fVec[1])); }
M(Sk2d) sqrt() const { return Sk2d( ::sqrt(fVec[0]), ::sqrt(fVec[1])); }
#endif
#undef M #undef M