[6328] | 1 | #ifndef _MPI_H_ |
---|
| 2 | #define _MPI_H_ |
---|
| 3 | |
---|
| 4 | #define MPI_MAX_LIBRARY_VERSION_STRING (80) |
---|
| 5 | |
---|
| 6 | typedef int MPI_Comm; |
---|
| 7 | typedef int MPI_Request; |
---|
| 8 | |
---|
| 9 | |
---|
| 10 | #define MPI_COMM_WORLD (1) |
---|
| 11 | #define MPI_COMM_NULL (0) /* handle 0 maps to NULL */ |
---|
| 12 | |
---|
| 13 | |
---|
| 14 | typedef int MPI_Group; |
---|
| 15 | |
---|
| 16 | /* MPI_GROUP_EMPTY and MPI_GROUP_NULL must not conflict with MPI_GROUP_ONE */ |
---|
| 17 | #define MPI_GROUP_EMPTY (-1) |
---|
| 18 | #define MPI_GROUP_NULL (0) |
---|
| 19 | |
---|
| 20 | |
---|
| 21 | /* |
---|
| 22 | * Return codes |
---|
| 23 | * On error, mpi-serial aborts so the values don't really matter |
---|
| 24 | * as long as they are different than MPI_SUCCESS |
---|
| 25 | * |
---|
| 26 | */ |
---|
| 27 | |
---|
| 28 | #define MPI_SUCCESS (0) |
---|
| 29 | #define MPI_ERR_BUFFER (-1) |
---|
| 30 | #define MPI_ERR_COUNT (-1) |
---|
| 31 | #define MPI_ERR_TYPE (-1) |
---|
| 32 | #define MPI_ERR_TAG (-1) |
---|
| 33 | #define MPI_ERR_COMM (-1) |
---|
| 34 | #define MPI_ERR_RANK (-1) |
---|
| 35 | #define MPI_ERR_REQUEST (-1) |
---|
| 36 | #define MPI_ERR_ROOT (-1) |
---|
| 37 | #define MPI_ERR_GROUP (-1) |
---|
| 38 | #define MPI_ERR_OP (-1) |
---|
| 39 | #define MPI_ERR_TOPOLOGY (-1) |
---|
| 40 | #define MPI_ERR_DIMS (-1) |
---|
| 41 | #define MPI_ERR_ARG (-1) |
---|
| 42 | #define MPI_ERR_UNKNOWN (-1) |
---|
| 43 | #define MPI_ERR_TRUNCATE (-1) |
---|
| 44 | #define MPI_ERR_OTHER (-1) |
---|
| 45 | #define MPI_ERR_INTERN (-1) |
---|
| 46 | #define MPI_PENDING (-1) |
---|
| 47 | #define MPI_ERR_IN_STATUS (-1) |
---|
| 48 | #define MPI_ERR_LASTCODE (-1) |
---|
| 49 | |
---|
| 50 | /* |
---|
| 51 | * MPI_UNDEFINED |
---|
| 52 | * |
---|
| 53 | * Uses: |
---|
| 54 | * value for "color" in e.g. comm_split |
---|
| 55 | * value for rank in Group_translate_ranks |
---|
| 56 | * |
---|
| 57 | */ |
---|
| 58 | |
---|
| 59 | |
---|
| 60 | #define MPI_UNDEFINED (-1) |
---|
| 61 | |
---|
| 62 | |
---|
| 63 | /* |
---|
| 64 | * Data types etc. |
---|
| 65 | */ |
---|
| 66 | |
---|
| 67 | typedef unsigned long int MPI_Aint; |
---|
| 68 | #define MPI_BOTTOM (0) |
---|
| 69 | #define MPI_IN_PLACE (void *)(-1) |
---|
| 70 | typedef int MPI_Datatype; |
---|
| 71 | |
---|
| 72 | |
---|
| 73 | /* The type's value is now a handle */ |
---|
| 74 | |
---|
| 75 | #define MPI_DATATYPE_NULL (0) |
---|
| 76 | |
---|
| 77 | //C types |
---|
| 78 | #define MPI_CHAR (-1) |
---|
| 79 | #define MPI_SHORT (-2) |
---|
| 80 | #define MPI_INT (-3) |
---|
| 81 | #define MPI_LONG (-4) |
---|
| 82 | #define MPI_UNSIGNED_CHAR (-5) |
---|
| 83 | #define MPI_UNSIGNED_SHORT (-6) |
---|
| 84 | #define MPI_UNSIGNED (-7) |
---|
| 85 | #define MPI_UNSIGNED_LONG (-8) |
---|
| 86 | #define MPI_FLOAT (-9) |
---|
| 87 | #define MPI_DOUBLE (-10) |
---|
| 88 | #define MPI_LONG_DOUBLE (-11) |
---|
| 89 | |
---|
| 90 | //Cross-language |
---|
| 91 | #define MPI_BYTE (-12) |
---|
| 92 | #define MPI_PACKED (-13) |
---|
| 93 | #define MPI_LB (-14) |
---|
| 94 | #define MPI_UB (-15) |
---|
| 95 | |
---|
| 96 | // Fortran types |
---|
| 97 | #define MPI_INTEGER (-16) // RML: why not (MPI_INT) |
---|
| 98 | #define MPI_REAL (-17) // RML: why not (MPI_FLOAT) |
---|
| 99 | #define MPI_DOUBLE_PRECISION (-18) // RML: why not (MPI_DOUBLE) |
---|
| 100 | |
---|
| 101 | #define MPI_COMPLEX (-19) |
---|
| 102 | #define MPI_DOUBLE_COMPLEX (-20) |
---|
| 103 | #define MPI_LOGICAL (-21) |
---|
| 104 | #define MPI_CHARACTER (-22) |
---|
| 105 | #define MPI_2REAL (-23) |
---|
| 106 | #define MPI_2DOUBLE_PRECISION (-24) |
---|
| 107 | #define MPI_2INTEGER (-25) |
---|
| 108 | |
---|
| 109 | //Reduction function types |
---|
| 110 | |
---|
| 111 | #define MPI_FLOAT_INT (-26) |
---|
| 112 | #define MPI_DOUBLE_INT (-27) |
---|
| 113 | #define MPI_LONG_INT (-28) |
---|
| 114 | #define MPI_2INT (-29) |
---|
| 115 | #define MPI_SHORT_INT (-30) |
---|
| 116 | #define MPI_LONG_DOUBLE_INT (-31) |
---|
| 117 | |
---|
| 118 | |
---|
| 119 | /* Fortran size-specific types */ |
---|
| 120 | |
---|
| 121 | #define MPI_INTEGER1 (-32) |
---|
| 122 | #define MPI_INTEGER2 (-33) |
---|
| 123 | #define MPI_INTEGER4 (-34) |
---|
| 124 | #define MPI_INTEGER8 (-35) |
---|
| 125 | #define MPI_INTEGER16 (-36) |
---|
| 126 | |
---|
| 127 | #define MPI_REAL4 (-37) |
---|
| 128 | #define MPI_REAL8 (-38) |
---|
| 129 | #define MPI_REAL16 (-39) |
---|
| 130 | |
---|
| 131 | #define MPI_COMPLEX8 (-40) |
---|
| 132 | #define MPI_COMPLEX16 (-41) |
---|
| 133 | #define MPI_COMPLEX32 (-42) |
---|
| 134 | |
---|
| 135 | /* Some more types */ |
---|
| 136 | |
---|
| 137 | #define MPI_LONG_LONG_INT (-43) |
---|
| 138 | #define MPI_LONG_LONG MPI_LONG_LONG_INT |
---|
| 139 | #define MPI_UNSIGNED_LONG_LONG (-44) |
---|
| 140 | |
---|
| 141 | #define MPI_OFFSET (-45) |
---|
| 142 | |
---|
| 143 | |
---|
| 144 | /* |
---|
| 145 | * Fortran int size |
---|
| 146 | * |
---|
| 147 | */ |
---|
| 148 | |
---|
| 149 | typedef int MPI_Fint; |
---|
| 150 | |
---|
| 151 | |
---|
| 152 | |
---|
| 153 | #define MPI_ANY_TAG (-1) |
---|
| 154 | |
---|
| 155 | #define MPI_ANY_SOURCE (-1) |
---|
| 156 | #define MPI_PROC_NULL (-2) |
---|
| 157 | #define MPI_ROOT (-3) |
---|
| 158 | |
---|
| 159 | #define MPI_REQUEST_NULL (0) |
---|
| 160 | |
---|
| 161 | #define MPI_MAX_ERROR_STRING (128) |
---|
| 162 | #define MPI_MAX_PROCESSOR_NAME (128) |
---|
| 163 | |
---|
| 164 | #define MPI_THREAD_SINGLE (0) |
---|
| 165 | #define MPI_THREAD_FUNNELED (1) |
---|
| 166 | #define MPI_THREAD_SERIALIZED (2) |
---|
| 167 | #define MPI_THREAD_MULTIPLE (3) |
---|
| 168 | |
---|
| 169 | /* |
---|
| 170 | * MPI_Status |
---|
| 171 | * |
---|
| 172 | * definition must be compatible with the mpif.h values for |
---|
| 173 | * MPI_STATUS_SIZE, MPI_SOURCE, MPI_TAG, and MPI_ERROR. |
---|
| 174 | * |
---|
| 175 | * Note: The type used for MPI_Status_int must be chosen to match |
---|
| 176 | * Fortran INTEGER. |
---|
| 177 | * |
---|
| 178 | */ |
---|
| 179 | |
---|
| 180 | typedef int MPI_Status_int; |
---|
| 181 | |
---|
| 182 | typedef struct /* Fortran: INTEGER status(MPI_STATUS_SIZE) */ |
---|
| 183 | { |
---|
| 184 | MPI_Status_int MPI_SOURCE; /* Fortran: status(MPI_SOURCE) */ |
---|
| 185 | MPI_Status_int MPI_TAG; /* Fortran: status(MPI_TAG) */ |
---|
| 186 | MPI_Status_int MPI_ERROR; /* Fortran: status(MPI_ERROR) */ |
---|
| 187 | int get_count; /* Number specified for send */ |
---|
| 188 | |
---|
| 189 | } MPI_Status; |
---|
| 190 | |
---|
| 191 | |
---|
| 192 | #define MPI_STATUS_IGNORE ((MPI_Status *)0) |
---|
| 193 | #define MPI_STATUSES_IGNORE ((MPI_Status *)0) |
---|
| 194 | |
---|
| 195 | |
---|
| 196 | /* |
---|
| 197 | * MPI Errhandling stubs (Not functional currently) |
---|
| 198 | */ |
---|
| 199 | typedef int MPI_Errhandler; |
---|
| 200 | |
---|
| 201 | #define MPI_ERRORS_ARE_FATAL ((MPI_Errhandler)0) |
---|
| 202 | #define MPI_ERRORS_RETURN ((MPI_Errhandler)-1) |
---|
| 203 | |
---|
| 204 | |
---|
| 205 | /* |
---|
| 206 | * Collective operations |
---|
| 207 | */ |
---|
| 208 | |
---|
| 209 | |
---|
| 210 | typedef int MPI_Op; |
---|
| 211 | |
---|
| 212 | typedef void MPI_User_function( void *invec, void *inoutvec, int *len, |
---|
| 213 | MPI_Datatype *datatype); |
---|
| 214 | |
---|
| 215 | #define MPI_OP_NULL (0) |
---|
| 216 | |
---|
| 217 | #define MPI_MAX (0) |
---|
| 218 | #define MPI_MIN (0) |
---|
| 219 | #define MPI_SUM (0) |
---|
| 220 | #define MPI_PROD (0) |
---|
| 221 | #define MPI_LAND (0) |
---|
| 222 | #define MPI_BAND (0) |
---|
| 223 | #define MPI_LOR (0) |
---|
| 224 | #define MPI_BOR (0) |
---|
| 225 | #define MPI_LXOR (0) |
---|
| 226 | #define MPI_BXOR (0) |
---|
| 227 | #define MPI_MAXLOC (0) |
---|
| 228 | #define MPI_MINLOC (0) |
---|
| 229 | |
---|
| 230 | |
---|
| 231 | |
---|
| 232 | #define MPI_STATUS_SIZE (sizeof(MPI_Status) / sizeof(int)) |
---|
| 233 | |
---|
| 234 | |
---|
| 235 | /* NOTE: the C type MPI_Offset is NOT the same as MPI datatype MPI_OFFSET */ |
---|
| 236 | typedef long long int MPI_Offset; |
---|
| 237 | |
---|
| 238 | |
---|
| 239 | /* info |
---|
| 240 | */ |
---|
| 241 | |
---|
| 242 | typedef int MPI_Info; /* handle */ |
---|
| 243 | |
---|
| 244 | #define MPI_INFO_NULL (0) |
---|
| 245 | |
---|
| 246 | |
---|
| 247 | |
---|
| 248 | /********************************************************** |
---|
| 249 | * |
---|
| 250 | * Note: if you need to regenerate the prototypes below, |
---|
| 251 | * you can use 'protify.awk' and paste the output here. |
---|
| 252 | * |
---|
| 253 | */ |
---|
| 254 | |
---|
| 255 | |
---|
| 256 | extern int MPI_Intercomm_create(MPI_Comm local_comm, int local_leader, |
---|
| 257 | MPI_Comm peer_comm, int remote_leader, |
---|
| 258 | int tag, MPI_Comm *newintercomm); |
---|
| 259 | extern int MPI_Intercomm_merge(MPI_Comm intercomm, int high, |
---|
| 260 | MPI_Comm *newintercomm); |
---|
| 261 | extern int MPI_Cart_create(MPI_Comm comm_old, int ndims, int *dims, |
---|
| 262 | int *periods, int reorder, MPI_Comm *comm_cart); |
---|
| 263 | extern int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims, |
---|
| 264 | int *periods, int *coords); |
---|
| 265 | extern int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, |
---|
| 266 | int *coords); |
---|
| 267 | extern int MPI_Dims_create(int nnodes, int ndims, int *dims); |
---|
| 268 | |
---|
| 269 | extern int MPI_Barrier(MPI_Comm comm ); |
---|
| 270 | extern int MPI_Bcast(void* buffer, int count, MPI_Datatype datatype, |
---|
| 271 | int root, MPI_Comm comm ); |
---|
| 272 | extern int MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 273 | void* recvbuf, int recvcount, MPI_Datatype recvtype, |
---|
| 274 | int root, MPI_Comm comm); |
---|
| 275 | extern int MPI_Gatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 276 | void* recvbuf, int *recvcounts, int *displs, |
---|
| 277 | MPI_Datatype recvtype, int root, MPI_Comm comm); |
---|
| 278 | extern int MPI_Allgather(void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 279 | void* recvbuf, int recvcount, MPI_Datatype recvtype, |
---|
| 280 | MPI_Comm comm); |
---|
| 281 | extern int MPI_Allgatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 282 | void* recvbuf, int *recvcounts, int *displs, |
---|
| 283 | MPI_Datatype recvtype, MPI_Comm comm); |
---|
| 284 | extern int MPI_Scatter( void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 285 | void* recvbuf, int recvcount, MPI_Datatype recvtype, |
---|
| 286 | int root, MPI_Comm comm); |
---|
| 287 | extern int MPI_Scatterv(void* sendbuf, int *sendcounts, int *displs, |
---|
| 288 | MPI_Datatype sendtype, void* recvbuf, int recvcount, |
---|
| 289 | MPI_Datatype recvtype, int root, MPI_Comm comm); |
---|
| 290 | extern int MPI_Reduce(void* sendbuf, void* recvbuf, int count, |
---|
| 291 | MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm); |
---|
| 292 | extern int MPI_Reduce_scatter(void* sendbuf, void* recvbuf, int *recvcounts, |
---|
| 293 | MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); |
---|
| 294 | extern int MPI_Allreduce(void* sendbuf, void* recvbuf, int count, |
---|
| 295 | MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); |
---|
| 296 | extern int MPI_Scan( void* sendbuf, void* recvbuf, int count, |
---|
| 297 | MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); |
---|
| 298 | extern int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 299 | void *recvbuf, int recvcount, MPI_Datatype recvtype, |
---|
| 300 | MPI_Comm comm); |
---|
| 301 | extern int MPI_Alltoallv(void *sendbuf, int *sendcounts, |
---|
| 302 | int *sdispls, MPI_Datatype sendtype, |
---|
| 303 | void *recvbuf, int *recvcounts, |
---|
| 304 | int *rdispls, MPI_Datatype recvtype, |
---|
| 305 | MPI_Comm comm) ; |
---|
| 306 | extern int MPI_Alltoallw(void *sendbuf, int *sendcounts, |
---|
| 307 | int *sdispls, MPI_Datatype *sendtypes, |
---|
| 308 | void *recvbuf, int *recvcounts, |
---|
| 309 | int *rdispls, MPI_Datatype *recvtypes, |
---|
| 310 | MPI_Comm comm) ; |
---|
| 311 | |
---|
| 312 | |
---|
| 313 | extern int MPI_Op_create(MPI_User_function *function, int commute, |
---|
| 314 | MPI_Op *op); |
---|
| 315 | extern MPI_Op MPI_Op_f2c(MPI_Fint op); |
---|
| 316 | extern MPI_Fint MPI_Op_c2f(MPI_Op op); |
---|
| 317 | extern MPI_Comm mpi_comm_new(void); |
---|
| 318 | extern int MPI_Op_free(MPI_Op *op); |
---|
| 319 | extern int MPI_Comm_free(MPI_Comm *comm); |
---|
| 320 | extern int MPI_Comm_size(MPI_Comm comm, int *size); |
---|
| 321 | extern int MPI_Comm_rank(MPI_Comm comm, int *rank); |
---|
| 322 | extern int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm); |
---|
| 323 | extern int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm); |
---|
| 324 | extern int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm); |
---|
| 325 | extern int MPI_Comm_group(MPI_Comm comm, MPI_Group *group); |
---|
| 326 | extern MPI_Comm MPI_Comm_f2c(MPI_Fint comm); |
---|
| 327 | extern MPI_Fint MPI_Comm_c2f(MPI_Comm comm); |
---|
| 328 | extern int MPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group *newgroup); |
---|
| 329 | extern int MPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], |
---|
| 330 | MPI_Group *newgroup); |
---|
| 331 | extern int MPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup); |
---|
| 332 | extern int MPI_Group_intersection(MPI_Group group1, MPI_Group group2, |
---|
| 333 | MPI_Group *newgroup); |
---|
| 334 | extern int MPI_Group_difference(MPI_Group group1, MPI_Group group2, |
---|
| 335 | MPI_Group *newgroup); |
---|
| 336 | extern int MPI_Group_free(MPI_Group *group); |
---|
| 337 | extern int MPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, |
---|
| 338 | MPI_Group group2, int *ranks2); |
---|
| 339 | extern MPI_Group MPI_Group_f2c(MPI_Fint group); |
---|
| 340 | extern MPI_Fint MPI_Group_c2f(MPI_Group group); |
---|
| 341 | |
---|
| 342 | extern int MPI_Init(int *argc, char **argv[]) ; |
---|
| 343 | extern int MPI_Finalize(void); |
---|
| 344 | extern int MPI_Abort(MPI_Comm comm, int errorcode); |
---|
| 345 | extern int MPI_Error_string(int errorcode, char *string, int *resultlen); |
---|
| 346 | extern int MPI_Get_processor_name(char *name, int *resultlen); |
---|
| 347 | |
---|
| 348 | extern int MPI_Info_create(MPI_Info *info); |
---|
| 349 | extern int MPI_Info_set(MPI_Info info, char *key, char *value); |
---|
| 350 | |
---|
| 351 | extern int MPI_Initialized(int *flag); |
---|
| 352 | extern int MPI_Pack( void *inbuf, int incount, MPI_Datatype datatype, |
---|
| 353 | void *outbuf, int outsize, int *position, MPI_Comm comm); |
---|
| 354 | extern int MPI_Unpack( void *inbuf, int insize, int *position, |
---|
| 355 | void *outbuf, int outcount, MPI_Datatype datatype, |
---|
| 356 | MPI_Comm comm ); |
---|
| 357 | extern int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, |
---|
| 358 | int source, int tag, MPI_Comm comm, MPI_Request *request); |
---|
| 359 | extern int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source, |
---|
| 360 | int tag, MPI_Comm comm, MPI_Status *status); |
---|
| 361 | |
---|
| 362 | extern int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status); |
---|
| 363 | extern int MPI_Wait(MPI_Request *request, MPI_Status *status); |
---|
| 364 | extern int MPI_Testany(int count, MPI_Request *array_of_requests, |
---|
| 365 | int *index, int *flag, MPI_Status *status); |
---|
| 366 | extern int MPI_Waitany(int count, MPI_Request *array_of_requests, |
---|
| 367 | int *index, MPI_Status *status); |
---|
| 368 | extern int MPI_Testall(int count, MPI_Request *array_of_requests, |
---|
| 369 | int *flag, MPI_Status *array_of_statuses); |
---|
| 370 | extern int MPI_Waitall(int count, MPI_Request *array_of_requests, |
---|
| 371 | MPI_Status *array_of_statuses); |
---|
| 372 | extern MPI_Request MPI_Request_f2c(MPI_Fint request); |
---|
| 373 | extern MPI_Fint MPI_Request_c2f(MPI_Request request); |
---|
| 374 | extern int MPI_Testsome(int incount, MPI_Request *array_of_requests, |
---|
| 375 | int *outcount, int *array_of_indices, |
---|
| 376 | MPI_Status *array_of_statuses); |
---|
| 377 | extern int MPI_Waitsome(int incount, MPI_Request *array_of_requests, |
---|
| 378 | int *outcount, int *array_of_indices, |
---|
| 379 | MPI_Status *array_of_statuses); |
---|
| 380 | extern int MPI_Request_free(MPI_Request * req); |
---|
| 381 | extern int MPI_Isend(void *buf, int count, MPI_Datatype datatype, |
---|
| 382 | int dest, int tag, MPI_Comm comm, MPI_Request *request) ; |
---|
| 383 | extern int MPI_Send(void* buf, int count, MPI_Datatype datatype, |
---|
| 384 | int dest, int tag, MPI_Comm comm); |
---|
| 385 | extern int MPI_Ssend(void* buf, int count, MPI_Datatype datatype, |
---|
| 386 | int dest, int tag, MPI_Comm comm); |
---|
| 387 | extern int MPI_Rsend(void* buf, int count, MPI_Datatype datatype, |
---|
| 388 | int dest, int tag, MPI_Comm comm); |
---|
| 389 | extern int MPI_Irsend(void *buf, int count, MPI_Datatype datatype, |
---|
| 390 | int dest, int tag, MPI_Comm comm, MPI_Request *request) ; |
---|
| 391 | extern int MPI_Sendrecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, |
---|
| 392 | int dest, int sendtag, |
---|
| 393 | void *recvbuf, int recvcount, MPI_Datatype recvtype, |
---|
| 394 | int source, int recvtag, |
---|
| 395 | MPI_Comm comm, MPI_Status *status); |
---|
| 396 | |
---|
| 397 | extern int MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status *status); |
---|
| 398 | extern int MPI_Iprobe(int source, int tag, MPI_Comm comm, |
---|
| 399 | int *flag, MPI_Status *status); |
---|
| 400 | |
---|
| 401 | extern int MPI_Pack_size(int incount, MPI_Datatype type, MPI_Comm comm, MPI_Aint * size); |
---|
| 402 | |
---|
| 403 | /* Error handling stub, not currently functional */ |
---|
| 404 | extern int MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler handle); |
---|
| 405 | |
---|
| 406 | /* new type functions */ |
---|
| 407 | extern int MPI_Get_count(MPI_Status *status, MPI_Datatype datatype, int *count); |
---|
| 408 | extern int MPI_Get_elements(MPI_Status *status, MPI_Datatype datatype, int *count); |
---|
| 409 | extern int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 410 | |
---|
| 411 | extern int MPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype oldtype, |
---|
| 412 | MPI_Datatype *newtype); |
---|
| 413 | |
---|
| 414 | extern int MPI_Type_hvector(int count, int blocklen, MPI_Aint stride, |
---|
| 415 | MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 416 | |
---|
| 417 | extern int MPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, |
---|
| 418 | MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 419 | |
---|
| 420 | extern int MPI_Type_indexed(int count, int *blocklens, int *displacements, |
---|
| 421 | MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 422 | |
---|
| 423 | extern int MPI_Type_create_indexed_block(int count, int blocklen, int *displacements, |
---|
| 424 | MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 425 | extern int MPI_Type_hindexed(int count, int *blocklens, MPI_Aint *displacements, |
---|
| 426 | MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 427 | extern int MPI_Type_size(MPI_Datatype type, int * size); |
---|
| 428 | extern int MPI_Type_struct(int count, int *blocklens, MPI_Aint *displacements, |
---|
| 429 | MPI_Datatype *oldtypes, MPI_Datatype *newtype); |
---|
| 430 | extern int MPI_Type_dup(MPI_Datatype oldtype, MPI_Datatype *newtype); |
---|
| 431 | |
---|
| 432 | extern int MPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent); |
---|
| 433 | extern int MPI_Type_commit(MPI_Datatype * datatype); |
---|
| 434 | extern int MPI_Type_free(MPI_Datatype * datatype); |
---|
| 435 | extern int MPI_Type_lb(MPI_Datatype datatype, MPI_Aint * lb); |
---|
| 436 | extern int MPI_Type_ub(MPI_Datatype datatype, MPI_Aint * ub); |
---|
| 437 | |
---|
| 438 | extern double MPI_Wtime(void); |
---|
| 439 | |
---|
| 440 | #endif |
---|