int main(int argc, char **argv) { int np[2]; ptrdiff_t n[4]; ptrdiff_t alloc_local; ptrdiff_t local_ni[4], local_i_start[4]; ptrdiff_t local_no[4], local_o_start[4]; double err, *in; pfft_complex *out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; /* Set size of FFT and process mesh */ n[0] = 13; n[1] = 14; n[2] = 19; n[3] = 17; np[0] = 2; np[1] = 2; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_dft_r2c(4, n, comm_cart_2d, PFFT_TRANSPOSED_OUT, local_ni, local_i_start, local_no, local_o_start); /* Allocate memory */ in = pfft_alloc_real(2 * alloc_local); out = pfft_alloc_complex(alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_dft_r2c( 4, n, in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back = pfft_plan_dft_c2r( 4, n, out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Initialize input with random numbers */ pfft_init_input_real(4, n, local_ni, local_i_start, in); /* execute parallel forward FFT */ pfft_execute(plan_forw); /* execute parallel backward FFT */ pfft_execute(plan_back); /* Scale data */ for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2] * local_ni[3]; l++) in[l] /= (n[0]*n[1]*n[2]*n[3]); /* Print error of back transformed data */ MPI_Barrier(MPI_COMM_WORLD); err = pfft_check_output_real(4, n, local_ni, local_i_start, in, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td, %td):\n", n[0], n[1], n[2], n[3]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); pfft_free(in); pfft_free(out); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int np[2]; ptrdiff_t n[4], ni[4], no[4]; ptrdiff_t alloc_local_forw, alloc_local_back, alloc_local, howmany; ptrdiff_t local_ni[4], local_i_start[4]; ptrdiff_t local_n[4], local_start[4]; ptrdiff_t local_no[4], local_o_start[4]; double err; double *planned_in, *executed_in; pfft_complex *planned_out, *executed_out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; /* Set size of FFT and process mesh */ ni[0] = ni[1] = ni[2] = ni[3] = 8; n[0] = 13; n[1] = 14; n[2] = 15; n[3] = 17; for(int t=0; t<4; t++) no[t] = ni[t]; np[0] = 2; np[1] = 2; howmany = 1; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local_forw = pfft_local_size_many_dft_r2c(4, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni, local_i_start, local_n, local_start); alloc_local_back = pfft_local_size_many_dft_c2r(4, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_n, local_start, local_no, local_o_start); /* Allocate enough memory for both trafos */ alloc_local = (alloc_local_forw > alloc_local_back) ? alloc_local_forw : alloc_local_back; planned_in = pfft_alloc_real(2 * alloc_local); planned_out = pfft_alloc_complex(alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_many_dft_r2c( 4, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, planned_in, planned_out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back = pfft_plan_many_dft_c2r( 4, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, planned_out, planned_in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Free planning arrays since we use other arrays for execution */ pfft_free(planned_in); pfft_free(planned_out); /* Allocate memory for execution */ executed_in = pfft_alloc_real(2 * alloc_local); executed_out = pfft_alloc_complex(alloc_local); /* Initialize input with random numbers */ pfft_init_input_real(4, n, local_ni, local_i_start, executed_in); /* execute parallel forward FFT */ pfft_execute_dft_r2c(plan_forw, executed_in, executed_out); /* clear the old input */ pfft_clear_input_real(4, n, local_ni, local_i_start, executed_in); /* execute parallel backward FFT */ pfft_execute_dft_c2r(plan_back, executed_out, executed_in); /* Scale data */ for(ptrdiff_t l=0; l < local_no[0] * local_no[1] * local_no[2] * local_no[3]; l++) executed_in[l] /= (n[0]*n[1]*n[2]*n[3]); /* Print error of back transformed data */ MPI_Barrier(MPI_COMM_WORLD); err = pfft_check_output_real(4, n, local_no, local_o_start, executed_in, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td, %td):\n", n[0], n[1], n[2], n[3]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); pfft_free(executed_in); pfft_free(executed_out); MPI_Finalize(); return 0; }
int main(int argc, char **argv){ ptrdiff_t n[3], gc_below[3], gc_above[3]; ptrdiff_t local_ni[3], local_i_start[3]; ptrdiff_t local_no[3], local_o_start[3]; ptrdiff_t local_ngc[3], local_gc_start[3]; ptrdiff_t alloc_local, alloc_local_gc; int np[3], rnk_self, size, verbose; double err; MPI_Comm comm_cart_2d; pfft_complex *data; pfft_gcplan ths; MPI_Init(&argc, &argv); pfft_init(); MPI_Comm_rank(MPI_COMM_WORLD, &rnk_self); MPI_Comm_size(MPI_COMM_WORLD, &size); /* default values */ n[0] = n[1] = n[2] = 8; /* n[0] = 3; n[1] = 5; n[2] = 7;*/ np[0]=2; np[1]=2; np[2] = 1; verbose = 0; for(int t=0; t<3; t++){ gc_below[t] = 0; gc_above[t] = 0; } gc_below[0] = 0; gc_above[0] = 8; /* set values by commandline */ init_parameters(argc, argv, n, np, gc_below, gc_above, &verbose); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_dft_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni, local_i_start, local_no, local_o_start); alloc_local_gc = pfft_local_size_gc_3d( local_ni, local_i_start, alloc_local, gc_below, gc_above, local_ngc, local_gc_start); /* Allocate memory */ data = pfft_alloc_complex(alloc_local_gc); /* Plan parallel ghost cell send */ ths = pfft_plan_cgc_3d(n, gc_below, gc_above, data, comm_cart_2d, PFFT_GC_NONTRANSPOSED); /* Initialize input with random numbers */ pfft_init_input_c2c_3d(n, local_ni, local_i_start, data); /* check gcell input */ if(verbose) pfft_apr_complex_3d(data, local_ni, local_i_start, "gcell input", comm_cart_2d); /* Execute parallel ghost cell send */ pfft_exchange(ths); /* Check gcell output */ if(verbose) pfft_apr_complex_3d(data, local_ngc, local_gc_start, "exchanged gcells", comm_cart_2d); /* Execute adjoint parallel ghost cell send */ pfft_reduce(ths); /* check input */ if(verbose) pfft_apr_complex_3d(data, local_no, local_o_start, "reduced gcells", comm_cart_2d); /* Scale data */ for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++) data[l] /= 3; /* Print error of back transformed data */ MPI_Barrier(comm_cart_2d); err = pfft_check_output_c2c_3d(n, local_ni, local_i_start, data, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one gcell exchange and reduce of size n=(%td, %td, %td),\n", n[0], n[1], n[2]); pfft_printf(comm_cart_2d, "gc_below = (%td, %td, %td), gc_above = (%td, %td, %td):\n", gc_below[0], gc_below[1], gc_below[2], gc_above[0], gc_above[1], gc_above[2]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_gcplan(ths); MPI_Comm_free(&comm_cart_2d); pfft_free(data); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int np[3]; ptrdiff_t n[4], N[4]; ptrdiff_t alloc_local; ptrdiff_t local_ni[4], local_i_start[4]; ptrdiff_t local_no[4], local_o_start[4]; double err, *in, *out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_3d; pfft_r2r_kind kinds_forw[4], kinds_back[4]; /* Set size of FFT and process mesh */ n[0] = 13; n[1] = 14; n[2] = 19; n[3] = 17; np[0] = 2; np[1] = 2; np[2] = 2; /* Set FFTW kinds of 1d R2R trafos */ kinds_forw[0] = PFFT_REDFT00; kinds_back[0] = PFFT_REDFT00; kinds_forw[1] = PFFT_REDFT01; kinds_back[1] = PFFT_REDFT10; kinds_forw[2] = PFFT_RODFT00; kinds_back[2] = PFFT_RODFT00; kinds_forw[3] = PFFT_RODFT10; kinds_back[3] = PFFT_RODFT01; /* Set logical DFT sizes corresponding to FFTW manual: * for REDFT00 N=2*(n-1), for RODFT00 N=2*(n+1), otherwise N=2*n */ N[0] = 2*(n[0]-1); N[1] = 2*n[1]; N[2] = 2*(n[2]+1); N[3] = 2*n[3]; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create three-dimensional process grid of size np[0] x np[1] x np[2], if possible */ if( pfft_create_procmesh(3, MPI_COMM_WORLD, np, &comm_cart_3d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]*np[2]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_r2r(4, n, comm_cart_3d, PFFT_TRANSPOSED_NONE, local_ni, local_i_start, local_no, local_o_start); /* Allocate memory */ in = pfft_alloc_real(alloc_local); out = pfft_alloc_real(alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_r2r( 4, n, in, out, comm_cart_3d, kinds_forw, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back = pfft_plan_r2r( 4, n, out, in, comm_cart_3d, kinds_back, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Initialize input with random numbers */ pfft_init_input_real(4, n, local_ni, local_i_start, in); /* execute parallel forward FFT */ pfft_execute(plan_forw); /* clear the old input */ pfft_clear_input_real(4, n, local_ni, local_i_start, in); /* execute parallel backward FFT */ pfft_execute(plan_back); /* Scale data */ for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2] * local_ni[3]; l++) in[l] /= (N[0]*N[1]*N[2]*N[3]); /* Print error of back transformed data */ MPI_Barrier(MPI_COMM_WORLD); err = pfft_check_output_real(4, n, local_ni, local_i_start, in, comm_cart_3d); pfft_printf(comm_cart_3d, "Error after one forward and backward trafo of size n=(%td, %td, %td, %td):\n", n[0], n[1], n[2], n[3]); pfft_printf(comm_cart_3d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_3d); pfft_free(in); pfft_free(out); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int nthreads=1; /*number of threads to initialize openmp with*/ int runs=1; /*number of runs for testing*/ int np[2]; ptrdiff_t n[3]; ptrdiff_t alloc_local; ptrdiff_t local_ni[3], local_i_start[3]; ptrdiff_t local_no[3], local_o_start[3]; double err; pfft_complex *in, *out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; /* Init OpenMP */ pfft_get_args(argc,argv,"-pfft_omp_threads",1,PFFT_INT,&nthreads); pfft_get_args(argc,argv,"-pfft_runs",1,PFFT_INT,&runs); pfft_plan_with_nthreads(nthreads); /* Set size of FFT and process mesh */ n[0] = NNN;n[1] =NNN; n[2] =NNN; np[0] = 1; np[1] = 1; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); pfft_plan_with_nthreads(nthreads); pfft_printf(MPI_COMM_WORLD, "# %4d threads will be used for openmp (default is 1)\n", nthreads); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_dft_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni, local_i_start, local_no, local_o_start); /* Allocate memory */ in = pfft_alloc_complex(alloc_local); out = pfft_alloc_complex(alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_dft_3d( n, in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT| PFFT_TUNE| PFFT_SHIFTED_IN); /* Plan parallel backward FFT */ plan_back = pfft_plan_dft_3d( n, out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT| PFFT_TUNE| PFFT_SHIFTED_OUT); /* Initialize input with random numbers */ pfft_init_input_complex_3d(n, local_ni, local_i_start, in); for(int i=0; i<runs; i++) { /* execute parallel forward FFT */ pfft_execute(plan_forw); /* clear the old input */ /* pfft_clear_input_complex_3d(n, local_ni, local_i_start, in); */ /* execute parallel backward FFT */ pfft_execute(plan_back); /* Scale data */ ptrdiff_t l; for(l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++) in[l] /= (n[0]*n[1]*n[2]); } pfft_print_average_timer_adv(plan_forw, MPI_COMM_WORLD); pfft_print_average_timer_adv(plan_back, MPI_COMM_WORLD); /* Print error of back transformed data */ err = pfft_check_output_complex_3d(n, local_ni, local_i_start, in, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after %d forward and backward trafos of size n=(%td, %td, %td):\n", runs, n[0], n[1], n[2]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); pfft_free(in); pfft_free(out); MPI_Finalize(); return 0; }
static void measure_pfft( const ptrdiff_t *n, int *np, MPI_Comm comm, int loops, int inplace, unsigned pfft_opt_flags ) { ptrdiff_t alloc_local; ptrdiff_t local_ni[3], local_i_start[3]; ptrdiff_t local_no[3], local_o_start[3]; double err=0.0, timer[4], max_timer[4]; pfft_complex *in, *out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(comm, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(comm, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); return; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_dft_3d(n, comm_cart_2d, PFFT_TRANSPOSED_OUT, local_ni, local_i_start, local_no, local_o_start); /* Allocate memory */ in = pfft_alloc_complex(alloc_local); out = (inplace) ? in : pfft_alloc_complex(alloc_local); /* Plan parallel forward FFT */ timer[0] = -MPI_Wtime(); plan_forw = pfft_plan_dft_3d( n, in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_OUT| pfft_opt_flags); timer[0] += MPI_Wtime(); /* Plan parallel backward FFT */ timer[1] = -MPI_Wtime(); plan_back = pfft_plan_dft_3d( n, out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_IN| pfft_opt_flags); timer[1] += MPI_Wtime(); /* Initialize input with random numbers */ pfft_init_input_complex_3d(n, local_ni, local_i_start, in); pfft_reset_timer(plan_forw); pfft_reset_timer(plan_back); timer[2] = timer[3] = 0; for(int t=0; t<loops; t++){ /* execute parallel forward FFT */ MPI_Barrier(MPI_COMM_WORLD); timer[2] -= MPI_Wtime(); pfft_execute(plan_forw); timer[2] += MPI_Wtime(); /* execute parallel backward FFT */ MPI_Barrier(MPI_COMM_WORLD); timer[3] -= MPI_Wtime(); pfft_execute(plan_back); timer[3] += MPI_Wtime(); /* Scale data */ for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++) in[l] /= (n[0]*n[1]*n[2]); } timer[2] /= loops; timer[3] /= loops; /* Print pfft timer */ pfft_print_average_timer_adv(plan_forw, comm_cart_2d); pfft_print_average_timer_adv(plan_back, comm_cart_2d); /* Print optimization flags */ pfft_printf(comm_cart_2d, "\nFlags = "); if(pfft_opt_flags & PFFT_TUNE) pfft_printf(comm_cart_2d, "PFFT_TUNE"); else pfft_printf(comm_cart_2d, "PFFT_NO_TUNE"); pfft_printf(comm_cart_2d, " | "); if(pfft_opt_flags & PFFT_ESTIMATE) pfft_printf(comm_cart_2d, "PFFT_ESTIMATE"); else if(pfft_opt_flags & PFFT_PATIENT) pfft_printf(comm_cart_2d, "PFFT_PATIENT"); else if(pfft_opt_flags & PFFT_EXHAUSTIVE) pfft_printf(comm_cart_2d, "PFFT_EXHAUSTIVE"); else pfft_printf(comm_cart_2d, "PFFT_MEASURE"); pfft_printf(comm_cart_2d, " | "); if(pfft_opt_flags & PFFT_DESTROY_INPUT) pfft_printf(comm_cart_2d, "PFFT_DESTROY_INPUT"); else pfft_printf(comm_cart_2d, "PFFT_PRESERVE_INPUT"); pfft_printf(comm_cart_2d, "\n"); /* Print error of back transformed data */ err = pfft_check_output_complex_3d(n, local_ni, local_i_start, in, comm_cart_2d); pfft_printf(comm_cart_2d, "Run %d loops of ", loops); if(inplace) pfft_printf(comm_cart_2d, "in-place"); else pfft_printf(comm_cart_2d, "out-of-place"); pfft_printf(comm_cart_2d, " forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]); MPI_Reduce(&timer, &max_timer, 4, MPI_DOUBLE, MPI_MAX, 0, comm_cart_2d); pfft_printf(comm_cart_2d, "tune_forw = %6.2e; tune_back = %6.2e, exec_forw = %6.2e, exec_back = %6.2e, error = %6.2e\n", max_timer[0], max_timer[1], max_timer[2], max_timer[3], err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); if(in != out) pfft_free(out); pfft_free(in); }
int main(int argc, char **argv) { int np[2]; ptrdiff_t n[3], ni[3], no[3]; ptrdiff_t alloc_local_forw, alloc_local_back, alloc_local, howmany; ptrdiff_t local_ni[3], local_i_start[3]; ptrdiff_t local_n[3], local_start[3]; ptrdiff_t local_no[3], local_o_start[3]; double err, *out; pfft_complex *in; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; /* Set size of FFT and process mesh */ ni[0] = ni[1] = ni[2] = no[0] = no[1] = no[2] = 16; n[0] = 29; n[1] = 27; n[2] = 31; np[0] = 2; np[1] = 2; howmany = 1; // ni[0] = 2; ni[1] = 4; ni[2] = 3; // n[0] = 2; n[1] = 4; n[2] = 3; // no[0] = 2; no[1] = 4; no[2] = 3; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local_forw = pfft_local_size_many_dft_c2r(3, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni, local_i_start, local_n, local_start); alloc_local_back = pfft_local_size_many_dft_r2c(3, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_n, local_start, local_no, local_o_start); alloc_local = (alloc_local_forw > alloc_local_back) ? alloc_local_forw : alloc_local_back; /* Allocate memory */ in = pfft_alloc_complex(alloc_local); out = pfft_alloc_real(2 * alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_many_dft_c2r( 3, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back = pfft_plan_many_dft_r2c( 3, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS, out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Initialize input with some numbers */ pfft_init_input_complex_hermitian_3d(ni, local_ni, local_i_start, in); // pfft_apr_complex_3d(in, local_ni, local_i_start, "in: ", comm_cart_2d); /* execute parallel forward FFT */ pfft_execute(plan_forw); /* clear the old input */ pfft_clear_input_complex_hermitian_3d(ni, local_ni, local_i_start, in); // pfft_apr_real_3d(out, local_n, local_start, "out: ", comm_cart_2d); /* execute parallel backward FFT */ pfft_execute(plan_back); /* Scale data */ for(ptrdiff_t l=0; l < local_no[0] * local_no[1] * local_no[2]; l++) in[l] /= (n[0]*n[1]*n[2]); /* Print error of back transformed data */ MPI_Barrier(MPI_COMM_WORLD); err = pfft_check_output_complex_hermitian_3d(no, local_no, local_o_start, in, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); pfft_free(in); pfft_free(out); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int np[2]; ptrdiff_t n[3], N[3]; ptrdiff_t alloc_local; ptrdiff_t local_ni[3], local_i_start[3]; ptrdiff_t local_no[3], local_o_start[3]; double err, *in, *out; pfft_plan plan_forw=NULL, plan_back=NULL; MPI_Comm comm_cart_2d; pfft_r2r_kind kinds_forw[3], kinds_back[3]; /* Set size of FFT and process mesh */ n[0] = 29; n[1] = 27; n[2] = 31; np[0] = 2; np[1] = 2; /* Set FFTW kinds of 1d R2R trafos */ kinds_forw[0] = PFFT_REDFT00; kinds_back[0] = PFFT_REDFT00; kinds_forw[1] = PFFT_REDFT01; kinds_back[1] = PFFT_REDFT10; kinds_forw[2] = PFFT_RODFT00; kinds_back[2] = PFFT_RODFT00; /* Set logical DFT sizes corresponding to FFTW manual: * for REDFT00 N=2*(n-1), for RODFT00 N=2*(n+1), otherwise N=2*n */ N[0] = 2*(n[0]-1); N[1] = 2*n[1]; N[2] = 2*(n[2]+1); /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local = pfft_local_size_r2r_3d(n, comm_cart_2d, PFFT_TRANSPOSED_OUT, local_ni, local_i_start, local_no, local_o_start); /* Allocate memory */ in = pfft_alloc_real(alloc_local); out = pfft_alloc_real(alloc_local); /* Plan parallel forward FFT */ plan_forw = pfft_plan_r2r_3d( n, in, out, comm_cart_2d, kinds_forw, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back = pfft_plan_r2r_3d( n, out, in, comm_cart_2d, kinds_back, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Initialize input with random numbers */ pfft_init_input_real_3d(n, local_ni, local_i_start, in); int myrank, size; MPI_Comm_rank(MPI_COMM_WORLD, &myrank); MPI_Comm_size(MPI_COMM_WORLD, &size); // for(int t=0; t<size; t++){ // if(t == myrank){ // int m=0; // for(int k0=0; k0<local_ni[0]; k0++) // for(int k1=0; k1<local_ni[1]; k1++){ // for(int k2=0; k2<local_ni[2]; k2++, m++) // printf("in[%d, %d, %d] = %.2f\t", k0+local_i_start[0], k1+local_i_start[1], k2+local_i_start[2], in[m]); // printf("\n"); // } // } // fflush(stderr); // MPI_Barrier(MPI_COMM_WORLD); // } /* execute parallel forward FFT */ pfft_execute(plan_forw); // for(int t=0; t<size; t++){ // if(t == myrank){ // int m=0; // for(int k1=0; k1<local_no[1]; k1++) // for(int k2=0; k2<local_no[2]; k2++){ // for(int k0=0; k0<local_no[0]; k0++, m++) // printf("out[%d, %d, %d] = %.2f\t", k0+local_o_start[0], k1+local_o_start[1], k2+local_o_start[2], out[m]); // printf("\n"); // } // } // fflush(stderr); // MPI_Barrier(MPI_COMM_WORLD); // } /* execute parallel backward FFT */ pfft_execute(plan_back); /* Scale data */ for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2]; l++) in[l] /= (N[0]*N[1]*N[2]); /* Print error of back transformed data */ MPI_Barrier(MPI_COMM_WORLD); err = pfft_check_output_real_3d(n, local_ni, local_i_start, in, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw); pfft_destroy_plan(plan_back); MPI_Comm_free(&comm_cart_2d); pfft_free(in); pfft_free(out); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int np[2]; ptrdiff_t n[3]; double err; ptrdiff_t alloc_local_c; ptrdiff_t local_ni_c[3], local_i_start_c[3]; ptrdiff_t local_no_c[3], local_o_start_c[3]; pfft_complex *in_c, *out_c; pfft_plan plan_forw_c=NULL, plan_back_c=NULL; ptrdiff_t alloc_local_r, alloc_local_forw, alloc_local_back; ptrdiff_t local_ni_r[3], local_i_start_r[3]; ptrdiff_t local_no_r[3], local_o_start_r[3]; pfft_complex *in_r; double *out_r; pfft_plan plan_forw_r=NULL, plan_back_r=NULL; MPI_Comm comm_cart_2d; /* Set size of FFT and process mesh */ n[0] = 4; n[1] = 4; n[2] = 6; np[0] = 2; np[1] = 2; /* Initialize MPI and PFFT */ MPI_Init(&argc, &argv); pfft_init(); /* Create two-dimensional process grid of size np[0] x np[1], if possible */ if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ){ pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]); MPI_Finalize(); return 1; } /* Get parameters of data distribution */ alloc_local_c = pfft_local_size_dft_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni_c, local_i_start_c, local_no_c, local_o_start_c); alloc_local_forw = pfft_local_size_dft_c2r_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_ni_r, local_i_start_r, local_no_r, local_o_start_r); alloc_local_back = pfft_local_size_dft_r2c_3d(n, comm_cart_2d, PFFT_TRANSPOSED_NONE, local_no_r, local_o_start_r, local_ni_r, local_i_start_r); alloc_local_r = (alloc_local_forw > alloc_local_back) ? alloc_local_forw : alloc_local_back; /* Allocate memory */ in_c = pfft_alloc_complex(alloc_local_c); out_c = pfft_alloc_complex(alloc_local_c); in_r = pfft_alloc_complex(alloc_local_r); out_r = pfft_alloc_real(2*alloc_local_r); /* Plan parallel forward FFT */ plan_forw_c = pfft_plan_dft_3d( n, in_c, out_c, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); plan_forw_r = pfft_plan_dft_c2r_3d( n, in_r, out_r, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Plan parallel backward FFT */ plan_back_c = pfft_plan_dft_3d( n, out_c, in_c, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); plan_back_r = pfft_plan_dft_r2c_3d( n, out_r, in_r, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_NONE| PFFT_MEASURE| PFFT_DESTROY_INPUT); /* Initialize input with random numbers */ init_input(n, local_ni_c, local_i_start_c, in_c); init_input(n, local_ni_r, local_i_start_r, in_r); /* execute parallel forward FFT */ pfft_execute(plan_forw_c); pfft_execute(plan_forw_r); /* execute parallel backward FFT */ pfft_execute(plan_back_c); pfft_execute(plan_back_r); /* Scale data */ for(ptrdiff_t l=0; l < local_ni_c[0] * local_ni_c[1] * local_ni_c[2]; l++) in_c[l] /= (n[0]*n[1]*n[2]); for(ptrdiff_t l=0; l < local_ni_r[0] * local_ni_r[1] * local_ni_r[2]; l++) in_r[l] /= (n[0]*n[1]*n[2]); /* Print error of back transformed data */ err = compare_c2c_c2r(local_ni_c, local_ni_r, in_c, in_r, comm_cart_2d); pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td):\n", n[0], n[1], n[2]); pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err); /* free mem and finalize */ pfft_destroy_plan(plan_forw_c); pfft_destroy_plan(plan_back_c); pfft_destroy_plan(plan_forw_r); pfft_destroy_plan(plan_back_r); MPI_Comm_free(&comm_cart_2d); pfft_free(in_c); pfft_free(out_c); pfft_free(in_r); pfft_free(out_r); MPI_Finalize(); return 0; }