Mercurial > hg > sv-dependency-builds

comparison src/fftw-3.3.3/rdft/scalar/r2cf/hc2cfdft_4.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:40:44 EST 2012 */
23
24 #include "codelet-rdft.h"
25
26 #ifdef HAVE_FMA
27
28 /* Generated by: ../../../genfft/gen_hc2cdft.native -fma -reorder-insns -schedule-for-pipeline -compact -variables 4 -pipeline-latency 4 -n 4 -dit -name hc2cfdft_4 -include hc2cf.h */
29
30 /*
31 * This function contains 30 FP additions, 20 FP multiplications,
32 * (or, 24 additions, 14 multiplications, 6 fused multiply/add),
33 * 32 stack variables, 1 constants, and 16 memory accesses
34 */
35 #include "hc2cf.h"
36
37 static void hc2cfdft_4(R *Rp, R *Ip, R *Rm, R *Im, const R *W, stride rs, INT mb, INT me, INT ms)
38 {
39 DK(KP500000000, +0.500000000000000000000000000000000000000000000);
40 {
41 INT m;
42 for (m = mb, W = W + ((mb - 1) * 6); m < me; m = m + 1, Rp = Rp + ms, Ip = Ip + ms, Rm = Rm - ms, Im = Im - ms, W = W + 6, MAKE_VOLATILE_STRIDE(16, rs)) {
43 E Td, Tu, Tr, T4, Tm, To, T9, T5, TA, Tp, Tv, TD, T6, Tq;
44 {
45 E Tk, Tl, Tf, TC, Tj, T7, T8, T1, Tn, Tb, Tc;
46 Tb = Ip[0];
47 Tc = Im[0];
48 {
49 E Ti, Tg, Th, T2, T3;
50 Tg = Rm[0];
51 Th = Rp[0];
52 Tk = W[1];
53 Tl = Tb + Tc;
54 Td = Tb - Tc;
55 Tu = Th + Tg;
56 Ti = Tg - Th;
57 Tf = W[0];
58 T2 = Ip[WS(rs, 1)];
59 T3 = Im[WS(rs, 1)];
60 TC = Tk * Ti;
61 Tj = Tf * Ti;
62 T7 = Rp[WS(rs, 1)];
63 Tr = T2 + T3;
64 T4 = T2 - T3;
65 T8 = Rm[WS(rs, 1)];
66 T1 = W[2];
67 Tn = W[4];
68 }
69 Tm = FNMS(Tk, Tl, Tj);
70 To = T7 - T8;
71 T9 = T7 + T8;
72 T5 = T1 * T4;
73 TA = Tn * Tr;
74 Tp = Tn * To;
75 Tv = T1 * T9;
76 TD = FMA(Tf, Tl, TC);
77 T6 = W[3];
78 Tq = W[5];
79 }
80 {
81 E Tw, Ta, TB, Ts;
82 Tw = FMA(T6, T4, Tv);
83 Ta = FNMS(T6, T9, T5);
84 TB = FNMS(Tq, To, TA);
85 Ts = FMA(Tq, Tr, Tp);
86 {
87 E TF, Tx, Te, Tz;
88 TF = Tu + Tw;
89 Tx = Tu - Tw;
90 Te = Ta + Td;
91 Tz = Td - Ta;
92 {
93 E TG, TE, Tt, Ty;
94 TG = TB + TD;
95 TE = TB - TD;
96 Tt = Tm - Ts;
97 Ty = Ts + Tm;
98 Im[0] = KP500000000 * (TE - Tz);
99 Ip[WS(rs, 1)] = KP500000000 * (Tz + TE);
100 Rp[0] = KP500000000 * (TF + TG);
101 Rm[WS(rs, 1)] = KP500000000 * (TF - TG);
102 Rp[WS(rs, 1)] = KP500000000 * (Tx + Ty);
103 Rm[0] = KP500000000 * (Tx - Ty);
104 Im[WS(rs, 1)] = KP500000000 * (Tt - Te);
105 Ip[0] = KP500000000 * (Te + Tt);
106 }
107 }
108 }
109 }
110 }
111 }
112
113 static const tw_instr twinstr[] = {
114 {TW_FULL, 1, 4},
115 {TW_NEXT, 1, 0}
116 };
117
118 static const hc2c_desc desc = { 4, "hc2cfdft_4", twinstr, &GENUS, {24, 14, 6, 0} };
119
120 void X(codelet_hc2cfdft_4) (planner *p) {
121 X(khc2c_register) (p, hc2cfdft_4, &desc, HC2C_VIA_DFT);
122 }
123 #else /* HAVE_FMA */
124
125 /* Generated by: ../../../genfft/gen_hc2cdft.native -compact -variables 4 -pipeline-latency 4 -n 4 -dit -name hc2cfdft_4 -include hc2cf.h */
126
127 /*
128 * This function contains 30 FP additions, 20 FP multiplications,
129 * (or, 24 additions, 14 multiplications, 6 fused multiply/add),
130 * 18 stack variables, 1 constants, and 16 memory accesses
131 */
132 #include "hc2cf.h"
133
134 static void hc2cfdft_4(R *Rp, R *Ip, R *Rm, R *Im, const R *W, stride rs, INT mb, INT me, INT ms)
135 {
136 DK(KP500000000, +0.500000000000000000000000000000000000000000000);
137 {
138 INT m;
139 for (m = mb, W = W + ((mb - 1) * 6); m < me; m = m + 1, Rp = Rp + ms, Ip = Ip + ms, Rm = Rm - ms, Im = Im - ms, W = W + 6, MAKE_VOLATILE_STRIDE(16, rs)) {
140 E Tc, Tr, Tk, Tx, T9, Ts, Tp, Tw;
141 {
142 E Ta, Tb, Tj, Tf, Tg, Th, Te, Ti;
143 Ta = Ip[0];
144 Tb = Im[0];
145 Tj = Ta + Tb;
146 Tf = Rm[0];
147 Tg = Rp[0];
148 Th = Tf - Tg;
149 Tc = Ta - Tb;
150 Tr = Tg + Tf;
151 Te = W[0];
152 Ti = W[1];
153 Tk = FNMS(Ti, Tj, Te * Th);
154 Tx = FMA(Ti, Th, Te * Tj);
155 }
156 {
157 E T4, To, T8, Tm;
158 {
159 E T2, T3, T6, T7;
160 T2 = Ip[WS(rs, 1)];
161 T3 = Im[WS(rs, 1)];
162 T4 = T2 - T3;
163 To = T2 + T3;
164 T6 = Rp[WS(rs, 1)];
165 T7 = Rm[WS(rs, 1)];
166 T8 = T6 + T7;
167 Tm = T6 - T7;
168 }
169 {
170 E T1, T5, Tl, Tn;
171 T1 = W[2];
172 T5 = W[3];
173 T9 = FNMS(T5, T8, T1 * T4);
174 Ts = FMA(T1, T8, T5 * T4);
175 Tl = W[4];
176 Tn = W[5];
177 Tp = FMA(Tl, Tm, Tn * To);
178 Tw = FNMS(Tn, Tm, Tl * To);
179 }
180 }
181 {
182 E Td, Tq, Tz, TA;
183 Td = T9 + Tc;
184 Tq = Tk - Tp;
185 Ip[0] = KP500000000 * (Td + Tq);
186 Im[WS(rs, 1)] = KP500000000 * (Tq - Td);
187 Tz = Tr + Ts;
188 TA = Tw + Tx;
189 Rm[WS(rs, 1)] = KP500000000 * (Tz - TA);
190 Rp[0] = KP500000000 * (Tz + TA);
191 }
192 {
193 E Tt, Tu, Tv, Ty;
194 Tt = Tr - Ts;
195 Tu = Tp + Tk;
196 Rm[0] = KP500000000 * (Tt - Tu);
197 Rp[WS(rs, 1)] = KP500000000 * (Tt + Tu);
198 Tv = Tc - T9;
199 Ty = Tw - Tx;
200 Ip[WS(rs, 1)] = KP500000000 * (Tv + Ty);
201 Im[0] = KP500000000 * (Ty - Tv);
202 }
203 }
204 }
205 }
206
207 static const tw_instr twinstr[] = {
208 {TW_FULL, 1, 4},
209 {TW_NEXT, 1, 0}
210 };
211
212 static const hc2c_desc desc = { 4, "hc2cfdft_4", twinstr, &GENUS, {24, 14, 6, 0} };
213
214 void X(codelet_hc2cfdft_4) (planner *p) {
215 X(khc2c_register) (p, hc2cfdft_4, &desc, HC2C_VIA_DFT);
216 }
217 #endif /* HAVE_FMA */