ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Merge pull request #8165 from Fangcong-Yin/latest_pr

Просмотр исходного кода 
Convert 12 .3in files to md
Этот коммит содержится в:
Jeff Squyres 2020-10-31 22:41:11 -04:00 коммит произвёл GitHub
родитель 6f2a5b91cd 7ee34e9c20
Коммит 5b25a06c7d
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 4AEE18F83AFDEB23
27 изменённых файлов: 1163 добавлений и 1109 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

120
ompi/mpi/man/man3/MPI_Graph_create.3in
Просмотреть файл

@ -1,120 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2013 Los Alamos National Security, LLC. All rights reserved.
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Graph_create 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Graph_create \fP \- Makes a new communicator to which topology information has been attached.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Graph_create(MPI_Comm \fIcomm_old\fP, int\fI nnodes\fP, const int\fI index[]\fP,
const int\fI edges[]\fP, int\fI reorder\fP, MPI_Comm\fI *comm_graph\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_CREATE(\fICOMM_OLD, NNODES, INDEX, EDGES, REORDER,
COMM_GRAPH, IERROR\fP)
INTEGER \fICOMM_OLD, NNODES, INDEX(*), EDGES(*)\fP
INTEGER \fICOMM_GRAPH, IERROR\fP
LOGICAL \fIREORDER\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Graph_create(\fIcomm_old\fP, \fInnodes\fP, \fIindex\fP, \fIedges\fP, \fIreorder\fP, \fIcomm_graph\fP,
\fIierror\fP)
TYPE(MPI_Comm), INTENT(IN) :: \fIcomm_old\fP
INTEGER, INTENT(IN) :: \fInnodes\fP, \fIindex(nnodes)\fP, \fIedges(*)\fP
LOGICAL, INTENT(IN) :: \fIreorder\fP
TYPE(MPI_Comm), INTENT(OUT) :: \fIcomm_graph\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
comm_old
Input communicator without topology (handle).
.TP 1i
nnodes
Number of nodes in graph (integer).
.TP 1i
index
Array of integers describing node degrees (see below).
.TP 1i
edges
Array of integers describing graph edges (see below).
.TP 1i
reorder
Ranking may be reordered (true) or not (false) (logical).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
comm_graph
Communicator with graph topology added (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_Graph_create returns a handle to a new communicator to which the graph topology information is attached. If reorder = false then the rank of each process in the new group is identical to its rank in the old group. Otherwise, the function may reorder the processes. If the size, nnodes, of the graph is smaller than the size of the group of comm_old, then some processes are returned MPI_COMM_NULL, in analogy to MPI_Cart_create and MPI_Comm_split. The call is erroneous if it specifies a graph that is larger than the group size of the input communicator.
.sp
The three parameters nnodes, index, and edges define the graph structure. nnodes is the number of nodes of the graph. The nodes are numbered from 0 to nnodes-1. The ith entry of array index stores the total number of neighbors of the first i graph nodes. The lists of neighbors of nodes 0,\ 1,\ ..., nnodes-1 are stored in consecutive locations in array edges. The array edges is a flattened representation of the edge lists. The total number of entries in index is nnodes and the total number of entries in edges is equal to the number of graph edges.
.sp
The definitions of the arguments nnodes, index, and edges are illustrated with the following simple example.
.sp
\fBExample:\fP Assume there are four processes 0, 1, 2, 3 with the
following adjacency matrix:
.sp
.nf
Process Neighbors
0 1, 3
1 0
2 3
3 0, 2
.fi
.sp
Then, the input arguments are:
.nf
nnodes = 4
index = 2, 3, 4, 6
edges = 1, 3, 0, 3, 0, 2
.fi
.sp
Thus, in C, index[0] is the degree of node zero, and index[i] - index[i-1]
is the degree of node i, i=1, . . . , nnodes-1; the list of neighbors of
node zero is stored in edges[j], for 0 <= j <= index[0] - 1 and the list of
neighbors of node i, i > 0 , is stored in edges[j], index[i-1] <= j <= index[i] - 1.
.sp
In Fortran, index(1) is the degree of node zero, and index(i+1) - index(i)
is the degree of node i, i=1, . . . , nnodes-1; the list of neighbors of
node zero is stored in edges(j), for 1 <= j <= index(1) and the list of
neighbors of node i, i > 0, is stored in edges(j), index(i) + 1 <= j <= index(i + 1).
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Graph_get
.br
MPI_Graphdims_get

125
ompi/mpi/man/man3/MPI_Graph_create.md Обычный файл
Просмотреть файл

@ -0,0 +1,125 @@
# Name
`MPI_Graph_create` - Makes a new communicator to which topology
information has been attached.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Graph_create(MPI_Comm comm_old, int nnodes, const int index[],
const int edges[], int reorder, MPI_Comm *comm_graph)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_CREATE(COMM_OLD, NNODES, INDEX, EDGES, REORDER,
COMM_GRAPH, IERROR)
INTEGER COMM_OLD, NNODES, INDEX(*), EDGES(*)
INTEGER COMM_GRAPH, IERROR
LOGICAL REORDER
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Graph_create(comm_old, nnodes, index, edges, reorder, comm_graph,
ierror)
TYPE(MPI_Comm), INTENT(IN) :: comm_old
INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*)
LOGICAL, INTENT(IN) :: reorder
TYPE(MPI_Comm), INTENT(OUT) :: comm_graph
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `comm_old` : Input communicator without topology (handle).
* `nnodes` : Number of nodes in graph (integer).
* `index` : Array of integers describing node degrees (see below).
* `edges` : Array of integers describing graph edges (see below).
* `reorder` : Ranking may be reordered (true) or not (false) (logical).
# Output Parameters
* `comm_graph` : Communicator with graph topology added (handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_Graph_create` returns a handle to a new communicator to which the
graph topology information is attached. If `reorder` = false then the rank
of each process in the new group is identical to its rank in the old
group. Otherwise, the function may `reorder` the processes. If the size,
`nnodes`, of the graph is smaller than the size of the group of `comm_old`,
then some processes are returned `MPI_COMM_NULL`, in analogy to
`MPI_Cart_create` and `MPI_Comm_split`. The call is erroneous if it
specifies a graph that is larger than the group size of the input
communicator.
The three parameters `nnodes`, `index`, and `edges` define the graph
structure. `nnodes` is the number of nodes of the graph. The nodes are
numbered from 0 to `nnodes`-1. The ith entry of array `index` stores the
total number of neighbors of the first i graph nodes. The lists of
neighbors of nodes 0, 1, ..., `nnodes`-1 are stored in consecutive
locations in array `edges`. The array `edges` is a flattened representation
of the edge lists. The total number of entries in `index` is `nnodes` and
the total number of entries in `edges` is equal to the number of graph
`edges`.
The definitions of the arguments `nnodes`, `index`, and `edges` are
illustrated with the following simple example.
Example: Assume there are four processes 0, 1, 2, 3 with the
following adjacency matrix:
| Process | Neighbors |
| ------- | --------- |
| 0 | 1, 3 |
| 1 | 0 |
| 2 | 3 |
| 3 | 0, 2 |
Then, the input arguments are:
* `nodes` = 4
* `index` = 2, 3, 4, 6
* `edges` = 1, 3, 0, 3, 0, 2
Thus, in C, `index[0]` is the degree of `node` zero, and `index[i]` -
`index[i-1]` is the degree of `node` i, i=1, . . . , nnodes-1; the list of
neighbors of node zero is stored in `edges[j]`, for 0 <= j <=
`index[0] - 1` and the list of neighbors of `node` i, i > 0 , is stored
in `edges[j]`, `index[i-1]` <= j <= `index[i] - 1`.
In Fortran, `index(1)` is the degree of `node` zero, and `index(i+1)` -
`index(i)` is the degree of `node` i, i=1, . . . , nnodes-1; the list of
neighbors of `node` zero is stored in `edges(j)`, for 1 <= j <= `index(1)`
and the list of neighbors of `node` i, i > 0, is stored in `edges(j)`,
`index(i) + 1` <= j <= `index(i + 1)`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Graph_get`(3)](MPI_Graph_get.html)
[`MPI_Graphdims_get`(3)](MPI_Graphdims_get.html)

83
ompi/mpi/man/man3/MPI_Graph_get.3in
Просмотреть файл

@ -1,83 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Graph_get 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Graph_get \fP \- Retrieves graph topology information associated with a communicator.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Graph_get(MPI_Comm \fIcomm\fP, int\fI maxindex\fP, int\fI maxedges\fP,
int\fI index\fP[], int\fI edges\fP[])
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_GET(\fICOMM, MAXINDEX, MAXEDGES, INDEX, EDGES, IERROR\fP)
INTEGER \fICOMM, MAXINDEX, MAXEDGES, INDEX(*)\fP
INTEGER \fIEDGES(*), IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Graph_get(\fIcomm\fP, \fImaxindex\fP, \fImaxedges\fP, \fIindex\fP, \fIedges\fP, \fIierror\fP)
TYPE(MPI_Comm), INTENT(IN) :: \fIcomm\fP
INTEGER, INTENT(IN) :: \fImaxindex\fP, \fImaxedges\fP
INTEGER, INTENT(OUT) :: \fIindex(maxindex)\fP, \fIedges(maxedges)\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
comm
Communicator with graph structure (handle).
.TP 1i
maxindex
Length of vector index in the calling program (integer).
.TP 1i
maxedges
Length of vector edges in the calling program (integer).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
index
Array of integers containing the graph structure (for details see the
definition of MPI_Graph_create).
.TP 1i
edges
Array of integers containing the graph structure.
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
Functions MPI_Graphdims_get and MPI_Graph_get retrieve the graph-topology information that was associated with a communicator by MPI_Graph_create.
.sp
The information provided by MPI_Graphdims_get can be used to dimension the vectors index and edges correctly for a call to MPI_Graph_get.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Graph_create
.br
MPI_Graphdims_get

79
ompi/mpi/man/man3/MPI_Graph_get.md Обычный файл
Просмотреть файл

@ -0,0 +1,79 @@
# Name
`MPI_Graph_get` - Retrieves graph topology information associated
with a communicator.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges,
int index[], int edges[])
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_GET(COMM, MAXINDEX, MAXEDGES, INDEX, EDGES, IERROR)
INTEGER COMM, MAXINDEX, MAXEDGES, INDEX(*)
INTEGER EDGES(*), IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Graph_get(comm, maxindex, maxedges, index, edges, ierror)
TYPE(MPI_Comm), INTENT(IN) :: comm
INTEGER, INTENT(IN) :: maxindex, maxedges
INTEGER, INTENT(OUT) :: index(maxindex), edges(maxedges)
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `comm` : Communicator with graph structure (handle).
* `maxindex` : Length of vector index in the calling program (integer).
* `maxedges` : Length of vector edges in the calling program (integer).
# Output Parameters
* `index` : Array of integers containing the graph structure (for details see
the definition of `MPI_Graph_create`).
* `edges` : Array of integers containing the graph structure.
* `IERROR` : Fortran only: Error status (integer).
# Description
Functions `MPI_Graphdims_get` and `MPI_Graph_get` retrieve the
graph-topology information that was associated with a communicator by
`MPI_Graph_create`.
The information provided by `MPI_Graphdims_get` can be used to dimension
the vectors `index` and `edges` correctly for a call to `MPI_Graph_get`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Graph_create`(3)](MPI_Graph_create.html)
[`MPI_Graphdims_get`(3)](MPI_Graphdims_get.html)

78
ompi/mpi/man/man3/MPI_Graph_map.3in
Просмотреть файл

@ -1,78 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2013 Los Alamos National Security, LLC. All rights reserved.
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Graph_map 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Graph_map \fP \- Maps process to graph topology information.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Graph_map(MPI_Comm \fIcomm\fP, int\fI nnodes\fP, const int\fI index\fP[],
const int\fI edges\fP[], int\fI *newrank\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_MAP(\fICOMM, NNODES, INDEX, EDGES, NEWRANK, IERROR\fP)
INTEGER \fICOMM, NNODES, INDEX(*), EDGES(*), NEWRANK, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Graph_map(\fIcomm\fP, \fInnodes\fP, \fIindex\fP, \fIedges\fP, \fInewrank\fP, \fIierror\fP)
TYPE(MPI_Comm), INTENT(IN) :: \fIcomm\fP
INTEGER, INTENT(IN) :: \fInnodes\fP, \fIindex(nnodes)\fP, \fIedges(*)\fP
INTEGER, INTENT(OUT) :: \fInewrank\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
comm
Input communicator (handle).
.TP 1i
nnodes
Number of graph nodes (integer).
.TP 1i
index
Integer array specifying the graph structure, see MPI_Graph_ create.
.TP 1i
edges
Integer array specifying the graph structure.
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
newrank
Reordered rank of the calling process; MPI_UNDEFINED if the calling process does not belong to graph (integer).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_Cart_map and MPI_Graph_map can be used to implement all other topology
functions. In general they will not be called by the user directly, unless he or she is creating additional virtual topology capability other than that provided by MPI.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.sp
MPI_Cart_map

75
ompi/mpi/man/man3/MPI_Graph_map.md Обычный файл
Просмотреть файл

@ -0,0 +1,75 @@
# Name
`MPI_Graph_map` - Maps process to graph topology information.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Graph_map(MPI_Comm comm, int nnodes, const int index[],
const int edges[], int *newrank)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_MAP(COMM, NNODES, INDEX, EDGES, NEWRANK, IERROR)
INTEGER COMM, NNODES, INDEX(*), EDGES(*), NEWRANK, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Graph_map(comm, nnodes, index, edges, newrank, ierror)
TYPE(MPI_Comm), INTENT(IN) :: comm
INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*)
INTEGER, INTENT(OUT) :: newrank
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `comm` : Input communicator (handle).
* `nnodes` : Number of graph nodes (integer).
* `index` : Integer array specifying the graph structure, see
`MPI_Graph_create`.
* `edges` : Integer array specifying the graph structure.
# Output Parameters
* `newrank` : Reordered rank of the calling process; MPI_UNDEFINED if the calling
process does not belong to graph (integer).
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_Cart_map` and `MPI_Graph_map` can be used to implement all other
topology functions. In general they will not be called by the user
directly, unless he or she is creating additional virtual topology
capability other than that provided by MPI.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Cart_map`(3)](MPI_Cart_map.html)

71
ompi/mpi/man/man3/MPI_Graph_neighbors_count.3in
Просмотреть файл

@ -1,71 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Graph_neighbors_count 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Graph_neighbors_count \fP \- Returns the number of neighbors of a node associated with a graph topology.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Graph_neighbors_count(MPI_Comm \fIcomm\fP, int\fI rank\fP,
int\fI *nneighbors\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_NEIGHBORS_COUNT(\fICOMM, RANK, NNEIGHBORS, IERROR\fP)
INTEGER \fICOMM, RANK, NNEIGHBORS, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Graph_neighbors_count(\fIcomm\fP, \fIrank\fP, \fInneighbors\fP, \fIierror\fP)
TYPE(MPI_Comm), INTENT(IN) :: \fIcomm\fP
INTEGER, INTENT(IN) :: \fIrank\fP
INTEGER, INTENT(OUT) :: \fInneighbors\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
comm
Communicator with graph topology (handle).
.TP 1i
rank
Rank of process in group of comm (integer).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
nneighbors
Number of neighbors of specified process (integer).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_Graph_neighbors_count and MPI_Graph_neighbors provide adjacency information for a general, graph topology. MPI_Graph_neighbors_count returns the number of neighbors for the process signified by rank.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Graph_neighbors

70
ompi/mpi/man/man3/MPI_Graph_neighbors_count.md Обычный файл
Просмотреть файл

@ -0,0 +1,70 @@
# Name
`MPI_Graph_neighbors_count` - Returns the number of neighbors of a
node associated with a graph topology.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Graph_neighbors_count(MPI_Comm comm, int rank,
int *nneighbors)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPH_NEIGHBORS_COUNT(COMM, RANK, NNEIGHBORS, IERROR)
INTEGER COMM, RANK, NNEIGHBORS, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Graph_neighbors_count(comm, rank, nneighbors, ierror)
TYPE(MPI_Comm), INTENT(IN) :: comm
INTEGER, INTENT(IN) :: rank
INTEGER, INTENT(OUT) :: nneighbors
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `comm` : Communicator with graph topology (handle).
* `rank` : Rank of process in group of comm (integer).
# Output Parameters
* `nneighbors` : Number of neighbors of specified process (integer).
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_Graph_neighbors_count` and `MPI_Graph_neighbors` provide adjacency
information for a general, graph topology. `MPI_Graph_neighbors_count`
returns the number of neighbors for the process signified by `rank`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Graph_neighbors`(3)](MPI_Graph_neighbors.html)

73
ompi/mpi/man/man3/MPI_Graphdims_get.3in
Просмотреть файл

@ -1,73 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Graphdims_get 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Graphdims_get \fP \- Retrieves graph topology information associated with a communicator.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Graphdims_get(MPI_Comm \fIcomm\fP, int\fI *nnodes\fP, int\fI *nedges\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPHDIMS_GET(\fICOMM, NNODES, NEDGES, IERROR\fP)
INTEGER \fICOMM, NNODES, NEDGES, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Graphdims_get(\fIcomm\fP, \fInnodes\fP, \fInedges\fP, \fIierror\fP)
TYPE(MPI_Comm), INTENT(IN) :: \fIcomm\fP
INTEGER, INTENT(OUT) :: \fInnodes\fP, \fInedges\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETER
.ft R
.TP 1i
comm
Communicator for group with graph structure (handle).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
nnodes
Number of nodes in graph (integer).
.TP 1i
nedges
Number of edges in graph (integer).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
Functions MPI_Graphdims_get and MPI_Graph_get retrieve the graph-topology information that was associated with a communicator by MPI_Graph_create.
.sp
The information provided by MPI_Graphdims_get can be used to dimension the vectors index and edges correctly for a call to MPI_Graph_get.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Graph_create
.br
MPI_Graph_get

72
ompi/mpi/man/man3/MPI_Graphdims_get.md Обычный файл
Просмотреть файл

@ -0,0 +1,72 @@
# Name
`MPI_Graphdims_get` - Retrieves graph topology information associated
with a communicator.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Graphdims_get(MPI_Comm comm, int *nnodes, int *nedges)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GRAPHDIMS_GET(COMM, NNODES, NEDGES, IERROR)
INTEGER COMM, NNODES, NEDGES, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Graphdims_get(comm, nnodes, nedges, ierror)
TYPE(MPI_Comm), INTENT(IN) :: comm
INTEGER, INTENT(OUT) :: nnodes, nedges
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameter
* `comm` : Communicator for group with graph structure (handle).
# Output Parameters
* `nnodes` : Number of nodes in graph (integer).
* `nedges` : Number of edges in graph (integer).
* `IERROR` : Fortran only: Error status (integer).
# Description
Functions `MPI_Graphdims_get` and `MPI_Graph_get` retrieve the
graph-topology information that was associated with a communicator by
`MPI_Graph_create`.
The information provided by `MPI_Graphdims_get` can be used to dimension
the vectors index and edges correctly for a call to `MPI_Graph_get`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Graph_create`(3)](MPI_Graph_create.html)
[`MPI_Graph_get`(3)](MPI_Graph_get.html)

59
ompi/mpi/man/man3/MPI_Grequest_complete.3in
Просмотреть файл

@ -1,59 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Grequest_complete 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Grequest_complete \fP \- Reports that a generalized request is complete.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Grequest_complete(MPI_Request \fIrequest\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GREQUEST_COMPLETE(\fIREQUEST, IERROR\fP)
INTEGER \fIREQUEST, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Grequest_complete(\fIrequest\fP, \fIierror\fP)
TYPE(MPI_Request), INTENT(IN) :: \fIrequest\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT/OUTPUT PARAMETER
.ft R
.TP 1i
request
Generalized request (handle).
.SH OUTPUT PARAMETER
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_Grequest_complete informs MPI that the operations represented by the generalized request \fIrequest\fP are complete. A call to MPI_Wait(\fIrequest, status\fP) will return, and a call to MPI_Test(\fIrequest, flag, status\fP) will return flag=true only after a call to MPI_Grequest_complete has declared that these operations are complete.
.sp
MPI imposes no restrictions on the code executed by the callback functions. However, new nonblocking operations should be defined so that the general semantic rules about MPI calls such as MPI_Test, MPI_Request_free, or MPI_Cancel still hold. For example, all these calls are supposed to be local and nonblocking. Therefore, the callback functions \fIquery_fn\fP, \fIfree_fn\fP, or \fIcancel_fn\fP should invoke blocking MPI communication calls only if the context is such that these calls are guaranteed to return in finite time. Once MPI_Cancel has been invoked, the canceled operation should complete in finite time, regardless of the state of other processes (the operation has acquired "local" semantics). It should either succeed or fail without side-effects. The user should guarantee these same properties for newly defined operations.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.

76
ompi/mpi/man/man3/MPI_Grequest_complete.md Обычный файл
Просмотреть файл

@ -0,0 +1,76 @@
# Name
`MPI_Grequest_complete` - Reports that a generalized request is
complete.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Grequest_complete(MPI_Request request)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GREQUEST_COMPLETE(REQUEST, IERROR)
INTEGER REQUEST, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Grequest_complete(request, ierror)
TYPE(MPI_Request), INTENT(IN) :: request
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input/Output Parameter
* `request` : Generalized request (handle).
# Output Parameter
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_Grequest_complete` informs MPI that the operations represented by the
generalized request `request` are complete. A call to `MPI_Wait(request, status)`
will return, and a call to `MPI_Test(request, flag, status)` will return
flag=true only after a call to `MPI_Grequest_complete` has
declared that these operations are complete.
MPI imposes no restrictions on the code executed by the callback
functions. However, new nonblocking operations should be defined so that
the general semantic rules about MPI calls such as `MPI_Test`,
`MPI_Request_free`, or `MPI_Cancel` still hold. For example, all these calls
are supposed to be local and nonblocking. Therefore, the callback
functions `query_fn`, `free_fn`, or `cancel_fn` should invoke blocking
MPI communication calls only if the context is such that these calls are
guaranteed to return in finite time. Once `MPI_Cancel` has been invoked,
the canceled operation should complete in finite time, regardless of the
state of other processes (the operation has acquired "local"
semantics). It should either succeed or fail without side-effects. The
user should guarantee these same properties for newly defined
operations.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.

155
ompi/mpi/man/man3/MPI_Grequest_start.3in
Просмотреть файл

@ -1,155 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Grequest_start 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Grequest_start \fP \- Starts a generalized request and returns a handle to it in \fIrequest\fP.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Grequest_start(MPI_Grequest_query_function \fI*query_fn\fP,
MPI_Grequest_free_function \fI*free_fn\fP,
MPI_Grequest_cancel_function \fI*cancel_fn\fP, void \fI*extra_state\fP,
MPI_Request \fI*request\fP)
.fi
.SH Fortran Syntax (see FORTRAN 77 NOTES)
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GREQUEST_START(\fIQUERY_FN, FREE_FN, CANCEL_FN, EXTRA_STATE,
REQUEST, IERROR\fP)
INTEGER \fIREQUEST, IERROR\fP
EXTERNAL \fIQUERY_FN, FREE_FN, CANCEL_FN\fP
INTEGER(KIND=MPI_ADDRESS_KIND) \fIEXTRA_STATE\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Grequest_start(\fIquery_fn\fP, \fIfree_fn\fP, \fIcancel_fn\fP, \fIextra_state\fP, \fIrequest\fP,
\fIierror\fP)
PROCEDURE(MPI_Grequest_query_function) :: \fIquery_fn\fP
PROCEDURE(MPI_Grequest_free_function) :: \fIfree_fn\fP
PROCEDURE(MPI_Grequest_cancel_function) :: \fIcancel_fn\fP
INTEGER(KIND=MPI_ADDRESS_KIND), INTENT(IN) :: \fIextra_state\fP
TYPE(MPI_Request), INTENT(OUT) :: \fIrequest\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
query_fn
Callback function invoked when request status is queried (function).
.TP 1i
free_fn
Callback function invoked when request is freed (function).
.TP 1i
cancel_fn
Callback function invoked when request is canceled (function).
.TP 1i
extra_state
Extra state.
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
request
Generalized request (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_Grequest_start starts a generalized request and returns a handle to it in \fIrequest\fP.
.sp
The syntax and meaning of the callback functions are listed below. All callback functions are passed the \fIextra_state\fP argument that was associated with the request by the starting call MPI_Grequest_start. This can be used to maintain user-defined state for the request. In C, the query function is
.sp
.nf
typedef int MPI_Grequest_query_function(void \fI*extra_state\fP,
MPI_Status \fI*status\fP);
.fi
.sp
In Fortran, it is
.sp
.nf
SUBROUTINE GREQUEST_QUERY_FUNCTION(\fIEXTRA_STATE, STATUS, IERROR\fP)
INTEGER STATUS(MPI_STATUS_SIZE), \fIIERROR\fP
INTEGER(KIND=MPI_ADDRESS_KIND) \fIEXTRA_STATE\fP
.fi
.sp
The \fIquery_fn\fP function computes the status that should be returned for the generalized request. The status also includes information about successful/unsuccessful cancellation of the request (result to be returned by MPI_Test_cancelled).
.sp
The \fIquery_fn\fP function is invoked by the MPI_{Wait|Test}{any|some|all} call that completed the generalized request associated with this callback. The callback function is also invoked by calls to MPI_Request_get_status if the request is complete when the call occurs. In both cases, the callback is passed a reference to the corresponding status variable passed by the user to the MPI call. If the user provided MPI_STATUS_IGNORE or MPI_STATUSES_IGNORE to the MPI function that causes \fIquery_fn\fP to be called, then MPI will pass a valid status object to \fIquery_fn\fP, and this status will be ignored upon return of the callback function. Note that \fIquery_fn\fP is invoked only after MPI_Grequest_complete is called on the request; it may be invoked several times for the same generalized request. Note also that a call to MPI_{Wait|Test}{some|all} may cause multiple invocations of \fIquery_fn\fP callback functions, one for each generalized request that is completed by the MPI call. The order of these invocations is not specified by MPI.
.sp
In C, the free function is
.sp
.nf
typedef int MPI_Grequest_free_function(void *\fIextra_state\fP);
.fi
.sp
And in Fortran, it is
.sp
.nf
SUBROUTINE GREQUEST_FREE_FUNCTION(\fIEXTRA_STATE, IERROR\fP)
INTEGER \fIIERROR\fP
INTEGER(KIND=MPI_ADDRESS_KIND) \fIEXTRA_STATE\fP
.fi
.sp
The \fIfree_fn\fP callback function is invoked to clean up user-allocated resources when the generalized request is freed.
.sp
The \fIfree_fn\fP function is invoked by the MPI_{Wait|Test}{any|some|all} call that completed the generalized request associated with this callback. \fIfree_fn\fP is invoked after the call to \fIquery_fn\fP for the same request. However, if the MPI call completed multiple generalized requests, the order in which \fIfree_fn\fP callback functions are invoked is not specified by MPI.
.sp
The \fIfree_fn\fP callback is also invoked for generalized requests that are freed by a call to MPI_Request_free (no call to MPI_{Wait|Test}{any|some|all} will occur for such a request). In this case, the callback function will be called either in the MPI call MPI_Request_free(request) or in the MPI call MPI_Grequest_complete(request), whichever happens last. In other words, in this case the actual freeing code is executed as soon as both calls (MPI_Request_free and MPI_Grequest_complete) have occurred. The \fIrequest\fP is not deallocated until after \fIfree_fn\fP completes. Note that \fIfree_fn\fP will be invoked only once per request by a correct program.
.sp
In C, the cancel function is
.sp
.nf
typedef int MPI_Grequest_cancel_function(void *\fIextra_state\fP, int \fIcomplete\fP);
.fi
.sp
In Fortran, the cancel function is
.sp
.nf
SUBROUTINE GREQUEST_CANCEL_FUNCTION(\fIEXTRA_STATE, COMPLETE, IERROR\fP)
INTEGER \fIIERROR\fP
INTEGER(KIND=MPI_ADDRESS_KIND) \fIEXTRA_STATE\fP
LOGICAL \fICOMPLETE\fP
.fi
.sp
The \fIcancel_fn\fP function is invoked to start the cancellation of a generalized request. It is called by MPI_Request_cancel(request). MPI passes to the callback function complete=true if MPI_Grequest_complete has already been called on the request, and complete=false otherwise.
.SH FORTRAN 77 NOTES
.ft R
The MPI standard prescribes portable Fortran syntax for
the \fIEXTRA_STATE\fP argument only for Fortran 90. FORTRAN 77
users may use the non-portable syntax
.sp
.nf
INTEGER*MPI_ADDRESS_KIND \fIEXTRA_STATE\fP
.fi
.sp
where MPI_ADDRESS_KIND is a constant defined in mpif.h
and gives the length of the declared integer in bytes.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.sp
All callback functions return an error code. The code is passed back and dealt with as appropriate for the error code by the MPI function that invoked the callback function. For example, if error codes are returned, then the error code returned by the callback function will be returned by the MPI function that invoked the callback function. In the case of a MPI_{Wait|Test}any call that invokes both \fIquery_fn\fP and \fIfree_fn\fP, the MPI call will return the error code returned by the last callback, namely \fIfree_fn\fP. If one or more of the requests in a call to MPI_{Wait|Test}{some|all} has failed, then the MPI call will return MPI_ERR_IN_STATUS. In such a case, if the MPI call was passed an array of statuses, then MPI will return in each of the statuses that correspond to a completed generalized request the error code returned by the corresponding invocation of its \fIfree_fn\fP callback function. However, if the MPI function was passed MPI_STATUSES_IGNORE, then the individual error codes returned by each callback function will be lost.
.sp
See the MPI man page for a full list of MPI error codes.

201
ompi/mpi/man/man3/MPI_Grequest_start.md Обычный файл
Просмотреть файл

@ -0,0 +1,201 @@
# Name
`MPI_Grequest_start` - Starts a generalized request and returns a
handle to it in `request`.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Grequest_start(MPI_Grequest_query_function *query_fn,
MPI_Grequest_free_function *free_fn,
MPI_Grequest_cancel_function *cancel_fn, void *extra_state,
MPI_Request *request)
```
## Fortran Syntax (See Fortran 77 Notes)
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GREQUEST_START(QUERY_FN, FREE_FN, CANCEL_FN, EXTRA_STATE,
REQUEST, IERROR)
INTEGER REQUEST, IERROR
EXTERNAL QUERY_FN, FREE_FN, CANCEL_FN
INTEGER(KIND=MPI_ADDRESS_KIND) EXTRA_STATE
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Grequest_start(query_fn, free_fn, cancel_fn, extra_state, request,
ierror)
PROCEDURE(MPI_Grequest_query_function) :: query_fn
PROCEDURE(MPI_Grequest_free_function) :: free_fn
PROCEDURE(MPI_Grequest_cancel_function) :: cancel_fn
INTEGER(KIND=MPI_ADDRESS_KIND), INTENT(IN) :: extra_state
TYPE(MPI_Request), INTENT(OUT) :: request
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `query_fn` : Callback function invoked when request status is queried (function).
* `free_fn` : Callback function invoked when request is freed (function).
* `cancel_fn` : Callback function invoked when request is canceled (function).
* `extra_state` : Extra state.
# Output Parameters
* `request` : Generalized request (handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_Grequest_start` starts a generalized `request` and returns a handle to
it in `request`.
The syntax and meaning of the callback functions are listed below. All
callback functions are passed the `extra_state` argument that was
associated with the `request` by the starting call `MPI_Grequest_start`.
This can be used to maintain user-defined state for the `request`. In C,
the query function is
```c
typedef int MPI_Grequest_query_function(void *extra_state,
MPI_Status *status);
```
In Fortran, it is
```fortran
SUBROUTINE GREQUEST_QUERY_FUNCTION(EXTRA_STATE, STATUS, IERROR)
INTEGER STATUS(MPI_STATUS_SIZE), IERROR
INTEGER(KIND=MPI_ADDRESS_KIND) EXTRA_STATE
```
The `query_fn` function computes the status that should be returned for
the generalized request. The status also includes information about
successful/unsuccessful cancellation of the request (result to be
returned by `MPI_Test_cancelled`).
The `query_fn` function is invoked by the
`MPI_{Wait|Test}{any|some|all}` call that completed the generalized
request associated with this callback. The callback function is also
invoked by calls to `MPI_Request_get_status` if the request is complete
when the call occurs. In both cases, the callback is passed a reference
to the corresponding status variable passed by the user to the MPI call.
If the user provided `MPI_STATUS_IGNORE` or `MPI_STATUSES_IGNORE` to the MPI
function that causes `query_fn` to be called, then MPI will pass a valid
status object to `query_fn`, and this status will be ignored upon return
of the callback function. Note that `query_fn` is invoked only after
`MPI_Grequest_complete` is called on the request; it may be invoked
several times for the same generalized request. Note also that a call to
`MPI_{Wait|Test}{some|all}` may cause multiple invocations of
`query_fn` callback functions, one for each generalized request that is
completed by the MPI call. The order of these invocations is not
specified by MPI.
In C, the free function is
```c
typedef int MPI_Grequest_free_function(void *extra_state);
```
And in Fortran, it is
```fortran
SUBROUTINE GREQUEST_FREE_FUNCTION(EXTRA_STATE, IERROR)
INTEGER IERROR
INTEGER(KIND=MPI_ADDRESS_KIND) EXTRA_STATE
```
The `free_fn` callback function is invoked to clean up user-allocated
resources when the generalized request is freed.
The `free_fn` function is invoked by the
`MPI_{Wait|Test}{any|some|all}` call that completed the generalized
request associated with this callback. `free_fn` is invoked after the
call to `query_fn` for the same request. However, if the MPI call
completed multiple generalized requests, the order in which `free_fn`
callback functions are invoked is not specified by MPI.
The `free_fn` callback is also invoked for generalized requests that are
freed by a call to `MPI_Request_free` (no call to
`MPI_{Wait|Test}{any|some|all}` will occur for such a request). In
this case, the callback function will be called either in the MPI call
`MPI_Request_free(request)` or in the MPI call
`MPI_Grequest_complete(request)`, whichever happens last. In other words,
in this case the actual freeing code is executed as soon as both calls
(`MPI_Request_free` and `MPI_Grequest_complete`) have occurred. The
`request` is not deallocated until after `free_fn` completes. Note that
`free_fn` will be invoked only once per request by a correct program.
In C, the cancel function is
```c
typedef int MPI_Grequest_cancel_function(void *extra_state, int complete);
```
In Fortran, the cancel function is
```Fortran
SUBROUTINE GREQUEST_CANCEL_FUNCTION(EXTRA_STATE, COMPLETE, IERROR)
INTEGER IERROR
INTEGER(KIND=MPI_ADDRESS_KIND) EXTRA_STATE
LOGICAL COMPLETE
```
The `cancel_fn` function is invoked to start the cancellation of a
generalized request. It is called by `MPI_Request_cancel(request)`. MPI
passes to the callback function complete=true if `MPI_Grequest_complete`
has already been called on the request, and complete=false otherwise.
# Fortran 77 Notes
The MPI standard prescribes portable Fortran syntax for the
`EXTRA_STATE` argument only for Fortran 90. FORTRAN 77 users may use the
non-portable syntax
```fortran
INTEGER*MPI_ADDRESS_KIND EXTRA_STATE
```
where `MPI_ADDRESS_KIND` is a constant defined in mpif.h and gives the
length of the declared integer in bytes.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
All callback functions return an error code. The code is passed back and
dealt with as appropriate for the error code by the MPI function that
invoked the callback function. For example, if error codes are returned,
then the error code returned by the callback function will be returned
by the MPI function that invoked the callback function. In the case of a
`MPI_{Wait|Test}any` call that invokes both `query_fn` and `free_fn`,
the MPI call will return the error code returned by the last callback,
namely `free_fn`. If one or more of the `request`s in a call to
`MPI_{Wait|Test}{some|all`} has failed, then the MPI call will return
`MPI_ERR_IN_STATUS`. In such a case, if the MPI call was passed an array
of statuses, then MPI will return in each of the statuses that
correspond to a completed generalized `request` the error code returned by
the corresponding invocation of its `free_fn` callback function.
However, if the MPI function was passed `MPI_STATUSES_IGNORE`, then the
individual error codes returned by each callback function will be lost.
See the MPI man page for a full list of MPI error codes.

64
ompi/mpi/man/man3/MPI_Group_compare.3in
Просмотреть файл

@ -1,64 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_compare 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_compare \fP \- Compares two groups.
.SH SYNTAX
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_compare(MPI_Group \fIgroup1\fP, MPI_Group\fI group2\fP,
int\fI *result\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_COMPARE(\fIGROUP1, GROUP2, RESULT, IERROR\fP)
INTEGER \fIGROUP1, GROUP2, RESULT, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_compare(\fIgroup1\fP, \fIgroup2\fP, \fIresult\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(IN) :: \fIgroup1\fP, \fIgroup2\fP
INTEGER, INTENT(OUT) :: \fIresult\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
group1
First group (handle).
.TP 1i
group2
Second group (handle).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
result
Integer which is MPI_IDENT if the order and members of the two groups are the same, MPI_SIMILAR if only the members are the same, and MPI_UNEQUAL otherwise.
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
MPI_IDENT results if the group members and group order is exactly the same in both groups. This happens for instance if group1 and group2 are the same handle. MPI_SIMILAR results if the group members are the same but the order is different. MPI_UNEQUAL results otherwise.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.

66
ompi/mpi/man/man3/MPI_Group_compare.md Обычный файл
Просмотреть файл

@ -0,0 +1,66 @@
# Name
`MPI_Group_compare` - Compares two groups.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_compare(MPI_Group group1, MPI_Group group2,
int *result)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_COMPARE(GROUP1, GROUP2, RESULT, IERROR)
INTEGER GROUP1, GROUP2, RESULT, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_compare(group1, group2, result, ierror)
TYPE(MPI_Group), INTENT(IN) :: group1, group2
INTEGER, INTENT(OUT) :: result
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `group1` : First group (handle).
* `group2` : Second group (handle).
# Output Parameters
* `result` : Integer which is MPI_IDENT if the order and members of the two
groups are the same, MPI_SIMILAR if only the members are the same,
and MPI_UNEQUAL otherwise.
* `IERROR` : Fortran only: Error status (integer).
# Description
`MPI_IDENT` results if the group members and group order is exactly the
same in both groups. This happens for instance if `group1` and `group2` are
the same handle. `MPI_SIMILAR` results if the group members are the same
but the order is different. `MPI_UNEQUAL` results otherwise.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.

83
ompi/mpi/man/man3/MPI_Group_difference.3in
Просмотреть файл

@ -1,83 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_difference 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_difference \fP \- Makes a group from the difference of two groups.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_difference(MPI_Group \fIgroup1\fP, MPI_Group\fI group2\fP,
MPI_Group\fI *newgroup\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_DIFFERENCE(\fIGROUP1, GROUP2, NEWGROUP, IERROR\fP)
INTEGER \fIGROUP1, GROUP2, NEWGROUP, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_difference(\fIgroup1\fP, \fIgroup2\fP, \fInewgroup\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(IN) :: \fIgroup1\fP, \fIgroup2\fP
TYPE(MPI_Group), INTENT(OUT) :: \fInewgroup\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
group1
First group (handle).
.TP 1i
group2
Second group (handle).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
newgroup
Difference group (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
The set-like operations are defined as follows:
.TP
o
union -- All elements of the first group (group1), followed by all elements
of second group (group2) that are not in the first group
.TP
o
intersect -- all elements of the first group that are also in the second
group, ordered as in first group
.TP
o
difference -- all elements of the first group that are not in the second group, ordered as in the first group
.LP
Note that for these operations the order of processes in the output group is determined primarily by order in the first group (if possible) and then, if necessary, by order in the second group. Neither union nor intersection are commutative, but both are associative.
.sp
The new group can be empty, that is, equal to MPI_GROUP_EMPTY.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
MPI_Group_free

79
ompi/mpi/man/man3/MPI_Group_difference.md Обычный файл
Просмотреть файл

@ -0,0 +1,79 @@
# Name
`MPI_Group_difference` - Makes a group from the difference of two
groups.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_difference(MPI_Group group1, MPI_Group group2,
MPI_Group *newgroup)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_DIFFERENCE(GROUP1, GROUP2, NEWGROUP, IERROR)
INTEGER GROUP1, GROUP2, NEWGROUP, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_difference(group1, group2, newgroup, ierror)
TYPE(MPI_Group), INTENT(IN) :: group1, group2
TYPE(MPI_Group), INTENT(OUT) :: newgroup
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `group1` : First group (handle).
* `group2` : Second group (handle).
# Output Parameters
* `newgroup` : Difference group (handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
The set-like operations are defined as follows:
* `union` -- All elements of the first group (`group1`), followed by all
elements of second group (`group2`) that are not in the first group
* `intersect` -- all elements of the first group that are also in the
second group, ordered as in first group
* `difference` -- all elements of the first group that are not in the
second group, ordered as in the first group
Note that for these operations the order of processes in the output
group is determined primarily by order in the first group (if possible)
and then, if necessary, by order in the second group. Neither union nor
intersection are commutative, but both are associative.
The new group can be empty, that is, equal to `MPI_GROUP_EMPTY`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Group_free`(3)](MPI_Group_free.html)

81
ompi/mpi/man/man3/MPI_Group_excl.3in
Просмотреть файл

@ -1,81 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2013 Los Alamos National Security, LLC. All rights reserved.
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_excl 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_excl\fP \- Produces a group by reordering an existing group and taking only unlisted members.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_excl(MPI_Group \fIgroup\fP, int\fI n\fP, const int\fI ranks\fP[],
MPI_Group\fI *newgroup\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_EXCL(\fIGROUP, N, RANKS, NEWGROUP, IERROR\fP)
INTEGER \fIGROUP, N, RANKS(*), NEWGROUP, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_excl(\fIgroup\fP, \fIn\fP, \fIranks\fP, \fInewgroup\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(IN) :: \fIgroup\fP
INTEGER, INTENT(IN) :: \fIn\fP, \fIranks(n)\fP
TYPE(MPI_Group), INTENT(OUT) :: \fInewgroup\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
group
Group (handle).
.TP 1i
n
Number of elements in array ranks (integer).
.TP 1i
ranks
Array of integer ranks in group not to appear in newgroup.
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
newgroup
New group derived from above, preserving the order defined by group (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
The function MPI_Group_excl creates a group of processes newgroup that is obtained by deleting from group those processes with ranks ranks[0], \&... ranks[n-1]. The ordering of processes in newgroup is identical to the ordering in group. Each of the n elements of ranks must be a valid rank in group and all elements must be distinct; otherwise, the call is erroneous. If n = 0, then newgroup is identical to group.
.SH NOTE
.ft R
Currently, each of the ranks to exclude must be a valid rank in the group and all elements must be distinct or the function is erroneous. This restriction is per the draft.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Group_range_excl
.br
MPI_Group_free

81
ompi/mpi/man/man3/MPI_Group_excl.md Обычный файл
Просмотреть файл

@ -0,0 +1,81 @@
# Name
`MPI_Group_excl` - Produces a group by reordering an existing group
and taking only unlisted members.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_excl(MPI_Group group, int n, const int ranks[],
MPI_Group *newgroup)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_EXCL(GROUP, N, RANKS, NEWGROUP, IERROR)
INTEGER GROUP, N, RANKS(*), NEWGROUP, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_excl(group, n, ranks, newgroup, ierror)
TYPE(MPI_Group), INTENT(IN) :: group
INTEGER, INTENT(IN) :: n, ranks(n)
TYPE(MPI_Group), INTENT(OUT) :: newgroup
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `group` : Group (handle).
* `n` : Number of elements in array ranks (integer).
* `ranks` : Array of integer ranks in group not to appear in newgroup.
# Output Parameters
* `newgroup` : New group derived from above, preserving the order defined by group
(handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
The function `MPI_Group_excl` creates a `group` of processes `newgroup` that
is obtained by deleting from `group` those processes with ranks
`ranks[0]`, ... `ranks[n-1]`. The ordering of processes in `newgroup` is
identical to the ordering in `group`. Each of the n elements of ranks must
be a valid rank in `group` and all elements must be distinct; otherwise,
the call is erroneous. If `n` = 0, then `newgroup` is identical to `group`.
# Note
Currently, each of the ranks to exclude must be a valid rank in the
`group` and all elements must be distinct or the function is erroneous.
This restriction is per the draft.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Group_range_excl`(3)](MPI_Group_range_excl.html)
[`MPI_Group_free`(3)](MPI_Group_free.html)

59
ompi/mpi/man/man3/MPI_Group_free.3in
Просмотреть файл

@ -1,59 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_free 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_free \fP \- Frees a group.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_free(MPI_Group *\fIgroup\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_FREE(\fIGROUP, IERROR\fP)
INTEGER \fIGROUP, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_free(\fIgroup\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(INOUT) :: \fIgroup\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT/OUTPUT PARAMETER
.TP 1i
group
Group (handle).
.SH OUTPUT PARAMETER
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
This operation marks a group object for deallocation. The handle group is set to MPI_GROUP_NULL by the call. Any ongoing operation using this group will complete normally.
.SH NOTE
.ft R
On return, group is set to MPI_GROUP_NULL.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.

63
ompi/mpi/man/man3/MPI_Group_free.md Обычный файл
Просмотреть файл

@ -0,0 +1,63 @@
# Name
`MPI_Group_free` - Frees a group.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_free(MPI_Group *group)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_FREE(GROUP, IERROR)
INTEGER GROUP, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_free(group, ierror)
TYPE(MPI_Group), INTENT(INOUT) :: group
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input/Output Parameter
* `group` : Group (handle).
# Output Parameter
* `IERROR` : Fortran only: Error status (integer).
# Description
This operation marks a `group` object for deallocation. The handle `group`
is set to `MPI_GROUP_NULL` by the call. Any ongoing operation using this
`group` will complete normally.
# Note
On return, `group` is set to `MPI_GROUP_NULL`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.

84
ompi/mpi/man/man3/MPI_Group_incl.3in
Просмотреть файл

@ -1,84 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2013 Los Alamos National Security, LLC. All rights reserved.
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_incl 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_incl \fP \- Produces a group by reordering an existing group and taking only listed members.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_incl(MPI_Group \fIgroup\fP, int\fI n\fP, const int\fI ranks\fP[],
MPI_Group\fI *newgroup\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_INCL(\fIGROUP, N, RANKS, NEWGROUP, IERROR\fP)
INTEGER \fIGROUP, N, RANKS(*), NEWGROUP, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_incl(\fIgroup\fP, \fIn\fP, \fIranks\fP, \fInewgroup\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(IN) :: \fIgroup\fP
INTEGER, INTENT(IN) :: \fIn\fP, \fIranks(n)\fP
TYPE(MPI_Group), INTENT(OUT) :: \fInewgroup\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
group
Group (handle).
.TP 1i
n
Number of elements in array ranks (and size of \fInewgroup\fP)(integer).
.TP 1i
ranks
Ranks of processes in group to appear in newgroup (array of integers).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
newgroup
New group derived from above, in the order defined by ranks (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
The function MPI_Group_incl creates a group group_out that consists of the n processes in group with ranks rank[0], \&..., rank[n-1]; the process with rank i in group_out is the process with rank ranks[i] in group. Each of the n elements of ranks must be a valid rank in group and all elements must be distinct, or else the program is erroneous. If n = 0, then group_out is MPI_GROUP_EMPTY. This function can, for instance, be used to reorder the elements of a group.
.SH NOTE
.ft R
This implementation does not currently check to ensure that there are no
duplicates in the list of ranks.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
.ft R
.sp
MPI_Group_compare
.br
MPI_Group_range_incl
.br
MPI_Group_free

83
ompi/mpi/man/man3/MPI_Group_incl.md Обычный файл
Просмотреть файл

@ -0,0 +1,83 @@
# Name
`MPI_Group_incl` - Produces a group by reordering an existing group
and taking only listed members.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_incl(MPI_Group group, int n, const int ranks[],
MPI_Group *newgroup)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_INCL(GROUP, N, RANKS, NEWGROUP, IERROR)
INTEGER GROUP, N, RANKS(*), NEWGROUP, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_incl(group, n, ranks, newgroup, ierror)
TYPE(MPI_Group), INTENT(IN) :: group
INTEGER, INTENT(IN) :: n, ranks(n)
TYPE(MPI_Group), INTENT(OUT) :: newgroup
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `group` : Group (handle).
* `n` : Number of elements in array ranks (and size of `newgroup`)(integer).
* `ranks` : Ranks of processes in group to appear in newgroup (array of
integers).
# Output Parameters
* `newgroup` : New group derived from above, in the order defined by ranks
(handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
The function `MPI_Group_incl` creates a group `group_out` that consists of
the n processes in `group` with ranks `rank[0]`, ..., `rank[n-1]`; the
process with rank i in `group_out` is the process with rank `ranks[i]` in
`group`. Each of the n elements of ranks must be a valid rank in `group` and
all elements must be distinct, or else the program is erroneous. If `n` =
0, then `group_out` is `MPI_GROUP_EMPTY`. This function can, for instance,
be used to reorder the elements of a `group`.
# Note
This implementation does not currently check to ensure that there are no
duplicates in the list of ranks.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Group_compare`(3)](MPI_Group_compare.html)
[`MPI_Group_range_incl`(3)](MPI_Group_range_incl.html)
[`MPI_Group_free`(3)](MPI_Group_free.html)

85
ompi/mpi/man/man3/MPI_Group_intersection.3in
Просмотреть файл

@ -1,85 +0,0 @@
.\" -*- nroff -*-
.\" Copyright 2010 Cisco Systems, Inc. All rights reserved.
.\" Copyright 2006-2008 Sun Microsystems, Inc.
.\" Copyright (c) 1996 Thinking Machines Corporation
.\" Copyright (c) 2020 Google, LLC. All rights reserved.
.\" $COPYRIGHT$
.TH MPI_Group_intersection 3 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
.SH NAME
\fBMPI_Group_intersection \fP \- Produces a group at the intersection of two existing groups.
.SH SYNTAX
.ft R
.SH C Syntax
.nf
#include <mpi.h>
int MPI_Group_intersection(MPI_Group \fIgroup1\fP, MPI_Group\fI group2\fP,
MPI_Group\fI *newgroup\fP)
.fi
.SH Fortran Syntax
.nf
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_INTERSECTION(\fIGROUP1, GROUP2, NEWGROUP, IERROR\fP)
INTEGER \fIGROUP1, GROUP2, NEWGROUP, IERROR\fP
.fi
.SH Fortran 2008 Syntax
.nf
USE mpi_f08
MPI_Group_intersection(\fIgroup1\fP, \fIgroup2\fP, \fInewgroup\fP, \fIierror\fP)
TYPE(MPI_Group), INTENT(IN) :: \fIgroup1\fP, \fIgroup2\fP
TYPE(MPI_Group), INTENT(OUT) :: \fInewgroup\fP
INTEGER, OPTIONAL, INTENT(OUT) :: \fIierror\fP
.fi
.SH INPUT PARAMETERS
.ft R
.TP 1i
group1
First group (handle).
.TP 1i
group2
Second group (handle).
.SH OUTPUT PARAMETERS
.ft R
.TP 1i
newgroup
Intersection group (handle).
.ft R
.TP 1i
IERROR
Fortran only: Error status (integer).
.SH DESCRIPTION
.ft R
The set-like operations are defined as follows:
.TP
o
union -- All elements of the first group (group1), followed by all elements
of second group (group2) not in first.
.TP
o
intersect -- all elements of the first group that are also in the second
group, ordered as in first group.
.TP
o
difference -- all elements of the first group that are not in the second group, ordered as in the first group.
.LP
Note that for these operations the order of processes in the output group is determined primarily by order in the first group (if possible) and then, if necessary, by order in the second group. Neither union nor intersection are commutative, but both are associative.
.sp
The new group can be empty, that is, equal to MPI_GROUP_EMPTY.
.SH ERRORS
Almost all MPI routines return an error value; C routines as the value of the function and Fortran routines in the last argument.
.sp
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for I/O function errors. The error handler may be changed with MPI_Comm_set_errhandler; the predefined error handler MPI_ERRORS_RETURN may be used to cause error values to be returned. Note that MPI does not guarantee that an MPI program can continue past an error.
.SH SEE ALSO
MPI_Group_free
.br

79
ompi/mpi/man/man3/MPI_Group_intersection.md Обычный файл
Просмотреть файл

@ -0,0 +1,79 @@
# Name
`MPI_Group_intersection` - Produces a group at the intersection of
two existing groups.
# Syntax
## C Syntax
```c
#include <mpi.h>
int MPI_Group_intersection(MPI_Group group1, MPI_Group group2,
MPI_Group *newgroup)
```
## Fortran Syntax
```fortran
USE MPI
! or the older form: INCLUDE 'mpif.h'
MPI_GROUP_INTERSECTION(GROUP1, GROUP2, NEWGROUP, IERROR)
INTEGER GROUP1, GROUP2, NEWGROUP, IERROR
```
## Fortran 2008 Syntax
```fortran
USE mpi_f08
MPI_Group_intersection(group1, group2, newgroup, ierror)
TYPE(MPI_Group), INTENT(IN) :: group1, group2
TYPE(MPI_Group), INTENT(OUT) :: newgroup
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
```
# Input Parameters
* `group1` : First group (handle).
* `group2` : Second group (handle).
# Output Parameters
* `newgroup` : Intersection group (handle).
* `IERROR` : Fortran only: Error status (integer).
# Description
The set-like operations are defined as follows:
* `union` -- All elements of the first group (`group1`), followed by all
elements of second group (`group2`) not in first.
* `intersect` -- all elements of the first group that are also in the
second group, ordered as in first group.
* `difference` -- all elements of the first group that are not in the
second group, ordered as in the first group.
Note that for these operations the order of processes in the output
group is determined primarily by order in the first group (if possible)
and then, if necessary, by order in the second group. Neither union nor
intersection are commutative, but both are associative.
The new group can be empty, that is, equal to `MPI_GROUP_EMPTY`.
# Errors
Almost all MPI routines return an error value; C routines as the value
of the function and Fortran routines in the last argument.
Before the error value is returned, the current MPI error handler is
called. By default, this error handler aborts the MPI job, except for
I/O function errors. The error handler may be changed with
`MPI_Comm_set_errhandler`; the predefined error handler `MPI_ERRORS_RETURN`
may be used to cause error values to be returned. Note that MPI does not
guarantee that an MPI program can continue past an error.
# See Also
[`MPI_Group_free`(3)](MPI_Group_free.html)

28
ompi/mpi/man/man3/Makefile.am
Просмотреть файл

@ -72,7 +72,20 @@ MD_FILES = \
MPI_Get_elements.md \
MPI_Get_library_version.md \
MPI_Get_processor_name.md \
MPI_Get_version.md
MPI_Get_version.md \
MPI_Graph_create.md \
MPI_Graph_get.md \
MPI_Graph_map.md \
MPI_Graph_neighbors_count.md \
MPI_Graphdims_get.md \
MPI_Grequest_complete.md \
MPI_Grequest_start.md \
MPI_Group_compare.md \
MPI_Group_difference.md \
MPI_Group_excl.md \
MPI_Group_free.md \
MPI_Group_incl.md \
MPI_Group_intersection.md
TEMPLATE_FILES = \
MPI_Abort.3in \
@ -201,22 +214,9 @@ TEMPLATE_FILES = \
MPI_Igather.3in \
MPI_Igatherv.3in \
MPI_Get_elements_x.3in \
MPI_Graph_create.3in \
MPI_Graphdims_get.3in \
MPI_Graph_get.3in \
MPI_Graph_map.3in \
MPI_Graph_neighbors.3in \
MPI_Graph_neighbors_count.3in \
MPI_Grequest_complete.3in \
MPI_Grequest_start.3in \
MPI_Group_c2f.3in \
MPI_Group_compare.3in \
MPI_Group_difference.3in \
MPI_Group_excl.3in \
MPI_Group_f2c.3in \
MPI_Group_free.3in \
MPI_Group_incl.3in \
MPI_Group_intersection.3in \
MPI_Group_range_excl.3in \
MPI_Group_range_incl.3in \
MPI_Group_rank.3in \