/fftw-3.3/dft/simd/common/n2bv_12.c

https://github.com/triciatricia/SIMPLE · C · 301 lines · 253 code · 15 blank · 33 comment · 2 complexity · 6f7f36e00183a9f3a3cc6a6a68447424 MD5 · raw file 

    

  1. /*
    2. 

  2.  * Copyright (c) 2003, 2007-11 Matteo Frigo
    3. 

  3.  * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
    4. 

  4.  *
    5. 

  5.  * This program is free software; you can redistribute it and/or modify
    6. 

  6.  * it under the terms of the GNU General Public License as published by
    7. 

  7.  * the Free Software Foundation; either version 2 of the License, or
    8. 

  8.  * (at your option) any later version.
    9. 

  9.  *
    10. 

  10.  * This program is distributed in the hope that it will be useful,
    11. 

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. 

  13.  * GNU General Public License for more details.
    14. 

  14.  *
    15. 

  15.  * You should have received a copy of the GNU General Public License
    16. 

  16.  * along with this program; if not, write to the Free Software
    17. 

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    18. 

  18.  *
    19. 

  19.  */
    20. 

  20. 

  21. /* This file was automatically generated --- DO NOT EDIT */
    22. 

  22. /* Generated on Wed Jul 27 06:14:02 EDT 2011 */
    23. 

  23. 

  24. #include "codelet-dft.h"
    25. 

  25. 

  26. #ifdef HAVE_FMA
    27. 

  27. 

  28. /* Generated by: ../../../genfft/gen_notw_c.native -fma -reorder-insns -schedule-for-pipeline -simd -compact -variables 4 -pipeline-latency 8 -sign 1 -n 12 -name n2bv_12 -with-ostride 2 -include n2b.h -store-multiple 2 */
    29. 

  29. 

  30. /*
    31. 

  31.  * This function contains 48 FP additions, 20 FP multiplications,
    32. 

  32.  * (or, 30 additions, 2 multiplications, 18 fused multiply/add),
    33. 

  33.  * 61 stack variables, 2 constants, and 30 memory accesses
    34. 

  34.  */
    35. 

  35. #include "n2b.h"
    36. 

  36. 

  37. static void n2bv_12(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs)
    38. 

  38. {
    39. 

  39.      DVK(KP866025403, +0.866025403784438646763723170752936183471402627);
    40. 

  40.      DVK(KP500000000, +0.500000000000000000000000000000000000000000000);
    41. 

  41.      {
    42. 

  42. 	  INT i;
    43. 

  43. 	  const R *xi;
    44. 

  44. 	  R *xo;
    45. 

  45. 	  xi = ii;
    46. 

  46. 	  xo = io;
    47. 

  47. 	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {
    48. 

  48. 	       V T1, T6, Tc, Th, Td, Te, Ti, Tz, T4, TA, T9, Tj, Tf, Tw;
    49. 

  49. 	       {
    50. 

  50. 		    V T2, T3, T7, T8;
    51. 

  51. 		    T1 = LD(&(xi[0]), ivs, &(xi[0]));
    52. 

  52. 		    T6 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));
    53. 

  53. 		    T2 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));
    54. 

  54. 		    T3 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));
    55. 

  55. 		    T7 = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));
    56. 

  56. 		    T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));
    57. 

  57. 		    Tc = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));
    58. 

  58. 		    Th = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));
    59. 

  59. 		    Td = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));
    60. 

  60. 		    Te = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));
    61. 

  61. 		    Ti = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));
    62. 

  62. 		    Tz = VSUB(T2, T3);
    63. 

  63. 		    T4 = VADD(T2, T3);
    64. 

  64. 		    TA = VSUB(T7, T8);
    65. 

  65. 		    T9 = VADD(T7, T8);
    66. 

  66. 		    Tj = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));
    67. 

  67. 	       }
    68. 

  68. 	       Tf = VADD(Td, Te);
    69. 

  69. 	       Tw = VSUB(Td, Te);
    70. 

  70. 	       {
    71. 

  71. 		    V T5, Tp, TJ, TB, Ta, Tq, Tk, Tx, Tg, Ts;
    72. 

  72. 		    T5 = VADD(T1, T4);
    73. 

  73. 		    Tp = VFNMS(LDK(KP500000000), T4, T1);
    74. 

  74. 		    TJ = VSUB(Tz, TA);
    75. 

  75. 		    TB = VADD(Tz, TA);
    76. 

  76. 		    Ta = VADD(T6, T9);
    77. 

  77. 		    Tq = VFNMS(LDK(KP500000000), T9, T6);
    78. 

  78. 		    Tk = VADD(Ti, Tj);
    79. 

  79. 		    Tx = VSUB(Tj, Ti);
    80. 

  80. 		    Tg = VADD(Tc, Tf);
    81. 

  81. 		    Ts = VFNMS(LDK(KP500000000), Tf, Tc);
    82. 

  82. 		    {
    83. 

  83. 			 V Tr, TF, Tb, Tn, TG, Ty, Tl, Tt;
    84. 

  84. 			 Tr = VADD(Tp, Tq);
    85. 

  85. 			 TF = VSUB(Tp, Tq);
    86. 

  86. 			 Tb = VSUB(T5, Ta);
    87. 

  87. 			 Tn = VADD(T5, Ta);
    88. 

  88. 			 TG = VADD(Tw, Tx);
    89. 

  89. 			 Ty = VSUB(Tw, Tx);
    90. 

  90. 			 Tl = VADD(Th, Tk);
    91. 

  91. 			 Tt = VFNMS(LDK(KP500000000), Tk, Th);
    92. 

  92. 			 {
    93. 

  93. 			      V TC, TE, TH, TL, Tu, TI, Tm, To;
    94. 

  94. 			      TC = VMUL(LDK(KP866025403), VSUB(Ty, TB));
    95. 

  95. 			      TE = VMUL(LDK(KP866025403), VADD(TB, Ty));
    96. 

  96. 			      TH = VFNMS(LDK(KP866025403), TG, TF);
    97. 

  97. 			      TL = VFMA(LDK(KP866025403), TG, TF);
    98. 

  98. 			      Tu = VADD(Ts, Tt);
    99. 

  99. 			      TI = VSUB(Ts, Tt);
    100. 

  100. 			      Tm = VSUB(Tg, Tl);
    101. 

  101. 			      To = VADD(Tg, Tl);
    102. 

  102. 			      {
    103. 

  103. 				   V TK, TM, Tv, TD;
    104. 

  104. 				   TK = VFMA(LDK(KP866025403), TJ, TI);
    105. 

  105. 				   TM = VFNMS(LDK(KP866025403), TJ, TI);
    106. 

  106. 				   Tv = VSUB(Tr, Tu);
    107. 

  107. 				   TD = VADD(Tr, Tu);
    108. 

  108. 				   {
    109. 

  109. 					V TN, TO, TP, TQ;
    110. 

  110. 					TN = VADD(Tn, To);
    111. 

  111. 					STM2(&(xo[0]), TN, ovs, &(xo[0]));
    112. 

  112. 					TO = VSUB(Tn, To);
    113. 

  113. 					STM2(&(xo[12]), TO, ovs, &(xo[0]));
    114. 

  114. 					TP = VFMAI(Tm, Tb);
    115. 

  115. 					STM2(&(xo[18]), TP, ovs, &(xo[2]));
    116. 

  116. 					TQ = VFNMSI(Tm, Tb);
    117. 

  117. 					STM2(&(xo[6]), TQ, ovs, &(xo[2]));
    118. 

  118. 					{
    119. 

  119. 					     V TR, TS, TT, TU;
    120. 

  120. 					     TR = VFMAI(TM, TL);
    121. 

  121. 					     STM2(&(xo[10]), TR, ovs, &(xo[2]));
    122. 

  122. 					     TS = VFNMSI(TM, TL);
    123. 

  123. 					     STM2(&(xo[14]), TS, ovs, &(xo[2]));
    124. 

  124. 					     STN2(&(xo[12]), TO, TS, ovs);
    125. 

  125. 					     TT = VFNMSI(TK, TH);
    126. 

  126. 					     STM2(&(xo[22]), TT, ovs, &(xo[2]));
    127. 

  127. 					     TU = VFMAI(TK, TH);
    128. 

  128. 					     STM2(&(xo[2]), TU, ovs, &(xo[2]));
    129. 

  129. 					     STN2(&(xo[0]), TN, TU, ovs);
    130. 

  130. 					     {
    131. 

  131. 						  V TV, TW, TX, TY;
    132. 

  132. 						  TV = VFNMSI(TE, TD);
    133. 

  133. 						  STM2(&(xo[16]), TV, ovs, &(xo[0]));
    134. 

  134. 						  STN2(&(xo[16]), TV, TP, ovs);
    135. 

  135. 						  TW = VFMAI(TE, TD);
    136. 

  136. 						  STM2(&(xo[8]), TW, ovs, &(xo[0]));
    137. 

  137. 						  STN2(&(xo[8]), TW, TR, ovs);
    138. 

  138. 						  TX = VFMAI(TC, Tv);
    139. 

  139. 						  STM2(&(xo[4]), TX, ovs, &(xo[0]));
    140. 

  140. 						  STN2(&(xo[4]), TX, TQ, ovs);
    141. 

  141. 						  TY = VFNMSI(TC, Tv);
    142. 

  142. 						  STM2(&(xo[20]), TY, ovs, &(xo[0]));
    143. 

  143. 						  STN2(&(xo[20]), TY, TT, ovs);
    144. 

  144. 					     }
    145. 

  145. 					}
    146. 

  146. 				   }
    147. 

  147. 			      }
    148. 

  148. 			 }
    149. 

  149. 		    }
    150. 

  150. 	       }
    151. 

  151. 	  }
    152. 

  152.      }
    153. 

  153.      VLEAVE();
    154. 

  154. }
    155. 

  155. 

  156. static const kdft_desc desc = { 12, XSIMD_STRING("n2bv_12"), {30, 2, 18, 0}, &GENUS, 0, 2, 0, 0 };
    157. 

  157. 

  158. void XSIMD(codelet_n2bv_12) (planner *p) {
    159. 

  159.      X(kdft_register) (p, n2bv_12, &desc);
    160. 

  160. }
    161. 

  161. 

  162. #else				/* HAVE_FMA */
    163. 

  163. 

  164. /* Generated by: ../../../genfft/gen_notw_c.native -simd -compact -variables 4 -pipeline-latency 8 -sign 1 -n 12 -name n2bv_12 -with-ostride 2 -include n2b.h -store-multiple 2 */
    165. 

  165. 

  166. /*
    167. 

  167.  * This function contains 48 FP additions, 8 FP multiplications,
    168. 

  168.  * (or, 44 additions, 4 multiplications, 4 fused multiply/add),
    169. 

  169.  * 33 stack variables, 2 constants, and 30 memory accesses
    170. 

  170.  */
    171. 

  171. #include "n2b.h"
    172. 

  172. 

  173. static void n2bv_12(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs)
    174. 

  174. {
    175. 

  175.      DVK(KP866025403, +0.866025403784438646763723170752936183471402627);
    176. 

  176.      DVK(KP500000000, +0.500000000000000000000000000000000000000000000);
    177. 

  177.      {
    178. 

  178. 	  INT i;
    179. 

  179. 	  const R *xi;
    180. 

  180. 	  R *xo;
    181. 

  181. 	  xi = ii;
    182. 

  182. 	  xo = io;
    183. 

  183. 	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {
    184. 

  184. 	       V T5, Ta, TG, TF, Ty, Tm, Ti, Tp, TJ, TI, Tx, Ts;
    185. 

  185. 	       {
    186. 

  186. 		    V T1, T6, T4, Tk, T9, Tl;
    187. 

  187. 		    T1 = LD(&(xi[0]), ivs, &(xi[0]));
    188. 

  188. 		    T6 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));
    189. 

  189. 		    {
    190. 

  190. 			 V T2, T3, T7, T8;
    191. 

  191. 			 T2 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));
    192. 

  192. 			 T3 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));
    193. 

  193. 			 T4 = VADD(T2, T3);
    194. 

  194. 			 Tk = VSUB(T2, T3);
    195. 

  195. 			 T7 = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));
    196. 

  196. 			 T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));
    197. 

  197. 			 T9 = VADD(T7, T8);
    198. 

  198. 			 Tl = VSUB(T7, T8);
    199. 

  199. 		    }
    200. 

  200. 		    T5 = VFNMS(LDK(KP500000000), T4, T1);
    201. 

  201. 		    Ta = VFNMS(LDK(KP500000000), T9, T6);
    202. 

  202. 		    TG = VADD(T6, T9);
    203. 

  203. 		    TF = VADD(T1, T4);
    204. 

  204. 		    Ty = VADD(Tk, Tl);
    205. 

  205. 		    Tm = VMUL(LDK(KP866025403), VSUB(Tk, Tl));
    206. 

  206. 	       }
    207. 

  207. 	       {
    208. 

  208. 		    V Tn, Tq, Te, To, Th, Tr;
    209. 

  209. 		    Tn = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));
    210. 

  210. 		    Tq = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));
    211. 

  211. 		    {
    212. 

  212. 			 V Tc, Td, Tf, Tg;
    213. 

  213. 			 Tc = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));
    214. 

  214. 			 Td = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));
    215. 

  215. 			 Te = VSUB(Tc, Td);
    216. 

  216. 			 To = VADD(Tc, Td);
    217. 

  217. 			 Tf = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));
    218. 

  218. 			 Tg = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));
    219. 

  219. 			 Th = VSUB(Tf, Tg);
    220. 

  220. 			 Tr = VADD(Tf, Tg);
    221. 

  221. 		    }
    222. 

  222. 		    Ti = VMUL(LDK(KP866025403), VSUB(Te, Th));
    223. 

  223. 		    Tp = VFNMS(LDK(KP500000000), To, Tn);
    224. 

  224. 		    TJ = VADD(Tq, Tr);
    225. 

  225. 		    TI = VADD(Tn, To);
    226. 

  226. 		    Tx = VADD(Te, Th);
    227. 

  227. 		    Ts = VFNMS(LDK(KP500000000), Tr, Tq);
    228. 

  228. 	       }
    229. 

  229. 	       {
    230. 

  230. 		    V TN, TO, TP, TQ, TR, TS;
    231. 

  231. 		    {
    232. 

  232. 			 V TH, TK, TL, TM;
    233. 

  233. 			 TH = VSUB(TF, TG);
    234. 

  234. 			 TK = VBYI(VSUB(TI, TJ));
    235. 

  235. 			 TN = VSUB(TH, TK);
    236. 

  236. 			 STM2(&(xo[6]), TN, ovs, &(xo[2]));
    237. 

  237. 			 TO = VADD(TH, TK);
    238. 

  238. 			 STM2(&(xo[18]), TO, ovs, &(xo[2]));
    239. 

  239. 			 TL = VADD(TF, TG);
    240. 

  240. 			 TM = VADD(TI, TJ);
    241. 

  241. 			 TP = VSUB(TL, TM);
    242. 

  242. 			 STM2(&(xo[12]), TP, ovs, &(xo[0]));
    243. 

  243. 			 TQ = VADD(TL, TM);
    244. 

  244. 			 STM2(&(xo[0]), TQ, ovs, &(xo[0]));
    245. 

  245. 		    }
    246. 

  246. 		    {
    247. 

  247. 			 V Tj, Tv, Tu, Tw, Tb, Tt, TT, TU;
    248. 

  248. 			 Tb = VSUB(T5, Ta);
    249. 

  249. 			 Tj = VSUB(Tb, Ti);
    250. 

  250. 			 Tv = VADD(Tb, Ti);
    251. 

  251. 			 Tt = VSUB(Tp, Ts);
    252. 

  252. 			 Tu = VBYI(VADD(Tm, Tt));
    253. 

  253. 			 Tw = VBYI(VSUB(Tt, Tm));
    254. 

  254. 			 TR = VSUB(Tj, Tu);
    255. 

  255. 			 STM2(&(xo[22]), TR, ovs, &(xo[2]));
    256. 

  256. 			 TS = VADD(Tv, Tw);
    257. 

  257. 			 STM2(&(xo[10]), TS, ovs, &(xo[2]));
    258. 

  258. 			 TT = VADD(Tj, Tu);
    259. 

  259. 			 STM2(&(xo[2]), TT, ovs, &(xo[2]));
    260. 

  260. 			 STN2(&(xo[0]), TQ, TT, ovs);
    261. 

  261. 			 TU = VSUB(Tv, Tw);
    262. 

  262. 			 STM2(&(xo[14]), TU, ovs, &(xo[2]));
    263. 

  263. 			 STN2(&(xo[12]), TP, TU, ovs);
    264. 

  264. 		    }
    265. 

  265. 		    {
    266. 

  266. 			 V Tz, TD, TC, TE, TA, TB;
    267. 

  267. 			 Tz = VBYI(VMUL(LDK(KP866025403), VSUB(Tx, Ty)));
    268. 

  268. 			 TD = VBYI(VMUL(LDK(KP866025403), VADD(Ty, Tx)));
    269. 

  269. 			 TA = VADD(T5, Ta);
    270. 

  270. 			 TB = VADD(Tp, Ts);
    271. 

  271. 			 TC = VSUB(TA, TB);
    272. 

  272. 			 TE = VADD(TA, TB);
    273. 

  273. 			 {
    274. 

  274. 			      V TV, TW, TX, TY;
    275. 

  275. 			      TV = VADD(Tz, TC);
    276. 

  276. 			      STM2(&(xo[4]), TV, ovs, &(xo[0]));
    277. 

  277. 			      STN2(&(xo[4]), TV, TN, ovs);
    278. 

  278. 			      TW = VSUB(TE, TD);
    279. 

  279. 			      STM2(&(xo[16]), TW, ovs, &(xo[0]));
    280. 

  280. 			      STN2(&(xo[16]), TW, TO, ovs);
    281. 

  281. 			      TX = VSUB(TC, Tz);
    282. 

  282. 			      STM2(&(xo[20]), TX, ovs, &(xo[0]));
    283. 

  283. 			      STN2(&(xo[20]), TX, TR, ovs);
    284. 

  284. 			      TY = VADD(TD, TE);
    285. 

  285. 			      STM2(&(xo[8]), TY, ovs, &(xo[0]));
    286. 

  286. 			      STN2(&(xo[8]), TY, TS, ovs);
    287. 

  287. 			 }
    288. 

  288. 		    }
    289. 

  289. 	       }
    290. 

  290. 	  }
    291. 

  291.      }
    292. 

  292.      VLEAVE();
    293. 

  293. }
    294. 

  294. 

  295. static const kdft_desc desc = { 12, XSIMD_STRING("n2bv_12"), {44, 4, 4, 0}, &GENUS, 0, 2, 0, 0 };
    296. 

  296. 

  297. void XSIMD(codelet_n2bv_12) (planner *p) {
    298. 

  298.      X(kdft_register) (p, n2bv_12, &desc);
    299. 

  299. }
    300. 

  300. 

  301. #endif				/* HAVE_FMA */
    302.