cannam@127: /*
cannam@127:  * Copyright (c) 2003, 2007-14 Matteo Frigo
cannam@127:  * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
cannam@127:  *
cannam@127:  * Generic128d added by Romain Dolbeau, and turned into simd-generic128.h
cannam@127:  * with single & double precision by Erik Lindahl.
cannam@127:  * Romain Dolbeau hereby places his modifications in the public domain.
cannam@127:  * Erik Lindahl hereby places his modifications in the public domain.
cannam@127:  * 
cannam@127:  * This program is free software; you can redistribute it and/or modify
cannam@127:  * it under the terms of the GNU General Public License as published by
cannam@127:  * the Free Software Foundation; either version 2 of the License, or
cannam@127:  * (at your option) any later version.
cannam@127:  *
cannam@127:  * This program is distributed in the hope that it will be useful,
cannam@127:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@127:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
cannam@127:  * GNU General Public License for more details.
cannam@127:  *
cannam@127:  * You should have received a copy of the GNU General Public License
cannam@127:  * along with this program; if not, write to the Free Software
cannam@127:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
cannam@127:  *
cannam@127:  */
cannam@127: 
cannam@127: 
cannam@127: #if defined(FFTW_LDOUBLE) || defined(FFTW_QUAD)
cannam@127: #  error "Generic simd128 only works in single or double precision"
cannam@127: #endif
cannam@127: 
cannam@127: #define SIMD_SUFFIX  _generic_simd128  /* for renaming */
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define DS(d,s) s /* single-precision option */
cannam@127: #  define VDUPL(x) (V){x[0],x[0],x[2],x[2]}
cannam@127: #  define VDUPH(x) (V){x[1],x[1],x[3],x[3]}
cannam@127: #  define DVK(var, val) V var = {val,val,val,val}
cannam@127: #else
cannam@127: #  define DS(d,s) d /* double-precision option */
cannam@127: #  define VDUPL(x) (V){x[0],x[0]}
cannam@127: #  define VDUPH(x) (V){x[1],x[1]}
cannam@127: #  define DVK(var, val) V var = {val, val}
cannam@127: #endif
cannam@127: 
cannam@127: #define VL DS(1,2)         /* SIMD vector length, in term of complex numbers */
cannam@127: #define SIMD_VSTRIDE_OKA(x) DS(1,((x) == 2))
cannam@127: #define SIMD_STRIDE_OKPAIR SIMD_STRIDE_OK
cannam@127: 
cannam@127: typedef DS(double,float) V __attribute__ ((vector_size(16)));
cannam@127: 
cannam@127: #define VADD(a,b) ((a)+(b))
cannam@127: #define VSUB(a,b) ((a)-(b))
cannam@127: #define VMUL(a,b) ((a)*(b))
cannam@127: 
cannam@127: 
cannam@127: #define LDK(x) x
cannam@127: 
cannam@127: static inline V LDA(const R *x, INT ivs, const R *aligned_like)
cannam@127: {
cannam@127:      (void)aligned_like; /* UNUSED */
cannam@127:      (void)ivs; /* UNUSED */
cannam@127:      return *(const V *)x;
cannam@127: }
cannam@127: 
cannam@127: static inline void STA(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:      (void)aligned_like; /* UNUSED */
cannam@127:      (void)ovs; /* UNUSED */
cannam@127:      *(V *)x = v;
cannam@127: }
cannam@127: 
cannam@127: static inline V LD(const R *x, INT ivs, const R *aligned_like)
cannam@127: {
cannam@127:     (void)aligned_like; /* UNUSED */
cannam@127:     V res;
cannam@127:     res[0] = x[0];
cannam@127:     res[1] = x[1];
cannam@127: #ifdef FFTW_SINGLE
cannam@127:     res[2] = x[ivs];
cannam@127:     res[3] = x[ivs+1];
cannam@127: #endif
cannam@127:     return res;
cannam@127: }
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: /* ST has to be separate due to the storage hack requiring reverse order */
cannam@127: static inline void ST(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:     (void)aligned_like; /* UNUSED */
cannam@127:     (void)ovs; /* UNUSED */
cannam@127:     *(x + ovs    ) = v[2];
cannam@127:     *(x + ovs + 1) = v[3];
cannam@127:     *(x    ) = v[0];
cannam@127:     *(x + 1) = v[1];
cannam@127: }
cannam@127: #else
cannam@127: /* FFTW_DOUBLE */
cannam@127: #  define ST STA
cannam@127: #endif
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #define STM2 ST
cannam@127: #define STN2(x, v0, v1, ovs) /* nop */
cannam@127: 
cannam@127: static inline void STN4(R *x, V v0, V v1, V v2, V v3, INT ovs)
cannam@127: {
cannam@127:     *(x              ) = v0[0];
cannam@127:     *(x           + 1) = v1[0];
cannam@127:     *(x           + 2) = v2[0];
cannam@127:     *(x           + 3) = v3[0];
cannam@127:     *(x     + ovs    ) = v0[1];
cannam@127:     *(x     + ovs + 1) = v1[1];
cannam@127:     *(x     + ovs + 2) = v2[1];
cannam@127:     *(x     + ovs + 3) = v3[1];
cannam@127:     *(x + 2 * ovs    ) = v0[2];
cannam@127:     *(x + 2 * ovs + 1) = v1[2];
cannam@127:     *(x + 2 * ovs + 2) = v2[2];
cannam@127:     *(x + 2 * ovs + 3) = v3[2];
cannam@127:     *(x + 3 * ovs    ) = v0[3];
cannam@127:     *(x + 3 * ovs + 1) = v1[3];
cannam@127:     *(x + 3 * ovs + 2) = v2[3];
cannam@127:     *(x + 3 * ovs + 3) = v3[3];
cannam@127: }
cannam@127: #define STM4(x, v, ovs, aligned_like) /* no-op */
cannam@127: 
cannam@127: 
cannam@127: #else
cannam@127: /* FFTW_DOUBLE */
cannam@127: 
cannam@127: #define STM2 STA
cannam@127: #define STN2(x, v0, v1, ovs) /* nop */
cannam@127: 
cannam@127: static inline void STM4(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:      (void)aligned_like; /* UNUSED */
cannam@127:      *(x) = v[0];
cannam@127:      *(x+ovs) = v[1];
cannam@127: }
cannam@127: #  define STN4(x, v0, v1, v2, v3, ovs) /* nothing */
cannam@127: #endif
cannam@127: 
cannam@127: 
cannam@127: static inline V FLIP_RI(V x)
cannam@127: {
cannam@127: #ifdef FFTW_SINGLE
cannam@127:     return (V){x[1],x[0],x[3],x[2]};
cannam@127: #else
cannam@127:     return (V){x[1],x[0]};
cannam@127: #endif
cannam@127: }
cannam@127: 
cannam@127: static inline V VCONJ(V x)
cannam@127: {
cannam@127: #ifdef FFTW_SINGLE
cannam@127:     return (V){x[0],-x[1],x[2],-x[3]};
cannam@127: #else
cannam@127:     return (V){x[0],-x[1]};
cannam@127: #endif
cannam@127: }
cannam@127: 
cannam@127: static inline V VBYI(V x)
cannam@127: {
cannam@127:      x = VCONJ(x);
cannam@127:      x = FLIP_RI(x);
cannam@127:      return x;
cannam@127: }
cannam@127: 
cannam@127: /* FMA support */
cannam@127: #define VFMA(a, b, c) VADD(c, VMUL(a, b))
cannam@127: #define VFNMS(a, b, c) VSUB(c, VMUL(a, b))
cannam@127: #define VFMS(a, b, c) VSUB(VMUL(a, b), c)
cannam@127: #define VFMAI(b, c) VADD(c, VBYI(b))
cannam@127: #define VFNMSI(b, c) VSUB(c, VBYI(b))
cannam@127: #define VFMACONJ(b,c)  VADD(VCONJ(b),c)
cannam@127: #define VFMSCONJ(b,c)  VSUB(VCONJ(b),c)
cannam@127: #define VFNMSCONJ(b,c) VSUB(c, VCONJ(b))
cannam@127: 
cannam@127: static inline V VZMUL(V tx, V sr)
cannam@127: {
cannam@127:      V tr = VDUPL(tx);
cannam@127:      V ti = VDUPH(tx);
cannam@127:      tr = VMUL(sr, tr);
cannam@127:      sr = VBYI(sr);
cannam@127:      return VFMA(ti, sr, tr);
cannam@127: }
cannam@127: 
cannam@127: static inline V VZMULJ(V tx, V sr)
cannam@127: {
cannam@127:      V tr = VDUPL(tx);
cannam@127:      V ti = VDUPH(tx);
cannam@127:      tr = VMUL(sr, tr);
cannam@127:      sr = VBYI(sr);
cannam@127:      return VFNMS(ti, sr, tr);
cannam@127: }
cannam@127: 
cannam@127: static inline V VZMULI(V tx, V sr)
cannam@127: {
cannam@127:      V tr = VDUPL(tx);
cannam@127:      V ti = VDUPH(tx);
cannam@127:      ti = VMUL(ti, sr);
cannam@127:      sr = VBYI(sr);
cannam@127:      return VFMS(tr, sr, ti);
cannam@127: }
cannam@127: 
cannam@127: static inline V VZMULIJ(V tx, V sr)
cannam@127: {
cannam@127:      V tr = VDUPL(tx);
cannam@127:      V ti = VDUPH(tx);
cannam@127:      ti = VMUL(ti, sr);
cannam@127:      sr = VBYI(sr);
cannam@127:      return VFMA(tr, sr, ti);
cannam@127: }
cannam@127: 
cannam@127: /* twiddle storage #1: compact, slower */
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define VTW1(v,x)  \
cannam@127:   {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_SIN, v, x}, {TW_SIN, v+1, x}
cannam@127: static inline V BYTW1(const R *t, V sr)
cannam@127: {
cannam@127:     return VZMUL(LDA(t, 2, t), sr);
cannam@127: }
cannam@127: static inline V BYTWJ1(const R *t, V sr)
cannam@127: {
cannam@127:     return VZMULJ(LDA(t, 2, t), sr);
cannam@127: }
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #  define VTW1(v,x) {TW_CEXP, v, x}
cannam@127: static inline V BYTW1(const R *t, V sr)
cannam@127: {
cannam@127:      V tx = LD(t, 1, t);
cannam@127:      return VZMUL(tx, sr);
cannam@127: }
cannam@127: static inline V BYTWJ1(const R *t, V sr)
cannam@127: {
cannam@127:      V tx = LD(t, 1, t);
cannam@127:      return VZMULJ(tx, sr);
cannam@127: }
cannam@127: #endif
cannam@127: #define TWVL1 (VL)
cannam@127: 
cannam@127: /* twiddle storage #2: twice the space, faster (when in cache) */
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define VTW2(v,x)                                                     \
cannam@127:   {TW_COS, v, x}, {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+1, x},   \
cannam@127:   {TW_SIN, v, -x}, {TW_SIN, v, x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #  define VTW2(v,x)                                                     \
cannam@127:   {TW_COS, v, x}, {TW_COS, v, x}, {TW_SIN, v, -x}, {TW_SIN, v, x}
cannam@127: #endif
cannam@127: #define TWVL2 (2 * VL)
cannam@127: static inline V BYTW2(const R *t, V sr)
cannam@127: {
cannam@127:      const V *twp = (const V *)t;
cannam@127:      V si = FLIP_RI(sr);
cannam@127:      V tr = twp[0], ti = twp[1];
cannam@127:      return VFMA(tr, sr, VMUL(ti, si));
cannam@127: }
cannam@127: static inline V BYTWJ2(const R *t, V sr)
cannam@127: {
cannam@127:      const V *twp = (const V *)t;
cannam@127:      V si = FLIP_RI(sr);
cannam@127:      V tr = twp[0], ti = twp[1];
cannam@127:      return VFNMS(ti, si, VMUL(tr, sr));
cannam@127: }
cannam@127: 
cannam@127: /* twiddle storage #3 */
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define VTW3(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}
cannam@127: #  define TWVL3 (VL)
cannam@127: #else
cannam@127: #  define VTW3(v,x) VTW1(v,x)
cannam@127: #  define TWVL3 TWVL1
cannam@127: #endif
cannam@127: 
cannam@127: /* twiddle storage for split arrays */
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define VTWS(v,x)                                                       \
cannam@127:     {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+2, x}, {TW_COS, v+3, x}, \
cannam@127:     {TW_SIN, v, x}, {TW_SIN, v+1, x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, x}
cannam@127: #else
cannam@127: #  define VTWS(v,x)                                                       \
cannam@127:     {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_SIN, v, x}, {TW_SIN, v+1, x}
cannam@127: #endif
cannam@127: #define TWVLS (2 * VL)
cannam@127: 
cannam@127: #define VLEAVE() /* nothing */
cannam@127: 
cannam@127: #include "simd-common.h"