Chris@42: /*
Chris@42:  * Copyright (c) 2003, 2007-14 Matteo Frigo
Chris@42:  * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
Chris@42:  *
Chris@42:  * Modifications by Romain Dolbeau & Erik Lindahl, derived from simd-avx.h
Chris@42:  * Romain Dolbeau hereby places his modifications in the public domain.
Chris@42:  * Erik Lindahl hereby places his modifications in the public domain.
Chris@42:  *
Chris@42:  * This program is free software; you can redistribute it and/or modify
Chris@42:  * it under the terms of the GNU General Public License as published by
Chris@42:  * the Free Software Foundation; either version 2 of the License, or
Chris@42:  * (at your option) any later version.
Chris@42:  *
Chris@42:  * This program is distributed in the hope that it will be useful,
Chris@42:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
Chris@42:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Chris@42:  * GNU General Public License for more details.
Chris@42:  *
Chris@42:  * You should have received a copy of the GNU General Public License
Chris@42:  * along with this program; if not, write to the Free Software
Chris@42:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
Chris@42:  *
Chris@42:  */
Chris@42: 
Chris@42: #if defined(FFTW_LDOUBLE) || defined(FFTW_QUAD)
Chris@42: #error "AVX2 only works in single or double precision"
Chris@42: #endif
Chris@42: 
Chris@42: #ifdef FFTW_SINGLE
Chris@42: #  define DS(d,s) s /* single-precision option */
Chris@42: #  define SUFF(name) name ## s
Chris@42: #else
Chris@42: #  define DS(d,s) d /* double-precision option */
Chris@42: #  define SUFF(name) name ## d
Chris@42: #endif
Chris@42: 
Chris@42: #define SIMD_SUFFIX  _avx2  /* for renaming */
Chris@42: #define VL DS(2, 4)        /* SIMD complex vector length */
Chris@42: #define SIMD_VSTRIDE_OKA(x) ((x) == 2) 
Chris@42: #define SIMD_STRIDE_OKPAIR SIMD_STRIDE_OK
Chris@42: 
Chris@42: #if defined(__GNUC__) && !defined(__AVX2__) /* sanity check */
Chris@42: #error "compiling simd-avx2.h without avx2 support"
Chris@42: #endif
Chris@42: 
Chris@42: #if !defined(HAVE_FMA)
Chris@42: #warning "You should probably enable FMAs with --enable-fma for AVX2"
Chris@42: #endif
Chris@42: 
Chris@42: #ifdef _MSC_VER
Chris@42: #ifndef inline
Chris@42: #define inline __inline
Chris@42: #endif
Chris@42: #endif
Chris@42: 
Chris@42: #include <immintrin.h>
Chris@42: 
Chris@42: typedef DS(__m256d, __m256) V;
Chris@42: #define VADD SUFF(_mm256_add_p)
Chris@42: #define VSUB SUFF(_mm256_sub_p)
Chris@42: #define VMUL SUFF(_mm256_mul_p)
Chris@42: #define VXOR SUFF(_mm256_xor_p)
Chris@42: #define VSHUF SUFF(_mm256_shuffle_p)
Chris@42: #define VPERM1 SUFF(_mm256_permute_p)
Chris@42: 
Chris@42: #define SHUFVALD(fp0,fp1) \
Chris@42:    (((fp1) << 3) | ((fp0) << 2) | ((fp1) << 1) | ((fp0)))
Chris@42: #define SHUFVALS(fp0,fp1,fp2,fp3) \
Chris@42:    (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | ((fp0)))
Chris@42: 
Chris@42: #define VDUPL(x) DS(_mm256_movedup_pd(x), _mm256_moveldup_ps(x))
Chris@42: #define VDUPH(x) DS(_mm256_permute_pd(x,SHUFVALD(1,1)), _mm256_movehdup_ps(x))
Chris@42: 
Chris@42: #define VLIT(x0, x1) DS(_mm256_set_pd(x0, x1, x0, x1), _mm256_set_ps(x0, x1, x0, x1, x0, x1, x0, x1))
Chris@42: #define DVK(var, val) V var = VLIT(val, val)
Chris@42: #define LDK(x) x
Chris@42: 
Chris@42: static inline V LDA(const R *x, INT ivs, const R *aligned_like)
Chris@42: {
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42:      (void)ivs; /* UNUSED */
Chris@42:      return SUFF(_mm256_loadu_p)(x);
Chris@42: }
Chris@42: 
Chris@42: static inline void STA(R *x, V v, INT ovs, const R *aligned_like)
Chris@42: {
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42:      (void)ovs; /* UNUSED */
Chris@42:      SUFF(_mm256_storeu_p)(x, v);
Chris@42: }
Chris@42: 
Chris@42: #if FFTW_SINGLE
Chris@42: 
Chris@42: #define LOADH(addr, val) _mm_loadh_pi(val, (const __m64 *)(addr))
Chris@42: #define LOADL(addr, val) _mm_loadl_pi(val, (const __m64 *)(addr))
Chris@42: #define STOREH(addr, val) _mm_storeh_pi((__m64 *)(addr), val)
Chris@42: #define STOREL(addr, val) _mm_storel_pi((__m64 *)(addr), val)
Chris@42: 
Chris@42: static inline V LD(const R *x, INT ivs, const R *aligned_like)
Chris@42: {
Chris@42:      __m128 l0, l1, h0, h1;
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42: #if defined(__ICC) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ > 8)
Chris@42:      l0 = LOADL(x, SUFF(_mm_undefined_p)());
Chris@42:      l1 = LOADL(x + ivs, SUFF(_mm_undefined_p)());
Chris@42:      h0 = LOADL(x + 2*ivs, SUFF(_mm_undefined_p)());
Chris@42:      h1 = LOADL(x + 3*ivs, SUFF(_mm_undefined_p)());
Chris@42: #else
Chris@42:      l0 = LOADL(x, l0);
Chris@42:      l1 = LOADL(x + ivs, l1);
Chris@42:      h0 = LOADL(x + 2*ivs, h0);
Chris@42:      h1 = LOADL(x + 3*ivs, h1);
Chris@42: #endif
Chris@42:      l0 = SUFF(_mm_movelh_p)(l0,l1);
Chris@42:      h0 = SUFF(_mm_movelh_p)(h0,h1);
Chris@42:      return _mm256_insertf128_ps(_mm256_castps128_ps256(l0), h0, 1);
Chris@42: }
Chris@42: 
Chris@42: static inline void ST(R *x, V v, INT ovs, const R *aligned_like)
Chris@42: {
Chris@42:      __m128 h = _mm256_extractf128_ps(v, 1);
Chris@42:      __m128 l = _mm256_castps256_ps128(v);
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42:      /* WARNING: the extra_iter hack depends upon STOREL occurring
Chris@42: 	after STOREH */
Chris@42:      STOREH(x + 3*ovs, h);
Chris@42:      STOREL(x + 2*ovs, h);
Chris@42:      STOREH(x + ovs, l);
Chris@42:      STOREL(x, l);
Chris@42: }
Chris@42: 
Chris@42: #define STM2(x, v, ovs, aligned_like) /* no-op */
Chris@42: static inline void STN2(R *x, V v0, V v1, INT ovs)
Chris@42: {
Chris@42:     V x0 = VSHUF(v0, v1, SHUFVALS(0, 1, 0, 1));
Chris@42:     V x1 = VSHUF(v0, v1, SHUFVALS(2, 3, 2, 3));
Chris@42:     __m128 h0 = _mm256_extractf128_ps(x0, 1);
Chris@42:     __m128 l0 = _mm256_castps256_ps128(x0);
Chris@42:     __m128 h1 = _mm256_extractf128_ps(x1, 1);
Chris@42:     __m128 l1 = _mm256_castps256_ps128(x1);
Chris@42:     *(__m128 *)(x + 3*ovs) = h1;
Chris@42:     *(__m128 *)(x + 2*ovs) = h0;
Chris@42:     *(__m128 *)(x + 1*ovs) = l1;
Chris@42:     *(__m128 *)(x + 0*ovs) = l0;
Chris@42: }
Chris@42: 
Chris@42: #define STM4(x, v, ovs, aligned_like) /* no-op */
Chris@42: #define STN4(x, v0, v1, v2, v3, ovs)				\
Chris@42: {								\
Chris@42:      V xxx0, xxx1, xxx2, xxx3;					\
Chris@42:      V yyy0, yyy1, yyy2, yyy3;					\
Chris@42:      xxx0 = _mm256_unpacklo_ps(v0, v2);				\
Chris@42:      xxx1 = _mm256_unpackhi_ps(v0, v2);				\
Chris@42:      xxx2 = _mm256_unpacklo_ps(v1, v3);				\
Chris@42:      xxx3 = _mm256_unpackhi_ps(v1, v3);				\
Chris@42:      yyy0 = _mm256_unpacklo_ps(xxx0, xxx2);			\
Chris@42:      yyy1 = _mm256_unpackhi_ps(xxx0, xxx2);			\
Chris@42:      yyy2 = _mm256_unpacklo_ps(xxx1, xxx3);			\
Chris@42:      yyy3 = _mm256_unpackhi_ps(xxx1, xxx3);			\
Chris@42:      *(__m128 *)(x + 0 * ovs) = _mm256_castps256_ps128(yyy0);	\
Chris@42:      *(__m128 *)(x + 4 * ovs) = _mm256_extractf128_ps(yyy0, 1);	\
Chris@42:      *(__m128 *)(x + 1 * ovs) = _mm256_castps256_ps128(yyy1);	\
Chris@42:      *(__m128 *)(x + 5 * ovs) = _mm256_extractf128_ps(yyy1, 1);	\
Chris@42:      *(__m128 *)(x + 2 * ovs) = _mm256_castps256_ps128(yyy2);	\
Chris@42:      *(__m128 *)(x + 6 * ovs) = _mm256_extractf128_ps(yyy2, 1);	\
Chris@42:      *(__m128 *)(x + 3 * ovs) = _mm256_castps256_ps128(yyy3);	\
Chris@42:      *(__m128 *)(x + 7 * ovs) = _mm256_extractf128_ps(yyy3, 1);	\
Chris@42: }
Chris@42: 
Chris@42: #else
Chris@42: static inline __m128d VMOVAPD_LD(const R *x)
Chris@42: {
Chris@42:      /* gcc-4.6 miscompiles the combination _mm256_castpd128_pd256(VMOVAPD_LD(x))
Chris@42: 	into a 256-bit vmovapd, which requires 32-byte aligment instead of
Chris@42: 	16-byte alignment.
Chris@42: 
Chris@42: 	Force the use of vmovapd via asm until compilers stabilize.
Chris@42:      */
Chris@42: #if defined(__GNUC__)
Chris@42:      __m128d var;
Chris@42:      __asm__("vmovapd %1, %0\n" : "=x"(var) : "m"(x[0]));
Chris@42:      return var;
Chris@42: #else
Chris@42:      return *(const __m128d *)x;
Chris@42: #endif
Chris@42: }
Chris@42: 
Chris@42: static inline V LD(const R *x, INT ivs, const R *aligned_like)
Chris@42: {
Chris@42:      V var;
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42:      var = _mm256_castpd128_pd256(VMOVAPD_LD(x));
Chris@42:      var = _mm256_insertf128_pd(var, *(const __m128d *)(x+ivs), 1);
Chris@42:      return var;
Chris@42: }
Chris@42: 
Chris@42: static inline void ST(R *x, V v, INT ovs, const R *aligned_like)
Chris@42: {
Chris@42:      (void)aligned_like; /* UNUSED */
Chris@42:      /* WARNING: the extra_iter hack depends upon the store of the low
Chris@42: 	part occurring after the store of the high part */
Chris@42:      *(__m128d *)(x + ovs) = _mm256_extractf128_pd(v, 1);
Chris@42:      *(__m128d *)x = _mm256_castpd256_pd128(v);
Chris@42: }
Chris@42: 
Chris@42: 
Chris@42: #define STM2 ST
Chris@42: #define STN2(x, v0, v1, ovs) /* nop */
Chris@42: #define STM4(x, v, ovs, aligned_like) /* no-op */
Chris@42: 
Chris@42: /* STN4 is a macro, not a function, thanks to Visual C++ developers
Chris@42:    deciding "it would be infrequent that people would want to pass more
Chris@42:    than 3 [__m128 parameters] by value."  Even though the comment
Chris@42:    was made about __m128 parameters, it appears to apply to __m256
Chris@42:    parameters as well. */
Chris@42: #define STN4(x, v0, v1, v2, v3, ovs)					\
Chris@42: {									\
Chris@42:      V xxx0, xxx1, xxx2, xxx3;						\
Chris@42:      xxx0 = _mm256_unpacklo_pd(v0, v1);					\
Chris@42:      xxx1 = _mm256_unpackhi_pd(v0, v1);					\
Chris@42:      xxx2 = _mm256_unpacklo_pd(v2, v3);					\
Chris@42:      xxx3 = _mm256_unpackhi_pd(v2, v3);					\
Chris@42:      STA(x,           _mm256_permute2f128_pd(xxx0, xxx2, 0x20), 0, 0); \
Chris@42:      STA(x +     ovs, _mm256_permute2f128_pd(xxx1, xxx3, 0x20), 0, 0); \
Chris@42:      STA(x + 2 * ovs, _mm256_permute2f128_pd(xxx0, xxx2, 0x31), 0, 0); \
Chris@42:      STA(x + 3 * ovs, _mm256_permute2f128_pd(xxx1, xxx3, 0x31), 0, 0); \
Chris@42: }
Chris@42: #endif
Chris@42: 
Chris@42: static inline V FLIP_RI(V x)
Chris@42: {
Chris@42:      return VPERM1(x, DS(SHUFVALD(1, 0), SHUFVALS(1, 0, 3, 2)));
Chris@42: }
Chris@42: 
Chris@42: static inline V VCONJ(V x)
Chris@42: {
Chris@42:      V pmpm = VLIT(-0.0, 0.0);
Chris@42:      return VXOR(pmpm, x);
Chris@42: }
Chris@42: 
Chris@42: static inline V VBYI(V x)
Chris@42: {
Chris@42:      return FLIP_RI(VCONJ(x));
Chris@42: }
Chris@42: 
Chris@42: /* FMA support */
Chris@42: #define VFMA    SUFF(_mm256_fmadd_p)
Chris@42: #define VFNMS   SUFF(_mm256_fnmadd_p)
Chris@42: #define VFMS    SUFF(_mm256_fmsub_p)
Chris@42: #define VFMAI(b, c) SUFF(_mm256_addsub_p)(c, FLIP_RI(b)) /* VADD(c, VBYI(b)) */
Chris@42: #define VFNMSI(b, c)   VSUB(c, VBYI(b))
Chris@42: #define VFMACONJ(b,c)  VADD(VCONJ(b),c)
Chris@42: #define VFMSCONJ(b,c)  VSUB(VCONJ(b),c)
Chris@42: #define VFNMSCONJ(b,c) SUFF(_mm256_addsub_p)(c, b)  /* VSUB(c, VCONJ(b)) */
Chris@42: 
Chris@42: static inline V VZMUL(V tx, V sr)
Chris@42: {
Chris@42:      /* V tr = VDUPL(tx); */
Chris@42:      /* V ti = VDUPH(tx); */
Chris@42:      /* tr = VMUL(sr, tr); */
Chris@42:      /* sr = VBYI(sr); */
Chris@42:      /* return VFMA(ti, sr, tr); */
Chris@42:      return SUFF(_mm256_fmaddsub_p)(sr, VDUPL(tx), VMUL(FLIP_RI(sr), VDUPH(tx)));
Chris@42: }
Chris@42: 
Chris@42: static inline V VZMULJ(V tx, V sr)
Chris@42: {
Chris@42:      /* V tr = VDUPL(tx); */
Chris@42:      /* V ti = VDUPH(tx); */
Chris@42:      /* tr = VMUL(sr, tr); */
Chris@42:      /* sr = VBYI(sr); */
Chris@42:      /* return VFNMS(ti, sr, tr); */
Chris@42:      return SUFF(_mm256_fmsubadd_p)(sr, VDUPL(tx), VMUL(FLIP_RI(sr), VDUPH(tx)));
Chris@42: }
Chris@42: 
Chris@42: static inline V VZMULI(V tx, V sr)
Chris@42: {
Chris@42:      V tr = VDUPL(tx);
Chris@42:      V ti = VDUPH(tx);
Chris@42:      ti = VMUL(ti, sr);
Chris@42:      sr = VBYI(sr);
Chris@42:      return VFMS(tr, sr, ti);
Chris@42:     /*
Chris@42:      * Keep the old version
Chris@42:      * (2 permute, 1 shuffle, 1 constant load (L1), 1 xor, 2 fp), since the below FMA one
Chris@42:      * would be 2 permute, 1 shuffle, 1 xor (setzero), 3 fp), but with a longer pipeline.
Chris@42:      *
Chris@42:      * Alternative new fma version:
Chris@42:      * return SUFF(_mm256_addsub_p)(SUFF(_mm256_fnmadd_p)(sr, VDUPH(tx), SUFF(_mm256_setzero_p)()),
Chris@42:      * VMUL(FLIP_RI(sr), VDUPL(tx)));
Chris@42:     */
Chris@42: }
Chris@42: 
Chris@42: static inline V VZMULIJ(V tx, V sr)
Chris@42: {
Chris@42:      /* V tr = VDUPL(tx); */
Chris@42:      /* V ti = VDUPH(tx); */
Chris@42:      /* ti = VMUL(ti, sr); */
Chris@42:      /* sr = VBYI(sr); */
Chris@42:      /* return VFMA(tr, sr, ti); */
Chris@42:      return SUFF(_mm256_fmaddsub_p)(sr, VDUPH(tx), VMUL(FLIP_RI(sr), VDUPL(tx)));
Chris@42: }
Chris@42: 
Chris@42: /* twiddle storage #1: compact, slower */
Chris@42: #ifdef FFTW_SINGLE
Chris@42: # define VTW1(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}, {TW_CEXP, v+2, x}, {TW_CEXP, v+3, x}
Chris@42: #else
Chris@42: # define VTW1(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}
Chris@42: #endif
Chris@42: #define TWVL1 (VL)
Chris@42: 
Chris@42: static inline V BYTW1(const R *t, V sr)
Chris@42: {
Chris@42:      return VZMUL(LDA(t, 2, t), sr);
Chris@42: }
Chris@42: 
Chris@42: static inline V BYTWJ1(const R *t, V sr)
Chris@42: {
Chris@42:      return VZMULJ(LDA(t, 2, t), sr);
Chris@42: }
Chris@42: 
Chris@42: /* twiddle storage #2: twice the space, faster (when in cache) */
Chris@42: #ifdef FFTW_SINGLE
Chris@42: # define VTW2(v,x)							\
Chris@42:    {TW_COS, v, x}, {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+1, x},	\
Chris@42:    {TW_COS, v+2, x}, {TW_COS, v+2, x}, {TW_COS, v+3, x}, {TW_COS, v+3, x}, \
Chris@42:    {TW_SIN, v, -x}, {TW_SIN, v, x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}, \
Chris@42:    {TW_SIN, v+2, -x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, -x}, {TW_SIN, v+3, x}
Chris@42: #else
Chris@42: # define VTW2(v,x)							\
Chris@42:    {TW_COS, v, x}, {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+1, x},	\
Chris@42:    {TW_SIN, v, -x}, {TW_SIN, v, x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}
Chris@42: #endif
Chris@42: #define TWVL2 (2 * VL)
Chris@42: 
Chris@42: static inline V BYTW2(const R *t, V sr)
Chris@42: {
Chris@42:      const V *twp = (const V *)t;
Chris@42:      V si = FLIP_RI(sr);
Chris@42:      V tr = twp[0], ti = twp[1];
Chris@42:      return VFMA(tr, sr, VMUL(ti, si));
Chris@42: }
Chris@42: 
Chris@42: static inline V BYTWJ2(const R *t, V sr)
Chris@42: {
Chris@42:      const V *twp = (const V *)t;
Chris@42:      V si = FLIP_RI(sr);
Chris@42:      V tr = twp[0], ti = twp[1];
Chris@42:      return VFNMS(ti, si, VMUL(tr, sr));
Chris@42: }
Chris@42: 
Chris@42: /* twiddle storage #3 */
Chris@42: #define VTW3 VTW1
Chris@42: #define TWVL3 TWVL1
Chris@42: 
Chris@42: /* twiddle storage for split arrays */
Chris@42: #ifdef FFTW_SINGLE
Chris@42: # define VTWS(v,x)							\
Chris@42:   {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+2, x}, {TW_COS, v+3, x},	\
Chris@42:   {TW_COS, v+4, x}, {TW_COS, v+5, x}, {TW_COS, v+6, x}, {TW_COS, v+7, x}, \
Chris@42:   {TW_SIN, v, x}, {TW_SIN, v+1, x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, x},	\
Chris@42:   {TW_SIN, v+4, x}, {TW_SIN, v+5, x}, {TW_SIN, v+6, x}, {TW_SIN, v+7, x}
Chris@42: #else
Chris@42: # define VTWS(v,x)							\
Chris@42:   {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+2, x}, {TW_COS, v+3, x},	\
Chris@42:   {TW_SIN, v, x}, {TW_SIN, v+1, x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, x}	
Chris@42: #endif
Chris@42: #define TWVLS (2 * VL)
Chris@42: 
Chris@42: #define VLEAVE _mm256_zeroupper
Chris@42: 
Chris@42: #include "simd-common.h"