src/smpi/smpi_mpi.cpp

   1 /* Copyright (c) 2007-2014. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "private.h"
   8 #include "simgrid/sg_config.h"
   9
  10 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi, smpi, "Logging specific to SMPI (mpi)");
  11
  12 /* MPI User level calls */
  13
  14 int MPI_Init(int *argc, char ***argv)
  15 {
  16   return PMPI_Init(argc, argv);
  17 }
  18
  19 int MPI_Finalize(void)
  20 {
  21   return PMPI_Finalize();
  22 }
  23
  24 int MPI_Finalized(int * flag)
  25 {
  26   return PMPI_Finalized(flag);
  27 }
  28
  29 int MPI_Init_thread(int *argc, char ***argv, int required, int *provided)
  30 {
  31   return PMPI_Init_thread(argc, argv, required, provided);
  32 }
  33
  34 int MPI_Query_thread(int *provided)
  35 {
  36   return PMPI_Query_thread(provided);
  37 }
  38
  39 int MPI_Is_thread_main(int *flag)
  40 {
  41   return PMPI_Is_thread_main(flag);
  42 }
  43
  44 int MPI_Abort(MPI_Comm comm, int errorcode)
  45 {
  46   return PMPI_Abort(comm, errorcode);
  47 }
  48
  49 double MPI_Wtime(void)
  50 {
  51   return PMPI_Wtime();
  52 }
  53
  54 double MPI_Wtick(void)
  55 {
  56   return PMPI_Wtick();
  57 }
  58
  59 int MPI_Address(void *location, MPI_Aint * address)
  60 {
  61   return PMPI_Address(location, address);
  62 }
  63
  64 int MPI_Get_address(void *location, MPI_Aint * address)
  65 {
  66   return PMPI_Get_address(location, address);
  67 }
  68
  69 int MPI_Type_free(MPI_Datatype * datatype)
  70 {
  71   return PMPI_Type_free(datatype);
  72 }
  73
  74 int MPI_Type_dup(MPI_Datatype  datatype, MPI_Datatype * newdatatype)
  75 {
  76   return PMPI_Type_dup(datatype, newdatatype);
  77 }
  78
  79 int MPI_Type_set_name(MPI_Datatype  datatype, char * name)
  80 {
  81   return PMPI_Type_set_name(datatype, name);
  82 }
  83
  84 int MPI_Type_get_name(MPI_Datatype  datatype, char * name, int* len)
  85 {
  86   return PMPI_Type_get_name(datatype,name,len);
  87 }
  88
  89 int MPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
  90 {
  91    return PMPI_Type_get_attr ( type, type_keyval, attribute_val, flag);
  92 }
  93
  94 int MPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
  95 {
  96    return PMPI_Type_set_attr ( type, type_keyval, attribute_val);
  97 }
  98
  99 int MPI_Type_delete_attr (MPI_Datatype type, int type_keyval)
 100 {
 101    return PMPI_Type_delete_attr (type,  type_keyval);
 102 }
 103
 104 int MPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval,
 105                            void* extra_state)
 106 {
 107    return PMPI_Type_create_keyval(copy_fn,  delete_fn,  keyval,  extra_state) ;
 108 }
 109
 110 int MPI_Type_free_keyval(int* keyval) {
 111    return PMPI_Type_free_keyval( keyval);
 112 }
 113
 114 int MPI_Pcontrol(const int level )
 115 {
 116   return PMPI_Pcontrol(level);
 117 }
 118
 119 int MPI_Type_size(MPI_Datatype datatype, int *size)
 120 {
 121   return PMPI_Type_size(datatype, size);
 122 }
 123
 124 int MPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 125 {
 126   return PMPI_Type_get_extent(datatype, lb, extent);
 127 }
 128
 129 int MPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 130 {
 131   return PMPI_Type_get_true_extent(datatype, lb, extent);
 132 }
 133
 134 int MPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
 135 {
 136   return PMPI_Type_extent(datatype, extent);
 137 }
 138
 139 int MPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
 140 {
 141   return PMPI_Type_lb(datatype, disp);
 142 }
 143
 144 int MPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
 145 {
 146   return PMPI_Type_ub(datatype, disp);
 147 }
 148
 149 int MPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
 150 {
 151   return PMPI_Op_create(function, commute, op);
 152 }
 153
 154 int MPI_Op_free(MPI_Op * op)
 155 {
 156   return PMPI_Op_free(op);
 157 }
 158
 159 int MPI_Group_free(MPI_Group * group)
 160 {
 161   return PMPI_Group_free(group);
 162 }
 163
 164 int MPI_Group_size(MPI_Group group, int *size)
 165 {
 166   return PMPI_Group_size(group, size);
 167 }
 168
 169 int MPI_Group_rank(MPI_Group group, int *rank)
 170 {
 171   return PMPI_Group_rank(group, rank);
 172 }
 173
 174 int MPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
 175 {
 176   return PMPI_Group_translate_ranks(group1, n, ranks1, group2, ranks2);
 177 }
 178
 179 int MPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
 180 {
 181   return PMPI_Group_compare(group1, group2, result);
 182 }
 183
 184 int MPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 185 {
 186   return PMPI_Group_union(group1, group2, newgroup);
 187 }
 188
 189 int MPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 190 {
 191   return PMPI_Group_intersection(group1, group2, newgroup);
 192 }
 193
 194 int MPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 195 {
 196   return PMPI_Group_difference(group1, group2, newgroup);
 197 }
 198
 199 int MPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 200 {
 201   return PMPI_Group_incl(group, n, ranks, newgroup);
 202 }
 203
 204 int MPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 205 {
 206   return PMPI_Group_excl(group, n, ranks, newgroup);
 207 }
 208
 209 int MPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 210 {
 211   return PMPI_Group_range_incl(group, n, ranges, newgroup);
 212 }
 213
 214 int MPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 215 {
 216   return PMPI_Group_range_excl(group, n, ranges, newgroup);
 217 }
 218
 219 int MPI_Comm_rank(MPI_Comm comm, int *rank)
 220 {
 221   return PMPI_Comm_rank(comm, rank);
 222 }
 223
 224 int MPI_Comm_size(MPI_Comm comm, int *size)
 225 {
 226   return PMPI_Comm_size(comm, size);
 227 }
 228
 229 int MPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
 230 {
 231   return PMPI_Comm_get_attr (comm, comm_keyval, attribute_val, flag);
 232 }
 233
 234 int MPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val)
 235 {
 236    return PMPI_Comm_set_attr ( comm, comm_keyval, attribute_val);
 237 }
 238
 239 int MPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval)
 240 {
 241    return PMPI_Comm_delete_attr (comm,  comm_keyval);
 242 }
 243
 244 int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval,
 245                            void* extra_state)
 246 {
 247    return PMPI_Comm_create_keyval(copy_fn,  delete_fn,  keyval,  extra_state) ;
 248 }
 249
 250 int MPI_Comm_free_keyval(int* keyval) {
 251    return PMPI_Comm_free_keyval( keyval);
 252 }
 253
 254 int MPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 255 {
 256   return PMPI_Comm_get_name(comm, name, len);
 257 }
 258
 259 int MPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 260 {
 261   return PMPI_Comm_group(comm, group);
 262 }
 263
 264 int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 265 {
 266   return PMPI_Comm_compare(comm1, comm2, result);
 267 }
 268
 269 int MPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 270 {
 271   return PMPI_Comm_dup(comm, newcomm);
 272 }
 273
 274 int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 275 {
 276   return PMPI_Comm_create(comm, group, newcomm);
 277 }
 278
 279 int MPI_Comm_free(MPI_Comm * comm)
 280 {
 281   return PMPI_Comm_free(comm);
 282 }
 283
 284 int MPI_Comm_disconnect(MPI_Comm * comm)
 285 {
 286   return PMPI_Comm_disconnect(comm);
 287 }
 288
 289 int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 290 {
 291   return PMPI_Comm_split(comm, color, key, comm_out);
 292 }
 293
 294 int MPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request * request)
 295 {
 296   return PMPI_Send_init(buf, count, datatype, dst, tag, comm, request);
 297 }
 298
 299 int MPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request * request)
 300 {
 301   return PMPI_Recv_init(buf, count, datatype, src, tag, comm, request);
 302 }
 303
 304 int MPI_Start(MPI_Request * request)
 305 {
 306   return PMPI_Start(request);
 307 }
 308
 309 int MPI_Startall(int count, MPI_Request * requests)
 310 {
 311   return PMPI_Startall(count, requests);
 312 }
 313
 314 int MPI_Request_free(MPI_Request * request)
 315 {
 316   return PMPI_Request_free(request);
 317 }
 318
 319 int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request * request)
 320 {
 321   return PMPI_Irecv(buf, count, datatype, src, tag, comm, request);
 322 }
 323
 324 int MPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request * request)
 325 {
 326   return PMPI_Isend(buf, count, datatype, dst, tag, comm, request);
 327 }
 328
 329 int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status * status)
 330 {
 331   return PMPI_Recv(buf, count, datatype, src, tag, comm, status);
 332 }
 333
 334 int MPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
 335 {
 336   return PMPI_Send(buf, count, datatype, dst, tag, comm);
 337 }
 338
 339 int MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,int dst, int sendtag, void *recvbuf, int recvcount,
 340                  MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status * status)
 341 {
 342   return PMPI_Sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag,
 343                        comm, status);
 344 }
 345
 346 int MPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dst, int sendtag, int src, int recvtag,
 347                          MPI_Comm comm, MPI_Status * status)
 348 {
 349   return PMPI_Sendrecv_replace(buf, count, datatype, dst, sendtag, src, recvtag, comm, status);
 350 }
 351
 352 int MPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
 353 {
 354   return PMPI_Test(request, flag, status);
 355 }
 356
 357 int MPI_Testany(int count, MPI_Request requests[], int *index, int *flag, MPI_Status * status)
 358 {
 359   return PMPI_Testany(count, requests, index, flag, status);
 360 }
 361
 362 int MPI_Wait(MPI_Request * request, MPI_Status * status)
 363 {
 364   return PMPI_Wait(request, status);
 365 }
 366
 367 int MPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
 368 {
 369   return PMPI_Waitany(count, requests, index, status);
 370 }
 371
 372 int MPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
 373 {
 374   return PMPI_Waitall(count, requests, status);
 375 }
 376
 377 int MPI_Waitsome(int incount, MPI_Request requests[], int *outcount, int *indices, MPI_Status status[])
 378 {
 379   return PMPI_Waitsome(incount, requests, outcount, indices, status);
 380 }
 381
 382 int MPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
 383 {
 384   return PMPI_Bcast(buf, count, datatype, root, comm);
 385 }
 386
 387 int MPI_Barrier(MPI_Comm comm)
 388 {
 389   return PMPI_Barrier(comm);
 390 }
 391
 392 int MPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype,
 393                int root, MPI_Comm comm)
 394 {
 395   return PMPI_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
 396 }
 397
 398 int MPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs,
 399                 MPI_Datatype recvtype, int root, MPI_Comm comm)
 400 {
 401   return PMPI_Gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm);
 402 }
 403
 404 int MPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount,
 405                   MPI_Datatype recvtype, MPI_Comm comm)
 406 {
 407   return PMPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
 408 }
 409
 410 int MPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs,
 411                    MPI_Datatype recvtype, MPI_Comm comm)
 412 {
 413   return PMPI_Allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
 414 }
 415
 416 int MPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbuf, int recvcount, MPI_Datatype recvtype,
 417                 int root, MPI_Comm comm)
 418 {
 419   return PMPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
 420 }
 421
 422 int MPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype, void *recvbuf, int recvcount,
 423                  MPI_Datatype recvtype, int root, MPI_Comm comm)
 424 {
 425   return PMPI_Scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
 426 }
 427
 428 int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
 429 {
 430   return PMPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
 431 }
 432
 433 int MPI_Reduce_local(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op){
 434   return PMPI_Reduce_local(inbuf, inoutbuf, count, datatype, op);
 435 }
 436
 437 int MPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 438 {
 439   return PMPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
 440 }
 441
 442 int MPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 443 {
 444   return PMPI_Scan(sendbuf, recvbuf, count, datatype, op, comm);
 445 }
 446
 447 int MPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 448 {
 449   return PMPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm);
 450 }
 451
 452 int MPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op,
 453                              MPI_Comm comm)
 454 {
 455   return PMPI_Reduce_scatter_block(sendbuf, recvbuf, recvcount, datatype, op, comm);
 456 }
 457
 458 int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbuf, int recvcount,
 459                  MPI_Datatype recvtype, MPI_Comm comm)
 460 {
 461   return PMPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
 462 }
 463
 464 int MPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps, MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
 465                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
 466 {
 467   return PMPI_Alltoallv(sendbuf, sendcounts, senddisps, sendtype, recvbuf, recvcounts, recvdisps, recvtype, comm);
 468 }
 469
 470 int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr){
 471   return PMPI_Alloc_mem(size, info, baseptr);
 472 }
 473
 474 int MPI_Free_mem(void *baseptr){
 475   return PMPI_Free_mem(baseptr);
 476 }
 477
 478 int MPI_Get_processor_name(char *name, int *resultlen)
 479 {
 480   return PMPI_Get_processor_name(name, resultlen);
 481 }
 482
 483 int MPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count)
 484 {
 485   return PMPI_Get_count(status, datatype, count);
 486 }
 487
 488 int MPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
 489   return PMPI_Pack_size(incount, datatype, comm, size);
 490 }
 491
 492 int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int* coords) {
 493   return PMPI_Cart_coords(comm, rank, maxdims, coords);
 494 }
 495
 496 int MPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder, MPI_Comm* comm_cart) {
 497   return PMPI_Cart_create(comm_old, ndims, dims, periods, reorder, comm_cart);
 498 }
 499
 500 int MPI_Cart_get(MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords) {
 501   return PMPI_Cart_get(comm, maxdims, dims, periods, coords);
 502 }
 503
 504 int MPI_Cart_map(MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank) {
 505   return PMPI_Cart_map(comm_old, ndims, dims, periods, newrank);
 506 }
 507
 508 int MPI_Cart_rank(MPI_Comm comm, int* coords, int* rank) {
 509   return PMPI_Cart_rank(comm, coords, rank);
 510 }
 511
 512 int MPI_Cart_shift(MPI_Comm comm, int direction, int displ, int* source, int* dest) {
 513   return PMPI_Cart_shift(comm, direction, displ, source, dest);
 514 }
 515
 516 int MPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) {
 517   return PMPI_Cart_sub(comm, remain_dims, comm_new);
 518 }
 519
 520 int MPI_Cartdim_get(MPI_Comm comm, int* ndims) {
 521   return PMPI_Cartdim_get(comm, ndims);
 522 }
 523
 524 int MPI_Graph_create(MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph) {
 525   return PMPI_Graph_create(comm_old, nnodes, index, edges, reorder, comm_graph);
 526 }
 527
 528 int MPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges) {
 529   return PMPI_Graph_get(comm, maxindex, maxedges, index, edges);
 530 }
 531
 532 int MPI_Graph_map(MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank) {
 533   return PMPI_Graph_map(comm_old, nnodes, index, edges, newrank);
 534 }
 535
 536 int MPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int* neighbors) {
 537   return PMPI_Graph_neighbors(comm, rank, maxneighbors, neighbors);
 538 }
 539
 540 int MPI_Graph_neighbors_count(MPI_Comm comm, int rank, int* nneighbors) {
 541   return PMPI_Graph_neighbors_count(comm, rank, nneighbors);
 542 }
 543
 544 int MPI_Graphdims_get(MPI_Comm comm, int* nnodes, int* nedges) {
 545   return PMPI_Graphdims_get(comm, nnodes, nedges);
 546 }
 547
 548 int MPI_Topo_test(MPI_Comm comm, int* top_type) {
 549   return PMPI_Topo_test(comm, top_type);
 550 }
 551
 552 int MPI_Error_class(int errorcode, int* errorclass) {
 553   return PMPI_Error_class(errorcode, errorclass);
 554 }
 555
 556 int MPI_Errhandler_create(MPI_Handler_function* function, MPI_Errhandler* errhandler) {
 557   return PMPI_Errhandler_create(function, errhandler);
 558 }
 559
 560 int MPI_Errhandler_free(MPI_Errhandler* errhandler) {
 561   return PMPI_Errhandler_free(errhandler);
 562 }
 563
 564 int MPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler* errhandler) {
 565   return PMPI_Errhandler_get(comm, errhandler);
 566 }
 567
 568 int MPI_Error_string(int errorcode, char* string, int* resultlen) {
 569   return PMPI_Error_string(errorcode, string, resultlen);
 570 }
 571
 572 int MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler) {
 573   return PMPI_Errhandler_set(comm, errhandler);
 574 }
 575
 576 int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
 577   return PMPI_Comm_set_errhandler(comm, errhandler);
 578 }
 579
 580 int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler* errhandler) {
 581   return PMPI_Errhandler_set(comm, errhandler);
 582 }
 583
 584 int MPI_Win_get_group(MPI_Win  win, MPI_Group * group){
 585   return PMPI_Win_get_group(win, group);
 586 }
 587
 588 int MPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler) {
 589   return PMPI_Win_set_errhandler(win, errhandler);
 590 }
 591
 592 int MPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* newtype) {
 593   return PMPI_Type_contiguous(count, old_type, newtype);
 594 }
 595
 596 int MPI_Cancel(MPI_Request* request) {
 597   return PMPI_Cancel(request);
 598 }
 599
 600 int MPI_Buffer_attach(void* buffer, int size) {
 601   return PMPI_Buffer_attach(buffer, size);
 602 }
 603
 604 int MPI_Buffer_detach(void* buffer, int* size) {
 605   return PMPI_Buffer_detach(buffer, size);
 606 }
 607
 608 int MPI_Testsome(int incount, MPI_Request* requests, int* outcount, int* indices, MPI_Status* statuses) {
 609   return PMPI_Testsome(incount, requests, outcount, indices, statuses);
 610 }
 611
 612 int MPI_Comm_test_inter(MPI_Comm comm, int* flag) {
 613   return PMPI_Comm_test_inter(comm, flag);
 614 }
 615
 616 int MPI_Unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
 617   return PMPI_Unpack(inbuf, insize, position, outbuf, outcount, type, comm);
 618 }
 619
 620 int MPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size){
 621   return PMPI_Pack_external_size(datarep, incount, datatype, size);
 622 }
 623
 624 int MPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outcount,
 625                       MPI_Aint *position){
 626   return PMPI_Pack_external(datarep, inbuf, incount, datatype, outbuf, outcount, position);
 627 }
 628
 629 int MPI_Unpack_external(char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount,
 630                         MPI_Datatype datatype){
 631   return PMPI_Unpack_external( datarep, inbuf, insize, position, outbuf, outcount, datatype);
 632 }
 633
 634 int MPI_Type_commit(MPI_Datatype* datatype) {
 635   return PMPI_Type_commit(datatype);
 636 }
 637
 638 int MPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype) {
 639   return PMPI_Type_hindexed(count, blocklens, indices, old_type, newtype);
 640 }
 641
 642 int MPI_Type_create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type,
 643                              MPI_Datatype* new_type) {
 644   return PMPI_Type_create_hindexed(count, blocklens,indices,old_type,new_type);
 645 }
 646
 647 int MPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type,
 648                                    MPI_Datatype* newtype) {
 649   return PMPI_Type_create_hindexed_block(count, blocklength, indices, old_type, newtype);
 650 }
 651
 652 int MPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* newtype) {
 653   return PMPI_Type_hvector(count, blocklen, stride, old_type, newtype);
 654 }
 655
 656 int MPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype) {
 657   return PMPI_Type_indexed(count, blocklens, indices, old_type, newtype);
 658 }
 659
 660 int MPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype) {
 661   return PMPI_Type_create_indexed(count, blocklens, indices, old_type, newtype);
 662 }
 663
 664 int MPI_Type_create_indexed_block(int count, int blocklength, int* indices,  MPI_Datatype old_type,
 665                                   MPI_Datatype *newtype){
 666   return PMPI_Type_create_indexed_block(count, blocklength, indices, old_type, newtype);
 667 }
 668
 669 int MPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* newtype) {
 670   return PMPI_Type_struct(count, blocklens, indices, old_types, newtype);
 671 }
 672
 673 int MPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types,
 674                            MPI_Datatype* newtype) {
 675   return PMPI_Type_create_struct(count, blocklens, indices, old_types, newtype);
 676 }
 677
 678 int MPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* newtype) {
 679   return PMPI_Type_vector(count, blocklen, stride, old_type, newtype);
 680 }
 681
 682 int MPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
 683   return PMPI_Ssend(buf, count, datatype, dest, tag, comm);
 684 }
 685
 686 int MPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request){
 687   return PMPI_Ssend_init(buf, count, datatype, dest, tag, comm, request);
 688 }
 689
 690 int MPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag,
 691                          MPI_Comm* comm_out) {
 692   return PMPI_Intercomm_create(local_comm, local_leader, peer_comm, remote_leader, tag, comm_out);
 693 }
 694
 695 int MPI_Intercomm_merge(MPI_Comm comm, int high, MPI_Comm* comm_out) {
 696   return PMPI_Intercomm_merge(comm, high, comm_out);
 697 }
 698
 699 int MPI_Bsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
 700   return PMPI_Bsend(buf, count, datatype, dest, tag, comm);
 701 }
 702
 703 int MPI_Bsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request){
 704   return PMPI_Bsend_init(buf, count, datatype, dest, tag, comm, request);
 705 }
 706
 707 int MPI_Ibsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
 708   return PMPI_Ibsend(buf, count, datatype, dest, tag, comm, request);
 709 }
 710
 711 int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group* group) {
 712   return PMPI_Comm_remote_group(comm, group);
 713 }
 714
 715 int MPI_Comm_remote_size(MPI_Comm comm, int* size) {
 716   return PMPI_Comm_remote_size(comm, size);
 717 }
 718
 719 int MPI_Issend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
 720   return PMPI_Issend(buf, count, datatype, dest, tag, comm, request);
 721 }
 722
 723 int MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
 724   return PMPI_Probe(source, tag, comm, status);
 725 }
 726
 727 int MPI_Attr_delete(MPI_Comm comm, int keyval) {
 728   return PMPI_Attr_delete(comm, keyval);
 729 }
 730
 731 int MPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) {
 732   return PMPI_Attr_get(comm, keyval, attr_value, flag);
 733 }
 734
 735 int MPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) {
 736   return PMPI_Attr_put(comm, keyval, attr_value);
 737 }
 738
 739 int MPI_Rsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
 740   return PMPI_Rsend(buf, count, datatype, dest, tag, comm);
 741 }
 742
 743 int MPI_Rsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request){
 744   return PMPI_Rsend_init(buf, count, datatype, dest, tag, comm, request);
 745 }
 746
 747 int MPI_Irsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
 748   return PMPI_Irsend(buf, count, datatype, dest, tag, comm, request);
 749 }
 750
 751 int MPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) {
 752   return PMPI_Keyval_create(copy_fn, delete_fn, keyval, extra_state);
 753 }
 754
 755 int MPI_Keyval_free(int* keyval) {
 756   return PMPI_Keyval_free(keyval);
 757 }
 758
 759 int MPI_Test_cancelled(MPI_Status* status, int* flag) {
 760   return PMPI_Test_cancelled(status, flag);
 761 }
 762
 763 int MPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
 764   return PMPI_Pack(inbuf, incount, type, outbuf, outcount, position, comm);
 765 }
 766
 767 int MPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses) {
 768   return PMPI_Testall(count, requests, flag, statuses);
 769 }
 770
 771 int MPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) {
 772   return PMPI_Get_elements(status, datatype, elements);
 773 }
 774
 775 int MPI_Dims_create(int nnodes, int ndims, int* dims) {
 776   return PMPI_Dims_create(nnodes, ndims, dims);
 777 }
 778
 779 int MPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {
 780   return PMPI_Iprobe(source, tag, comm, flag, status);
 781 }
 782
 783 int MPI_Initialized(int* flag) {
 784   return PMPI_Initialized(flag);
 785 }
 786
 787 int MPI_Win_fence( int assert,  MPI_Win win){
 788    return PMPI_Win_fence( assert, win);
 789 }
 790
 791 int MPI_Win_free( MPI_Win* win){
 792    return PMPI_Win_free(  win);
 793 }
 794
 795 int MPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
 796   return PMPI_Win_create( base, size, disp_unit, info, comm,win);
 797 }
 798
 799 int MPI_Win_set_name(MPI_Win  win, char * name)
 800 {
 801   return PMPI_Win_set_name(win, name);
 802 }
 803
 804 int MPI_Win_get_name(MPI_Win  win, char * name, int* len)
 805 {
 806   return PMPI_Win_get_name(win,name,len);
 807 }
 808
 809 int MPI_Win_complete(MPI_Win win){
 810   return PMPI_Win_complete(win);
 811 }
 812
 813 int MPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win) {
 814   return PMPI_Win_lock(lock_type, rank, assert, win);
 815 }
 816
 817 int MPI_Win_post(MPI_Group group, int assert, MPI_Win win){
 818   return PMPI_Win_post(group, assert, win);
 819 }
 820
 821 int MPI_Win_start(MPI_Group group, int assert, MPI_Win win){
 822   return PMPI_Win_start(group, assert, win);
 823 }
 824
 825 int MPI_Win_test(MPI_Win win, int *flag){
 826   return PMPI_Win_test(win, flag);
 827 }
 828
 829 int MPI_Win_unlock(int rank, MPI_Win win){
 830   return PMPI_Win_unlock(rank, win);
 831 }
 832
 833 int MPI_Win_wait(MPI_Win win){
 834   return PMPI_Win_wait(win);
 835 }
 836
 837 int MPI_Info_create( MPI_Info *info){
 838   return PMPI_Info_create( info);
 839 }
 840
 841 int MPI_Info_set( MPI_Info info, char *key, char *value){
 842   return PMPI_Info_set( info, key, value);
 843 }
 844
 845 int MPI_Info_free( MPI_Info *info){
 846   return PMPI_Info_free( info);
 847 }
 848
 849 int MPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 850     MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 851   return PMPI_Get(origin_addr,origin_count, origin_datatype,target_rank, target_disp, target_count,target_datatype,win);
 852 }
 853
 854 int MPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 855     MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 856   return PMPI_Put(origin_addr,origin_count, origin_datatype,target_rank,target_disp, target_count,target_datatype, win);
 857 }
 858
 859 int MPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 860     MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
 861   return PMPI_Accumulate( origin_addr,origin_count, origin_datatype,target_rank,
 862       target_disp, target_count,target_datatype,op, win);
 863 }
 864
 865 int MPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers,
 866                           int *num_addresses, int *num_datatypes, int *combiner){
 867   return PMPI_Type_get_envelope(  datatype, num_integers, num_addresses, num_datatypes, combiner);
 868 }
 869
 870 int MPI_Type_get_contents(MPI_Datatype datatype, int max_integers, int max_addresses, int max_datatypes,
 871                           int* array_of_integers, MPI_Aint* array_of_addresses, MPI_Datatype *array_of_datatypes){
 872   return PMPI_Type_get_contents(datatype, max_integers, max_addresses,max_datatypes, array_of_integers,
 873                                 array_of_addresses, array_of_datatypes);
 874 }
 875
 876 int MPI_Type_create_darray(int size, int rank, int ndims, int* array_of_gsizes, int* array_of_distribs,
 877                             int* array_of_dargs, int* array_of_psizes,int order, MPI_Datatype oldtype,
 878                             MPI_Datatype *newtype) {
 879   return PMPI_Type_create_darray(size, rank, ndims, array_of_gsizes,array_of_distribs, array_of_dargs, array_of_psizes,
 880       order,  oldtype, newtype) ;
 881 }
 882
 883 int MPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
 884   return PMPI_Type_create_resized(oldtype,lb, extent, newtype);
 885 }
 886
 887 int MPI_Type_create_subarray(int ndims,int *array_of_sizes, int *array_of_subsizes, int *array_of_starts, int order,
 888                              MPI_Datatype oldtype, MPI_Datatype *newtype){
 889   return PMPI_Type_create_subarray(ndims,array_of_sizes, array_of_subsizes, array_of_starts, order, oldtype, newtype);
 890 }
 891
 892 int MPI_Type_match_size(int typeclass,int size,MPI_Datatype *datatype){
 893   return PMPI_Type_match_size(typeclass,size,datatype);
 894 }
 895
 896 int MPI_Alltoallw( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes,
 897                    void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes, MPI_Comm comm){
 898   return PMPI_Alltoallw( sendbuf, sendcnts, sdispls, sendtypes, recvbuf, recvcnts, rdispls, recvtypes, comm);
 899 }
 900
 901 int MPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm){
 902   return PMPI_Exscan(sendbuf, recvbuf, count, datatype, op, comm);
 903 }
 904
 905 int MPI_Comm_set_name (MPI_Comm comm, char* name){
 906   return PMPI_Comm_set_name (comm, name);
 907 }
 908
 909 int MPI_Comm_dup_with_info(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm){
 910   return PMPI_Comm_dup_with_info(comm,info,newcomm);
 911 }
 912
 913 int MPI_Comm_split_type(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm *newcomm){
 914   return PMPI_Comm_split_type(comm, split_type, key, info, newcomm);
 915 }
 916
 917 int MPI_Comm_set_info (MPI_Comm comm, MPI_Info info){
 918   return PMPI_Comm_set_info (comm, info);
 919 }
 920
 921 int MPI_Comm_get_info (MPI_Comm comm, MPI_Info* info){
 922   return PMPI_Comm_get_info (comm, info);
 923 }
 924
 925 int MPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){
 926   return PMPI_Info_get(info,key,valuelen, value, flag);
 927 }
 928
 929 int MPI_Comm_create_errhandler( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler){
 930   return PMPI_Comm_create_errhandler( function, errhandler);
 931 }
 932
 933 int MPI_Add_error_class( int *errorclass){
 934   return PMPI_Add_error_class( errorclass);
 935 }
 936
 937 int MPI_Add_error_code(  int errorclass, int *errorcode){
 938   return PMPI_Add_error_code(errorclass, errorcode);
 939 }
 940
 941 int MPI_Add_error_string( int errorcode, char *string){
 942   return PMPI_Add_error_string(errorcode, string);
 943 }
 944
 945 int MPI_Comm_call_errhandler(MPI_Comm comm,int errorcode){
 946   return PMPI_Comm_call_errhandler(comm, errorcode);
 947 }
 948
 949 int MPI_Info_dup(MPI_Info info, MPI_Info *newinfo){
 950   return PMPI_Info_dup(info, newinfo);
 951 }
 952
 953 int MPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){
 954   return PMPI_Info_get_valuelen( info, key, valuelen, flag);
 955 }
 956
 957 int MPI_Info_delete(MPI_Info info, char *key){
 958   return PMPI_Info_delete(info, key);
 959 }
 960
 961 int MPI_Info_get_nkeys( MPI_Info info, int *nkeys){
 962   return PMPI_Info_get_nkeys(  info, nkeys);
 963 }
 964
 965 int MPI_Info_get_nthkey( MPI_Info info, int n, char *key){
 966   return PMPI_Info_get_nthkey( info, n, key);
 967 }
 968
 969 int MPI_Get_version (int *version,int *subversion){
 970   return PMPI_Get_version (version,subversion);
 971 }
 972
 973 int MPI_Get_library_version (char *version,int *len){
 974   return PMPI_Get_library_version (version,len);
 975 }
 976
 977 int MPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
 978   return PMPI_Request_get_status( request, flag, status);
 979 }
 980
 981 int MPI_Grequest_start(MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn,
 982                        MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request){
 983   return PMPI_Grequest_start( query_fn, free_fn, cancel_fn, extra_state, request);
 984 }
 985
 986 int MPI_Grequest_complete( MPI_Request request){
 987   return PMPI_Grequest_complete( request);
 988 }
 989
 990 int MPI_Status_set_cancelled(MPI_Status *status,int flag){
 991   return PMPI_Status_set_cancelled(status,flag);
 992 }
 993
 994 int MPI_Status_set_elements( MPI_Status *status, MPI_Datatype datatype, int count){
 995   return PMPI_Status_set_elements( status, datatype, count);
 996 }
 997
 998 int MPI_Comm_connect( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
 999   return PMPI_Comm_connect( port_name, info, root, comm, newcomm);
1000 }
1001
1002 int MPI_Publish_name( char *service_name, MPI_Info info, char *port_name){
1003   return PMPI_Publish_name( service_name, info, port_name);
1004 }
1005
1006 int MPI_Unpublish_name( char *service_name, MPI_Info info, char *port_name){
1007   return PMPI_Unpublish_name( service_name, info, port_name);
1008 }
1009
1010 int MPI_Lookup_name( char *service_name, MPI_Info info, char *port_name){
1011   return PMPI_Lookup_name( service_name, info, port_name);
1012 }
1013
1014 int MPI_Comm_join( int fd, MPI_Comm *intercomm){
1015   return PMPI_Comm_join( fd, intercomm);
1016 }
1017
1018 int MPI_Open_port( MPI_Info info, char *port_name){
1019   return PMPI_Open_port( info,port_name);
1020 }
1021
1022 int MPI_Close_port( char *port_name){
1023   return PMPI_Close_port( port_name);
1024 }
1025
1026 int MPI_Comm_accept( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
1027  return PMPI_Comm_accept( port_name, info, root, comm, newcomm);
1028 }
1029
1030 int MPI_Comm_spawn( char *command, char **argv, int maxprocs, MPI_Info info, int root,
1031                     MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes){
1032   return PMPI_Comm_spawn( command, argv, maxprocs, info, root, comm, intercomm, array_of_errcodes);
1033 }
1034
1035 int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char*** array_of_argv, int* array_of_maxprocs,
1036                             MPI_Info* array_of_info, int root, MPI_Comm comm, MPI_Comm *intercomm,
1037                             int* array_of_errcodes){
1038   return PMPI_Comm_spawn_multiple( count, array_of_commands, array_of_argv, array_of_maxprocs,
1039                                   array_of_info, root, comm, intercomm, array_of_errcodes);
1040 }
1041
1042 int MPI_Comm_get_parent( MPI_Comm *parent){
1043   return PMPI_Comm_get_parent( parent);
1044 }
1045
1046 int MPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
1047   return PMPI_Type_create_hvector(count, blocklen, stride, old_type, new_type);
1048 }
1049
1050 MPI_Datatype MPI_Type_f2c(MPI_Fint datatype){
1051   return PMPI_Type_f2c(datatype);
1052 }
1053
1054 MPI_Fint MPI_Type_c2f(MPI_Datatype datatype){
1055   return PMPI_Type_c2f( datatype);
1056 }
1057
1058 MPI_Group MPI_Group_f2c(MPI_Fint group){
1059   return PMPI_Group_f2c( group);
1060 }
1061
1062 MPI_Fint MPI_Group_c2f(MPI_Group group){
1063   return PMPI_Group_c2f(group);
1064 }
1065
1066 MPI_Request MPI_Request_f2c(MPI_Fint request){
1067   return PMPI_Request_f2c(request);
1068 }
1069
1070 MPI_Fint MPI_Request_c2f(MPI_Request request) {
1071   return PMPI_Request_c2f(request);
1072 }
1073
1074 MPI_Win MPI_Win_f2c(MPI_Fint win){
1075   return PMPI_Win_f2c(win);
1076 }
1077
1078 MPI_Fint MPI_Win_c2f(MPI_Win win){
1079   return PMPI_Win_c2f(win);
1080 }
1081
1082 MPI_Op MPI_Op_f2c(MPI_Fint op){
1083   return PMPI_Op_f2c(op);
1084 }
1085
1086 MPI_Fint MPI_Op_c2f(MPI_Op op){
1087   return PMPI_Op_c2f(op);
1088 }
1089
1090 MPI_Comm MPI_Comm_f2c(MPI_Fint comm){
1091   return PMPI_Comm_f2c(comm);
1092 }
1093
1094 MPI_Fint MPI_Comm_c2f(MPI_Comm comm){
1095   return PMPI_Comm_c2f(comm);
1096 }
1097
1098 MPI_Info MPI_Info_f2c(MPI_Fint info){
1099   return PMPI_Info_f2c(info);
1100 }
1101
1102 MPI_Fint MPI_Info_c2f(MPI_Info info){
1103   return PMPI_Info_c2f(info);
1104 }
1105
1106 MPI_Errhandler MPI_Errhandler_f2c(MPI_Fint errhandler){
1107   return PMPI_Errhandler_f2c(errhandler);
1108 }
1109
1110 MPI_Fint MPI_Errhandler_c2f(MPI_Errhandler errhandler){
1111   return PMPI_Errhandler_c2f(errhandler);
1112 }
1113
1114 int MPI_File_get_errhandler (MPI_File file, MPI_Errhandler *errhandler){
1115   return PMPI_File_get_errhandler(file, errhandler);
1116 }
1117
1118 int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler){
1119   return PMPI_File_set_errhandler(file, errhandler);
1120 }
1121
1122 int MPI_File_open(MPI_Comm comm, const char *filename, int amode, MPI_Info info, MPI_File *fh){
1123   return PMPI_File_open(comm, filename, amode, info, fh);
1124 }
1125
1126 int MPI_File_close(MPI_File *fh){
1127   return PMPI_File_close(fh);
1128 }
1129
1130 int MPI_File_delete(const char *filename, MPI_Info info){
1131   return PMPI_File_delete(filename, info);
1132 }
1133
1134 int MPI_File_set_size(MPI_File fh, MPI_Offset size){
1135   return PMPI_File_set_size(fh,size);
1136 }
1137
1138 int MPI_File_get_size(MPI_File fh, MPI_Offset *size){
1139   return PMPI_File_get_size(fh, size);
1140 }
1141
1142 int MPI_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, const char *datarep, MPI_Info info){
1143   return PMPI_File_set_view(fh, disp, etype, filetype, datarep, info);
1144 }
1145
1146 int MPI_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep){
1147   return PMPI_File_get_view(fh, disp, etype, filetype, datarep);
1148 }
1149
1150 int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status){
1151   return PMPI_File_read_at(fh,offset,buf,count,datatype,status);
1152 }
1153
1154 int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void * buf, int count,
1155                          MPI_Datatype datatype, MPI_Status *status){
1156   return PMPI_File_read_at_all(fh,offset, buf, count,
1157                          datatype, status);
1158 }
1159
1160 int MPI_File_write_at(MPI_File fh, MPI_Offset offset, const void * buf, int count,
1161                       MPI_Datatype datatype, MPI_Status *status){
1162   return PMPI_File_write_at(fh, offset,buf, count, datatype, status);
1163 }
1164
1165 int MPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,
1166                           MPI_Datatype datatype, MPI_Status *status){
1167   return PMPI_File_write_at_all(fh,offset,buf,count, datatype,status);
1168 }
1169
1170 int MPI_File_set_atomicity(MPI_File fh, int flag){
1171   return PMPI_File_set_atomicity(fh,flag);
1172 }
1173
1174 int MPI_File_get_atomicity(MPI_File fh, int *flag){
1175   return PMPI_File_get_atomicity(fh, flag);
1176 }
1177
1178 int MPI_File_sync(MPI_File fh){
1179   return PMPI_File_sync(fh);
1180 }
1181
1182 int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf, int count,
1183                                MPI_Datatype datatype){
1184   return PMPI_File_read_at_all_begin(fh,offset,buf,count,datatype);
1185 }
1186
1187 int MPI_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status){
1188   return PMPI_File_read_at_all_end(fh,buf,status);
1189 }
1190
1191 int MPI_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype){
1192   return PMPI_File_write_at_all_begin(fh,offset,buf,count,datatype);
1193 }
1194
1195 int MPI_File_write_at_all_end(MPI_File fh, const void *buf, MPI_Status *status){
1196   return PMPI_File_write_at_all_end(fh,buf,status);
1197 }
1198
1199 int MPI_File_read_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype){
1200   return PMPI_File_read_all_begin(fh, buf,count,datatype);
1201 }
1202
1203 int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status){
1204   return PMPI_File_read_all_end(fh, buf, status);
1205 }
1206
1207 int MPI_File_write_all_begin(MPI_File fh, const void *buf, int count, MPI_Datatype datatype){
1208   return PMPI_File_write_all_begin(fh, buf, count,datatype);
1209 }
1210
1211 int MPI_File_write_all_end(MPI_File fh, const void *buf, MPI_Status *status){
1212   return PMPI_File_write_all_end(fh,buf,status);
1213 }
1214
1215 int MPI_File_read_ordered_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype){
1216   return PMPI_File_read_ordered_begin(fh, buf, count, datatype);
1217 }
1218
1219 int MPI_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status){
1220   return PMPI_File_read_ordered_end(fh, buf, status);
1221 }
1222
1223 int MPI_File_write_ordered_begin(MPI_File fh, const void *buf, int count, MPI_Datatype datatype){
1224   return PMPI_File_write_ordered_begin(fh, buf,count, datatype);
1225 }
1226
1227 int MPI_File_write_ordered_end(MPI_File fh, const void *buf, MPI_Status *status){
1228   return PMPI_File_write_ordered_end(fh,buf, status);
1229 }
1230
1231