← Back to branch summary

~ubuntu-branches/ubuntu/quantal/fftw/quantal

« back to all changes in this revision

Viewing changes to cilk/executor_cilk.cilk

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2011-11-29 01:48:33 UTC
  • mfrom: (5.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20111129014833-3leawsns2nghyaoj
Tags: 2.1.5-1
http://bugs.debian.org/571446
http://bugs.debian.org/633175
* Team upload.
* New upstream release
* Package moved into the Debian Science team (no answer from the previous
  maintainer) and package not maintained.
* Standards-Version updated to version 3.9.2
* Vcs-Browser & Vcs-Svn updated
* Switch to mpi-default-dev (Closes: #571446)
* Get ride of .la files (Closes: #633175)
* Fix lintian warning debhelper-but-no-misc-depends
* Fix lintian warning patch-system-but-direct-changes-in-diff 
* Switch to dpkg-source 3.0 (quilt) format

Show diffs side-by-side

added added

removed removed

Lines of Context:
cilk/executor_cilk.cilk
1
1
/*
2
 
 * Copyright (c) 1997-1999 Massachusetts Institute of Technology
 
2
 * Copyright (c) 1997-1999, 2003 Massachusetts Institute of Technology
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License as published by
29
29
#include "fftw_cilk.cilkh"
30
30
 
31
31
static cilk void parallel_twiddle_codelet(int a, int b,
32
 
                                          fftw_twiddle_codelet *codelet,
33
 
                                          fftw_complex *W,
34
 
                                          fftw_complex *out,
35
 
                                          int ostride,
36
 
                                          int dist,
37
 
                                          int ntwiddle)
 
32
          fftw_twiddle_codelet *codelet,
 
33
          fftw_complex *W,
 
34
          fftw_complex *out,
 
35
          int ostride,
 
36
          int dist,
 
37
          int ntwiddle)
38
38
{
39
39
     if (b - a < 32) {
40
 
          (*codelet)(out + dist * a, W + ntwiddle * a, ostride, b - a, dist);
 
40
          (*codelet)(out + dist * a, W + ntwiddle * a, ostride, b - a, dist);
41
41
     } else {
42
 
          int ab = (a + b) / 2;
43
 
          spawn parallel_twiddle_codelet(a, ab, codelet, W, out, ostride,
44
 
                                         dist, ntwiddle);
45
 
          spawn parallel_twiddle_codelet(ab, b, codelet, W, out, ostride,
46
 
                                         dist, ntwiddle);
47
 
          sync;
 
42
          int ab = (a + b) / 2;
 
43
          spawn parallel_twiddle_codelet(a, ab, codelet, W, out, ostride,
 
44
                                         dist, ntwiddle);
 
45
          spawn parallel_twiddle_codelet(ab, b, codelet, W, out, ostride,
 
46
                                         dist, ntwiddle);
 
47
          sync;
48
48
     }
49
49
}
50
50
 
51
51
static cilk void executor_simple_cilk(int n, const fftw_complex *in,
52
 
                                      fftw_complex *out,
53
 
                                      fftw_plan_node *p,
54
 
                                      int istride,
55
 
                                      int ostride)
 
52
                                      fftw_complex *out,
 
53
                                      fftw_plan_node *p,
 
54
                                      int istride,
 
55
                                      int ostride)
56
56
{
57
57
     switch (p->type) {
58
 
         case FFTW_NOTW:
59
 
              (*p->nodeu.notw.codelet)(in, out, istride, ostride);
60
 
              break;
61
 
 
62
 
         case FFTW_TWIDDLE:
63
 
              {
64
 
                   int r = p->nodeu.twiddle.size;
65
 
                   int m = n / r;
66
 
                   int i;
67
 
                   fftw_twiddle_codelet *codelet;
68
 
                   fftw_complex *W;
69
 
 
70
 
                   if (n < 128) {
71
 
                        fftw_executor_simple(n, in, out, p,
72
 
                                             istride, ostride);
73
 
                        break;
74
 
                   }
75
 
 
76
 
                   for (i = 0; i < r; ++i)
77
 
                        spawn executor_simple_cilk(m, in + i * istride,
78
 
                                                   out + i * (m * ostride),
79
 
                                                   p->nodeu.twiddle.recurse,
80
 
                                                   istride * r, ostride);
81
 
                        
82
 
                   sync;
83
 
                   codelet = p->nodeu.twiddle.codelet;
84
 
                   W = p->nodeu.twiddle.tw->twarray;
85
 
 
86
 
                   spawn parallel_twiddle_codelet(0, m,
87
 
                                                  codelet, 
88
 
                                                  W, out, m * ostride,
89
 
                                                  ostride,
90
 
                                      p->nodeu.twiddle.codelet_desc->ntwiddle);
91
 
                   sync;
92
 
 
93
 
                   break;
94
 
              }
95
 
 
96
 
         case FFTW_GENERIC:
97
 
              {
98
 
                   int r = p->nodeu.generic.size;
99
 
                   int m = n / r;
100
 
                   int i;
101
 
                   fftw_generic_codelet *codelet;
102
 
                   fftw_complex *W;
103
 
 
104
 
                   for (i = 0; i < r; ++i)
105
 
                        spawn executor_simple_cilk(m, in + i * istride,
106
 
                                                   out + i * (m * ostride),
107
 
                                                   p->nodeu.generic.recurse,
108
 
                                                   istride * r, ostride);
109
 
                                                   
110
 
                   sync;
111
 
 
112
 
                   codelet = p->nodeu.generic.codelet;
113
 
                   W = p->nodeu.generic.tw->twarray;
114
 
 
115
 
                   (*codelet)(out, W, m, r, n, ostride);
116
 
 
117
 
                   break;
118
 
              }
119
 
 
120
 
         case FFTW_RADER:
121
 
              {
122
 
                   int r = p->nodeu.rader.size;
123
 
                   int m = n / r;
124
 
                   int i;
125
 
                   fftw_rader_codelet *codelet;
126
 
                   fftw_complex *W;
127
 
 
128
 
                   for (i = 0; i < r; ++i) {
129
 
                        spawn executor_simple_cilk(m, in + i * istride,
130
 
                                             out + i * (m * ostride),
131
 
                                             p->nodeu.rader.recurse,
132
 
                                             istride * r, ostride);
133
 
                   }
134
 
                   sync;
135
 
 
136
 
                   codelet = p->nodeu.rader.codelet;
137
 
                   W = p->nodeu.rader.tw->twarray;
138
 
                   (*codelet)(out, W, m, r, ostride,
139
 
                              p->nodeu.rader.rader_data);
140
 
 
141
 
                   break;
142
 
              }
143
 
 
144
 
         default:
145
 
              fftw_die("BUG in executor: illegal plan\n");
146
 
              break;
 
58
     case FFTW_NOTW:
 
59
          (*p->nodeu.notw.codelet)(in, out, istride, ostride);
 
60
          break;
 
61
 
 
62
     case FFTW_TWIDDLE:
 
63
          {
 
64
               int r = p->nodeu.twiddle.size;
 
65
               int m = n / r;
 
66
               int i;
 
67
               fftw_twiddle_codelet *codelet;
 
68
               fftw_complex *W;
 
69
 
 
70
               if (n < 128) {
 
71
                    fftw_executor_simple(n, in, out, p,
 
72
                                         istride, ostride,
 
73
                                         FFTW_NORMAL_RECURSE);
 
74
                    break;
 
75
               }
 
76
 
 
77
               for (i = 0; i < r; ++i)
 
78
                    spawn executor_simple_cilk(m, in + i * istride,
 
79
                                               out + i * (m * ostride),
 
80
                                               p->nodeu.twiddle.recurse,
 
81
                                               istride * r, ostride);
 
82
 
 
83
               sync;
 
84
               codelet = p->nodeu.twiddle.codelet;
 
85
               W = p->nodeu.twiddle.tw->twarray;
 
86
 
 
87
               spawn parallel_twiddle_codelet(0, m,
 
88
                                              codelet,
 
89
                                              W, out, m * ostride,
 
90
                                              ostride,
 
91
                                              p->nodeu.twiddle.codelet_desc->ntwiddle);
 
92
               sync;
 
93
 
 
94
               break;
 
95
          }
 
96
 
 
97
     case FFTW_GENERIC:
 
98
          {
 
99
               int r = p->nodeu.generic.size;
 
100
               int m = n / r;
 
101
               int i;
 
102
               fftw_generic_codelet *codelet;
 
103
               fftw_complex *W;
 
104
 
 
105
               for (i = 0; i < r; ++i)
 
106
                    spawn executor_simple_cilk(m, in + i * istride,
 
107
                                               out + i * (m * ostride),
 
108
                                               p->nodeu.generic.recurse,
 
109
                                               istride * r, ostride);
 
110
 
 
111
               sync;
 
112
 
 
113
               codelet = p->nodeu.generic.codelet;
 
114
               W = p->nodeu.generic.tw->twarray;
 
115
 
 
116
               (*codelet)(out, W, m, r, n, ostride);
 
117
 
 
118
               break;
 
119
          }
 
120
 
 
121
     case FFTW_RADER:
 
122
          {
 
123
               int r = p->nodeu.rader.size;
 
124
               int m = n / r;
 
125
               int i;
 
126
               fftw_rader_codelet *codelet;
 
127
               fftw_complex *W;
 
128
 
 
129
               for (i = 0; i < r; ++i) {
 
130
                    spawn executor_simple_cilk(m, in + i * istride,
 
131
                                               out + i * (m * ostride),
 
132
                                               p->nodeu.rader.recurse,
 
133
                                               istride * r, ostride);
 
134
               }
 
135
               sync;
 
136
 
 
137
               codelet = p->nodeu.rader.codelet;
 
138
               W = p->nodeu.rader.tw->twarray;
 
139
               (*codelet)(out, W, m, r, ostride,
 
140
                          p->nodeu.rader.rader_data);
 
141
 
 
142
               break;
 
143
          }
 
144
 
 
145
     default:
 
146
          fftw_die("BUG in executor: illegal plan\n");
 
147
          break;
147
148
     }
148
149
}
149
150
 
150
151
static cilk void executor_simple_inplace_cilk(int n, fftw_complex *in,
151
 
                                                 fftw_plan_node *p,
152
 
                                                 int istride)
 
152
          fftw_plan_node *p,
 
153
          int istride)
153
154
{
154
155
     switch (p->type) {
155
 
         case FFTW_NOTW:
156
 
              (*p->nodeu.notw.codelet) (in, in, istride, istride);
157
 
              break;
158
 
 
159
 
         default:
160
 
              {
161
 
                   fftw_complex *tmp;
162
 
 
163
 
                   tmp = (fftw_complex *)
164
 
                        Cilk_alloca(n * sizeof(fftw_complex));
165
 
 
166
 
                   spawn executor_simple_cilk(n, in, tmp, p, istride, 1);
167
 
                   sync;
168
 
                   fftw_strided_copy(n, tmp, istride, in);
169
 
              }
 
156
     case FFTW_NOTW:
 
157
          (*p->nodeu.notw.codelet) (in, in, istride, istride);
 
158
          break;
 
159
 
 
160
     default:
 
161
          {
 
162
               fftw_complex *tmp;
 
163
 
 
164
               tmp = (fftw_complex *)
 
165
                     Cilk_alloca(n * sizeof(fftw_complex));
 
166
 
 
167
               spawn executor_simple_cilk(n, in, tmp, p, istride, 1);
 
168
               sync;
 
169
               fftw_strided_copy(n, tmp, istride, in);
 
170
          }
170
171
     }
171
172
}
172
173
 
173
174
#define FFTW_CILK_HOWMANY_CODELET_THRESHOLD 16
174
175
#define FFTW_CILK_HOWMANY_SIMPLE_THRESHOLD 16
175
176
 
176
 
typedef struct {
177
 
     int n; fftw_plan_node *p;
 
177
typedef struct
 
178
{
 
179
     int n;
 
180
     fftw_plan_node *p;
178
181
     fftw_notw_codelet *codelet;
179
 
     const fftw_complex *in,*out;
180
 
     int istride, ostride, idist,odist;
181
 
} execute_howmany_data;
 
182
     const fftw_complex *in;
 
183
     fftw_complex *out;
 
184
     int istride, ostride, idist, odist;
 
185
}
 
186
execute_howmany_data;
182
187
 
183
188
static cilk void execute_howmany_codelets(
184
189
     execute_howmany_data *d,
185
190
     int min, int max)
186
191
{
187
192
     if (max - min > FFTW_CILK_HOWMANY_CODELET_THRESHOLD) {
188
 
          spawn execute_howmany_codelets(d,
189
 
                                         min,(min+max)/2);
190
 
          spawn execute_howmany_codelets(d,
191
 
                                         (min+max)/2+1,max);
192
 
     }
193
 
     else {
194
 
          fftw_notw_codelet *codelet;
195
 
          fftw_complex *in,*out;
196
 
          int istride, ostride, idist,odist;
197
 
 
198
 
          codelet = d->codelet;
199
 
          in = d->in; out = d->out;
200
 
          istride = d->istride; ostride = d->ostride;
201
 
          idist = d->idist; odist = d->odist;
202
 
 
203
 
          for (; min <= max; ++min)
204
 
               (*codelet)(in + min * idist, 
205
 
                          out + min * odist,istride,ostride);
 
193
          spawn execute_howmany_codelets(d,
 
194
                                         min,(min+max)/2);
 
195
          spawn execute_howmany_codelets(d,
 
196
                                         (min+max)/2+1,max);
 
197
     } else {
 
198
          fftw_notw_codelet *codelet;
 
199
          const fftw_complex *in;
 
200
          fftw_complex *out;
 
201
          int istride, ostride, idist, odist;
 
202
 
 
203
          codelet = d->codelet;
 
204
          in = d->in;
 
205
          out = d->out;
 
206
          istride = d->istride;
 
207
          ostride = d->ostride;
 
208
          idist = d->idist;
 
209
          odist = d->odist;
 
210
 
 
211
          for (; min <= max; ++min)
 
212
               (*codelet)(in + min * idist,
 
213
                          out + min * odist, istride, ostride);
206
214
     }
207
215
}
208
216
 
211
219
     int min, int max)
212
220
{
213
221
     if (max - min > FFTW_CILK_HOWMANY_SIMPLE_THRESHOLD) {
214
 
          spawn execute_howmany_simple(d,
215
 
                                       min,(min+max)/2);
216
 
          spawn execute_howmany_simple(d,
217
 
                                       (min+max)/2+1,max);
218
 
     }
219
 
     else {
220
 
          int n;
221
 
          fftw_complex *in, *out;
222
 
          fftw_plan_node *p;
223
 
          int idist, odist, istride, ostride;
224
 
 
225
 
          n = d->n;
226
 
          p = d->p;
227
 
          in = d->in;
228
 
          out = d->out;
229
 
          istride = d->istride;
230
 
          ostride = d->ostride;
231
 
          idist = d->idist;
232
 
          odist = d->odist;
233
 
 
234
 
          for (; min <= max; ++min)
235
 
               fftw_executor_simple(n, in + min*idist, 
236
 
                                    out + min*odist,
237
 
                                    p, istride, ostride);
 
222
          spawn execute_howmany_simple(d,
 
223
                                       min,(min+max)/2);
 
224
          spawn execute_howmany_simple(d,
 
225
                                       (min+max)/2+1,max);
 
226
     } else {
 
227
          int n;
 
228
          const fftw_complex *in;
 
229
          fftw_complex *out;
 
230
          fftw_plan_node *p;
 
231
          int idist, odist, istride, ostride;
 
232
 
 
233
          n = d->n;
 
234
          p = d->p;
 
235
          in = d->in;
 
236
          out = d->out;
 
237
          istride = d->istride;
 
238
          ostride = d->ostride;
 
239
          idist = d->idist;
 
240
          odist = d->odist;
 
241
 
 
242
          for (; min <= max; ++min)
 
243
               fftw_executor_simple(n, in + min*idist,
 
244
                                    out + min*odist,
 
245
                                    p, istride, ostride,
 
246
                                    FFTW_NORMAL_RECURSE);
238
247
     }
239
248
}
240
249
 
241
250
static cilk void executor_many_cilk(int n, const fftw_complex *in,
242
 
                                    fftw_complex *out,
243
 
                                    fftw_plan_node *p,
244
 
                                    int istride,
245
 
                                    int ostride,
246
 
                                    int howmany, int idist, int odist)
 
251
                                    fftw_complex *out,
 
252
                                    fftw_plan_node *p,
 
253
                                    int istride,
 
254
                                    int ostride,
 
255
                                    int howmany, int idist, int odist)
247
256
{
248
257
     switch (p->type) {
249
 
         case FFTW_NOTW:
250
 
              {
251
 
                   execute_howmany_data d;
252
 
 
253
 
                   d.codelet = p->nodeu.notw.codelet;
254
 
                   d.in = in; d.out = out;
255
 
                   d.istride = istride; d.ostride = ostride;
256
 
                   d.idist = idist; d.odist = odist;
257
 
 
258
 
                   spawn execute_howmany_codelets(&d,0,howmany-1);
259
 
 
260
 
                   break;
261
 
              }
262
 
 
263
 
         default:
264
 
              {
265
 
                   execute_howmany_data d;
266
 
 
267
 
                   d.n = n; d.p = p;
268
 
                   d.in = in; d.out = out;
269
 
                   d.istride = istride; d.ostride = ostride;
270
 
                   d.idist = idist; d.odist = odist;
271
 
 
272
 
                   spawn execute_howmany_simple(&d,0,howmany-1);
273
 
              }
 
258
     case FFTW_NOTW:
 
259
          {
 
260
               execute_howmany_data d;
 
261
 
 
262
               d.codelet = p->nodeu.notw.codelet;
 
263
               d.in = in;
 
264
               d.out = out;
 
265
               d.istride = istride;
 
266
               d.ostride = ostride;
 
267
               d.idist = idist;
 
268
               d.odist = odist;
 
269
 
 
270
               spawn execute_howmany_codelets(&d,0,howmany-1);
 
271
 
 
272
               break;
 
273
          }
 
274
 
 
275
     default:
 
276
          {
 
277
               execute_howmany_data d;
 
278
 
 
279
               d.n = n;
 
280
               d.p = p;
 
281
               d.in = in;
 
282
               d.out = out;
 
283
               d.istride = istride;
 
284
               d.ostride = ostride;
 
285
               d.idist = idist;
 
286
               d.odist = odist;
 
287
 
 
288
               spawn execute_howmany_simple(&d,0,howmany-1);
 
289
          }
274
290
     }
275
291
}
276
292
 
279
295
     int min, int max)
280
296
{
281
297
     if (max - min > FFTW_CILK_HOWMANY_CODELET_THRESHOLD) {
282
 
          spawn execute_howmany_codelets_in_place(d,
283
 
                                                  min,(min+max)/2);
284
 
          spawn execute_howmany_codelets_in_place(d,
285
 
                                                  (min+max)/2+1,max);
286
 
     }
287
 
     else {
288
 
          fftw_notw_codelet *codelet;
289
 
          fftw_complex *in;
290
 
          int istride, idist;
291
 
 
292
 
          codelet = d->codelet;
293
 
          in = d->in;
294
 
          istride = d->istride;
295
 
          idist = d->idist;
296
 
 
297
 
          for (; min <= max; ++min)
298
 
               (*codelet)(in + min * idist, 
299
 
                          in + min * idist,istride,istride);
 
298
          spawn execute_howmany_codelets_in_place(d,
 
299
                                                  min,(min+max)/2);
 
300
          spawn execute_howmany_codelets_in_place(d,
 
301
                                                  (min+max)/2+1,max);
 
302
     } else {
 
303
          fftw_notw_codelet *codelet;
 
304
          const fftw_complex *in;
 
305
          int istride, idist;
 
306
 
 
307
          codelet = d->codelet;
 
308
          in = d->in;
 
309
          istride = d->istride;
 
310
          idist = d->idist;
 
311
 
 
312
          for (; min <= max; ++min)
 
313
               (*codelet)(in + min * idist,
 
314
                          (fftw_complex *)in + min * idist,
 
315
                          istride, istride);
300
316
     }
301
317
}
302
318
 
305
321
     int min, int max)
306
322
{
307
323
     if (max - min > FFTW_CILK_HOWMANY_SIMPLE_THRESHOLD) {
308
 
          spawn execute_howmany_simple_in_place(d,
309
 
                                                min,(min+max)/2);
310
 
          spawn execute_howmany_simple_in_place(d,
311
 
                                                (min+max)/2+1,max);
312
 
     }
313
 
     else {
314
 
          int n;
315
 
          fftw_complex *in,*tmp;
316
 
          int istride,idist;
317
 
          fftw_plan_node *p;
318
 
          
319
 
          n = d->n;
320
 
          p = d->p;
321
 
          in = d->in + min * (idist = d->idist);
 
324
          spawn execute_howmany_simple_in_place(d,
 
325
                                                min,(min+max)/2);
 
326
          spawn execute_howmany_simple_in_place(d,
 
327
                                                (min+max)/2+1,max);
 
328
     } else {
 
329
          int n;
 
330
          fftw_complex *in;
 
331
          fftw_complex *tmp;
 
332
          int istride, idist;
 
333
          fftw_plan_node *p;
 
334
 
 
335
          n = d->n;
 
336
          p = d->p;
 
337
          in = (fftw_complex *)d->in + min * (idist = d->idist);
322
338
          istride = d->istride;
323
 
          tmp = d->out + n * Self;
 
339
          tmp = d->out + n * Self;
324
340
 
325
 
          for (; min <= max; ++min) {
326
 
               fftw_executor_simple(n, in, tmp, p, istride, 1);
327
 
               fftw_strided_copy(n, tmp, istride, in);
328
 
               in += idist;
329
 
          }
 
341
          for (; min <= max; ++min) {
 
342
               fftw_executor_simple(n, in, tmp, p, istride, 1,
 
343
                                    FFTW_NORMAL_RECURSE);
 
344
               fftw_strided_copy(n, tmp, istride, in);
 
345
               in += idist;
 
346
          }
330
347
     }
331
348
}
332
349
 
333
350
static cilk void executor_many_inplace_cilk(int n, fftw_complex *in,
334
 
                                            fftw_plan_node *p,
335
 
                                            int istride,
336
 
                                            int howmany, int idist)
 
351
          fftw_plan_node *p,
 
352
          int istride,
 
353
          int howmany, int idist)
337
354
{
338
355
     switch (p->type) {
339
 
         case FFTW_NOTW:
340
 
              {
341
 
                   execute_howmany_data d;
342
 
 
343
 
                   d.codelet = p->nodeu.notw.codelet;
344
 
                   d.in = in;
345
 
                   d.istride = istride;
346
 
                   d.idist = idist;
347
 
 
348
 
                   spawn execute_howmany_codelets_in_place(&d,0,howmany-1);
349
 
 
350
 
                   break;
351
 
              }
352
 
 
353
 
         default:
354
 
              {
355
 
                   execute_howmany_data d;
356
 
 
357
 
                   d.n = n;
358
 
                   d.p = p;
359
 
                   d.in = in;
360
 
                   d.istride = istride;
361
 
                   d.idist = idist;
362
 
                   d.out = (fftw_complex *)
363
 
                        Cilk_alloca(Cilk_active_size *
364
 
                                    n * sizeof(fftw_complex));
365
 
 
366
 
                   spawn execute_howmany_simple_in_place(&d,0,howmany-1);
367
 
              }
 
356
     case FFTW_NOTW:
 
357
          {
 
358
               execute_howmany_data d;
 
359
 
 
360
               d.codelet = p->nodeu.notw.codelet;
 
361
               d.in = in;
 
362
               d.istride = istride;
 
363
               d.idist = idist;
 
364
 
 
365
               spawn execute_howmany_codelets_in_place(&d,0,howmany-1);
 
366
 
 
367
               break;
 
368
          }
 
369
 
 
370
     default:
 
371
          {
 
372
               execute_howmany_data d;
 
373
 
 
374
               d.n = n;
 
375
               d.p = p;
 
376
               d.in = in;
 
377
               d.istride = istride;
 
378
               d.idist = idist;
 
379
               d.out = (fftw_complex *)
 
380
                       Cilk_alloca(Cilk_active_size *
 
381
                                   n * sizeof(fftw_complex));
 
382
 
 
383
               spawn execute_howmany_simple_in_place(&d,0,howmany-1);
 
384
          }
368
385
     }
369
386
}
370
387
 
371
388
/* user interface */
372
389
cilk void fftw_cilk(fftw_plan plan, int howmany, fftw_complex *in, int istride,
373
 
                    int idist, fftw_complex *out, int ostride, int odist)
 
390
                    int idist, fftw_complex *out, int ostride, int odist)
374
391
{
375
392
     int n = plan->n;
376
393
 
377
394
     if (plan->flags & FFTW_IN_PLACE) {
378
 
          if (howmany == 1) {
379
 
               spawn executor_simple_inplace_cilk(n, in, 
380
 
                                                  plan->root, istride);
381
 
          } else {
382
 
               spawn executor_many_inplace_cilk(n, in,
383
 
                                                plan->root, istride, howmany,
384
 
                                                idist);
385
 
          }
 
395
          if (howmany == 1) {
 
396
               spawn executor_simple_inplace_cilk(n, in,
 
397
                                                  plan->root, istride);
 
398
          } else {
 
399
               spawn executor_many_inplace_cilk(n, in,
 
400
                                                plan->root, istride, howmany,
 
401
                                                idist);
 
402
          }
386
403
     } else {
387
 
          if (howmany == 1) {
388
 
               spawn executor_simple_cilk(n, in, out,
389
 
                                          plan->root, istride, ostride);
390
 
          } else {
391
 
               spawn executor_many_cilk(n, in, out, 
392
 
                                        plan->root, istride, ostride,
393
 
                                        howmany, idist, odist);
394
 
          }
 
404
          if (howmany == 1) {
 
405
               spawn executor_simple_cilk(n, in, out,
 
406
                                          plan->root, istride, ostride);
 
407
          } else {
 
408
               spawn executor_many_cilk(n, in, out,
 
409
                                        plan->root, istride, ostride,
 
410
                                        howmany, idist, odist);
 
411
          }
395
412
     }
396
413
}