Mercurial > hg > sv-dependency-builds

annotate src/fftw-3.3.5/mpi/api.c @ 43:5ea0608b923f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Current zlib source
author Chris Cannam
date Tue, 18 Oct 2016 14:33:52 +0100
parents 2cd0e3b3e1fd
children
rev   line source
Chris@42 1 /*
Chris@42 2 * Copyright (c) 2003, 2007-14 Matteo Frigo
Chris@42 3 * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
Chris@42 4 *
Chris@42 5 * This program is free software; you can redistribute it and/or modify
Chris@42 6 * it under the terms of the GNU General Public License as published by
Chris@42 7 * the Free Software Foundation; either version 2 of the License, or
Chris@42 8 * (at your option) any later version.
Chris@42 9 *
Chris@42 10 * This program is distributed in the hope that it will be useful,
Chris@42 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Chris@42 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Chris@42 13 * GNU General Public License for more details.
Chris@42 14 *
Chris@42 15 * You should have received a copy of the GNU General Public License
Chris@42 16 * along with this program; if not, write to the Free Software
Chris@42 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Chris@42 18 *
Chris@42 19 */
Chris@42 20
Chris@42 21 #include "api.h"
Chris@42 22 #include "fftw3-mpi.h"
Chris@42 23 #include "ifftw-mpi.h"
Chris@42 24 #include "mpi-transpose.h"
Chris@42 25 #include "mpi-dft.h"
Chris@42 26 #include "mpi-rdft.h"
Chris@42 27 #include "mpi-rdft2.h"
Chris@42 28
Chris@42 29 /* Convert API flags to internal MPI flags. */
Chris@42 30 #define MPI_FLAGS(f) ((f) >> 27)
Chris@42 31
Chris@42 32 /*************************************************************************/
Chris@42 33
Chris@42 34 static int mpi_inited = 0;
Chris@42 35
Chris@42 36 static MPI_Comm problem_comm(const problem *p) {
Chris@42 37 switch (p->adt->problem_kind) {
Chris@42 38 case PROBLEM_MPI_DFT:
Chris@42 39 return ((const problem_mpi_dft *) p)->comm;
Chris@42 40 case PROBLEM_MPI_RDFT:
Chris@42 41 return ((const problem_mpi_rdft *) p)->comm;
Chris@42 42 case PROBLEM_MPI_RDFT2:
Chris@42 43 return ((const problem_mpi_rdft2 *) p)->comm;
Chris@42 44 case PROBLEM_MPI_TRANSPOSE:
Chris@42 45 return ((const problem_mpi_transpose *) p)->comm;
Chris@42 46 default:
Chris@42 47 return MPI_COMM_NULL;
Chris@42 48 }
Chris@42 49 }
Chris@42 50
Chris@42 51 /* used to synchronize cost measurements (timing or estimation)
Chris@42 52 across all processes for an MPI problem, which is critical to
Chris@42 53 ensure that all processes decide to use the same MPI plans
Chris@42 54 (whereas serial plans need not be syncronized). */
Chris@42 55 static double cost_hook(const problem *p, double t, cost_kind k)
Chris@42 56 {
Chris@42 57 MPI_Comm comm = problem_comm(p);
Chris@42 58 double tsum;
Chris@42 59 if (comm == MPI_COMM_NULL) return t;
Chris@42 60 MPI_Allreduce(&t, &tsum, 1, MPI_DOUBLE,
Chris@42 61 k == COST_SUM ? MPI_SUM : MPI_MAX, comm);
Chris@42 62 return tsum;
Chris@42 63 }
Chris@42 64
Chris@42 65 /* Used to reject wisdom that is not in sync across all processes
Chris@42 66 for an MPI problem, which is critical to ensure that all processes
Chris@42 67 decide to use the same MPI plans. (Even though costs are synchronized,
Chris@42 68 above, out-of-sync wisdom may result from plans being produced
Chris@42 69 by communicators that do not span all processes, either from a
Chris@42 70 user-specified communicator or e.g. from transpose-recurse. */
Chris@42 71 static int wisdom_ok_hook(const problem *p, flags_t flags)
Chris@42 72 {
Chris@42 73 MPI_Comm comm = problem_comm(p);
Chris@42 74 int eq_me, eq_all;
Chris@42 75 /* unpack flags bitfield, since MPI communications may involve
Chris@42 76 byte-order changes and MPI cannot do this for bit fields */
Chris@42 77 #if SIZEOF_UNSIGNED_INT >= 4 /* must be big enough to hold 20-bit fields */
Chris@42 78 unsigned int f[5];
Chris@42 79 #else
Chris@42 80 unsigned long f[5]; /* at least 32 bits as per C standard */
Chris@42 81 #endif
Chris@42 82
Chris@42 83 if (comm == MPI_COMM_NULL) return 1; /* non-MPI wisdom is always ok */
Chris@42 84
Chris@42 85 if (XM(any_true)(0, comm)) return 0; /* some process had nowisdom_hook */
Chris@42 86
Chris@42 87 /* otherwise, check that the flags and solver index are identical
Chris@42 88 on all processes in this problem's communicator.
Chris@42 89
Chris@42 90 TO DO: possibly we can relax strict equality, but it is
Chris@42 91 critical to ensure that any flags which affect what plan is
Chris@42 92 created (and whether the solver is applicable) are the same,
Chris@42 93 e.g. DESTROY_INPUT, NO_UGLY, etcetera. (If the MPI algorithm
Chris@42 94 differs between processes, deadlocks/crashes generally result.) */
Chris@42 95 f[0] = flags.l;
Chris@42 96 f[1] = flags.hash_info;
Chris@42 97 f[2] = flags.timelimit_impatience;
Chris@42 98 f[3] = flags.u;
Chris@42 99 f[4] = flags.slvndx;
Chris@42 100 MPI_Bcast(f, 5,
Chris@42 101 SIZEOF_UNSIGNED_INT >= 4 ? MPI_UNSIGNED : MPI_UNSIGNED_LONG,
Chris@42 102 0, comm);
Chris@42 103 eq_me = f[0] == flags.l && f[1] == flags.hash_info
Chris@42 104 && f[2] == flags.timelimit_impatience
Chris@42 105 && f[3] == flags.u && f[4] == flags.slvndx;
Chris@42 106 MPI_Allreduce(&eq_me, &eq_all, 1, MPI_INT, MPI_LAND, comm);
Chris@42 107 return eq_all;
Chris@42 108 }
Chris@42 109
Chris@42 110 /* This hook is called when wisdom is not found. The any_true here
Chris@42 111 matches up with the any_true in wisdom_ok_hook, in order to handle
Chris@42 112 the case where some processes had wisdom (and called wisdom_ok_hook)
Chris@42 113 and some processes didn't have wisdom (and called nowisdom_hook). */
Chris@42 114 static void nowisdom_hook(const problem *p)
Chris@42 115 {
Chris@42 116 MPI_Comm comm = problem_comm(p);
Chris@42 117 if (comm == MPI_COMM_NULL) return; /* nothing to do for non-MPI p */
Chris@42 118 XM(any_true)(1, comm); /* signal nowisdom to any wisdom_ok_hook */
Chris@42 119 }
Chris@42 120
Chris@42 121 /* needed to synchronize planner bogosity flag, in case non-MPI problems
Chris@42 122 on a subset of processes encountered bogus wisdom */
Chris@42 123 static wisdom_state_t bogosity_hook(wisdom_state_t state, const problem *p)
Chris@42 124 {
Chris@42 125 MPI_Comm comm = problem_comm(p);
Chris@42 126 if (comm != MPI_COMM_NULL /* an MPI problem */
Chris@42 127 && XM(any_true)(state == WISDOM_IS_BOGUS, comm)) /* bogus somewhere */
Chris@42 128 return WISDOM_IS_BOGUS;
Chris@42 129 return state;
Chris@42 130 }
Chris@42 131
Chris@42 132 void XM(init)(void)
Chris@42 133 {
Chris@42 134 if (!mpi_inited) {
Chris@42 135 planner *plnr = X(the_planner)();
Chris@42 136 plnr->cost_hook = cost_hook;
Chris@42 137 plnr->wisdom_ok_hook = wisdom_ok_hook;
Chris@42 138 plnr->nowisdom_hook = nowisdom_hook;
Chris@42 139 plnr->bogosity_hook = bogosity_hook;
Chris@42 140 XM(conf_standard)(plnr);
Chris@42 141 mpi_inited = 1;
Chris@42 142 }
Chris@42 143 }
Chris@42 144
Chris@42 145 void XM(cleanup)(void)
Chris@42 146 {
Chris@42 147 X(cleanup)();
Chris@42 148 mpi_inited = 0;
Chris@42 149 }
Chris@42 150
Chris@42 151 /*************************************************************************/
Chris@42 152
Chris@42 153 static dtensor *mkdtensor_api(int rnk, const XM(ddim) *dims0)
Chris@42 154 {
Chris@42 155 dtensor *x = XM(mkdtensor)(rnk);
Chris@42 156 int i;
Chris@42 157 for (i = 0; i < rnk; ++i) {
Chris@42 158 x->dims[i].n = dims0[i].n;
Chris@42 159 x->dims[i].b[IB] = dims0[i].ib;
Chris@42 160 x->dims[i].b[OB] = dims0[i].ob;
Chris@42 161 }
Chris@42 162 return x;
Chris@42 163 }
Chris@42 164
Chris@42 165 static dtensor *default_sz(int rnk, const XM(ddim) *dims0, int n_pes,
Chris@42 166 int rdft2)
Chris@42 167 {
Chris@42 168 dtensor *sz = XM(mkdtensor)(rnk);
Chris@42 169 dtensor *sz0 = mkdtensor_api(rnk, dims0);
Chris@42 170 block_kind k;
Chris@42 171 int i;
Chris@42 172
Chris@42 173 for (i = 0; i < rnk; ++i)
Chris@42 174 sz->dims[i].n = dims0[i].n;
Chris@42 175
Chris@42 176 if (rdft2) sz->dims[rnk-1].n = dims0[rnk-1].n / 2 + 1;
Chris@42 177
Chris@42 178 for (i = 0; i < rnk; ++i) {
Chris@42 179 sz->dims[i].b[IB] = dims0[i].ib ? dims0[i].ib : sz->dims[i].n;
Chris@42 180 sz->dims[i].b[OB] = dims0[i].ob ? dims0[i].ob : sz->dims[i].n;
Chris@42 181 }
Chris@42 182
Chris@42 183 /* If we haven't used all of the processes yet, and some of the
Chris@42 184 block sizes weren't specified (i.e. 0), then set the
Chris@42 185 unspecified blocks so as to use as many processes as
Chris@42 186 possible with as few distributed dimensions as possible. */
Chris@42 187 FORALL_BLOCK_KIND(k) {
Chris@42 188 INT nb = XM(num_blocks_total)(sz, k);
Chris@42 189 INT np = n_pes / nb;
Chris@42 190 for (i = 0; i < rnk && np > 1; ++i)
Chris@42 191 if (!sz0->dims[i].b[k]) {
Chris@42 192 sz->dims[i].b[k] = XM(default_block)(sz->dims[i].n, np);
Chris@42 193 nb *= XM(num_blocks)(sz->dims[i].n, sz->dims[i].b[k]);
Chris@42 194 np = n_pes / nb;
Chris@42 195 }
Chris@42 196 }
Chris@42 197
Chris@42 198 if (rdft2) sz->dims[rnk-1].n = dims0[rnk-1].n;
Chris@42 199
Chris@42 200 /* punt for 1d prime */
Chris@42 201 if (rnk == 1 && X(is_prime)(sz->dims[0].n))
Chris@42 202 sz->dims[0].b[IB] = sz->dims[0].b[OB] = sz->dims[0].n;
Chris@42 203
Chris@42 204 XM(dtensor_destroy)(sz0);
Chris@42 205 sz0 = XM(dtensor_canonical)(sz, 0);
Chris@42 206 XM(dtensor_destroy)(sz);
Chris@42 207 return sz0;
Chris@42 208 }
Chris@42 209
Chris@42 210 /* allocate simple local (serial) dims array corresponding to n[rnk] */
Chris@42 211 static XM(ddim) *simple_dims(int rnk, const ptrdiff_t *n)
Chris@42 212 {
Chris@42 213 XM(ddim) *dims = (XM(ddim) *) MALLOC(sizeof(XM(ddim)) * rnk,
Chris@42 214 TENSORS);
Chris@42 215 int i;
Chris@42 216 for (i = 0; i < rnk; ++i)
Chris@42 217 dims[i].n = dims[i].ib = dims[i].ob = n[i];
Chris@42 218 return dims;
Chris@42 219 }
Chris@42 220
Chris@42 221 /*************************************************************************/
Chris@42 222
Chris@42 223 static void local_size(int my_pe, const dtensor *sz, block_kind k,
Chris@42 224 ptrdiff_t *local_n, ptrdiff_t *local_start)
Chris@42 225 {
Chris@42 226 int i;
Chris@42 227 if (my_pe >= XM(num_blocks_total)(sz, k))
Chris@42 228 for (i = 0; i < sz->rnk; ++i)
Chris@42 229 local_n[i] = local_start[i] = 0;
Chris@42 230 else {
Chris@42 231 XM(block_coords)(sz, k, my_pe, local_start);
Chris@42 232 for (i = 0; i < sz->rnk; ++i) {
Chris@42 233 local_n[i] = XM(block)(sz->dims[i].n, sz->dims[i].b[k],
Chris@42 234 local_start[i]);
Chris@42 235 local_start[i] *= sz->dims[i].b[k];
Chris@42 236 }
Chris@42 237 }
Chris@42 238 }
Chris@42 239
Chris@42 240 static INT prod(int rnk, const ptrdiff_t *local_n)
Chris@42 241 {
Chris@42 242 int i;
Chris@42 243 INT N = 1;
Chris@42 244 for (i = 0; i < rnk; ++i) N *= local_n[i];
Chris@42 245 return N;
Chris@42 246 }
Chris@42 247
Chris@42 248 ptrdiff_t XM(local_size_guru)(int rnk, const XM(ddim) *dims0,
Chris@42 249 ptrdiff_t howmany, MPI_Comm comm,
Chris@42 250 ptrdiff_t *local_n_in,
Chris@42 251 ptrdiff_t *local_start_in,
Chris@42 252 ptrdiff_t *local_n_out,
Chris@42 253 ptrdiff_t *local_start_out,
Chris@42 254 int sign, unsigned flags)
Chris@42 255 {
Chris@42 256 INT N;
Chris@42 257 int my_pe, n_pes, i;
Chris@42 258 dtensor *sz;
Chris@42 259
Chris@42 260 if (rnk == 0)
Chris@42 261 return howmany;
Chris@42 262
Chris@42 263 MPI_Comm_rank(comm, &my_pe);
Chris@42 264 MPI_Comm_size(comm, &n_pes);
Chris@42 265 sz = default_sz(rnk, dims0, n_pes, 0);
Chris@42 266
Chris@42 267 /* Now, we must figure out how much local space the user should
Chris@42 268 allocate (or at least an upper bound). This depends strongly
Chris@42 269 on the exact algorithms we employ...ugh! FIXME: get this info
Chris@42 270 from the solvers somehow? */
Chris@42 271 N = 1; /* never return zero allocation size */
Chris@42 272 if (rnk > 1 && XM(is_block1d)(sz, IB) && XM(is_block1d)(sz, OB)) {
Chris@42 273 INT Nafter;
Chris@42 274 ddim odims[2];
Chris@42 275
Chris@42 276 /* dft-rank-geq2-transposed */
Chris@42 277 odims[0] = sz->dims[0]; odims[1] = sz->dims[1]; /* save */
Chris@42 278 /* we may need extra space for transposed intermediate data */
Chris@42 279 for (i = 0; i < 2; ++i)
Chris@42 280 if (XM(num_blocks)(sz->dims[i].n, sz->dims[i].b[IB]) == 1 &&
Chris@42 281 XM(num_blocks)(sz->dims[i].n, sz->dims[i].b[OB]) == 1) {
Chris@42 282 sz->dims[i].b[IB]
Chris@42 283 = XM(default_block)(sz->dims[i].n, n_pes);
Chris@42 284 sz->dims[1-i].b[IB] = sz->dims[1-i].n;
Chris@42 285 local_size(my_pe, sz, IB, local_n_in, local_start_in);
Chris@42 286 N = X(imax)(N, prod(rnk, local_n_in));
Chris@42 287 sz->dims[i] = odims[i];
Chris@42 288 sz->dims[1-i] = odims[1-i];
Chris@42 289 break;
Chris@42 290 }
Chris@42 291
Chris@42 292 /* dft-rank-geq2 */
Chris@42 293 Nafter = howmany;
Chris@42 294 for (i = 1; i < sz->rnk; ++i) Nafter *= sz->dims[i].n;
Chris@42 295 N = X(imax)(N, (sz->dims[0].n
Chris@42 296 * XM(block)(Nafter, XM(default_block)(Nafter, n_pes),
Chris@42 297 my_pe) + howmany - 1) / howmany);
Chris@42 298
Chris@42 299 /* dft-rank-geq2 with dimensions swapped */
Chris@42 300 Nafter = howmany * sz->dims[0].n;
Chris@42 301 for (i = 2; i < sz->rnk; ++i) Nafter *= sz->dims[i].n;
Chris@42 302 N = X(imax)(N, (sz->dims[1].n
Chris@42 303 * XM(block)(Nafter, XM(default_block)(Nafter, n_pes),
Chris@42 304 my_pe) + howmany - 1) / howmany);
Chris@42 305 }
Chris@42 306 else if (rnk == 1) {
Chris@42 307 if (howmany >= n_pes && !MPI_FLAGS(flags)) { /* dft-rank1-bigvec */
Chris@42 308 ptrdiff_t n[2], start[2];
Chris@42 309 dtensor *sz2 = XM(mkdtensor)(2);
Chris@42 310 sz2->dims[0] = sz->dims[0];
Chris@42 311 sz2->dims[0].b[IB] = sz->dims[0].n;
Chris@42 312 sz2->dims[1].n = sz2->dims[1].b[OB] = howmany;
Chris@42 313 sz2->dims[1].b[IB] = XM(default_block)(howmany, n_pes);
Chris@42 314 local_size(my_pe, sz2, IB, n, start);
Chris@42 315 XM(dtensor_destroy)(sz2);
Chris@42 316 N = X(imax)(N, (prod(2, n) + howmany - 1) / howmany);
Chris@42 317 }
Chris@42 318 else { /* dft-rank1 */
Chris@42 319 INT r, m, rblock[2], mblock[2];
Chris@42 320
Chris@42 321 /* Since the 1d transforms are so different, we require
Chris@42 322 the user to call local_size_1d for this case. Ugh. */
Chris@42 323 CK(sign == FFTW_FORWARD || sign == FFTW_BACKWARD);
Chris@42 324
Chris@42 325 if ((r = XM(choose_radix)(sz->dims[0], n_pes, flags, sign,
Chris@42 326 rblock, mblock))) {
Chris@42 327 m = sz->dims[0].n / r;
Chris@42 328 if (flags & FFTW_MPI_SCRAMBLED_IN)
Chris@42 329 sz->dims[0].b[IB] = rblock[IB] * m;
Chris@42 330 else { /* !SCRAMBLED_IN */
Chris@42 331 sz->dims[0].b[IB] = r * mblock[IB];
Chris@42 332 N = X(imax)(N, rblock[IB] * m);
Chris@42 333 }
Chris@42 334 if (flags & FFTW_MPI_SCRAMBLED_OUT)
Chris@42 335 sz->dims[0].b[OB] = r * mblock[OB];
Chris@42 336 else { /* !SCRAMBLED_OUT */
Chris@42 337 N = X(imax)(N, r * mblock[OB]);
Chris@42 338 sz->dims[0].b[OB] = rblock[OB] * m;
Chris@42 339 }
Chris@42 340 }
Chris@42 341 }
Chris@42 342 }
Chris@42 343
Chris@42 344 local_size(my_pe, sz, IB, local_n_in, local_start_in);
Chris@42 345 local_size(my_pe, sz, OB, local_n_out, local_start_out);
Chris@42 346
Chris@42 347 /* at least, make sure we have enough space to store input & output */
Chris@42 348 N = X(imax)(N, X(imax)(prod(rnk, local_n_in), prod(rnk, local_n_out)));
Chris@42 349
Chris@42 350 XM(dtensor_destroy)(sz);
Chris@42 351 return N * howmany;
Chris@42 352 }
Chris@42 353
Chris@42 354 ptrdiff_t XM(local_size_many_transposed)(int rnk, const ptrdiff_t *n,
Chris@42 355 ptrdiff_t howmany,
Chris@42 356 ptrdiff_t xblock, ptrdiff_t yblock,
Chris@42 357 MPI_Comm comm,
Chris@42 358 ptrdiff_t *local_nx,
Chris@42 359 ptrdiff_t *local_x_start,
Chris@42 360 ptrdiff_t *local_ny,
Chris@42 361 ptrdiff_t *local_y_start)
Chris@42 362 {
Chris@42 363 ptrdiff_t N;
Chris@42 364 XM(ddim) *dims;
Chris@42 365 ptrdiff_t *local;
Chris@42 366
Chris@42 367 if (rnk == 0) {
Chris@42 368 *local_nx = *local_ny = 1;
Chris@42 369 *local_x_start = *local_y_start = 0;
Chris@42 370 return howmany;
Chris@42 371 }
Chris@42 372
Chris@42 373 dims = simple_dims(rnk, n);
Chris@42 374 local = (ptrdiff_t *) MALLOC(sizeof(ptrdiff_t) * rnk * 4, TENSORS);
Chris@42 375
Chris@42 376 /* default 1d block distribution, with transposed output
Chris@42 377 if yblock < n[1] */
Chris@42 378 dims[0].ib = xblock;
Chris@42 379 if (rnk > 1) {
Chris@42 380 if (yblock < n[1])
Chris@42 381 dims[1].ob = yblock;
Chris@42 382 else
Chris@42 383 dims[0].ob = xblock;
Chris@42 384 }
Chris@42 385 else
Chris@42 386 dims[0].ob = xblock; /* FIXME: 1d not really supported here
Chris@42 387 since we don't have flags/sign */
Chris@42 388
Chris@42 389 N = XM(local_size_guru)(rnk, dims, howmany, comm,
Chris@42 390 local, local + rnk,
Chris@42 391 local + 2*rnk, local + 3*rnk,
Chris@42 392 0, 0);
Chris@42 393 *local_nx = local[0];
Chris@42 394 *local_x_start = local[rnk];
Chris@42 395 if (rnk > 1) {
Chris@42 396 *local_ny = local[2*rnk + 1];
Chris@42 397 *local_y_start = local[3*rnk + 1];
Chris@42 398 }
Chris@42 399 else {
Chris@42 400 *local_ny = *local_nx;
Chris@42 401 *local_y_start = *local_x_start;
Chris@42 402 }
Chris@42 403 X(ifree)(local);
Chris@42 404 X(ifree)(dims);
Chris@42 405 return N;
Chris@42 406 }
Chris@42 407
Chris@42 408 ptrdiff_t XM(local_size_many)(int rnk, const ptrdiff_t *n,
Chris@42 409 ptrdiff_t howmany,
Chris@42 410 ptrdiff_t xblock,
Chris@42 411 MPI_Comm comm,
Chris@42 412 ptrdiff_t *local_nx,
Chris@42 413 ptrdiff_t *local_x_start)
Chris@42 414 {
Chris@42 415 ptrdiff_t local_ny, local_y_start;
Chris@42 416 return XM(local_size_many_transposed)(rnk, n, howmany,
Chris@42 417 xblock, rnk > 1
Chris@42 418 ? n[1] : FFTW_MPI_DEFAULT_BLOCK,
Chris@42 419 comm,
Chris@42 420 local_nx, local_x_start,
Chris@42 421 &local_ny, &local_y_start);
Chris@42 422 }
Chris@42 423
Chris@42 424
Chris@42 425 ptrdiff_t XM(local_size_transposed)(int rnk, const ptrdiff_t *n,
Chris@42 426 MPI_Comm comm,
Chris@42 427 ptrdiff_t *local_nx,
Chris@42 428 ptrdiff_t *local_x_start,
Chris@42 429 ptrdiff_t *local_ny,
Chris@42 430 ptrdiff_t *local_y_start)
Chris@42 431 {
Chris@42 432 return XM(local_size_many_transposed)(rnk, n, 1,
Chris@42 433 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 434 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 435 comm,
Chris@42 436 local_nx, local_x_start,
Chris@42 437 local_ny, local_y_start);
Chris@42 438 }
Chris@42 439
Chris@42 440 ptrdiff_t XM(local_size)(int rnk, const ptrdiff_t *n,
Chris@42 441 MPI_Comm comm,
Chris@42 442 ptrdiff_t *local_nx,
Chris@42 443 ptrdiff_t *local_x_start)
Chris@42 444 {
Chris@42 445 return XM(local_size_many)(rnk, n, 1, FFTW_MPI_DEFAULT_BLOCK, comm,
Chris@42 446 local_nx, local_x_start);
Chris@42 447 }
Chris@42 448
Chris@42 449 ptrdiff_t XM(local_size_many_1d)(ptrdiff_t nx, ptrdiff_t howmany,
Chris@42 450 MPI_Comm comm, int sign, unsigned flags,
Chris@42 451 ptrdiff_t *local_nx, ptrdiff_t *local_x_start,
Chris@42 452 ptrdiff_t *local_ny, ptrdiff_t *local_y_start)
Chris@42 453 {
Chris@42 454 XM(ddim) d;
Chris@42 455 d.n = nx;
Chris@42 456 d.ib = d.ob = FFTW_MPI_DEFAULT_BLOCK;
Chris@42 457 return XM(local_size_guru)(1, &d, howmany, comm,
Chris@42 458 local_nx, local_x_start,
Chris@42 459 local_ny, local_y_start, sign, flags);
Chris@42 460 }
Chris@42 461
Chris@42 462 ptrdiff_t XM(local_size_1d)(ptrdiff_t nx,
Chris@42 463 MPI_Comm comm, int sign, unsigned flags,
Chris@42 464 ptrdiff_t *local_nx, ptrdiff_t *local_x_start,
Chris@42 465 ptrdiff_t *local_ny, ptrdiff_t *local_y_start)
Chris@42 466 {
Chris@42 467 return XM(local_size_many_1d)(nx, 1, comm, sign, flags,
Chris@42 468 local_nx, local_x_start,
Chris@42 469 local_ny, local_y_start);
Chris@42 470 }
Chris@42 471
Chris@42 472 ptrdiff_t XM(local_size_2d_transposed)(ptrdiff_t nx, ptrdiff_t ny,
Chris@42 473 MPI_Comm comm,
Chris@42 474 ptrdiff_t *local_nx,
Chris@42 475 ptrdiff_t *local_x_start,
Chris@42 476 ptrdiff_t *local_ny,
Chris@42 477 ptrdiff_t *local_y_start)
Chris@42 478 {
Chris@42 479 ptrdiff_t n[2];
Chris@42 480 n[0] = nx; n[1] = ny;
Chris@42 481 return XM(local_size_transposed)(2, n, comm,
Chris@42 482 local_nx, local_x_start,
Chris@42 483 local_ny, local_y_start);
Chris@42 484 }
Chris@42 485
Chris@42 486 ptrdiff_t XM(local_size_2d)(ptrdiff_t nx, ptrdiff_t ny, MPI_Comm comm,
Chris@42 487 ptrdiff_t *local_nx, ptrdiff_t *local_x_start)
Chris@42 488 {
Chris@42 489 ptrdiff_t n[2];
Chris@42 490 n[0] = nx; n[1] = ny;
Chris@42 491 return XM(local_size)(2, n, comm, local_nx, local_x_start);
Chris@42 492 }
Chris@42 493
Chris@42 494 ptrdiff_t XM(local_size_3d_transposed)(ptrdiff_t nx, ptrdiff_t ny,
Chris@42 495 ptrdiff_t nz,
Chris@42 496 MPI_Comm comm,
Chris@42 497 ptrdiff_t *local_nx,
Chris@42 498 ptrdiff_t *local_x_start,
Chris@42 499 ptrdiff_t *local_ny,
Chris@42 500 ptrdiff_t *local_y_start)
Chris@42 501 {
Chris@42 502 ptrdiff_t n[3];
Chris@42 503 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 504 return XM(local_size_transposed)(3, n, comm,
Chris@42 505 local_nx, local_x_start,
Chris@42 506 local_ny, local_y_start);
Chris@42 507 }
Chris@42 508
Chris@42 509 ptrdiff_t XM(local_size_3d)(ptrdiff_t nx, ptrdiff_t ny, ptrdiff_t nz,
Chris@42 510 MPI_Comm comm,
Chris@42 511 ptrdiff_t *local_nx, ptrdiff_t *local_x_start)
Chris@42 512 {
Chris@42 513 ptrdiff_t n[3];
Chris@42 514 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 515 return XM(local_size)(3, n, comm, local_nx, local_x_start);
Chris@42 516 }
Chris@42 517
Chris@42 518 /*************************************************************************/
Chris@42 519 /* Transpose API */
Chris@42 520
Chris@42 521 X(plan) XM(plan_many_transpose)(ptrdiff_t nx, ptrdiff_t ny,
Chris@42 522 ptrdiff_t howmany,
Chris@42 523 ptrdiff_t xblock, ptrdiff_t yblock,
Chris@42 524 R *in, R *out,
Chris@42 525 MPI_Comm comm, unsigned flags)
Chris@42 526 {
Chris@42 527 int n_pes;
Chris@42 528 XM(init)();
Chris@42 529
Chris@42 530 if (howmany < 0 || xblock < 0 || yblock < 0 ||
Chris@42 531 nx <= 0 || ny <= 0) return 0;
Chris@42 532
Chris@42 533 MPI_Comm_size(comm, &n_pes);
Chris@42 534 if (!xblock) xblock = XM(default_block)(nx, n_pes);
Chris@42 535 if (!yblock) yblock = XM(default_block)(ny, n_pes);
Chris@42 536 if (n_pes < XM(num_blocks)(nx, xblock)
Chris@42 537 || n_pes < XM(num_blocks)(ny, yblock))
Chris@42 538 return 0;
Chris@42 539
Chris@42 540 return
Chris@42 541 X(mkapiplan)(FFTW_FORWARD, flags,
Chris@42 542 XM(mkproblem_transpose)(nx, ny, howmany,
Chris@42 543 in, out, xblock, yblock,
Chris@42 544 comm, MPI_FLAGS(flags)));
Chris@42 545 }
Chris@42 546
Chris@42 547 X(plan) XM(plan_transpose)(ptrdiff_t nx, ptrdiff_t ny, R *in, R *out,
Chris@42 548 MPI_Comm comm, unsigned flags)
Chris@42 549
Chris@42 550 {
Chris@42 551 return XM(plan_many_transpose)(nx, ny, 1,
Chris@42 552 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 553 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 554 in, out, comm, flags);
Chris@42 555 }
Chris@42 556
Chris@42 557 /*************************************************************************/
Chris@42 558 /* Complex DFT API */
Chris@42 559
Chris@42 560 X(plan) XM(plan_guru_dft)(int rnk, const XM(ddim) *dims0,
Chris@42 561 ptrdiff_t howmany,
Chris@42 562 C *in, C *out,
Chris@42 563 MPI_Comm comm, int sign, unsigned flags)
Chris@42 564 {
Chris@42 565 int n_pes, i;
Chris@42 566 dtensor *sz;
Chris@42 567
Chris@42 568 XM(init)();
Chris@42 569
Chris@42 570 if (howmany < 0 || rnk < 1) return 0;
Chris@42 571 for (i = 0; i < rnk; ++i)
Chris@42 572 if (dims0[i].n < 1 || dims0[i].ib < 0 || dims0[i].ob < 0)
Chris@42 573 return 0;
Chris@42 574
Chris@42 575 MPI_Comm_size(comm, &n_pes);
Chris@42 576 sz = default_sz(rnk, dims0, n_pes, 0);
Chris@42 577
Chris@42 578 if (XM(num_blocks_total)(sz, IB) > n_pes
Chris@42 579 || XM(num_blocks_total)(sz, OB) > n_pes) {
Chris@42 580 XM(dtensor_destroy)(sz);
Chris@42 581 return 0;
Chris@42 582 }
Chris@42 583
Chris@42 584 return
Chris@42 585 X(mkapiplan)(sign, flags,
Chris@42 586 XM(mkproblem_dft_d)(sz, howmany,
Chris@42 587 (R *) in, (R *) out,
Chris@42 588 comm, sign,
Chris@42 589 MPI_FLAGS(flags)));
Chris@42 590 }
Chris@42 591
Chris@42 592 X(plan) XM(plan_many_dft)(int rnk, const ptrdiff_t *n,
Chris@42 593 ptrdiff_t howmany,
Chris@42 594 ptrdiff_t iblock, ptrdiff_t oblock,
Chris@42 595 C *in, C *out,
Chris@42 596 MPI_Comm comm, int sign, unsigned flags)
Chris@42 597 {
Chris@42 598 XM(ddim) *dims = simple_dims(rnk, n);
Chris@42 599 X(plan) pln;
Chris@42 600
Chris@42 601 if (rnk == 1) {
Chris@42 602 dims[0].ib = iblock;
Chris@42 603 dims[0].ob = oblock;
Chris@42 604 }
Chris@42 605 else if (rnk > 1) {
Chris@42 606 dims[0 != (flags & FFTW_MPI_TRANSPOSED_IN)].ib = iblock;
Chris@42 607 dims[0 != (flags & FFTW_MPI_TRANSPOSED_OUT)].ob = oblock;
Chris@42 608 }
Chris@42 609
Chris@42 610 pln = XM(plan_guru_dft)(rnk,dims,howmany, in,out, comm, sign, flags);
Chris@42 611 X(ifree)(dims);
Chris@42 612 return pln;
Chris@42 613 }
Chris@42 614
Chris@42 615 X(plan) XM(plan_dft)(int rnk, const ptrdiff_t *n, C *in, C *out,
Chris@42 616 MPI_Comm comm, int sign, unsigned flags)
Chris@42 617 {
Chris@42 618 return XM(plan_many_dft)(rnk, n, 1,
Chris@42 619 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 620 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 621 in, out, comm, sign, flags);
Chris@42 622 }
Chris@42 623
Chris@42 624 X(plan) XM(plan_dft_1d)(ptrdiff_t nx, C *in, C *out,
Chris@42 625 MPI_Comm comm, int sign, unsigned flags)
Chris@42 626 {
Chris@42 627 return XM(plan_dft)(1, &nx, in, out, comm, sign, flags);
Chris@42 628 }
Chris@42 629
Chris@42 630 X(plan) XM(plan_dft_2d)(ptrdiff_t nx, ptrdiff_t ny, C *in, C *out,
Chris@42 631 MPI_Comm comm, int sign, unsigned flags)
Chris@42 632 {
Chris@42 633 ptrdiff_t n[2];
Chris@42 634 n[0] = nx; n[1] = ny;
Chris@42 635 return XM(plan_dft)(2, n, in, out, comm, sign, flags);
Chris@42 636 }
Chris@42 637
Chris@42 638 X(plan) XM(plan_dft_3d)(ptrdiff_t nx, ptrdiff_t ny, ptrdiff_t nz,
Chris@42 639 C *in, C *out,
Chris@42 640 MPI_Comm comm, int sign, unsigned flags)
Chris@42 641 {
Chris@42 642 ptrdiff_t n[3];
Chris@42 643 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 644 return XM(plan_dft)(3, n, in, out, comm, sign, flags);
Chris@42 645 }
Chris@42 646
Chris@42 647 /*************************************************************************/
Chris@42 648 /* R2R API */
Chris@42 649
Chris@42 650 X(plan) XM(plan_guru_r2r)(int rnk, const XM(ddim) *dims0,
Chris@42 651 ptrdiff_t howmany,
Chris@42 652 R *in, R *out,
Chris@42 653 MPI_Comm comm, const X(r2r_kind) *kind,
Chris@42 654 unsigned flags)
Chris@42 655 {
Chris@42 656 int n_pes, i;
Chris@42 657 dtensor *sz;
Chris@42 658 rdft_kind *k;
Chris@42 659 X(plan) pln;
Chris@42 660
Chris@42 661 XM(init)();
Chris@42 662
Chris@42 663 if (howmany < 0 || rnk < 1) return 0;
Chris@42 664 for (i = 0; i < rnk; ++i)
Chris@42 665 if (dims0[i].n < 1 || dims0[i].ib < 0 || dims0[i].ob < 0)
Chris@42 666 return 0;
Chris@42 667
Chris@42 668 k = X(map_r2r_kind)(rnk, kind);
Chris@42 669
Chris@42 670 MPI_Comm_size(comm, &n_pes);
Chris@42 671 sz = default_sz(rnk, dims0, n_pes, 0);
Chris@42 672
Chris@42 673 if (XM(num_blocks_total)(sz, IB) > n_pes
Chris@42 674 || XM(num_blocks_total)(sz, OB) > n_pes) {
Chris@42 675 XM(dtensor_destroy)(sz);
Chris@42 676 return 0;
Chris@42 677 }
Chris@42 678
Chris@42 679 pln = X(mkapiplan)(0, flags,
Chris@42 680 XM(mkproblem_rdft_d)(sz, howmany,
Chris@42 681 in, out,
Chris@42 682 comm, k, MPI_FLAGS(flags)));
Chris@42 683 X(ifree0)(k);
Chris@42 684 return pln;
Chris@42 685 }
Chris@42 686
Chris@42 687 X(plan) XM(plan_many_r2r)(int rnk, const ptrdiff_t *n,
Chris@42 688 ptrdiff_t howmany,
Chris@42 689 ptrdiff_t iblock, ptrdiff_t oblock,
Chris@42 690 R *in, R *out,
Chris@42 691 MPI_Comm comm, const X(r2r_kind) *kind,
Chris@42 692 unsigned flags)
Chris@42 693 {
Chris@42 694 XM(ddim) *dims = simple_dims(rnk, n);
Chris@42 695 X(plan) pln;
Chris@42 696
Chris@42 697 if (rnk == 1) {
Chris@42 698 dims[0].ib = iblock;
Chris@42 699 dims[0].ob = oblock;
Chris@42 700 }
Chris@42 701 else if (rnk > 1) {
Chris@42 702 dims[0 != (flags & FFTW_MPI_TRANSPOSED_IN)].ib = iblock;
Chris@42 703 dims[0 != (flags & FFTW_MPI_TRANSPOSED_OUT)].ob = oblock;
Chris@42 704 }
Chris@42 705
Chris@42 706 pln = XM(plan_guru_r2r)(rnk,dims,howmany, in,out, comm, kind, flags);
Chris@42 707 X(ifree)(dims);
Chris@42 708 return pln;
Chris@42 709 }
Chris@42 710
Chris@42 711 X(plan) XM(plan_r2r)(int rnk, const ptrdiff_t *n, R *in, R *out,
Chris@42 712 MPI_Comm comm,
Chris@42 713 const X(r2r_kind) *kind,
Chris@42 714 unsigned flags)
Chris@42 715 {
Chris@42 716 return XM(plan_many_r2r)(rnk, n, 1,
Chris@42 717 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 718 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 719 in, out, comm, kind, flags);
Chris@42 720 }
Chris@42 721
Chris@42 722 X(plan) XM(plan_r2r_2d)(ptrdiff_t nx, ptrdiff_t ny, R *in, R *out,
Chris@42 723 MPI_Comm comm,
Chris@42 724 X(r2r_kind) kindx, X(r2r_kind) kindy,
Chris@42 725 unsigned flags)
Chris@42 726 {
Chris@42 727 ptrdiff_t n[2];
Chris@42 728 X(r2r_kind) kind[2];
Chris@42 729 n[0] = nx; n[1] = ny;
Chris@42 730 kind[0] = kindx; kind[1] = kindy;
Chris@42 731 return XM(plan_r2r)(2, n, in, out, comm, kind, flags);
Chris@42 732 }
Chris@42 733
Chris@42 734 X(plan) XM(plan_r2r_3d)(ptrdiff_t nx, ptrdiff_t ny, ptrdiff_t nz,
Chris@42 735 R *in, R *out,
Chris@42 736 MPI_Comm comm,
Chris@42 737 X(r2r_kind) kindx, X(r2r_kind) kindy,
Chris@42 738 X(r2r_kind) kindz,
Chris@42 739 unsigned flags)
Chris@42 740 {
Chris@42 741 ptrdiff_t n[3];
Chris@42 742 X(r2r_kind) kind[3];
Chris@42 743 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 744 kind[0] = kindx; kind[1] = kindy; kind[2] = kindz;
Chris@42 745 return XM(plan_r2r)(3, n, in, out, comm, kind, flags);
Chris@42 746 }
Chris@42 747
Chris@42 748 /*************************************************************************/
Chris@42 749 /* R2C/C2R API */
Chris@42 750
Chris@42 751 static X(plan) plan_guru_rdft2(int rnk, const XM(ddim) *dims0,
Chris@42 752 ptrdiff_t howmany,
Chris@42 753 R *r, C *c,
Chris@42 754 MPI_Comm comm, rdft_kind kind, unsigned flags)
Chris@42 755 {
Chris@42 756 int n_pes, i;
Chris@42 757 dtensor *sz;
Chris@42 758 R *cr = (R *) c;
Chris@42 759
Chris@42 760 XM(init)();
Chris@42 761
Chris@42 762 if (howmany < 0 || rnk < 2) return 0;
Chris@42 763 for (i = 0; i < rnk; ++i)
Chris@42 764 if (dims0[i].n < 1 || dims0[i].ib < 0 || dims0[i].ob < 0)
Chris@42 765 return 0;
Chris@42 766
Chris@42 767 MPI_Comm_size(comm, &n_pes);
Chris@42 768 sz = default_sz(rnk, dims0, n_pes, 1);
Chris@42 769
Chris@42 770 sz->dims[rnk-1].n = dims0[rnk-1].n / 2 + 1;
Chris@42 771 if (XM(num_blocks_total)(sz, IB) > n_pes
Chris@42 772 || XM(num_blocks_total)(sz, OB) > n_pes) {
Chris@42 773 XM(dtensor_destroy)(sz);
Chris@42 774 return 0;
Chris@42 775 }
Chris@42 776 sz->dims[rnk-1].n = dims0[rnk-1].n;
Chris@42 777
Chris@42 778 if (kind == R2HC)
Chris@42 779 return X(mkapiplan)(0, flags,
Chris@42 780 XM(mkproblem_rdft2_d)(sz, howmany,
Chris@42 781 r, cr, comm, R2HC,
Chris@42 782 MPI_FLAGS(flags)));
Chris@42 783 else
Chris@42 784 return X(mkapiplan)(0, flags,
Chris@42 785 XM(mkproblem_rdft2_d)(sz, howmany,
Chris@42 786 cr, r, comm, HC2R,
Chris@42 787 MPI_FLAGS(flags)));
Chris@42 788 }
Chris@42 789
Chris@42 790 X(plan) XM(plan_many_dft_r2c)(int rnk, const ptrdiff_t *n,
Chris@42 791 ptrdiff_t howmany,
Chris@42 792 ptrdiff_t iblock, ptrdiff_t oblock,
Chris@42 793 R *in, C *out,
Chris@42 794 MPI_Comm comm, unsigned flags)
Chris@42 795 {
Chris@42 796 XM(ddim) *dims = simple_dims(rnk, n);
Chris@42 797 X(plan) pln;
Chris@42 798
Chris@42 799 if (rnk == 1) {
Chris@42 800 dims[0].ib = iblock;
Chris@42 801 dims[0].ob = oblock;
Chris@42 802 }
Chris@42 803 else if (rnk > 1) {
Chris@42 804 dims[0 != (flags & FFTW_MPI_TRANSPOSED_IN)].ib = iblock;
Chris@42 805 dims[0 != (flags & FFTW_MPI_TRANSPOSED_OUT)].ob = oblock;
Chris@42 806 }
Chris@42 807
Chris@42 808 pln = plan_guru_rdft2(rnk,dims,howmany, in,out, comm, R2HC, flags);
Chris@42 809 X(ifree)(dims);
Chris@42 810 return pln;
Chris@42 811 }
Chris@42 812
Chris@42 813 X(plan) XM(plan_many_dft_c2r)(int rnk, const ptrdiff_t *n,
Chris@42 814 ptrdiff_t howmany,
Chris@42 815 ptrdiff_t iblock, ptrdiff_t oblock,
Chris@42 816 C *in, R *out,
Chris@42 817 MPI_Comm comm, unsigned flags)
Chris@42 818 {
Chris@42 819 XM(ddim) *dims = simple_dims(rnk, n);
Chris@42 820 X(plan) pln;
Chris@42 821
Chris@42 822 if (rnk == 1) {
Chris@42 823 dims[0].ib = iblock;
Chris@42 824 dims[0].ob = oblock;
Chris@42 825 }
Chris@42 826 else if (rnk > 1) {
Chris@42 827 dims[0 != (flags & FFTW_MPI_TRANSPOSED_IN)].ib = iblock;
Chris@42 828 dims[0 != (flags & FFTW_MPI_TRANSPOSED_OUT)].ob = oblock;
Chris@42 829 }
Chris@42 830
Chris@42 831 pln = plan_guru_rdft2(rnk,dims,howmany, out,in, comm, HC2R, flags);
Chris@42 832 X(ifree)(dims);
Chris@42 833 return pln;
Chris@42 834 }
Chris@42 835
Chris@42 836 X(plan) XM(plan_dft_r2c)(int rnk, const ptrdiff_t *n, R *in, C *out,
Chris@42 837 MPI_Comm comm, unsigned flags)
Chris@42 838 {
Chris@42 839 return XM(plan_many_dft_r2c)(rnk, n, 1,
Chris@42 840 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 841 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 842 in, out, comm, flags);
Chris@42 843 }
Chris@42 844
Chris@42 845 X(plan) XM(plan_dft_r2c_2d)(ptrdiff_t nx, ptrdiff_t ny, R *in, C *out,
Chris@42 846 MPI_Comm comm, unsigned flags)
Chris@42 847 {
Chris@42 848 ptrdiff_t n[2];
Chris@42 849 n[0] = nx; n[1] = ny;
Chris@42 850 return XM(plan_dft_r2c)(2, n, in, out, comm, flags);
Chris@42 851 }
Chris@42 852
Chris@42 853 X(plan) XM(plan_dft_r2c_3d)(ptrdiff_t nx, ptrdiff_t ny, ptrdiff_t nz,
Chris@42 854 R *in, C *out, MPI_Comm comm, unsigned flags)
Chris@42 855 {
Chris@42 856 ptrdiff_t n[3];
Chris@42 857 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 858 return XM(plan_dft_r2c)(3, n, in, out, comm, flags);
Chris@42 859 }
Chris@42 860
Chris@42 861 X(plan) XM(plan_dft_c2r)(int rnk, const ptrdiff_t *n, C *in, R *out,
Chris@42 862 MPI_Comm comm, unsigned flags)
Chris@42 863 {
Chris@42 864 return XM(plan_many_dft_c2r)(rnk, n, 1,
Chris@42 865 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 866 FFTW_MPI_DEFAULT_BLOCK,
Chris@42 867 in, out, comm, flags);
Chris@42 868 }
Chris@42 869
Chris@42 870 X(plan) XM(plan_dft_c2r_2d)(ptrdiff_t nx, ptrdiff_t ny, C *in, R *out,
Chris@42 871 MPI_Comm comm, unsigned flags)
Chris@42 872 {
Chris@42 873 ptrdiff_t n[2];
Chris@42 874 n[0] = nx; n[1] = ny;
Chris@42 875 return XM(plan_dft_c2r)(2, n, in, out, comm, flags);
Chris@42 876 }
Chris@42 877
Chris@42 878 X(plan) XM(plan_dft_c2r_3d)(ptrdiff_t nx, ptrdiff_t ny, ptrdiff_t nz,
Chris@42 879 C *in, R *out, MPI_Comm comm, unsigned flags)
Chris@42 880 {
Chris@42 881 ptrdiff_t n[3];
Chris@42 882 n[0] = nx; n[1] = ny; n[2] = nz;
Chris@42 883 return XM(plan_dft_c2r)(3, n, in, out, comm, flags);
Chris@42 884 }
Chris@42 885
Chris@42 886 /*************************************************************************/
Chris@42 887 /* New-array execute functions */
Chris@42 888
Chris@42 889 void XM(execute_dft)(const X(plan) p, C *in, C *out) {
Chris@42 890 /* internally, MPI plans are just rdft plans */
Chris@42 891 X(execute_r2r)(p, (R*) in, (R*) out);
Chris@42 892 }
Chris@42 893
Chris@42 894 void XM(execute_dft_r2c)(const X(plan) p, R *in, C *out) {
Chris@42 895 /* internally, MPI plans are just rdft plans */
Chris@42 896 X(execute_r2r)(p, in, (R*) out);
Chris@42 897 }
Chris@42 898
Chris@42 899 void XM(execute_dft_c2r)(const X(plan) p, C *in, R *out) {
Chris@42 900 /* internally, MPI plans are just rdft plans */
Chris@42 901 X(execute_r2r)(p, (R*) in, out);
Chris@42 902 }
Chris@42 903
Chris@42 904 void XM(execute_r2r)(const X(plan) p, R *in, R *out) {
Chris@42 905 /* internally, MPI plans are just rdft plans */
Chris@42 906 X(execute_r2r)(p, in, out);
Chris@42 907 }