GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


       MPI_Type_struct -  Creates a struct datatype


       int MPI_Type_struct(int count,
                          const int *array_of_blocklengths,
                          const MPI_Aint *array_of_displacements,
                          const MPI_Datatype *array_of_types,
                          MPI_Datatype *newtype)


       count  - number of blocks (integer) -- also number of entries in arrays
              array_of_types       ,        array_of_displacements         and
              - number of elements in each block (array)
              - byte displacement of each block (array)
              -  type  of elements in each block (array of handles to datatype


              - new datatype (handle)


       The MPI-2 standard  deprecated  a  number  of  routines  because  MPI-2
       provides  better  versions.   This  routine  is  one  of those that was
       deprecated.  The routine may continue to be used, but new  code  should
       use  the  replacement  routine.   The  replacement  for this routine is


       If an upperbound is set explicitly by using the MPI datatype  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
       struct { int a; char b; } foo;

       may have 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 datatype as including  an  epsilon  that  would
       have  allowed  an implementation to make the extent an MPI datatype for
       this structure equal to 2*sizeof(int) .

       However, since different systems might define different paddings, there
       was  much  discussion by the MPI Forum about what was the correct value
       of epsilon, and one suggestion was to define  epsilon  as  zero.   This
       would have been the best thing to do in MPI 1.0, particularly since the
       MPI_UB type allows the user to easily set the  end  of  the  structure.
       Unfortunately,  this  change  did  not make it into the final document.
       Currently, this routine does not add any padding, since the  amount  of
       padding  needed is determined by the compiler that the user is using to
       build their code, not the compiler used to construct the  MPI  library.
       A  later  version  of  MPICH  may  provide  for some natural choices of
       padding (e.g., multiple of the size of the largest basic  member),  but
       users  are  advised  to  never  depend  on  this,  even with vendor MPI
       implementations.  Instead, if you define a structure datatype 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; array_of_displacements[0] = 0; oldtypes[0] = MPI_INT;
       blen[1] = 1; array_of_displacements[1] = &foo.b - &foo; oldtypes[1] = MPI_CHAR;
       blen[2] = 1; array_of_displacements[2] = sizeof(foo); oldtypes[2] = MPI_UB;
       MPI_Type_struct( 3, blen, array_of_displacements, oldtypes, &newtype );


       This  routine  is  thread-safe.   This  means  that this routine may be
       safely used by multiple threads without the need for any  user-provided
       thread  locks.  However, the routine is not interrupt safe.  Typically,
       this is due to the use of memory allocation routines such as malloc  or
       other  non-MPICH  runtime  routines  that are themselves not interrupt-


       All MPI routines in Fortran (except for MPI_WTIME and MPI_WTICK )  have
       an  additional  argument ierr at the end of the argument list.  ierr is
       an integer and has the same meaning as the return value of the  routine
       in  C.   In Fortran, MPI routines are subroutines, and are invoked with
       the call statement.

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


       All  MPI  routines  (except  MPI_Wtime  and MPI_Wtick ) return an error
       value; C routines as the value of the function and Fortran routines  in
       the last argument.  Before the value is returned, the current MPI error
       handler is called.  By default, this error handler aborts the MPI  job.
       The  error  handler  may  be  changed with MPI_Comm_set_errhandler (for
       communicators),    MPI_File_set_errhandler     (for     files),     and
       MPI_Win_set_errhandler   (for   RMA   windows).    The   MPI-1  routine
       MPI_Errhandler_set  may  be  used  but  its  use  is  deprecated.   The
       predefined  error  handler MPI_ERRORS_RETURN may be used to cause error
       values to be returned.  Note that MPI does not guarentee  that  an  MPI
       program  can  continue past an error; however, MPI implementations will
       attempt to continue whenever possible.

              - No error; MPI routine completed successfully.
              - Invalid datatype argument.  May be an uncommitted MPI_Datatype
              (see MPI_Type_commit ).
              - Invalid count argument.  Count arguments must be non-negative;
              a count of zero is often valid.
              -  This  error  is  returned  when  some  part  of   the   MPICH
              implementation is unable to acquire memory.



                                   2/20/2014                MPI_Type_struct(3)

  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to
Page load time: 0.089 seconds. Last modified: November 04 2018 12:49:43.