MPI_NEIGHBOR_ALLTOALL(3)

📦

version 5.0.10 · 7 versions

MPI_NEIGHBOR_ALLTOALL(3) 💖

okay so bestie, this is the Open MPI manual page (section 3, the library-calls section, iykyk), and it's about MPI_Neighbor_alltoall and her two iconic sisters. Buckle up, we're doing topology gossip. ✨

🌸 NAME 🌸

MPI_Neighbor_alltoall, MPI_Ineighbor_alltoall, MPI_Neighbor_alltoall_init — all processes send data to neighboring processes in a virtual topology communicator. No cap, that's the whole vibe: it's a group-chat blast radius, but everyone only messages their actual neighbors. 🫶

✨ SYNTAX ✨

💅 C Syntax

#include <mpi.h>

int MPI_Neighbor_alltoall(const void *sendbuf, int sendcount,
     MPI_Datatype sendtype, void *recvbuf, int recvcount,
     MPI_Datatype recvtype, MPI_Comm comm)

int MPI_Ineighbor_alltoall(const void *sendbuf, int sendcount,
     MPI_Datatype sendtype, void *recvbuf, int recvcount,
     MPI_Datatype recvtype, MPI_Comm comm, MPI_Request *request)

int MPI_Neighbor_alltoall_init(const void *sendbuf, int sendcount,
     MPI_Datatype sendtype, void *recvbuf, int recvcount,
     MPI_Datatype recvtype, MPI_Comm comm, MPI_Info info, MPI_Request *request)

🧚 Fortran Syntax

USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_NEIGHBOR_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT,
     RECVTYPE, COMM, IERROR)

     <type>  SENDBUF(*), RECVBUF(*)
     INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE
     INTEGER COMM, IERROR

MPI_INEIGHBOR_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT,
     RECVTYPE, COMM, REQUEST, IERROR)

     <type>  SENDBUF(*), RECVBUF(*)
     INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE
     INTEGER COMM, REQUEST, IERROR

MPI_NEIGHBOR_ALLTOALL_INIT(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT,
     RECVTYPE, COMM, INFO, REQUEST, IERROR)

     <type>  SENDBUF(*), RECVBUF(*)
     INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE
     INTEGER COMM, INFO, REQUEST, IERROR

🦋 Fortran 2008 Syntax

USE mpi_f08
MPI_Neighbor_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount,
             recvtype, comm, ierror)

     TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf
     TYPE(*), DIMENSION(..) :: recvbuf
     INTEGER, INTENT(IN) :: sendcount, recvcount
     TYPE(MPI_Datatype), INTENT(IN) :: sendtype, recvtype
     TYPE(MPI_Comm), INTENT(IN) :: comm
     INTEGER, OPTIONAL, INTENT(OUT) :: ierror

MPI_Ineighbor_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount,
             recvtype, comm, request, ierror)

     TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf
     TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf
     INTEGER, INTENT(IN) :: sendcount, recvcount
     TYPE(MPI_Datatype), INTENT(IN) :: sendtype, recvtype
     TYPE(MPI_Comm), INTENT(IN) :: comm
     TYPE(MPI_Request), INTENT(OUT) :: request
     INTEGER, OPTIONAL, INTENT(OUT) :: ierror

MPI_Neighbor_alltoall_init(sendbuf, sendcount, sendtype, recvbuf, recvcount,
             recvtype, comm, info, request, ierror)

     TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf
     TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf
     INTEGER, INTENT(IN) :: sendcount, recvcount
     TYPE(MPI_Datatype), INTENT(IN) :: sendtype, recvtype
     TYPE(MPI_Comm), INTENT(IN) :: comm
     TYPE(MPI_Info), INTENT(IN) :: info
     TYPE(MPI_Request), INTENT(OUT) :: request
     INTEGER, OPTIONAL, INTENT(OUT) :: ierror

🎀 INPUT PARAMETERS 🎀

sendbuf — starting address of send buffer (choice). yes bestie, "choice", that's the actual MPI word for it.
sendcount — number of elements to send to each process (integer).
sendtype — datatype of send buffer elements (handle).
recvcount — number of elements to receive from each process (integer).
recvtype — datatype of receive buffer elements (handle).
comm — communicator over which data is to be exchanged (handle).
info — Info (handle, persistent only). only the persistent girly gets an info, periodt.

💜 OUTPUT PARAMETERS 💜

recvbuf — starting address of receive buffer (choice).
request — Request (handle, non-blocking only).
ierror — Fortran only: Error status (integer).

🔥 DESCRIPTION 🔥

MPI_Neighbor_alltoall is a collective operation where literally every process sends and receives the same amount of data to each neighbor. It's the "everyone gets the same-sized gift bag" version of the neighborhood swap. 🎁

The way this routine works can be represented like this — each process does 2n independent point-to-point communications, where n is the number of neighbors in communicator comm. And the neighbors plus the buffer layout? All determined by the topology of comm. Slay. ✨

Example of MPI_Neighbor_alltoall semantics for cartesian topologies:

MPI_Cart_get(comm, maxdims, dims, periods, coords);
for (dim = 0, i = 0 ; dim < dims ; ++dim) {
    MPI_Cart_shift(comm, dim, 1, &r0, &r1);
    MPI_Isend(sendbuf + i * sendcount * extent(sendtype),
              sendcount, sendtype, r0, ..., comm, ...);
    MPI_Irecv(recvbuf + i * recvcount * extent(recvtype),
              recvcount, recvtype, r0, ..., comm, ...);
    ++i;
    MPI_Isend(sendbuf + i * sendcount * extent(sendtype),
              sendcount, sendtype, r1, ..., comm, &req[i]);
    MPI_Irecv(recvbuf + i * recvcount * extent(recvtype),
              recvcount, recvtype, r1, ..., comm, ...);
    ++i;
}

MPI_Waitall (...);

So here's the tea: each process breaks up its local sendbuf into n blocks — each block containing sendcount elements of type sendtype — and divides its recvbuf similarly, according to recvcount and recvtype. Then process j sends the k-th block of its local sendbuf to neighbor k, and neighbor k drops that data into the j-th block of its local recvbuf. The amount of data sent must be equal to the amount of data received, pairwise, between every pair of processes. Like, the vibes have to match on both sides, fr fr. 😭

🌈 NEIGHBOR ORDERING 🌈

Distributed graph topology, created with MPI_Dist_graph_create: the sequence of neighbors in the send and receive buffers at each process is defined as the sequence returned by MPI_Dist_graph_neighbors for destinations and sources, respectively. 👑

General graph topology, created with MPI_Graph_create: the order of neighbors in the send and receive buffers is defined as the sequence of neighbors as returned by MPI_Graph_neighbors. ⭐

ngl bestie, general graph topologies should generally be replaced by the distributed graph topologies. that's not me being mean, that's literally in the manual. 💅

Cartesian topology, created with MPI_Cart_create: the sequence of neighbors in the send and receive buffers at each process is defined by order of the dimensions — first the neighbor in the negative direction and then in the positive direction with displacement 1. The numbers of sources and destinations in the communication routines are 2*ndims, with ndims defined in MPI_Cart_create.

If a neighbor does not exist — i.e., at the border of a Cartesian topology in the case of a non-periodic virtual grid dimension (i.e., periods[…]==false) — then this neighbor is defined to be MPI_PROC_NULL. 🫥

If a neighbor in any of the functions is MPI_PROC_NULL, then the neighborhood collective communication behaves like a point-to-point communication with MPI_PROC_NULL in this direction. That is: the buffer is still part of the sequence of neighbors but it is neither communicated nor updated. It's giving "you're on the list but you're not getting the message." 💀

💖 NOTES 💖

The MPI_IN_PLACE option for sendbuf is not meaningful for this function. Don't try it, bestie.
All arguments on all processes are significant. The comm argument, in particular, must describe the same communicator on all processes. And comm must be either a cartesian, graph, or dist graph communicator. No random communicators allowed, gatekeeping is real. 🚪
There are two MPI library functions that are more general than MPI_Neighbor_alltoall:
- MPI_Neighbor_alltoallv allows all-to-all communication to and from buffers that need not be contiguous; different processes may send and receive different amounts of data. (flexible, chaotic, iconic 💅)
- MPI_Neighbor_alltoallw expands MPI_Neighbor_alltoallv's functionality to allow the exchange of data with different datatypes. (even more unhinged, we love her ✨)

💖 ERRORS 💖

okay bestie, so here's the tea on how errors work — literally almost every MPI routine hands you back an error value. C routines give it to you as the return result of the function, and Fortran routines put it in the last argument. no cap. 🌸

But before that error value even comes back to you, the current MPI error handler attached to the communication object (think: communicator, window, file) gets called. and if there's like, no communication object associated with the MPI call at all? then the call is considered attached to MPI_COMM_SELF and it calls the error handler associated with that instead. 🙈

Now — when MPI_COMM_SELF is not initialized (so: before MPI_Init/MPI_Init_thread, after MPI_Finalize, or when you're using the Sessions Model exclusively), the error raises the initial error handler. and you can change that initial error handler by:

calling MPI_Comm_set_errhandler on MPI_COMM_SELF when you're using the World model, or
the mpi_initial_errhandler CLI argument to mpiexec, or
the info key to MPI_Comm_spawn/MPI_Comm_spawn_multiple.

And if literally no other appropriate error handler has been set? then MPI_ERRORS_RETURN gets called for MPI I/O functions, and MPI_ERRORS_ABORT gets called for all the other MPI functions. that's just how it goes. ✨

🌈 the three predefined error handlers Open MPI ships with 🌈

MPI_ERRORS_ARE_FATAL — causes the program to abort all connected MPI processes. it is giving nuclear option 💀
MPI_ERRORS_ABORT — an error handler that can be invoked on a communicator, window, file, or session. when called on a communicator, it acts as if MPI_Abort was called on that communicator. if called on a window or file, it acts as if MPI_Abort was called on a communicator containing the group of processes in the corresponding window or file. if called on a session, it aborts only the local process. 👑
MPI_ERRORS_RETURN — returns an error code to the application. the chill one 🫶

🎀 and you can absolutely write your own error handlers 🎀

MPI applications can implement their own error handlers by calling:

MPI_Comm_create_errhandler then MPI_Comm_set_errhandler
MPI_File_create_errhandler then MPI_File_set_errhandler
MPI_Session_create_errhandler then MPI_Session_set_errhandler or at MPI_Session_init
MPI_Win_create_errhandler then MPI_Win_set_errhandler

match your create with your set, bestie, that's the whole vibe. 💅

real talk warning: note that MPI does not guarantee that an MPI program can continue past an error. like, it might. it might not. don't build your whole personality on it continuing. 😭

Wanna see every single MPI error code laid out? check the MPI man page for a full list of MPI error codes. and for the deep lore, see the Error Handling section of the MPI-3.1 standard. 📚

👀 See also

MPI_Neighbor_alltoallv
MPI_Neighbor_alltoallw
MPI_Cart_create
MPI_Graph_create
MPI_Dist_graph_create
MPI_Dist_graph_create_adjacent

💜 Copyright 💜

2003-2026, The Open MPI Community

and that's a wrap on the whole page, bestie!! 🥳 this was from the Open MPI source, version MPI_NEIGHBOR_ALLTOALL(3), dated Sep 10, 2026 — go forth and neighbor-alltoall your little heart out, you absolute icon 💅✨🦋

📦 where this page comes from

ubuntu stonking: openmpi-doc 5.0.10-6 · other
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-11-03: a language model's rewrite of the original, under its terms