### 6.3 2d MPI example ¶

Before we document the FFTW MPI interface in detail, we begin with a simple example outlining how one would perform a two-dimensional `N0` by `N1` complex DFT.

    #include <fftw3-mpi.h>

    int main(int argc, char **argv)
    {
        const ptrdiff_t N0 = ..., N1 = ...;
        fftw_plan plan;
        fftw_complex *data;
        ptrdiff_t alloc_local, local_n0, local_0_start, i, j;

        MPI_Init(&argc, &argv);
        fftw_mpi_init();

        /* get local data size and allocate */
        alloc_local = fftw_mpi_local_size_2d(N0, N1, MPI_COMM_WORLD,
                                             &local_n0, &local_0_start);
        data = fftw_alloc_complex(alloc_local);

        /* create plan for in-place forward DFT */
        plan = fftw_mpi_plan_dft_2d(N0, N1, data, data, MPI_COMM_WORLD,
                                    FFTW_FORWARD, FFTW_ESTIMATE);

        /* initialize data to some function my_function(x,y) */
        for (i = 0; i < local_n0; ++i) for (j = 0; j < N1; ++j)
           data[i*N1 + j] = my_function(local_0_start + i, j);

        /* compute transforms, in-place, as many times as desired */
        fftw_execute(plan);

        fftw_destroy_plan(plan);

        MPI_Finalize();
    }

As can be seen above, the MPI interface follows the same basic style of allocate/plan/execute/destroy as the serial FFTW routines. All of the MPI-specific routines are prefixed with ‘`fftw_mpi_`’ instead of ‘`fftw_`’. There are a few important differences, however:

First, we must call `fftw_mpi_init()` after calling `MPI_Init` (required in all MPI programs) and before calling any other ‘`fftw_mpi_`’ routine.

Second, when we create the plan with `fftw_mpi_plan_dft_2d`, analogous to `fftw_plan_dft_2d`, we pass an additional argument: the communicator, indicating which processes will participate in the transform (here `MPI_COMM_WORLD`, indicating all processes). Whenever you create, execute, or destroy a plan for an MPI transform, you must call the corresponding FFTW routine on all processes in the communicator for that transform. (That is, these are collective calls.) Note that the plan for the MPI transform uses the standard `fftw_execute` and `fftw_destroy` routines (on the other hand, there are MPI-specific new-array execute functions documented below).

Third, all of the FFTW MPI routines take `ptrdiff_t` arguments instead of `int` as for the serial FFTW. `ptrdiff_t` is a standard C integer type which is (at least) 32 bits wide on a 32-bit machine and 64 bits wide on a 64-bit machine. This is to make it easy to specify very large parallel transforms on a 64-bit machine. (You can specify 64-bit transform sizes in the serial FFTW, too, but only by using the ‘`guru64`’ planner interface. See 64-bit Guru Interface.)

Fourth, and most importantly, you don’t allocate the entire two-dimensional array on each process. Instead, you call `fftw_mpi_local_size_2d` to find out what portion of the array resides on each processor, and how much space to allocate. Here, the portion of the array on each process is a `local_n0` by `N1` slice of the total array, starting at index `local_0_start`. The total number of `fftw_complex` numbers to allocate is given by the `alloc_local` return value, which may be greater than `local_n0 * N1` (in case some intermediate calculations require additional storage). The data distribution in FFTW’s MPI interface is described in more detail by the next section.

Given the portion of the array that resides on the local process, it is straightforward to initialize the data (here to a function `myfunction`) and otherwise manipulate it. Of course, at the end of the program you may want to output the data somehow, but synchronizing this output is up to you and is beyond the scope of this manual. (One good way to output a large multi-dimensional distributed array in MPI to a portable binary file is to use the free HDF5 library; see the HDF home page.)