cannam@127: /*
cannam@127:  * Copyright (c) 2003, 2007-11 Matteo Frigo
cannam@127:  * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
cannam@127:  * 
cannam@127:  * Knights Corner Vector Instruction support added by Romain Dolbeau.
cannam@127:  * Romain Dolbeau hereby places his modifications in the public domain.
cannam@127:  *
cannam@127:  * Permission is hereby granted, free of charge, to any person obtaining a copy
cannam@127:  * of this software and associated documentation files (the "Software"), to deal
cannam@127:  * in the Software without restriction, including without limitation the rights
cannam@127:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
cannam@127:  * copies of the Software, and to permit persons to whom the Software is
cannam@127:  * furnished to do so, subject to the following conditions:
cannam@127:  *
cannam@127:  * The above copyright notice and this permission notice shall be included in
cannam@127:  * all copies or substantial portions of the Software.
cannam@127:  *
cannam@127:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
cannam@127:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
cannam@127:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
cannam@127:  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
cannam@127:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
cannam@127:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
cannam@127:  * THE SOFTWARE.
cannam@127:  *
cannam@127:  */
cannam@127: 
cannam@127: #if defined(FFTW_LDOUBLE) || defined(FFTW_QUAD)
cannam@127: #error "Knights Corner vector instructions only works in single or double precision"
cannam@127: #endif
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #  define DS(d,s) s /* single-precision option */
cannam@127: #  define SUFF(name) name ## _ps
cannam@127: #  define SCAL(x) x ## f
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #  define DS(d,s) d /* double-precision option */
cannam@127: #  define SUFF(name) name ## _pd
cannam@127: #  define SCAL(x) x
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: 
cannam@127: #define SIMD_SUFFIX  _kcvi  /* for renaming */
cannam@127: #define VL DS(4, 8)        /* SIMD complex vector length */
cannam@127: #define SIMD_VSTRIDE_OKA(x) ((x) == 2) 
cannam@127: #define SIMD_STRIDE_OKPAIR SIMD_STRIDE_OK
cannam@127: 
cannam@127: /* configuration ; KNF 0 0 0 1 0 1 */
cannam@127: #define KCVI_VBYI_SINGLE_USE_MUL 0
cannam@127: #define KCVI_VBYI_DOUBLE_USE_MUL 0
cannam@127: #define KCVI_LD_DOUBLE_USE_UNPACK 1
cannam@127: #define KCVI_ST_DOUBLE_USE_PACK 1
cannam@127: #define KCVI_ST2_DOUBLE_USE_STN2 0
cannam@127: #define KCVI_MULZ_USE_SWIZZLE 1
cannam@127: 
cannam@127: #include <immintrin.h>
cannam@127: 
cannam@127: typedef DS(__m512d, __m512) V;
cannam@127: 
cannam@127: #define VADD(a,b) SUFF(_mm512_add)(a,b)
cannam@127: #define VSUB(a,b) SUFF(_mm512_sub)(a,b)
cannam@127: #define VMUL(a,b) SUFF(_mm512_mul)(a,b)
cannam@127: 
cannam@127: #define VFMA(a, b, c) SUFF(_mm512_fmadd)(a, b, c) //VADD(c, VMUL(a, b))
cannam@127: #define VFMS(a, b, c) SUFF(_mm512_fmsub)(a, b, c) //VSUB(VMUL(a, b), c)
cannam@127: #define VFNMS(a, b, c) SUFF(_mm512_fnmadd)(a, b, c) //VSUB(c, VMUL(a, b))
cannam@127: 
cannam@127: #define LDK(x) x
cannam@127: #define VLIT(re, im) SUFF(_mm512_setr4)(im, re, im, re)
cannam@127: #define DVK(var, val) V var = SUFF(_mm512_set1)(val)
cannam@127: 
cannam@127: static inline V LDA(const R *x, INT ivs, const R *aligned_like) {
cannam@127:   return SUFF(_mm512_load)(x);
cannam@127: }
cannam@127: static inline void STA(R *x, V v, INT ovs, const R *aligned_like) {
cannam@127:   SUFF(_mm512_store)(x, v);
cannam@127: }
cannam@127: 
cannam@127: #if FFTW_SINGLE
cannam@127: #define VXOR(a,b) _mm512_xor_epi32(a,b)
cannam@127: 
cannam@127: static inline V LDu(const R *x, INT ivs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   __m512i index = _mm512_set_epi32(7 * ivs + 1, 7 * ivs,
cannam@127:                                    6 * ivs + 1, 6 * ivs,
cannam@127:                                    5 * ivs + 1, 5 * ivs,
cannam@127:                                    4 * ivs + 1, 4 * ivs,
cannam@127:                                    3 * ivs + 1, 3 * ivs,
cannam@127:                                    2 * ivs + 1, 2 * ivs,
cannam@127:                                    1 * ivs + 1, 1 * ivs,
cannam@127:                                    0 * ivs + 1, 0 * ivs);
cannam@127:   
cannam@127:   return _mm512_i32gather_ps(index, x, _MM_SCALE_4);
cannam@127: }
cannam@127: 
cannam@127: static inline void STu(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   __m512i index = _mm512_set_epi32(7 * ovs + 1, 7 * ovs,
cannam@127:                                    6 * ovs + 1, 6 * ovs,
cannam@127:                                    5 * ovs + 1, 5 * ovs,
cannam@127:                                    4 * ovs + 1, 4 * ovs,
cannam@127:                                    3 * ovs + 1, 3 * ovs,
cannam@127:                                    2 * ovs + 1, 2 * ovs,
cannam@127:                                    1 * ovs + 1, 1 * ovs,
cannam@127:                                    0 * ovs + 1, 0 * ovs);
cannam@127:   
cannam@127:   _mm512_i32scatter_ps(x, index, v, _MM_SCALE_4);
cannam@127: }
cannam@127: 
cannam@127: static inline V FLIP_RI(V x)
cannam@127: {
cannam@127:   return (V)_mm512_shuffle_epi32((__m512i)x, _MM_PERM_CDAB);
cannam@127: }
cannam@127: 
cannam@127: #define VDUPH(a) (V)_mm512_shuffle_epi32((__m512i)a, _MM_PERM_DDBB);
cannam@127: #define VDUPL(a) (V)_mm512_shuffle_epi32((__m512i)a, _MM_PERM_CCAA);
cannam@127: 
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #define VXOR(a,b) _mm512_xor_epi64(a,b)
cannam@127: 
cannam@127: #if defined (KCVI_LD_DOUBLE_USE_UNPACK) && KCVI_LD_DOUBLE_USE_UNPACK
cannam@127: static inline V LDu(const R *x, INT ivs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   V temp;
cannam@127:   /* no need for hq here */
cannam@127:   temp = _mm512_mask_loadunpacklo_pd(temp, 0x0003, x + (0 * ivs));
cannam@127:   temp = _mm512_mask_loadunpacklo_pd(temp, 0x000c, x + (1 * ivs));
cannam@127:   temp = _mm512_mask_loadunpacklo_pd(temp, 0x0030, x + (2 * ivs));
cannam@127:   temp = _mm512_mask_loadunpacklo_pd(temp, 0x00c0, x + (3 * ivs));
cannam@127:   return temp;
cannam@127: }
cannam@127: #else
cannam@127: static inline V LDu(const R *x, INT ivs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   __declspec(align(64)) R temp[8]; 
cannam@127:   int i;
cannam@127:   for (i = 0 ; i < 4 ; i++) {
cannam@127:     temp[i*2]   = x[i * ivs];
cannam@127:     temp[i*2+1] = x[i * ivs + 1];
cannam@127:   }
cannam@127:   return _mm512_load_pd(temp);
cannam@127: }
cannam@127: #endif
cannam@127: 
cannam@127: #if defined(KCVI_ST_DOUBLE_USE_PACK) && KCVI_ST_DOUBLE_USE_PACK
cannam@127: static inline void STu(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   /* no need for hq here */
cannam@127:   _mm512_mask_packstorelo_pd(x + (0 * ovs), 0x0003, v);
cannam@127:   _mm512_mask_packstorelo_pd(x + (1 * ovs), 0x000c, v);
cannam@127:   _mm512_mask_packstorelo_pd(x + (2 * ovs), 0x0030, v);
cannam@127:   _mm512_mask_packstorelo_pd(x + (3 * ovs), 0x00c0, v);
cannam@127: }
cannam@127: #else
cannam@127: static inline void STu(R *x, V v, INT ovs, const R *aligned_like)
cannam@127: {
cannam@127:   (void)aligned_like; /* UNUSED */
cannam@127:   __declspec(align(64)) R temp[8];
cannam@127:   int i;
cannam@127:   _mm512_store_pd(temp, v);
cannam@127:   for (i = 0 ; i < 4 ; i++) {
cannam@127:     x[i * ovs] = temp[i*2];
cannam@127:     x[i * ovs + 1] = temp[i*2+1];
cannam@127:   } 
cannam@127: }
cannam@127: #endif
cannam@127: 
cannam@127: static inline V FLIP_RI(V x)
cannam@127: {
cannam@127:   return (V)_mm512_shuffle_epi32((__m512i)x, _MM_PERM_BADC);
cannam@127: }
cannam@127: 
cannam@127: #define VDUPH(a) (V)_mm512_shuffle_epi32((__m512i)a, _MM_PERM_DCDC);
cannam@127: #define VDUPL(a) (V)_mm512_shuffle_epi32((__m512i)a, _MM_PERM_BABA);
cannam@127: 
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: 
cannam@127: #define LD LDu
cannam@127: #define ST STu
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #define STM2(x, v, ovs, a) ST(x, v, ovs, a)
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:   __m512i index = _mm512_set_epi32(15 * ovs, 14 * ovs,
cannam@127:                                    13 * ovs, 12 * ovs,
cannam@127:                                    11 * ovs, 10 * ovs,
cannam@127:                                    9 * ovs, 8 * ovs,
cannam@127:                                    7 * ovs, 6 * ovs,
cannam@127:                                    5 * ovs, 4 * ovs,
cannam@127:                                    3 * ovs, 2 * ovs,
cannam@127:                                    1 * ovs, 0 * ovs);
cannam@127:   
cannam@127:   _mm512_i32scatter_ps(x, index, v, _MM_SCALE_4);
cannam@127: }
cannam@127: #define STN4(x, v0, v1, v2, v3, ovs)  /* no-op */
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #if defined(KCVI_ST2_DOUBLE_USE_STN2) && KCVI_ST2_DOUBLE_USE_STN2
cannam@127: #define STM2(x, v, ovs, a) /* no-op */
cannam@127: static inline void STN2(R *x, V v0, V v1, INT ovs) {
cannam@127:   /*  we start
cannam@127:      AB CD EF GH -> *x (2 DBL), ovs between complex
cannam@127:      IJ KL MN OP -> *(x+2) (2DBL), ovs between complex
cannam@127:       and we want
cannam@127:      ABIJ  EFMN -> *x (4 DBL), 2 * ovs between complex pairs
cannam@127:       CDKL  GHOP -> *(x+ovs) (4DBL), 2 * ovs between complex pairs
cannam@127:   */
cannam@127:   V x00 = (V)_mm512_mask_permute4f128_epi32((__m512i)v0, 0xF0F0, (__m512i)v1, _MM_PERM_CDAB);
cannam@127:   V x01 = (V)_mm512_mask_permute4f128_epi32((__m512i)v1, 0x0F0F, (__m512i)v0, _MM_PERM_CDAB);
cannam@127:   _mm512_mask_packstorelo_pd(x + (0 * ovs) + 0, 0x000F, x00);
cannam@127: /*   _mm512_mask_packstorehi_pd(x + (0 * ovs) + 8, 0x000F, x00); */
cannam@127:   _mm512_mask_packstorelo_pd(x + (2 * ovs) + 0, 0x00F0, x00);
cannam@127: /*   _mm512_mask_packstorehi_pd(x + (2 * ovs) + 8, 0x00F0, x00); */
cannam@127:   _mm512_mask_packstorelo_pd(x + (1 * ovs) + 0, 0x000F, x01);
cannam@127: /*   _mm512_mask_packstorehi_pd(x + (1 * ovs) + 8, 0x000F, x01); */
cannam@127:   _mm512_mask_packstorelo_pd(x + (3 * ovs) + 0, 0x00F0, x01);
cannam@127: /*   _mm512_mask_packstorehi_pd(x + (3 * ovs) + 8, 0x00F0, x01); */
cannam@127: }
cannam@127: #else
cannam@127: #define STM2(x, v, ovs, a) ST(x, v, ovs, a)
cannam@127: #define STN2(x, v0, v1, ovs) /* nop */
cannam@127: #endif
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:   __m512i index = _mm512_set_epi32(0, 0, 0, 0, 0, 0, 0, 0,
cannam@127:                                    7 * ovs, 6 * ovs,
cannam@127:                                    5 * ovs, 4 * ovs,
cannam@127:                                    3 * ovs, 2 * ovs,
cannam@127:                                    1 * ovs, 0 * ovs);
cannam@127:   
cannam@127:   _mm512_i32loscatter_pd(x, index, v, _MM_SCALE_8);
cannam@127: }
cannam@127: #define STN4(x, v0, v1, v2, v3, ovs)  /* no-op */
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: 
cannam@127: static inline V VFMAI(V b, V c) {
cannam@127:   V mpmp = VLIT(SCAL(1.0), SCAL(-1.0));
cannam@127:   return SUFF(_mm512_fmadd)(mpmp, SUFF(_mm512_swizzle)(b, _MM_SWIZ_REG_CDAB), c);
cannam@127: }
cannam@127: 
cannam@127: static inline V VFNMSI(V b, V c) {
cannam@127:   V mpmp = VLIT(SCAL(1.0), SCAL(-1.0));
cannam@127:   return SUFF(_mm512_fnmadd)(mpmp, SUFF(_mm512_swizzle)(b, _MM_SWIZ_REG_CDAB), c);
cannam@127: }
cannam@127: 
cannam@127: static inline V VFMACONJ(V b, V c) {
cannam@127:   V pmpm = VLIT(SCAL(-1.0), SCAL(1.0));
cannam@127:   return SUFF(_mm512_fmadd)(pmpm, b, c);
cannam@127: }
cannam@127: 
cannam@127: static inline V VFMSCONJ(V b, V c) {
cannam@127:   V pmpm = VLIT(SCAL(-1.0), SCAL(1.0));
cannam@127:   return SUFF(_mm512_fmsub)(pmpm, b, c);
cannam@127: }
cannam@127: 
cannam@127: static inline V VFNMSCONJ(V b, V c) {
cannam@127:   V pmpm = VLIT(SCAL(-1.0), SCAL(1.0));
cannam@127:   return SUFF(_mm512_fnmadd)(pmpm, b, c);
cannam@127: }
cannam@127: 
cannam@127: static inline V VCONJ(V x)
cannam@127: {
cannam@127:      V pmpm = VLIT(SCAL(-0.0), SCAL(0.0));
cannam@127:      return (V)VXOR((__m512i)pmpm, (__m512i)x);
cannam@127: }
cannam@127: 
cannam@127: #ifdef FFTW_SINGLE
cannam@127: #if defined(KCVI_VBYI_SINGLE_USE_MUL) && KCVI_VBYI_SINGLE_USE_MUL
cannam@127: /* untested */
cannam@127: static inline V VBYI(V x)
cannam@127: {
cannam@127:   V mpmp = VLIT(SCAL(1.0), SCAL(-1.0));
cannam@127:   return _mm512_mul_ps(mpmp, _mm512_swizzle_ps(x, _MM_SWIZ_REG_CDAB));
cannam@127: }
cannam@127: #else
cannam@127: static inline V VBYI(V x)
cannam@127: {
cannam@127:      return FLIP_RI(VCONJ(x));
cannam@127: }
cannam@127: #endif
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: #if defined(KCVI_VBYI_DOUBLE_USE_MUL) && KCVI_VBYI_DOUBLE_USE_MUL
cannam@127: /* on KNF, using mul_pd is slower than shuf128x32 + xor */
cannam@127: static inline V VBYI(V x)
cannam@127: {
cannam@127:   V mpmp = VLIT(SCAL(1.0), SCAL(-1.0));
cannam@127:   return _mm512_mul_pd(mpmp, _mm512_swizzle_pd(x, _MM_SWIZ_REG_CDAB));
cannam@127: }
cannam@127: #else
cannam@127: static inline V VBYI(V x)
cannam@127: {
cannam@127:      return FLIP_RI(VCONJ(x));
cannam@127: }
cannam@127: #endif
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: 
cannam@127: #if defined(KCVI_MULZ_USE_SWIZZLE) && KCVI_MULZ_USE_SWIZZLE
cannam@127: static inline V VZMUL(V tx, V sr) /* (a,b) (c,d) */
cannam@127: {
cannam@127:   V ac = SUFF(_mm512_mul)(tx, sr); /* (a*c,b*d) */
cannam@127:   V ad = SUFF(_mm512_mul)(tx, SUFF(_mm512_swizzle)(sr, _MM_SWIZ_REG_CDAB)); /* (a*d,b*c) */
cannam@127:   V acmbd = SUFF(_mm512_sub)(ac, SUFF(_mm512_swizzle)(ac, _MM_SWIZ_REG_CDAB)); /* (a*c-b*d, b*d-a*c) */
cannam@127:   V res = SUFF(_mm512_mask_add)(acmbd, DS(0x00aa,0xaaaa), ad, SUFF(_mm512_swizzle)(ad, _MM_SWIZ_REG_CDAB)); /* ([a*c+b*c] a*c-b*d, b*c+a*d) */
cannam@127:   return res;
cannam@127: }
cannam@127: static inline V VZMULJ(V tx, V sr) /* (a,b) (c,d) */
cannam@127: {
cannam@127:   V ac = SUFF(_mm512_mul)(tx, sr); /* (a*c,b*d) */
cannam@127:   V ad = SUFF(_mm512_mul)(tx, SUFF(_mm512_swizzle)(sr, _MM_SWIZ_REG_CDAB)); /* (a*d,b*c) */
cannam@127:   V acmbd = SUFF(_mm512_add)(ac, SUFF(_mm512_swizzle)(ac, _MM_SWIZ_REG_CDAB)); /* (a*c+b*d, b*d+a*c) */
cannam@127:   V res = SUFF(_mm512_mask_subr)(acmbd, DS(0x00aa,0xaaaa), ad, SUFF(_mm512_swizzle)(ad, _MM_SWIZ_REG_CDAB)); /* ([a*c+b*c] a*c+b*d, a*d-b*c) */
cannam@127:   return res;
cannam@127: }
cannam@127: static inline V VZMULI(V tx, V sr) /* (a,b) (c,d) */
cannam@127: {
cannam@127:   DVK(zero, SCAL(0.0));
cannam@127:   V ac = SUFF(_mm512_mul)(tx, sr); /* (a*c,b*d) */
cannam@127:   V ad = SUFF(_mm512_fnmadd)(tx, SUFF(_mm512_swizzle)(sr, _MM_SWIZ_REG_CDAB), zero); /* (-a*d,-b*c) */
cannam@127:   V acmbd = SUFF(_mm512_subr)(ac, SUFF(_mm512_swizzle)(ac, _MM_SWIZ_REG_CDAB)); /* (b*d-a*c, a*c-b*d) */
cannam@127:   V res = SUFF(_mm512_mask_add)(acmbd, DS(0x0055,0x5555), ad, SUFF(_mm512_swizzle)(ad, _MM_SWIZ_REG_CDAB)); /*  (-a*d-b*c, a*c-b*d) */
cannam@127:   return res;
cannam@127: }
cannam@127: static inline V VZMULIJ(V tx, V sr) /* (a,b) (c,d) */
cannam@127: {
cannam@127:   DVK(zero, SCAL(0.0));
cannam@127:   V ac = SUFF(_mm512_mul)(tx, sr); /* (a*c,b*d) */
cannam@127:   V ad = SUFF(_mm512_fnmadd)(tx, SUFF(_mm512_swizzle)(sr, _MM_SWIZ_REG_CDAB), zero); /* (-a*d,-b*c) */
cannam@127:   V acmbd = SUFF(_mm512_add)(ac, SUFF(_mm512_swizzle)(ac, _MM_SWIZ_REG_CDAB)); /* (b*d+a*c, a*c+b*d) */
cannam@127:   V res = SUFF(_mm512_mask_sub)(acmbd, DS(0x0055,0x5555), ad, SUFF(_mm512_swizzle)(ad, _MM_SWIZ_REG_CDAB)); /*  (-a*d+b*c, a*c-b*d) */
cannam@127:   return res;
cannam@127: }
cannam@127: #else
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: #endif
cannam@127: 
cannam@127: /* twiddle storage #1: compact, slower */
cannam@127: #ifdef FFTW_SINGLE
cannam@127: # define VTW1(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}, {TW_CEXP, v+2, x}, {TW_CEXP, v+3, x}, {TW_CEXP, v+4, x}, {TW_CEXP, v+5, x}, {TW_CEXP, v+6, x}, {TW_CEXP, v+7, x}
cannam@127: #else /* !FFTW_SINGLE */
cannam@127: # define VTW1(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}, {TW_CEXP, v+2, x}, {TW_CEXP, v+3, x}
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: #define TWVL1 (VL)
cannam@127: 
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: 
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: 
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_COS, v+2,  x}, {TW_COS, v+2, x}, {TW_COS, v+3,  x}, {TW_COS, v+3, x}, \
cannam@127:    {TW_COS, v+4,  x}, {TW_COS, v+4, x}, {TW_COS, v+5,  x}, {TW_COS, v+5, x}, \
cannam@127:    {TW_COS, v+6,  x}, {TW_COS, v+6, x}, {TW_COS, v+7,  x}, {TW_COS, v+7, x}, \
cannam@127:    {TW_SIN, v  , -x}, {TW_SIN, v  , x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}, \
cannam@127:    {TW_SIN, v+2, -x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, -x}, {TW_SIN, v+3, x}, \
cannam@127:    {TW_SIN, v+4, -x}, {TW_SIN, v+4, x}, {TW_SIN, v+5, -x}, {TW_SIN, v+5, x}, \
cannam@127:    {TW_SIN, v+6, -x}, {TW_SIN, v+6, x}, {TW_SIN, v+7, -x}, {TW_SIN, v+7, x}
cannam@127: #else /* !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_COS, v+2,  x}, {TW_COS, v+2, x}, {TW_COS, v+3,  x}, {TW_COS, v+3, x}, \
cannam@127:    {TW_SIN, v  , -x}, {TW_SIN, v  , x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}, \
cannam@127:    {TW_SIN, v+2, -x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, -x}, {TW_SIN, v+3, x}
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: #define TWVL2 (2 * VL)
cannam@127: 
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: /*      V tr = LD(t, 2, t), ti = LD(t + VL, 2, t + VL); */
cannam@127:      return VFMA(tr, sr, VMUL(ti, si));
cannam@127: }
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: /*      V tr = LD(t, 2, t), ti = LD(t + VL, 2, t + VL); */
cannam@127:      return VFNMS(ti, si, VMUL(tr, sr));
cannam@127: }
cannam@127: 
cannam@127: /* twiddle storage #3 */
cannam@127: #define VTW3(v,x) VTW1(v,x)
cannam@127: #define TWVL3 TWVL1
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_COS, v+4 , x}, {TW_COS, v+5 , x}, {TW_COS, v+6 , x}, {TW_COS, v+7 , x}, \
cannam@127:   {TW_COS, v+8 , x}, {TW_COS, v+9 , x}, {TW_COS, v+10, x}, {TW_COS, v+11, x}, \
cannam@127:   {TW_COS, v+12, x}, {TW_COS, v+13, x}, {TW_COS, v+14, x}, {TW_COS, v+15, x}, \
cannam@127:   {TW_SIN, v   , x}, {TW_SIN, v+1 , x}, {TW_SIN, v+2 , x}, {TW_SIN, v+3 , x}, \
cannam@127:   {TW_SIN, v+4 , x}, {TW_SIN, v+5 , x}, {TW_SIN, v+6 , x}, {TW_SIN, v+7 , x}, \
cannam@127:   {TW_SIN, v+8 , x}, {TW_SIN, v+9 , x}, {TW_SIN, v+10, x}, {TW_SIN, v+11, x}, \
cannam@127:   {TW_SIN, v+12, x}, {TW_SIN, v+13, x}, {TW_SIN, v+14, x}, {TW_SIN, v+15, x}
cannam@127: #else /* !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_COS, v+4, x}, {TW_COS, v+5, x}, {TW_COS, v+6, x}, {TW_COS, v+7, x}, \
cannam@127:   {TW_SIN, v  , x}, {TW_SIN, v+1, x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, x}, \
cannam@127:   {TW_SIN, v+4, x}, {TW_SIN, v+5, x}, {TW_SIN, v+6, x}, {TW_SIN, v+7, x}
cannam@127: #endif /* FFTW_SINGLE */
cannam@127: #define TWVLS (2 * VL)
cannam@127: 
cannam@127: #define VLEAVE() /* nothing */
cannam@127: 
cannam@127: #include "simd-common.h"