There are many occasions on which it would be useful to allow a user to associate a printable identifier with an MPI communicator, window, or datatype, for instance error reporting, debugging, and profiling. The names attached to opaque objects do not propagate when the object is duplicated or copied by MPI routines. For communicators this can be achieved using the following two functions.
| MPI_COMM_SET_NAME (comm, comm_name) | |
| INOUT comm | communicator whose identifier is to be set (handle) |
| IN comm_name | the character string which is remembered as the name (string) |
int MPI_Comm_set_name(MPI_Comm comm, char *comm_name)
MPI_COMM_SET_NAME(COMM, COMM_NAME, IERROR)
INTEGER COMM, IERROR
CHARACTER*(*) COMM_NAME
{ void MPI::Comm::Set_name(const char* comm_name) (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_COMM_SET_NAME allows a user to associate a name
string with a communicator. The character string which is passed to
MPI_COMM_SET_NAME will be saved inside the MPI
library (so it can be freed by the caller immediately after the call, or
allocated on the stack).
Leading spaces in name are
significant but trailing ones are not.
MPI_COMM_SET_NAME is a local (non-collective) operation,
which only affects the name of the communicator as seen in the process
which made the MPI_COMM_SET_NAME call. There is no
requirement that the same (or any) name be assigned to a communicator
in every process where it exists.
Since MPI_COMM_SET_NAME is provided to help debug code, it
is sensible to give the same name to a communicator in all of the
processes where it exists, to avoid confusion.
( End of advice to users.)
Under circumstances of store exhaustion an attempt to put a
name of any length could fail, therefore the value of
MPI_MAX_OBJECT_NAME should be viewed only as a strict upper
bound on the name length, not a guarantee that setting names of less
than this length will always succeed.
( End of advice to users.)
Implementations which pre-allocate a fixed size space for a name
should use the length of that allocation as the value of
MPI_MAX_OBJECT_NAME.
Implementations which allocate space for the name from the heap should
still define MPI_MAX_OBJECT_NAME to be a relatively small
value, since the user has to allocate space for a string of up to this
size when calling MPI_COMM_GET_NAME.
( End of advice to implementors.)
int MPI_Comm_get_name(MPI_Comm comm, char *comm_name, int *resultlen)
MPI_COMM_GET_NAME(COMM, COMM_NAME, RESULTLEN, IERROR)
{ void MPI::Comm::Get_name(char* comm_name, int& resultlen) const (binding deprecated, see Section Deprecated since MPI-2.2
) }
MPI_COMM_GET_NAME returns the last name which has previously been
associated with the given communicator. The name may be set and got
from any language. The same name will be returned independent of the
language used.
name should be allocated so that it can hold a resulting string
of length MPI_MAX_OBJECT_NAME characters.
MPI_COMM_GET_NAME
returns a copy of the set name in name.
In C, a null character is additionally stored at name[resultlen].
resultlen cannot be larger then
MPI_MAX_OBJECT_NAME-1.
In Fortran, name is padded on the right with blank characters.
resultlen cannot be larger then
MPI_MAX_OBJECT_NAME.
If the user has not associated a name with a communicator, or an error
occurs, MPI_COMM_GET_NAME will return an empty string (all
spaces in Fortran, "" in C and C++). The three predefined
communicators will have predefined names associated with them.
Thus, the names of MPI_COMM_WORLD, MPI_COMM_SELF, and
the communicator returned by MPI_COMM_GET_PARENT
(if not MPI_COMM_NULL)
will have the default of MPI_COMM_WORLD, MPI_COMM_SELF, and MPI_COMM_PARENT.
The fact that the system may have chosen to give a default name to a
communicator does not prevent the user from setting a name on the same
communicator; doing this removes the old name and assigns the new one.
We provide separate functions for setting and getting the name of a
communicator, rather than simply providing a predefined attribute key
for the following reasons:
The above definition means that it is safe simply to print the string
returned by MPI_COMM_GET_NAME, as it is always a valid
string even if there was no name.
Note that associating a name with a communicator has no effect on the
semantics of an MPI program, and will (necessarily)
increase the store requirement of the program, since the names must be
saved. Therefore there is no requirement that users use these functions to
associate names with
communicators. However debugging and profiling MPI applications may be made
easier if names are associated with communicators,
since the debugger or profiler should then be able to present
information in a less cryptic manner.
( End of advice to users.)
int MPI_Type_set_name(MPI_Datatype type, char *type_name)
MPI_TYPE_SET_NAME(TYPE, TYPE_NAME, IERROR)
{ void MPI::Datatype::Set_name(const char* type_name) (binding deprecated, see Section Deprecated since MPI-2.2
) }
int MPI_Type_get_name(MPI_Datatype type, char *type_name, int *resultlen)
MPI_TYPE_GET_NAME(TYPE, TYPE_NAME, RESULTLEN, IERROR)
{ void MPI::Datatype::Get_name(char* type_name, int& resultlen) const (binding deprecated, see Section Deprecated since MPI-2.2
) }
Named predefined datatypes have the default names of the datatype name.
For example, MPI_WCHAR has the default name of MPI_WCHAR.
The following functions are used for setting and getting names of windows.
int MPI_Win_set_name(MPI_Win win, char *win_name)
MPI_WIN_SET_NAME(WIN, WIN_NAME, IERROR)
{ void MPI::Win::Set_name(const char* win_name) (binding deprecated, see Section Deprecated since MPI-2.2
) }
int MPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen)
MPI_WIN_GET_NAME(WIN, WIN_NAME, RESULTLEN, IERROR)
{ void MPI::Win::Get_name(char* win_name, int& resultlen) const (binding deprecated, see Section Deprecated since MPI-2.2
) }
Advice to users.
The length of the name which can be stored is limited to the value of
MPI_MAX_OBJECT_NAME in Fortran and
MPI_MAX_OBJECT_NAME-1 in C and C++ to allow for the null terminator.
Attempts to put names longer than this
will result in truncation of the name.
MPI_MAX_OBJECT_NAME must have a value of at least 64.
Advice to users.
Advice
to implementors.
MPI_COMM_GET_NAME (comm, comm_name, resultlen) IN comm communicator whose name is to be returned (handle) OUT comm_name the name previously stored on the communicator, or an empty string if no such name exists (string) OUT resultlen length of returned name (integer)
INTEGER COMM, RESULTLEN, IERROR
CHARACTER*(*) COMM_NAME
Rationale.
( End of rationale.)
Advice to users.
The following functions are used for setting and getting names of datatypes.
MPI_TYPE_SET_NAME (type, type_name) INOUT type datatype whose identifier is to be set (handle) IN type_name the character string which is remembered as the name (string)
INTEGER TYPE, IERROR
CHARACTER*(*) TYPE_NAME
MPI_TYPE_GET_NAME (type, type_name, resultlen) IN type datatype whose name is to be returned (handle) OUT type_name the name previously stored on the datatype, or a
empty string if no such name exists (string) OUT resultlen length of returned name (integer)
INTEGER TYPE, RESULTLEN, IERROR
CHARACTER*(*) TYPE_NAME
MPI_WIN_SET_NAME (win, win_name) INOUT win window whose identifier is to be set (handle) IN win_name the character string which is remembered as the name (string)
INTEGER WIN, IERROR
CHARACTER*(*) WIN_NAME
MPI_WIN_GET_NAME (win, win_name, resultlen) IN win window whose name is to be returned (handle) OUT win_name the name previously stored on the window, or a
empty string if no such name exists (string) OUT resultlen length of returned name (integer)
INTEGER WIN, RESULTLEN, IERROR
CHARACTER*(*) WIN_NAME
Up: Contents
Next: Formalizing the Loosely Synchronous Model
Previous: Attributes Example
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009