MPI manages system memory that is used for buffering messages and for storing internal representations of various MPI objects such as groups, communicators, datatypes, etc. This memory is not directly accessible to the user, and objects stored there are opaque: their size and shape is not visible to the user. Opaque objects are accessed via handles, which exist in opaque objects handles user space. MPI procedures that operate on opaque objects are passed handle arguments to access these objects. In addition to their use by MPI calls for object access, handles can participate in assignments and comparisons.
In Fortran, all handles have type INTEGER. In C, a different handle type is defined for each category of objects. Implementations should use types that support assignment and equality operators.
In Fortran, the handle can be an index in a table of opaque objects, while in C it can be such an index or a pointer to the object. More bizarre possibilities exist.
Opaque objects are allocated and deallocated
by calls that are specific to each object type.
These are listed in the sections where the objects are described.
The calls accept a handle argument of matching type.
In an allocate call this is an argument that
returns a valid reference to the object.
In a call to deallocate this is an argument which returns
with a ``null handle'' value.
MPI provides a ``null handle'' constant
for each object type. Comparisons to this constant are used to test for
validity of the handle.
handle, null
MPI calls do not change the value of handles, with the exception of
calls that allocate and deallocate objects, and of the call
MPI_TYPE_COMMIT, defined in Section 
.
A null handle argument is an erroneous argument in
MPI calls, unless an exception is explicitly stated in the text that
defines the function. Such exceptions are allowed for handles to
request objects in Wait and Test calls
(Section ).
Otherwise, a null handle can only be passed to a function that
allocates a new object and returns a reference to it in the handle.
A call to deallocate invalidates the handle and marks the object for deallocation. The object is not accessible to the user after the call. However, MPI need not deallocate the object immediately. Any operation pending (at the time of the deallocate) that involves this object will complete normally; the object will be deallocated afterwards.
An opaque object and its handle are significant only at the process where the object was created, and cannot be transferred to another process.
MPI provides certain predefined opaque objects and predefined, static handles to these objects. Such objects may not be destroyed.
