MPI_REDUCE_LOCAL(3)

📦
version 5.0.10 · 7 versions
, in ubuntu stonking

👑 NAME 👑 (the vibe)

MPI_Reduce_local — do a reduction all by yourself, no friends required. It's the Open MPI man page, bestie. 🫶

🎀 SYNTAX 🎀

C Syntax

#include <mpi.h>

int MPI_Reduce_local(const void *inbuf, void *inoutbuf, int count,
     MPI_Datatype datatype, MPI_Op op)

Fortran Syntax

USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_REDUCE_LOCAL(INBUF, INOUTBUF, COUNT, DATATYPE, OP, IERROR)
     <type>  INBUF(*), INOUTBUF(*)
     INTEGER COUNT, DATATYPE, OP, IERROR

Fortran 2008 Syntax

USE mpi_f08
MPI_Reduce_local(inbuf, inoutbuf, count, datatype, op, ierror)
     TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf
     TYPE(*), DIMENSION(..) :: inoutbuf
     INTEGER, INTENT(IN) :: count
     TYPE(MPI_Datatype), INTENT(IN) :: datatype
     TYPE(MPI_Op), INTENT(IN) :: op
     INTEGER, OPTIONAL, INTENT(OUT) :: ierror

🌸 INPUT PARAMETERS 🌸

  • inbuf — the address of the input buffer (choice). The drama starts here. ✨
  • count — number of elements in the input buffer (integer). Count them, babes.
  • datatype — the data type of the elements of the input buffer (handle). 👑
  • op — the reduce operation (handle). This is the flavor of reduction you want.

💅 OUTPUT PARAMETERS 💅

  • inoutbuf — address of the in/out buffer (choice). Yes bestie, it's read and written. Main character behaviour.
  • ierror — Fortran only: error status (integer).

✨ DESCRIPTION ✨

okay so, the global reduce functions — that's MPI_Reduce_local, MPI_Op_create, MPI_Op_free, MPI_Allreduce, MPI_Reduce_local_scatter, and MPI_Scan — they all do a global reduce operation (think: sum, max, logical AND, that whole genre) across all the members of a group. The reduction operation can be one of the predefined ops, or one you made yourself, no gatekeeping. The global reduction functions come in a few flavors: a reduce that hands the result back at one node, an all-reduce that gives it to every node, and a scan (parallel prefix) operation. And bonus: a reduce-scatter operation that fuses a reduce and a scatter together, like a collab. 🎤

MPI_Reduce_local combines the elements you drop into the input and input/output buffers of the local process, using the operation op, and returns the combined value in the inout/output buffer. The input buffer is defined by the arguments inbuf, count, and datatype; the output buffer is defined by the arguments inoutbuf, count, and datatype. Both have the same number of elements, with the same type. And this routine is a local call — no comms, just vibes. The process can provide one element, or a whole sequence of elements, in which case the combine operation runs element-wise on each entry of the sequence. For example, if the operation is MPI_MAX and the input buffer contains two elements that are floating-point numbers (count = 2 and datatype = MPI_FLOAT), then inoutbuf(1) = global max (inbuf(1)) and inoutbuf(2) = global max(inbuf(2)). Periodt. 💅

🚫 USE OF IN-PLACE OPTION 🚫

The use of MPI_IN_PLACE is disallowed with MPI_Reduce_local. Not allowed. Nope. Don't even try it bestie, it's giving forbidden fruit. 💀

🔥 PREDEFINED REDUCE OPERATIONS 🔥

The set of predefined operations MPI hands you is listed below (Predefined Reduce Operations). That section also enumerates the datatypes each operation can be applied to. On top of that, users may define their own operations that can be overloaded to operate on several datatypes, either basic or derived. That's explained more in the description of the user-defined operations (see the man pages for MPI_Op_create and MPI_Op_free). 🎀

The operation op is always assumed to be associative. All predefined operations are also assumed to be commutative. Users may define operations that are assumed to be associative, but not commutative. The ``canonical'' evaluation order of a reduction is determined by the ranks of the processes in the group. However, the implementation can take advantage of associativity, or associativity and commutativity, in order to change the order of evaluation. This may change the result of the reduction for operations that are not strictly associative and commutative, such as floating point addition. ⚠️ So like, if your op is chaotic, don't be shocked when the math is chaotic back.

Predefined operators work only with the MPI types listed below (Predefined Reduce Operations, and the section MINLOC and MAXLOC, below). User-defined operators may operate on general, derived datatypes. In this case, each argument that the reduce operation is applied to is one element described by such a datatype, which may contain several basic values. This is further explained in Section 4.9.4 of the MPI Standard, “User-Defined Operations.”

The following predefined operations are supplied for MPI_Reduce_local and related functions MPI_Allreduce, MPI_Reduce_scatter, and MPI_Scan. These operations are invoked by placing the following in op:

Name                Meaning
---------           --------------------
MPI_MAX             maximum
MPI_MIN             minimum
MPI_SUM             sum
MPI_PROD            product
MPI_LAND            logical and
MPI_BAND            bit-wise and
MPI_LOR             logical or
MPI_BOR             bit-wise or
MPI_LXOR            logical xor
MPI_BXOR            bit-wise xor
MPI_MAXLOC          max value and location
MPI_MINLOC          min value and location

The two operations MPI_MINLOC and MPI_MAXLOC are discussed separately below (MINLOC and MAXLOC). For the other predefined operations, we enumerate below the allowed combinations of op and datatype arguments. First, define groups of MPI basic datatypes in the following way:

C integer:            MPI_INT, MPI_LONG, MPI_SHORT,
                      MPI_UNSIGNED_SHORT, MPI_UNSIGNED,
                      MPI_UNSIGNED_LONG
Fortran integer:      MPI_INTEGER
Floating-point:       MPI_FLOAT, MPI_DOUBLE, MPI_REAL,
                      MPI_DOUBLE_PRECISION, MPI_LONG_DOUBLE
Logical:              MPI_LOGICAL
Complex:              MPI_COMPLEX
Byte:                 MPI_BYTE

Now, the valid datatypes for each option is specified below. ✨

Op                              Allowed Types
----------------         ---------------------------
MPI_MAX, MPI_MIN                C integer, Fortran integer,
                                        floating-point

MPI_SUM, MPI_PROD               C integer, Fortran integer,
                                        floating-point, complex

MPI_LAND, MPI_LOR,              C integer, logical
MPI_LXOR

MPI_BAND, MPI_BOR,              C integer, Fortran integer, byte
MPI_BXOR

🦋 MINLOC AND MAXLOC 🦋

The operator MPI_MINLOC is used to compute a global minimum and an index attached to the minimum value. MPI_MAXLOC similarly computes a global maximum and index. One application of these is to compute a global minimum (maximum) and the rank of the process containing this value. So like — who's the best, and which rank are they? 👑

The operation that defines MPI_MAXLOC is

            ( u )    (  v )      ( w )
            (   )  o (    )   =  (   )
            ( i )    (  j )      ( k )

where

     w = max(u, v)

and

            ( i            if u > v
            (
      k   = ( min(i, j)    if u = v
            (
            (  j           if u < v)

MPI_MINLOC is defined similarly:

            ( u )    (  v )      ( w )
            (   )  o (    )   =  (   )
            ( i )    (  j )      ( k )

where

     w = min(u, v)

and

            ( i            if u < v
            (
      k   = ( min(i, j)    if u = v
            (
            (  j           if u > v)

Both operations are associative and commutative. Note that if MPI_MAXLOC is applied to reduce a sequence of pairs (u(0), 0), (u(1), 1), …, (u(n-1), n-1), then the value returned is (u , r), where u= max(i) u(i) and r is the index of the first global maximum in the sequence. Thus, if each process supplies a value and its rank within the group, then a reduce operation with op = MPI_MAXLOC will return the maximum value and the rank of the first process with that value. Similarly, MPI_MINLOC can be used to return a minimum and its index. More generally, MPI_MINLOC computes a lexicographic minimum, where elements are ordered according to the first component of each pair, and ties are resolved according to the second component. Tie-breaker energy, iconic. 🎀

The reduce operation is defined to operate on arguments that consist of a pair: value and index. For both Fortran and C, types are provided to describe the pair. The potentially mixed-type nature of such arguments is a problem in Fortran. The problem is circumvented, for Fortran, by having the MPI-provided type consist of a pair of the same type as value, and coercing the index to this type also. In C, the MPI-provided pair type has distinct types and the index is an int.

In order to use MPI_MINLOC and MPI_MAXLOC in a reduce operation, one must provide a datatype argument that represents a pair (value and index). MPI provides nine such predefined datatypes. The operations MPI_MAXLOC and MPI_MINLOC can be used with each of the following datatypes:

Fortran:

  • MPI_2REAL — pair of REALs
  • MPI_2DOUBLE_PRECISION — pair of DOUBLE-PRECISION variables
  • MPI_2INTEGER — pair of INTEGERs

C:

  • MPI_FLOAT_INT — float and int
  • MPI_DOUBLE_INT — double and int
  • MPI_LONG_INT — long and int
  • MPI_2INT — pair of ints
  • MPI_SHORT_INT — short and int
  • MPI_LONG_DOUBLE_INT — long double and int

The data type MPI_2REAL is equivalent to:

call MPI_TYPE_CONTIGUOUS(2, MPI_REAL, MPI_2REAL)

Similar statements apply for MPI_2INTEGER, MPI_2DOUBLE_PRECISION, and MPI_2INT.

The datatype MPI_FLOAT_INT is as if defined by the following sequence of instructions.

type[0] = MPI_FLOAT type[1] = MPI_INT disp[0] = 0 disp[1] =
sizeof(float) block[0] = 1 block[1] = 1 MPI_TYPE_STRUCT(2, block,
disp, type, MPI_FLOAT_INT)

Similar statements apply for MPI_LONG_INT and MPI_DOUBLE_INT.

All MPI objects (e.g., MPI_Datatype, MPI_Comm) are of type INTEGER in Fortran. 💜

😭 NOTES ON COLLECTIVE OPERATIONS 😭

The reduction operators (MPI_Op) do not return an error value. As a result, if the functions detect an error, all they can do is either call MPI_Abort or silently skip the problem. Thus, if you change the error handler from MPI_ERRORS_ARE_FATAL to something else, for example, MPI_ERRORS_RETURN, then no error may be indicated. 🙈 Like bestie, it's not ghosting you... it's just that it can't tell you. Not me discovering this at 3am.

The reason for this is the performance problems in ensuring that all collective routines return the same error value. Performance said no. 💅

💀 ERRORS

okay so this part is important, bestie, don't skip it 🫶

Almost all MPI routines return an error value. C routines give it back to you as the return result of the function, and Fortran routines put it in the last argument. (yes, every single time, the last one, they're consistent like that 💅)

Before that error value makes it back to you, the current MPI error handler associated with the communication object (think: communicator, window, file — the whole friend group) gets called. And if no communication object is associated with the MPI call? Then the call is considered attached to MPI_COMM_SELF and it'll call the error handler associated with that.

Now here's the tea ☕ — when MPI_COMM_SELF is not initialized (like: 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
  • via the mpi_initial_errhandler CLI argument to mpiexec, or the info key to MPI_Comm_spawn/MPI_Comm_spawn_multiple.

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

🌈 Predefined error handlers in Open MPI

Open MPI ships with three predefined error handlers you can use, and they are giving very different energies:

  • MPI_ERRORS_ARE_FATAL — causes the program to abort all connected MPI processes. everybody's going down together, sorry bestie 😭
  • MPI_ERRORS_ABORT — an error handler that can be invoked on a communicator, window, file, or session. When it's called on a communicator, it acts as if MPI_Abort was called on that communicator. If it's 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. And if it's called on a session, it aborts only the local process (scoped! we love boundaries 💅).
  • MPI_ERRORS_RETURN — just returns an error code to the application. lowkey the chill one. hands you the receipt and walks away 🧾

🛠️ Making your own

MPI applications can also implement their own error handlers by calling these iconic little duos:

  • 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

so many options, so much main character energy 🌟

⚠️ Note that MPI does not guarantee that an MPI program can continue past an error. like, fr fr. don't assume you just get to keep going, bestie. plan for it. 💀

See the MPI man page for a full list of MPI error codes.

See the Error Handling section of the MPI-3.1 standard for more information.

👀 See also:

  • MPI_Allreduce
  • MPI_Reduce
  • MPI_Reduce_scatter
  • MPI_Scan
  • MPI_Op_create
  • MPI_Op_free

2003-2026, The Open MPI Community

and that's a wrap on MPI_REDUCE_LOCAL(3), bestie!! 🦋 you just read the whole thing, you're literally an icon 👑 this page dropped on Sep 10, 2026, brought to you by the Open MPI Community, and you absolutely ate it. go MPI_Reduce_local something, mwah 💖✨🌸

📦 where this page comes from