MPI_Type_create_struct - Creates a struct datatype


SYNOPSIS

       C:

            #include <mpi.h>

            int MPI_Type_create_struct( count, blocklens, indices,
            old_types,
            newtype )
            int           count;
            int        blocklens[];
            MPI_Aint      indices[];
            MPI_Datatype  old_types[];
            MPI_Datatype *newtype;

       C++:

            #include <mpi.h>

            Datatype Datatype::Create_struct(
            int               count,
            const int         array_of_blocklengths[],
            const Aint        array_of_displacements[],
            const Datatype    array_of_types[])

       Fortran:

            INCLUDE "mpif.h" (or USE MPI)

            INTEGER count, array_of_blocklengths(*), array_of_types(*),
            newtype, ierror
            INTEGER(KIND=MPI_ADDRESS_KIND) array_of_displacements(*)

            CALL MPI_TYPE_CREATE_STRUCT(count, array_of_blocklengths(*),
            array_of_displacements(*), array_of_types(*),
            newtype, ierror)


DESCRIPTION

       The MPI_Type_create_struct routine creates a struct data
       type. The MPI_Type_create_struct routine is an MPI-2
       implementation replacing the MPI-1 MPI_Type_struct routine
       which has been deprecated.  This routine differs from the
       MPI-1 routine in that in the Fortran implementation the
       array_of_displacements(*) argument is of type
       MPI_ADDRESS_KIND, which makes it more suitable for ABI 64.
       Currently, the Fortran version of this function is
       implemented only for ABI 64.  This routine accepts the
       following parameters:

       count          Specifies the number of blocks. Also
                      specifies the  number of entries in


       blocklens      Specifies the number of elements in each
                      block (array).

       indices        Specifies the byte displacement of each
                      block (array).

       old_types      Specifies the type of elements in each
                      block (array of handles to data type
                      objects).

       newtype        Returns the new data type (handle).

       ierror         Specifies the return code value for
                      successful completion, which is in
                      MPI_SUCCESS.  MPI_SUCCESS is defined in the
                      mpif.h file.


NOTES

       If an upper bound is set explicitly by using the MPI data
       type MPI_UB, the corresponding index must be positive.

       The MPI standard originally made vague statements about
       padding and alignment; this was intended to allow the
       simple definition of structures that could be sent with a
       count greater than one.  For example, in the structure
       definition, struct { int a; char b; } foo;, the sizeof
       value might be sizeof(foo) > sizeof(int) + sizeof(char)
       (for example, sizeof(foo) == 2*sizeof(int)).  The initial
       version of the MPI standard defined the extent of a data
       type as including an epsilon that would have allowed an
       implementation to make the extent an MPI data type for
       this structure equal to 2*sizeof(int).  However, since
       different systems might define different paddings, a
       clarification to the standard made epsilon zero.  Thus, if
       you define a structure data type and wish to send or
       receive multiple items, you should explicitly include an
       MPI_UB entry as the last member of the structure.  For
       example, the following code can be used for the structure
       foo:

           blen[0] = 1; indices[0] = 0; oldtypes[0] = MPI_INT;
           blen[1] = 1; indices[1] = &foo.b - &foo; oldtypes[1] = MPI_CHAR;
           blen[2] = 1; indices[2] = sizeof(foo); oldtypes[2] = MPI_UB;
           MPI_Type_create_struct( 3, blen, indices, oldtypes, &newtype );


Man(1) output converted with man2html