← Back to branch summary

~ubuntu-branches/ubuntu/raring/fftw3/raring-proposed

« back to all changes in this revision

Viewing changes to dft/simd/codelets/t1bv_8.c

  • Committer: Bazaar Package Importer
  • Author(s): Paul Brossier
  • Date: 2006-05-31 13:44:05 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060531134405-ol9hrbg6bh81sg0c
Tags: 3.1.1-1
http://bugs.debian.org/350327
http://bugs.debian.org/338487
http://bugs.debian.org/338501
* New upstream release (closes: #350327, #338487, #338501)
* Add --enable-portable-binary to use -mtune instead of -march
* Use --with-gcc-arch=G5 / pentium4 on powerpc / i386
* Updated Standards-Version

Show diffs side-by-side

added added

removed removed

Lines of Context:
dft/simd/codelets/t1bv_8.c
1
1
/*
2
 
 * Copyright (c) 2003 Matteo Frigo
3
 
 * Copyright (c) 2003 Massachusetts Institute of Technology
 
2
 * Copyright (c) 2003, 2006 Matteo Frigo
 
3
 * Copyright (c) 2003, 2006 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
19
19
 */
20
20
 
21
21
/* This file was automatically generated --- DO NOT EDIT */
22
 
/* Generated on Sat Jul  5 21:43:43 EDT 2003 */
 
22
/* Generated on Tue Mar  7 10:20:30 EST 2006 */
23
23
 
24
24
#include "codelet-dft.h"
25
25
 
26
 
/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_twiddle_c -simd -compact -variables 4 -n 8 -name t1bv_8 -include t1b.h -sign 1 */
 
26
#ifdef HAVE_FMA
 
27
 
 
28
/* Generated by: ../../../genfft/gen_twiddle_c -fma -reorder-insns -schedule-for-pipeline -simd -compact -variables 4 -pipeline-latency 8 -n 8 -name t1bv_8 -include t1b.h -sign 1 */
 
29
 
 
30
/*
 
31
 * This function contains 33 FP additions, 24 FP multiplications,
 
32
 * (or, 23 additions, 14 multiplications, 10 fused multiply/add),
 
33
 * 36 stack variables, and 16 memory accesses
 
34
 */
 
35
/*
 
36
 * Generator Id's : 
 
37
 * $Id: algsimp.ml,v 1.9 2006-02-12 23:34:12 athena Exp $
 
38
 * $Id: fft.ml,v 1.4 2006-01-05 03:04:27 stevenj Exp $
 
39
 * $Id: gen_twiddle_c.ml,v 1.14 2006-02-12 23:34:12 athena Exp $
 
40
 */
 
41
 
 
42
#include "t1b.h"
 
43
 
 
44
static const R *t1bv_8(R *ri, R *ii, const R *W, stride ios, INT m, INT dist)
 
45
{
 
46
     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);
 
47
     INT i;
 
48
     R *x;
 
49
     x = ii;
 
50
     for (i = m; i > 0; i = i - VL, x = x + (VL * dist), W = W + (TWVL * 14), MAKE_VOLATILE_STRIDE(ios)) {
 
51
          V T1, T2, Th, Tj, T5, T7, Ta, Tc;
 
52
          T1 = LD(&(x[0]), dist, &(x[0]));
 
53
          T2 = LD(&(x[WS(ios, 4)]), dist, &(x[0]));
 
54
          Th = LD(&(x[WS(ios, 2)]), dist, &(x[0]));
 
55
          Tj = LD(&(x[WS(ios, 6)]), dist, &(x[0]));
 
56
          T5 = LD(&(x[WS(ios, 1)]), dist, &(x[WS(ios, 1)]));
 
57
          T7 = LD(&(x[WS(ios, 5)]), dist, &(x[WS(ios, 1)]));
 
58
          Ta = LD(&(x[WS(ios, 7)]), dist, &(x[WS(ios, 1)]));
 
59
          Tc = LD(&(x[WS(ios, 3)]), dist, &(x[WS(ios, 1)]));
 
60
          {
 
61
               V T3, Ti, Tk, T6, T8, Tb, Td;
 
62
               T3 = BYTW(&(W[TWVL * 6]), T2);
 
63
               Ti = BYTW(&(W[TWVL * 2]), Th);
 
64
               Tk = BYTW(&(W[TWVL * 10]), Tj);
 
65
               T6 = BYTW(&(W[0]), T5);
 
66
               T8 = BYTW(&(W[TWVL * 8]), T7);
 
67
               Tb = BYTW(&(W[TWVL * 12]), Ta);
 
68
               Td = BYTW(&(W[TWVL * 4]), Tc);
 
69
               {
 
70
                    V Tq, T4, Tr, Tl, Tt, T9, Tu, Te, Tw, Ts;
 
71
                    Tq = VADD(T1, T3);
 
72
                    T4 = VSUB(T1, T3);
 
73
                    Tr = VADD(Ti, Tk);
 
74
                    Tl = VSUB(Ti, Tk);
 
75
                    Tt = VADD(T6, T8);
 
76
                    T9 = VSUB(T6, T8);
 
77
                    Tu = VADD(Tb, Td);
 
78
                    Te = VSUB(Tb, Td);
 
79
                    Tw = VADD(Tq, Tr);
 
80
                    Ts = VSUB(Tq, Tr);
 
81
                    {
 
82
                         V Tx, Tv, Tm, Tf;
 
83
                         Tx = VADD(Tt, Tu);
 
84
                         Tv = VSUB(Tt, Tu);
 
85
                         Tm = VSUB(T9, Te);
 
86
                         Tf = VADD(T9, Te);
 
87
                         {
 
88
                              V Tp, Tn, To, Tg;
 
89
                              ST(&(x[0]), VADD(Tw, Tx), dist, &(x[0]));
 
90
                              ST(&(x[WS(ios, 4)]), VSUB(Tw, Tx), dist, &(x[0]));
 
91
                              ST(&(x[WS(ios, 2)]), VFMAI(Tv, Ts), dist, &(x[0]));
 
92
                              ST(&(x[WS(ios, 6)]), VFNMSI(Tv, Ts), dist, &(x[0]));
 
93
                              Tp = VFMA(LDK(KP707106781), Tm, Tl);
 
94
                              Tn = VFNMS(LDK(KP707106781), Tm, Tl);
 
95
                              To = VFMA(LDK(KP707106781), Tf, T4);
 
96
                              Tg = VFNMS(LDK(KP707106781), Tf, T4);
 
97
                              ST(&(x[WS(ios, 1)]), VFMAI(Tp, To), dist, &(x[WS(ios, 1)]));
 
98
                              ST(&(x[WS(ios, 7)]), VFNMSI(Tp, To), dist, &(x[WS(ios, 1)]));
 
99
                              ST(&(x[WS(ios, 5)]), VFMAI(Tn, Tg), dist, &(x[WS(ios, 1)]));
 
100
                              ST(&(x[WS(ios, 3)]), VFNMSI(Tn, Tg), dist, &(x[WS(ios, 1)]));
 
101
                         }
 
102
                    }
 
103
               }
 
104
          }
 
105
     }
 
106
     return W;
 
107
}
 
108
 
 
109
static const tw_instr twinstr[] = {
 
110
     VTW(1),
 
111
     VTW(2),
 
112
     VTW(3),
 
113
     VTW(4),
 
114
     VTW(5),
 
115
     VTW(6),
 
116
     VTW(7),
 
117
     {TW_NEXT, VL, 0}
 
118
};
 
119
 
 
120
static const ct_desc desc = { 8, "t1bv_8", twinstr, &GENUS, {23, 14, 10, 0}, 0, 0, 0 };
 
121
 
 
122
void X(codelet_t1bv_8) (planner *p) {
 
123
     X(kdft_dit_register) (p, t1bv_8, &desc);
 
124
}
 
125
#else                           /* HAVE_FMA */
 
126
 
 
127
/* Generated by: ../../../genfft/gen_twiddle_c -simd -compact -variables 4 -pipeline-latency 8 -n 8 -name t1bv_8 -include t1b.h -sign 1 */
27
128
 
28
129
/*
29
130
 * This function contains 33 FP additions, 16 FP multiplications,
32
133
 */
33
134
/*
34
135
 * Generator Id's : 
35
 
 * $Id: algsimp.ml,v 1.7 2003/03/15 20:29:42 stevenj Exp $
36
 
 * $Id: fft.ml,v 1.2 2003/03/15 20:29:42 stevenj Exp $
37
 
 * $Id: gen_twiddle_c.ml,v 1.7 2003/04/16 19:51:27 athena Exp $
 
136
 * $Id: algsimp.ml,v 1.9 2006-02-12 23:34:12 athena Exp $
 
137
 * $Id: fft.ml,v 1.4 2006-01-05 03:04:27 stevenj Exp $
 
138
 * $Id: gen_twiddle_c.ml,v 1.14 2006-02-12 23:34:12 athena Exp $
38
139
 */
39
140
 
40
141
#include "t1b.h"
41
142
 
42
 
static const R *t1bv_8(R *ri, R *ii, const R *W, stride ios, int m, int dist)
 
143
static const R *t1bv_8(R *ri, R *ii, const R *W, stride ios, INT m, INT dist)
43
144
{
44
145
     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);
45
 
     int i;
 
146
     INT i;
46
147
     R *x;
47
148
     x = ii;
48
 
     BEGIN_SIMD();
49
 
     for (i = m; i > 0; i = i - VL, x = x + (VL * dist), W = W + (TWVL * 14)) {
 
149
     for (i = m; i > 0; i = i - VL, x = x + (VL * dist), W = W + (TWVL * 14), MAKE_VOLATILE_STRIDE(ios)) {
50
150
          V Tl, Tq, Tg, Tr, T5, Tt, Ta, Tu, Ti, Tk, Tj;
51
151
          Ti = LD(&(x[0]), dist, &(x[0]));
52
152
          Tj = LD(&(x[WS(ios, 4)]), dist, &(x[0]));
105
205
               }
106
206
          }
107
207
     }
108
 
     END_SIMD();
109
208
     return W;
110
209
}
111
210
 
120
219
     {TW_NEXT, VL, 0}
121
220
};
122
221
 
123
 
static const ct_desc desc = { 8, "t1bv_8", twinstr, {33, 16, 0, 0}, &GENUS, 0, 0, 0 };
 
222
static const ct_desc desc = { 8, "t1bv_8", twinstr, &GENUS, {33, 16, 0, 0}, 0, 0, 0 };
124
223
 
125
224
void X(codelet_t1bv_8) (planner *p) {
126
225
     X(kdft_dit_register) (p, t1bv_8, &desc);
127
226
}
 
227
#endif                          /* HAVE_FMA */