Mercurial > hg > sv-dependency-builds

comparison src/fftw-3.3.3/dft/simd/common/t1fv_12.c @ 10:37bf6b4a2645

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add FFTW3
author Chris Cannam
date Wed, 20 Mar 2013 15:35:50 +0000
parents
children
comparison
equal deleted inserted replaced
9:c0fb53affa76 10:37bf6b4a2645
1 /*
2 * Copyright (c) 2003, 2007-11 Matteo Frigo
3 * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 */
20
21 /* This file was automatically generated --- DO NOT EDIT */
22 /* Generated on Sun Nov 25 07:38:03 EST 2012 */
23
24 #include "codelet-dft.h"
25
26 #ifdef HAVE_FMA
27
28 /* Generated by: ../../../genfft/gen_twiddle_c.native -fma -reorder-insns -schedule-for-pipeline -simd -compact -variables 4 -pipeline-latency 8 -n 12 -name t1fv_12 -include t1f.h */
29
30 /*
31 * This function contains 59 FP additions, 42 FP multiplications,
32 * (or, 41 additions, 24 multiplications, 18 fused multiply/add),
33 * 41 stack variables, 2 constants, and 24 memory accesses
34 */
35 #include "t1f.h"
36
37 static void t1fv_12(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms)
38 {
39 DVK(KP866025403, +0.866025403784438646763723170752936183471402627);
40 DVK(KP500000000, +0.500000000000000000000000000000000000000000000);
41 {
42 INT m;
43 R *x;
44 x = ri;
45 for (m = mb, W = W + (mb * ((TWVL / VL) * 22)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 22), MAKE_VOLATILE_STRIDE(12, rs)) {
46 V Tq, Ti, T7, TQ, Tu, TA, TU, Tk, TR, Tf, TE, TM;
47 {
48 V T9, TC, Tj, TD, Te;
49 {
50 V T1, T4, T2, Tm, Tx, To;
51 T1 = LD(&(x[0]), ms, &(x[0]));
52 T4 = LD(&(x[WS(rs, 8)]), ms, &(x[0]));
53 T2 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));
54 Tm = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));
55 Tx = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));
56 To = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));
57 {
58 V T5, T3, Tn, Ty, Tp, Td, Tb, T8, Tc, Ta;
59 T8 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));
60 Tc = LD(&(x[WS(rs, 2)]), ms, &(x[0]));
61 Ta = LD(&(x[WS(rs, 10)]), ms, &(x[0]));
62 T5 = BYTWJ(&(W[TWVL * 14]), T4);
63 T3 = BYTWJ(&(W[TWVL * 6]), T2);
64 Tn = BYTWJ(&(W[0]), Tm);
65 Ty = BYTWJ(&(W[TWVL * 16]), Tx);
66 Tp = BYTWJ(&(W[TWVL * 8]), To);
67 T9 = BYTWJ(&(W[TWVL * 10]), T8);
68 Td = BYTWJ(&(W[TWVL * 2]), Tc);
69 Tb = BYTWJ(&(W[TWVL * 18]), Ta);
70 {
71 V Th, T6, Tt, Tz;
72 Th = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));
73 TC = VSUB(T5, T3);
74 T6 = VADD(T3, T5);
75 Tt = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));
76 Tz = VADD(Tn, Tp);
77 Tq = VSUB(Tn, Tp);
78 Tj = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));
79 TD = VSUB(Td, Tb);
80 Te = VADD(Tb, Td);
81 Ti = BYTWJ(&(W[TWVL * 20]), Th);
82 T7 = VFNMS(LDK(KP500000000), T6, T1);
83 TQ = VADD(T1, T6);
84 Tu = BYTWJ(&(W[TWVL * 4]), Tt);
85 TA = VFNMS(LDK(KP500000000), Tz, Ty);
86 TU = VADD(Ty, Tz);
87 }
88 }
89 }
90 Tk = BYTWJ(&(W[TWVL * 12]), Tj);
91 TR = VADD(T9, Te);
92 Tf = VFNMS(LDK(KP500000000), Te, T9);
93 TE = VSUB(TC, TD);
94 TM = VADD(TC, TD);
95 }
96 {
97 V Tv, Tl, TI, Tg, TW, TS;
98 Tv = VADD(Tk, Ti);
99 Tl = VSUB(Ti, Tk);
100 TI = VADD(T7, Tf);
101 Tg = VSUB(T7, Tf);
102 TW = VADD(TQ, TR);
103 TS = VSUB(TQ, TR);
104 {
105 V TT, Tw, TL, Tr;
106 TT = VADD(Tu, Tv);
107 Tw = VFNMS(LDK(KP500000000), Tv, Tu);
108 TL = VSUB(Tl, Tq);
109 Tr = VADD(Tl, Tq);
110 {
111 V TP, TN, TG, Ts, TO, TK, TH, TF;
112 {
113 V TX, TV, TJ, TB;
114 TX = VADD(TT, TU);
115 TV = VSUB(TT, TU);
116 TJ = VADD(Tw, TA);
117 TB = VSUB(Tw, TA);
118 TP = VMUL(LDK(KP866025403), VADD(TM, TL));
119 TN = VMUL(LDK(KP866025403), VSUB(TL, TM));
120 TG = VFNMS(LDK(KP866025403), Tr, Tg);
121 Ts = VFMA(LDK(KP866025403), Tr, Tg);
122 ST(&(x[WS(rs, 6)]), VSUB(TW, TX), ms, &(x[0]));
123 ST(&(x[0]), VADD(TW, TX), ms, &(x[0]));
124 ST(&(x[WS(rs, 3)]), VFMAI(TV, TS), ms, &(x[WS(rs, 1)]));
125 ST(&(x[WS(rs, 9)]), VFNMSI(TV, TS), ms, &(x[WS(rs, 1)]));
126 TO = VADD(TI, TJ);
127 TK = VSUB(TI, TJ);
128 TH = VFMA(LDK(KP866025403), TE, TB);
129 TF = VFNMS(LDK(KP866025403), TE, TB);
130 }
131 ST(&(x[WS(rs, 4)]), VFMAI(TP, TO), ms, &(x[0]));
132 ST(&(x[WS(rs, 8)]), VFNMSI(TP, TO), ms, &(x[0]));
133 ST(&(x[WS(rs, 10)]), VFNMSI(TN, TK), ms, &(x[0]));
134 ST(&(x[WS(rs, 2)]), VFMAI(TN, TK), ms, &(x[0]));
135 ST(&(x[WS(rs, 5)]), VFNMSI(TH, TG), ms, &(x[WS(rs, 1)]));
136 ST(&(x[WS(rs, 7)]), VFMAI(TH, TG), ms, &(x[WS(rs, 1)]));
137 ST(&(x[WS(rs, 11)]), VFMAI(TF, Ts), ms, &(x[WS(rs, 1)]));
138 ST(&(x[WS(rs, 1)]), VFNMSI(TF, Ts), ms, &(x[WS(rs, 1)]));
139 }
140 }
141 }
142 }
143 }
144 VLEAVE();
145 }
146
147 static const tw_instr twinstr[] = {
148 VTW(0, 1),
149 VTW(0, 2),
150 VTW(0, 3),
151 VTW(0, 4),
152 VTW(0, 5),
153 VTW(0, 6),
154 VTW(0, 7),
155 VTW(0, 8),
156 VTW(0, 9),
157 VTW(0, 10),
158 VTW(0, 11),
159 {TW_NEXT, VL, 0}
160 };
161
162 static const ct_desc desc = { 12, XSIMD_STRING("t1fv_12"), twinstr, &GENUS, {41, 24, 18, 0}, 0, 0, 0 };
163
164 void XSIMD(codelet_t1fv_12) (planner *p) {
165 X(kdft_dit_register) (p, t1fv_12, &desc);
166 }
167 #else /* HAVE_FMA */
168
169 /* Generated by: ../../../genfft/gen_twiddle_c.native -simd -compact -variables 4 -pipeline-latency 8 -n 12 -name t1fv_12 -include t1f.h */
170
171 /*
172 * This function contains 59 FP additions, 30 FP multiplications,
173 * (or, 55 additions, 26 multiplications, 4 fused multiply/add),
174 * 28 stack variables, 2 constants, and 24 memory accesses
175 */
176 #include "t1f.h"
177
178 static void t1fv_12(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms)
179 {
180 DVK(KP866025403, +0.866025403784438646763723170752936183471402627);
181 DVK(KP500000000, +0.500000000000000000000000000000000000000000000);
182 {
183 INT m;
184 R *x;
185 x = ri;
186 for (m = mb, W = W + (mb * ((TWVL / VL) * 22)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 22), MAKE_VOLATILE_STRIDE(12, rs)) {
187 V T1, TH, T6, TA, Tq, TE, Tv, TL, T9, TI, Te, TB, Ti, TD, Tn;
188 V TK;
189 {
190 V T5, T3, T4, T2;
191 T1 = LD(&(x[0]), ms, &(x[0]));
192 T4 = LD(&(x[WS(rs, 8)]), ms, &(x[0]));
193 T5 = BYTWJ(&(W[TWVL * 14]), T4);
194 T2 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));
195 T3 = BYTWJ(&(W[TWVL * 6]), T2);
196 TH = VSUB(T5, T3);
197 T6 = VADD(T3, T5);
198 TA = VFNMS(LDK(KP500000000), T6, T1);
199 }
200 {
201 V Tu, Ts, Tp, Tt, Tr;
202 Tp = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));
203 Tq = BYTWJ(&(W[TWVL * 16]), Tp);
204 Tt = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));
205 Tu = BYTWJ(&(W[TWVL * 8]), Tt);
206 Tr = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));
207 Ts = BYTWJ(&(W[0]), Tr);
208 TE = VSUB(Tu, Ts);
209 Tv = VADD(Ts, Tu);
210 TL = VFNMS(LDK(KP500000000), Tv, Tq);
211 }
212 {
213 V Td, Tb, T8, Tc, Ta;
214 T8 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));
215 T9 = BYTWJ(&(W[TWVL * 10]), T8);
216 Tc = LD(&(x[WS(rs, 2)]), ms, &(x[0]));
217 Td = BYTWJ(&(W[TWVL * 2]), Tc);
218 Ta = LD(&(x[WS(rs, 10)]), ms, &(x[0]));
219 Tb = BYTWJ(&(W[TWVL * 18]), Ta);
220 TI = VSUB(Td, Tb);
221 Te = VADD(Tb, Td);
222 TB = VFNMS(LDK(KP500000000), Te, T9);
223 }
224 {
225 V Tm, Tk, Th, Tl, Tj;
226 Th = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));
227 Ti = BYTWJ(&(W[TWVL * 4]), Th);
228 Tl = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));
229 Tm = BYTWJ(&(W[TWVL * 20]), Tl);
230 Tj = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));
231 Tk = BYTWJ(&(W[TWVL * 12]), Tj);
232 TD = VSUB(Tm, Tk);
233 Tn = VADD(Tk, Tm);
234 TK = VFNMS(LDK(KP500000000), Tn, Ti);
235 }
236 {
237 V Tg, Ty, Tx, Tz;
238 {
239 V T7, Tf, To, Tw;
240 T7 = VADD(T1, T6);
241 Tf = VADD(T9, Te);
242 Tg = VSUB(T7, Tf);
243 Ty = VADD(T7, Tf);
244 To = VADD(Ti, Tn);
245 Tw = VADD(Tq, Tv);
246 Tx = VBYI(VSUB(To, Tw));
247 Tz = VADD(To, Tw);
248 }
249 ST(&(x[WS(rs, 9)]), VSUB(Tg, Tx), ms, &(x[WS(rs, 1)]));
250 ST(&(x[0]), VADD(Ty, Tz), ms, &(x[0]));
251 ST(&(x[WS(rs, 3)]), VADD(Tg, Tx), ms, &(x[WS(rs, 1)]));
252 ST(&(x[WS(rs, 6)]), VSUB(Ty, Tz), ms, &(x[0]));
253 }
254 {
255 V TS, TW, TV, TX;
256 {
257 V TQ, TR, TT, TU;
258 TQ = VADD(TA, TB);
259 TR = VADD(TK, TL);
260 TS = VSUB(TQ, TR);
261 TW = VADD(TQ, TR);
262 TT = VADD(TD, TE);
263 TU = VADD(TH, TI);
264 TV = VBYI(VMUL(LDK(KP866025403), VSUB(TT, TU)));
265 TX = VBYI(VMUL(LDK(KP866025403), VADD(TU, TT)));
266 }
267 ST(&(x[WS(rs, 10)]), VSUB(TS, TV), ms, &(x[0]));
268 ST(&(x[WS(rs, 4)]), VADD(TW, TX), ms, &(x[0]));
269 ST(&(x[WS(rs, 2)]), VADD(TS, TV), ms, &(x[0]));
270 ST(&(x[WS(rs, 8)]), VSUB(TW, TX), ms, &(x[0]));
271 }
272 {
273 V TG, TP, TN, TO;
274 {
275 V TC, TF, TJ, TM;
276 TC = VSUB(TA, TB);
277 TF = VMUL(LDK(KP866025403), VSUB(TD, TE));
278 TG = VSUB(TC, TF);
279 TP = VADD(TC, TF);
280 TJ = VMUL(LDK(KP866025403), VSUB(TH, TI));
281 TM = VSUB(TK, TL);
282 TN = VBYI(VADD(TJ, TM));
283 TO = VBYI(VSUB(TJ, TM));
284 }
285 ST(&(x[WS(rs, 5)]), VSUB(TG, TN), ms, &(x[WS(rs, 1)]));
286 ST(&(x[WS(rs, 11)]), VSUB(TP, TO), ms, &(x[WS(rs, 1)]));
287 ST(&(x[WS(rs, 7)]), VADD(TN, TG), ms, &(x[WS(rs, 1)]));
288 ST(&(x[WS(rs, 1)]), VADD(TO, TP), ms, &(x[WS(rs, 1)]));
289 }
290 }
291 }
292 VLEAVE();
293 }
294
295 static const tw_instr twinstr[] = {
296 VTW(0, 1),
297 VTW(0, 2),
298 VTW(0, 3),
299 VTW(0, 4),
300 VTW(0, 5),
301 VTW(0, 6),
302 VTW(0, 7),
303 VTW(0, 8),
304 VTW(0, 9),
305 VTW(0, 10),
306 VTW(0, 11),
307 {TW_NEXT, VL, 0}
308 };
309
310 static const ct_desc desc = { 12, XSIMD_STRING("t1fv_12"), twinstr, &GENUS, {55, 26, 4, 0}, 0, 0, 0 };
311
312 void XSIMD(codelet_t1fv_12) (planner *p) {
313 X(kdft_dit_register) (p, t1fv_12, &desc);
314 }
315 #endif /* HAVE_FMA */