Mercurial > hg > sv-dependency-builds

comparison src/fftw-3.3.3/dft/simd/common/t1bv_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:39:04 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 t1bv_12 -include t1b.h -sign 1 */
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 "t1b.h"
36
37 static void t1bv_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 = ii;
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 TI, Ti, TA, T7, Tm, TE, Tw, Tk, Tf, TB, TU, TM;
47 {
48 V T9, TK, Tj, TL, Te;
49 {
50 V T1, T4, T2, Tp, Tt, Tr;
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 Tp = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));
55 Tt = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));
56 Tr = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));
57 {
58 V T5, T3, Tq, Tu, Ts, 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 = BYTW(&(W[TWVL * 14]), T4);
63 T3 = BYTW(&(W[TWVL * 6]), T2);
64 Tq = BYTW(&(W[TWVL * 16]), Tp);
65 Tu = BYTW(&(W[TWVL * 8]), Tt);
66 Ts = BYTW(&(W[0]), Tr);
67 T9 = BYTW(&(W[TWVL * 10]), T8);
68 Td = BYTW(&(W[TWVL * 2]), Tc);
69 Tb = BYTW(&(W[TWVL * 18]), Ta);
70 {
71 V Th, T6, Tl, Tv;
72 Th = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));
73 TK = VSUB(T3, T5);
74 T6 = VADD(T3, T5);
75 Tl = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));
76 Tv = VADD(Ts, Tu);
77 TI = VSUB(Tu, Ts);
78 Tj = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));
79 TL = VSUB(Tb, Td);
80 Te = VADD(Tb, Td);
81 Ti = BYTW(&(W[TWVL * 4]), Th);
82 TA = VFNMS(LDK(KP500000000), T6, T1);
83 T7 = VADD(T1, T6);
84 Tm = BYTW(&(W[TWVL * 20]), Tl);
85 TE = VFNMS(LDK(KP500000000), Tv, Tq);
86 Tw = VADD(Tq, Tv);
87 }
88 }
89 }
90 Tk = BYTW(&(W[TWVL * 12]), Tj);
91 Tf = VADD(T9, Te);
92 TB = VFNMS(LDK(KP500000000), Te, T9);
93 TU = VSUB(TK, TL);
94 TM = VADD(TK, TL);
95 }
96 {
97 V Tn, TH, TC, TQ, Ty, Tg;
98 Tn = VADD(Tk, Tm);
99 TH = VSUB(Tk, Tm);
100 TC = VADD(TA, TB);
101 TQ = VSUB(TA, TB);
102 Ty = VADD(T7, Tf);
103 Tg = VSUB(T7, Tf);
104 {
105 V To, TD, TJ, TR;
106 To = VADD(Ti, Tn);
107 TD = VFNMS(LDK(KP500000000), Tn, Ti);
108 TJ = VSUB(TH, TI);
109 TR = VADD(TH, TI);
110 {
111 V TP, TN, TW, TS, TO, TG, TX, TV;
112 {
113 V Tz, Tx, TF, TT;
114 Tz = VADD(To, Tw);
115 Tx = VSUB(To, Tw);
116 TF = VADD(TD, TE);
117 TT = VSUB(TD, TE);
118 TP = VMUL(LDK(KP866025403), VADD(TM, TJ));
119 TN = VMUL(LDK(KP866025403), VSUB(TJ, TM));
120 TW = VFMA(LDK(KP866025403), TR, TQ);
121 TS = VFNMS(LDK(KP866025403), TR, TQ);
122 ST(&(x[WS(rs, 6)]), VSUB(Ty, Tz), ms, &(x[0]));
123 ST(&(x[0]), VADD(Ty, Tz), ms, &(x[0]));
124 ST(&(x[WS(rs, 9)]), VFMAI(Tx, Tg), ms, &(x[WS(rs, 1)]));
125 ST(&(x[WS(rs, 3)]), VFNMSI(Tx, Tg), ms, &(x[WS(rs, 1)]));
126 TO = VADD(TC, TF);
127 TG = VSUB(TC, TF);
128 TX = VFNMS(LDK(KP866025403), TU, TT);
129 TV = VFMA(LDK(KP866025403), TU, TT);
130 }
131 ST(&(x[WS(rs, 8)]), VFNMSI(TP, TO), ms, &(x[0]));
132 ST(&(x[WS(rs, 4)]), VFMAI(TP, TO), ms, &(x[0]));
133 ST(&(x[WS(rs, 2)]), VFMAI(TN, TG), ms, &(x[0]));
134 ST(&(x[WS(rs, 10)]), VFNMSI(TN, TG), ms, &(x[0]));
135 ST(&(x[WS(rs, 5)]), VFMAI(TX, TW), ms, &(x[WS(rs, 1)]));
136 ST(&(x[WS(rs, 7)]), VFNMSI(TX, TW), ms, &(x[WS(rs, 1)]));
137 ST(&(x[WS(rs, 11)]), VFNMSI(TV, TS), ms, &(x[WS(rs, 1)]));
138 ST(&(x[WS(rs, 1)]), VFMAI(TV, 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("t1bv_12"), twinstr, &GENUS, {41, 24, 18, 0}, 0, 0, 0 };
163
164 void XSIMD(codelet_t1bv_12) (planner *p) {
165 X(kdft_dit_register) (p, t1bv_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 t1bv_12 -include t1b.h -sign 1 */
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 "t1b.h"
177
178 static void t1bv_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 = ii;
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, Tt, T6, T7, TB, Tq, TC, TD, T9, Tu, Te, Tf, Tx, Tl, Ty;
188 V Tz;
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 = BYTW(&(W[TWVL * 14]), T4);
194 T2 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));
195 T3 = BYTW(&(W[TWVL * 6]), T2);
196 Tt = VSUB(T3, T5);
197 T6 = VADD(T3, T5);
198 T7 = VFNMS(LDK(KP500000000), T6, T1);
199 }
200 {
201 V Tn, Tp, Tm, TA, To;
202 Tm = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));
203 Tn = BYTW(&(W[0]), Tm);
204 TA = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));
205 TB = BYTW(&(W[TWVL * 16]), TA);
206 To = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));
207 Tp = BYTW(&(W[TWVL * 8]), To);
208 Tq = VSUB(Tn, Tp);
209 TC = VADD(Tn, Tp);
210 TD = VFNMS(LDK(KP500000000), TC, TB);
211 }
212 {
213 V Td, Tb, T8, Tc, Ta;
214 T8 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));
215 T9 = BYTW(&(W[TWVL * 10]), T8);
216 Tc = LD(&(x[WS(rs, 2)]), ms, &(x[0]));
217 Td = BYTW(&(W[TWVL * 2]), Tc);
218 Ta = LD(&(x[WS(rs, 10)]), ms, &(x[0]));
219 Tb = BYTW(&(W[TWVL * 18]), Ta);
220 Tu = VSUB(Tb, Td);
221 Te = VADD(Tb, Td);
222 Tf = VFNMS(LDK(KP500000000), Te, T9);
223 }
224 {
225 V Ti, Tk, Th, Tw, Tj;
226 Th = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));
227 Ti = BYTW(&(W[TWVL * 12]), Th);
228 Tw = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));
229 Tx = BYTW(&(W[TWVL * 4]), Tw);
230 Tj = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));
231 Tk = BYTW(&(W[TWVL * 20]), Tj);
232 Tl = VSUB(Ti, Tk);
233 Ty = VADD(Ti, Tk);
234 Tz = VFNMS(LDK(KP500000000), Ty, Tx);
235 }
236 {
237 V Ts, TG, TF, TH;
238 {
239 V Tg, Tr, Tv, TE;
240 Tg = VSUB(T7, Tf);
241 Tr = VMUL(LDK(KP866025403), VSUB(Tl, Tq));
242 Ts = VSUB(Tg, Tr);
243 TG = VADD(Tg, Tr);
244 Tv = VMUL(LDK(KP866025403), VSUB(Tt, Tu));
245 TE = VSUB(Tz, TD);
246 TF = VBYI(VADD(Tv, TE));
247 TH = VBYI(VSUB(TE, Tv));
248 }
249 ST(&(x[WS(rs, 11)]), VSUB(Ts, TF), ms, &(x[WS(rs, 1)]));
250 ST(&(x[WS(rs, 5)]), VADD(TG, TH), ms, &(x[WS(rs, 1)]));
251 ST(&(x[WS(rs, 1)]), VADD(Ts, TF), ms, &(x[WS(rs, 1)]));
252 ST(&(x[WS(rs, 7)]), VSUB(TG, TH), ms, &(x[WS(rs, 1)]));
253 }
254 {
255 V TS, TW, TV, TX;
256 {
257 V TQ, TR, TT, TU;
258 TQ = VADD(T1, T6);
259 TR = VADD(T9, Te);
260 TS = VSUB(TQ, TR);
261 TW = VADD(TQ, TR);
262 TT = VADD(Tx, Ty);
263 TU = VADD(TB, TC);
264 TV = VBYI(VSUB(TT, TU));
265 TX = VADD(TT, TU);
266 }
267 ST(&(x[WS(rs, 3)]), VSUB(TS, TV), ms, &(x[WS(rs, 1)]));
268 ST(&(x[0]), VADD(TW, TX), ms, &(x[0]));
269 ST(&(x[WS(rs, 9)]), VADD(TS, TV), ms, &(x[WS(rs, 1)]));
270 ST(&(x[WS(rs, 6)]), VSUB(TW, TX), ms, &(x[0]));
271 }
272 {
273 V TK, TO, TN, TP;
274 {
275 V TI, TJ, TL, TM;
276 TI = VADD(Tl, Tq);
277 TJ = VADD(Tt, Tu);
278 TK = VBYI(VMUL(LDK(KP866025403), VSUB(TI, TJ)));
279 TO = VBYI(VMUL(LDK(KP866025403), VADD(TJ, TI)));
280 TL = VADD(T7, Tf);
281 TM = VADD(Tz, TD);
282 TN = VSUB(TL, TM);
283 TP = VADD(TL, TM);
284 }
285 ST(&(x[WS(rs, 2)]), VADD(TK, TN), ms, &(x[0]));
286 ST(&(x[WS(rs, 8)]), VSUB(TP, TO), ms, &(x[0]));
287 ST(&(x[WS(rs, 10)]), VSUB(TN, TK), ms, &(x[0]));
288 ST(&(x[WS(rs, 4)]), VADD(TO, TP), ms, &(x[0]));
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("t1bv_12"), twinstr, &GENUS, {55, 26, 4, 0}, 0, 0, 0 };
311
312 void XSIMD(codelet_t1bv_12) (planner *p) {
313 X(kdft_dit_register) (p, t1bv_12, &desc);
314 }
315 #endif /* HAVE_FMA */