This source file includes following definitions.
- MPI_Type_create_darray
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 #include "mpioimpl.h"
   9 
  10 #ifdef HAVE_WEAK_SYMBOLS
  11 
  12 #if defined(HAVE_PRAGMA_WEAK)
  13 #pragma weak MPI_Type_create_darray = PMPI_Type_create_darray
  14 #elif defined(HAVE_PRAGMA_HP_SEC_DEF)
  15 #pragma _HP_SECONDARY_DEF PMPI_Type_create_darray MPI_Type_create_darray
  16 #elif defined(HAVE_PRAGMA_CRI_DUP)
  17 #pragma _CRI duplicate MPI_Type_create_darray as PMPI_Type_create_darray
  18 
  19 #endif
  20 
  21 
  22 #define MPIO_BUILD_PROFILING
  23 #include "mpioprof.h"
  24 #endif
  25 
  26 
  27 
  28 
  29 
  30 
  31 
  32 
  33 
  34 
  35 
  36 
  37 
  38 
  39 
  40 
  41 
  42 
  43 
  44 
  45 int MPI_Type_create_darray(int size, int rank, int ndims, 
  46                            int *array_of_gsizes, int *array_of_distribs, 
  47                            int *array_of_dargs, int *array_of_psizes, 
  48                            int order, MPI_Datatype oldtype, 
  49                            MPI_Datatype *newtype) 
  50 {
  51     int err, error_code;
  52     int i;
  53     MPI_Aint orig_extent, orig_lb, size_with_aint;
  54     MPI_Offset size_with_offset;
  55     static char myname[] = "MPI_TYPE_CREATE_DARRAY";
  56 
  57     
  58     if (size <= 0) {
  59         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  60                                           myname, __LINE__, MPI_ERR_ARG,
  61                                           "Invalid size argument", 0);
  62         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  63     }
  64     if (rank < 0) {
  65         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  66                                           myname, __LINE__, MPI_ERR_ARG,
  67                                           "Invalid rank argument", 0);
  68         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  69     }
  70     if (ndims <= 0) {
  71         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  72                                           myname, __LINE__, MPI_ERR_ARG,
  73                                           "Invalid ndoms argument", 0);
  74         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  75     }
  76     if (array_of_gsizes <= (int *) 0) {
  77         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  78                                           myname, __LINE__, MPI_ERR_ARG,
  79                                           "Invalid array_of_gsizes argument", 0);
  80         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  81     }
  82     if (array_of_distribs <= (int *) 0) {
  83         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  84                                           myname, __LINE__, MPI_ERR_ARG,
  85                                           "Invalid array_of_distribs argument", 0);
  86         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  87     }
  88     if (array_of_dargs <= (int *) 0) {
  89         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  90                                           myname, __LINE__, MPI_ERR_ARG,
  91                                           "Invalid array_of_dargs argument", 0);
  92         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  93     }
  94     if (array_of_psizes <= (int *) 0) {
  95         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  96                                           myname, __LINE__, MPI_ERR_ARG,
  97                                           "Invalid array_of_psizes argument", 0);
  98         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
  99     }
 100 
 101     for (i=0; i<ndims; i++) {
 102         if (array_of_gsizes[i] <= 0) {
 103             error_code = MPIO_Err_create_code(MPI_SUCCESS,MPIR_ERR_RECOVERABLE,
 104                                               myname, __LINE__, MPI_ERR_ARG,
 105                                               "Invalid gsize argument", 0);
 106             return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 107         }
 108 
 109         
 110 
 111         if ((array_of_dargs[i] != MPI_DISTRIBUTE_DFLT_DARG) && 
 112             (array_of_dargs[i] <= 0))
 113         {
 114             error_code = MPIO_Err_create_code(MPI_SUCCESS,
 115                                               MPIR_ERR_RECOVERABLE,
 116                                               myname, __LINE__, MPI_ERR_ARG,
 117                                               "Invalid darg argument", 0);
 118             return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 119         }
 120 
 121         if (array_of_psizes[i] <= 0) {
 122             error_code = MPIO_Err_create_code(MPI_SUCCESS,
 123                                               MPIR_ERR_RECOVERABLE,
 124                                               myname, __LINE__, MPI_ERR_ARG,
 125                                               "Invalid psize argument", 0);
 126             return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 127         }
 128         if (array_of_distribs[i] != MPI_DISTRIBUTE_BLOCK &&
 129             array_of_distribs[i] != MPI_DISTRIBUTE_CYCLIC &&
 130             array_of_distribs[i] != MPI_DISTRIBUTE_NONE)
 131         {
 132             error_code = MPIO_Err_create_code(MPI_SUCCESS,
 133                                               MPIR_ERR_RECOVERABLE,
 134                                               myname, __LINE__,
 135                                               MPI_ERR_ARG,
 136                                               "Invalid distrib argument",
 137                                               0);
 138             return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 139         }
 140         if (array_of_distribs[i] == MPI_DISTRIBUTE_NONE &&
 141             array_of_psizes[i] != 1)
 142         {
 143                     error_code = MPIO_Err_create_code(MPI_SUCCESS,
 144                                                       MPIR_ERR_RECOVERABLE,
 145                                                       myname, __LINE__,
 146                                                       MPI_ERR_ARG,
 147                                                       "For MPI_DISTRIBUTE_NONE, the number of processes in that dimension of the grid must be 1",
 148                                                       0);
 149                     return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 150         }
 151     }
 152 
 153     
 154 
 155     if (oldtype == MPI_DATATYPE_NULL) {
 156         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 157                                           myname, __LINE__, MPI_ERR_ARG,
 158                                           "Invalid type argument", 0);
 159         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 160     }
 161 
 162     MPI_Type_get_extent(oldtype, &orig_lb, &orig_extent);
 163 
 164 
 165 
 166 
 167     size_with_aint = orig_extent;
 168     for (i=0; i<ndims; i++) size_with_aint *= array_of_gsizes[i];
 169     size_with_offset = orig_extent;
 170     for (i=0; i<ndims; i++) size_with_offset *= array_of_gsizes[i];
 171 
 172     if (size_with_aint != size_with_offset) {
 173         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 174                                           myname, __LINE__, MPI_ERR_ARG,
 175                                           "Invalid array size", 0);
 176         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 177     }
 178 
 179     if (order != MPI_ORDER_FORTRAN && order != MPI_ORDER_C) {
 180         error_code = MPIO_Err_create_code(MPI_SUCCESS,
 181                                           MPIR_ERR_RECOVERABLE,
 182                                           myname, __LINE__, MPI_ERR_ARG,
 183                                           "Invalid order argument", 0);
 184         return MPIO_Err_return_comm(MPI_COMM_SELF, error_code);
 185     }
 186     
 187 
 188     err = ADIO_Type_create_darray(size,
 189                                   rank,
 190                                   ndims,
 191                                   array_of_gsizes,
 192                                   array_of_distribs,
 193                                   array_of_dargs,
 194                                   array_of_psizes,
 195                                   order,
 196                                   oldtype,
 197                                   newtype);
 198     
 199     if (err != MPI_SUCCESS) {
 200         error_code = MPIO_Err_create_code(MPI_SUCCESS,
 201                                           MPIR_ERR_RECOVERABLE,
 202                                           myname, __LINE__, err,
 203                                           "Internal error", 0);
 204     }
 205     
 206 
 207     return MPI_SUCCESS;
 208 }
 209