src/smpi/smpi_pmpi.c

   1 /* Copyright (c) 2007, 2008, 2009, 2010. 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 "smpi_mpi_dt_private.h"
   9
  10 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_pmpi, smpi,
  11                                 "Logging specific to SMPI (pmpi)");
  12
  13 #ifdef HAVE_TRACING
  14 //this function need to be here because of the calls to smpi_bench
  15 void TRACE_smpi_set_category(const char *category)
  16 {
  17   //need to end bench otherwise categories for execution tasks are wrong
  18   smpi_bench_end();
  19   TRACE_internal_smpi_set_category (category);
  20   //begin bench after changing process's category
  21   smpi_bench_begin();
  22 }
  23 #endif
  24
  25 /* PMPI User level calls */
  26
  27 int PMPI_Init(int *argc, char ***argv)
  28 {
  29   smpi_process_init(argc, argv);
  30 #ifdef HAVE_TRACING
  31   int rank = smpi_process_index();
  32   TRACE_smpi_init(rank);
  33
  34   TRACE_smpi_computing_init(rank);
  35 #endif
  36   smpi_bench_begin();
  37   return MPI_SUCCESS;
  38 }
  39
  40 int PMPI_Finalize(void)
  41 {
  42   smpi_process_finalize();
  43   smpi_bench_end();
  44 #ifdef HAVE_TRACING
  45   int rank = smpi_process_index();
  46   TRACE_smpi_computing_out(rank);
  47   TRACE_smpi_finalize(smpi_process_index());
  48 #endif
  49   smpi_process_destroy();
  50   return MPI_SUCCESS;
  51 }
  52
  53 int PMPI_Finalized(int* flag)
  54 {
  55   *flag=smpi_process_finalized();
  56   return MPI_SUCCESS;
  57 }
  58
  59 int PMPI_Get_version (int *version,int *subversion){
  60   *version = MPI_VERSION;
  61   *subversion= MPI_SUBVERSION;
  62   return MPI_SUCCESS;
  63 }
  64
  65 int PMPI_Get_library_version (char *version,int *len){
  66   int retval = MPI_SUCCESS;
  67   smpi_bench_end();
  68   snprintf(version,MPI_MAX_LIBRARY_VERSION_STRING,"SMPI Version %d.%d. Copyright The Simgrid Team 2007-2013",SIMGRID_VERSION_MAJOR,
  69           SIMGRID_VERSION_MINOR);
  70   *len = strlen(version) > MPI_MAX_LIBRARY_VERSION_STRING ? MPI_MAX_LIBRARY_VERSION_STRING : strlen(version);
  71   smpi_bench_begin();
  72   return retval;
  73 }
  74
  75 int PMPI_Init_thread(int *argc, char ***argv, int required, int *provided)
  76 {
  77   if (provided != NULL) {
  78     *provided = MPI_THREAD_MULTIPLE;
  79   }
  80   return MPI_Init(argc, argv);
  81 }
  82
  83 int PMPI_Query_thread(int *provided)
  84 {
  85   int retval;
  86
  87   smpi_bench_end();
  88   if (provided == NULL) {
  89     retval = MPI_ERR_ARG;
  90   } else {
  91     *provided = MPI_THREAD_MULTIPLE;
  92     retval = MPI_SUCCESS;
  93   }
  94   smpi_bench_begin();
  95   return retval;
  96 }
  97
  98 int PMPI_Is_thread_main(int *flag)
  99 {
 100   int retval;
 101
 102   smpi_bench_end();
 103   if (flag == NULL) {
 104     retval = MPI_ERR_ARG;
 105   } else {
 106     *flag = smpi_process_index() == 0;
 107     retval = MPI_SUCCESS;
 108   }
 109   smpi_bench_begin();
 110   return retval;
 111 }
 112
 113 int PMPI_Abort(MPI_Comm comm, int errorcode)
 114 {
 115   smpi_bench_end();
 116   smpi_process_destroy();
 117 #ifdef HAVE_TRACING
 118   int rank = smpi_process_index();
 119   TRACE_smpi_computing_out(rank);
 120 #endif
 121   // FIXME: should kill all processes in comm instead
 122   simcall_process_kill(SIMIX_process_self());
 123   return MPI_SUCCESS;
 124 }
 125
 126 double PMPI_Wtime(void)
 127 {
 128   double time;
 129
 130   smpi_bench_end();
 131   time = SIMIX_get_clock();
 132   smpi_bench_begin();
 133   return time;
 134 }
 135 extern double sg_maxmin_precision;
 136 double PMPI_Wtick(void)
 137 {
 138   return sg_maxmin_precision;
 139 }
 140
 141 int PMPI_Address(void *location, MPI_Aint * address)
 142 {
 143   int retval;
 144
 145   smpi_bench_end();
 146   if (!address) {
 147     retval = MPI_ERR_ARG;
 148   } else {
 149     *address = (MPI_Aint) location;
 150     retval = MPI_SUCCESS;
 151   }
 152   smpi_bench_begin();
 153   return retval;
 154 }
 155
 156 int PMPI_Get_address(void *location, MPI_Aint * address)
 157 {
 158   return PMPI_Address(location, address);
 159 }
 160
 161 int PMPI_Type_free(MPI_Datatype * datatype)
 162 {
 163   int retval;
 164
 165   smpi_bench_end();
 166   if (!datatype) {
 167     retval = MPI_ERR_ARG;
 168   } else {
 169     smpi_datatype_free(datatype);
 170     retval = MPI_SUCCESS;
 171   }
 172   smpi_bench_begin();
 173   return retval;
 174 }
 175
 176 int PMPI_Type_size(MPI_Datatype datatype, int *size)
 177 {
 178   int retval;
 179
 180   smpi_bench_end();
 181   if (datatype == MPI_DATATYPE_NULL) {
 182     retval = MPI_ERR_TYPE;
 183   } else if (size == NULL) {
 184     retval = MPI_ERR_ARG;
 185   } else {
 186     *size = (int) smpi_datatype_size(datatype);
 187     retval = MPI_SUCCESS;
 188   }
 189   smpi_bench_begin();
 190   return retval;
 191 }
 192
 193 int PMPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 194 {
 195   int retval;
 196
 197   smpi_bench_end();
 198   if (datatype == MPI_DATATYPE_NULL) {
 199     retval = MPI_ERR_TYPE;
 200   } else if (lb == NULL || extent == NULL) {
 201     retval = MPI_ERR_ARG;
 202   } else {
 203     retval = smpi_datatype_extent(datatype, lb, extent);
 204   }
 205   smpi_bench_begin();
 206   return retval;
 207 }
 208
 209 int PMPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
 210 {
 211   return PMPI_Type_get_extent(datatype, lb, extent);
 212 }
 213
 214 int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
 215 {
 216   int retval;
 217
 218   smpi_bench_end();
 219   if (datatype == MPI_DATATYPE_NULL) {
 220     retval = MPI_ERR_TYPE;
 221   } else if (extent == NULL) {
 222     retval = MPI_ERR_ARG;
 223   } else {
 224     *extent = smpi_datatype_get_extent(datatype);
 225     retval = MPI_SUCCESS;
 226   }
 227   smpi_bench_begin();
 228   return retval;
 229 }
 230
 231 int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
 232 {
 233   int retval;
 234
 235   smpi_bench_end();
 236   if (datatype == MPI_DATATYPE_NULL) {
 237     retval = MPI_ERR_TYPE;
 238   } else if (disp == NULL) {
 239     retval = MPI_ERR_ARG;
 240   } else {
 241     *disp = smpi_datatype_lb(datatype);
 242     retval = MPI_SUCCESS;
 243   }
 244   smpi_bench_begin();
 245   return retval;
 246 }
 247
 248 int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
 249 {
 250   int retval;
 251
 252   smpi_bench_end();
 253   if (datatype == MPI_DATATYPE_NULL) {
 254     retval = MPI_ERR_TYPE;
 255   } else if (disp == NULL) {
 256     retval = MPI_ERR_ARG;
 257   } else {
 258     *disp = smpi_datatype_ub(datatype);
 259     retval = MPI_SUCCESS;
 260   }
 261   smpi_bench_begin();
 262   return retval;
 263 }
 264
 265 int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
 266 {
 267   int retval;
 268
 269   smpi_bench_end();
 270   if (function == NULL || op == NULL) {
 271     retval = MPI_ERR_ARG;
 272   } else {
 273     *op = smpi_op_new(function, commute);
 274     retval = MPI_SUCCESS;
 275   }
 276   smpi_bench_begin();
 277   return retval;
 278 }
 279
 280 int PMPI_Op_free(MPI_Op * op)
 281 {
 282   int retval;
 283
 284   smpi_bench_end();
 285   if (op == NULL) {
 286     retval = MPI_ERR_ARG;
 287   } else if (*op == MPI_OP_NULL) {
 288     retval = MPI_ERR_OP;
 289   } else {
 290     smpi_op_destroy(*op);
 291     *op = MPI_OP_NULL;
 292     retval = MPI_SUCCESS;
 293   }
 294   smpi_bench_begin();
 295   return retval;
 296 }
 297
 298 int PMPI_Group_free(MPI_Group * group)
 299 {
 300   int retval;
 301
 302   smpi_bench_end();
 303   if (group == NULL) {
 304     retval = MPI_ERR_ARG;
 305   } else {
 306     if(*group!= smpi_comm_group(MPI_COMM_WORLD))// do not free the group of the comm_world
 307     smpi_group_destroy(*group);
 308     *group = MPI_GROUP_NULL;
 309     retval = MPI_SUCCESS;
 310   }
 311   smpi_bench_begin();
 312   return retval;
 313 }
 314
 315 int PMPI_Group_size(MPI_Group group, int *size)
 316 {
 317   int retval;
 318
 319   smpi_bench_end();
 320   if (group == MPI_GROUP_NULL) {
 321     retval = MPI_ERR_GROUP;
 322   } else if (size == NULL) {
 323     retval = MPI_ERR_ARG;
 324   } else {
 325     *size = smpi_group_size(group);
 326     retval = MPI_SUCCESS;
 327   }
 328   smpi_bench_begin();
 329   return retval;
 330 }
 331
 332 int PMPI_Group_rank(MPI_Group group, int *rank)
 333 {
 334   int retval;
 335
 336   smpi_bench_end();
 337   if (group == MPI_GROUP_NULL) {
 338     retval = MPI_ERR_GROUP;
 339   } else if (rank == NULL) {
 340     retval = MPI_ERR_ARG;
 341   } else {
 342     *rank = smpi_group_rank(group, smpi_process_index());
 343     retval = MPI_SUCCESS;
 344   }
 345   smpi_bench_begin();
 346   return retval;
 347 }
 348
 349 int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1,
 350                               MPI_Group group2, int *ranks2)
 351 {
 352   int retval, i, index;
 353   smpi_bench_end();
 354   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 355     retval = MPI_ERR_GROUP;
 356   } else {
 357     for (i = 0; i < n; i++) {
 358       if(ranks1[i]==MPI_PROC_NULL){
 359         ranks2[i]=MPI_PROC_NULL;
 360       }else{
 361         index = smpi_group_index(group1, ranks1[i]);
 362         ranks2[i] = smpi_group_rank(group2, index);
 363       }
 364     }
 365     retval = MPI_SUCCESS;
 366   }
 367   smpi_bench_begin();
 368   return retval;
 369 }
 370
 371 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
 372 {
 373   int retval;
 374
 375   smpi_bench_end();
 376   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 377     retval = MPI_ERR_GROUP;
 378   } else if (result == NULL) {
 379     retval = MPI_ERR_ARG;
 380   } else {
 381     *result = smpi_group_compare(group1, group2);
 382     retval = MPI_SUCCESS;
 383   }
 384   smpi_bench_begin();
 385   return retval;
 386 }
 387
 388 int PMPI_Group_union(MPI_Group group1, MPI_Group group2,
 389                     MPI_Group * newgroup)
 390 {
 391   int retval, i, proc1, proc2, size, size2;
 392
 393   smpi_bench_end();
 394   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 395     retval = MPI_ERR_GROUP;
 396   } else if (newgroup == NULL) {
 397     retval = MPI_ERR_ARG;
 398   } else {
 399     size = smpi_group_size(group1);
 400     size2 = smpi_group_size(group2);
 401     for (i = 0; i < size2; i++) {
 402       proc2 = smpi_group_index(group2, i);
 403       proc1 = smpi_group_rank(group1, proc2);
 404       if (proc1 == MPI_UNDEFINED) {
 405         size++;
 406       }
 407     }
 408     if (size == 0) {
 409       *newgroup = MPI_GROUP_EMPTY;
 410     } else {
 411       *newgroup = smpi_group_new(size);
 412       size2 = smpi_group_size(group1);
 413       for (i = 0; i < size2; i++) {
 414         proc1 = smpi_group_index(group1, i);
 415         smpi_group_set_mapping(*newgroup, proc1, i);
 416       }
 417       for (i = size2; i < size; i++) {
 418         proc2 = smpi_group_index(group2, i - size2);
 419         smpi_group_set_mapping(*newgroup, proc2, i);
 420       }
 421     }
 422     smpi_group_use(*newgroup);
 423     retval = MPI_SUCCESS;
 424   }
 425   smpi_bench_begin();
 426   return retval;
 427 }
 428
 429 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2,
 430                            MPI_Group * newgroup)
 431 {
 432   int retval, i, proc1, proc2, size;
 433
 434   smpi_bench_end();
 435   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 436     retval = MPI_ERR_GROUP;
 437   } else if (newgroup == NULL) {
 438     retval = MPI_ERR_ARG;
 439   } else {
 440     size = smpi_group_size(group2);
 441     for (i = 0; i < size; i++) {
 442       proc2 = smpi_group_index(group2, i);
 443       proc1 = smpi_group_rank(group1, proc2);
 444       if (proc1 == MPI_UNDEFINED) {
 445         size--;
 446       }
 447     }
 448     if (size == 0) {
 449       *newgroup = MPI_GROUP_EMPTY;
 450     } else {
 451       *newgroup = smpi_group_new(size);
 452       int j=0;
 453       for (i = 0; i < smpi_group_size(group2); i++) {
 454         proc2 = smpi_group_index(group2, i);
 455         proc1 = smpi_group_rank(group1, proc2);
 456         if (proc1 != MPI_UNDEFINED) {
 457           smpi_group_set_mapping(*newgroup, proc2, j);
 458           j++;
 459         }
 460       }
 461     }
 462     smpi_group_use(*newgroup);
 463     retval = MPI_SUCCESS;
 464   }
 465   smpi_bench_begin();
 466   return retval;
 467 }
 468
 469 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 470 {
 471   int retval, i, proc1, proc2, size, size2;
 472
 473   smpi_bench_end();
 474   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 475     retval = MPI_ERR_GROUP;
 476   } else if (newgroup == NULL) {
 477     retval = MPI_ERR_ARG;
 478   } else {
 479     size = size2 = smpi_group_size(group1);
 480     for (i = 0; i < size2; i++) {
 481       proc1 = smpi_group_index(group1, i);
 482       proc2 = smpi_group_rank(group2, proc1);
 483       if (proc2 != MPI_UNDEFINED) {
 484         size--;
 485       }
 486     }
 487     if (size == 0) {
 488       *newgroup = MPI_GROUP_EMPTY;
 489     } else {
 490       *newgroup = smpi_group_new(size);
 491       for (i = 0; i < size2; i++) {
 492         proc1 = smpi_group_index(group1, i);
 493         proc2 = smpi_group_rank(group2, proc1);
 494         if (proc2 == MPI_UNDEFINED) {
 495           smpi_group_set_mapping(*newgroup, proc1, i);
 496         }
 497       }
 498     }
 499     smpi_group_use(*newgroup);
 500     retval = MPI_SUCCESS;
 501   }
 502   smpi_bench_begin();
 503   return retval;
 504 }
 505
 506 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 507 {
 508   int retval, i, index;
 509
 510   smpi_bench_end();
 511   if (group == MPI_GROUP_NULL) {
 512     retval = MPI_ERR_GROUP;
 513   } else if (newgroup == NULL) {
 514     retval = MPI_ERR_ARG;
 515   } else {
 516     if (n == 0) {
 517       *newgroup = MPI_GROUP_EMPTY;
 518     } else if (n == smpi_group_size(group)) {
 519       *newgroup = group;
 520     } else {
 521       *newgroup = smpi_group_new(n);
 522       for (i = 0; i < n; i++) {
 523         index = smpi_group_index(group, ranks[i]);
 524         smpi_group_set_mapping(*newgroup, index, i);
 525       }
 526     }
 527     smpi_group_use(*newgroup);
 528     retval = MPI_SUCCESS;
 529   }
 530   smpi_bench_begin();
 531   return retval;
 532 }
 533
 534 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 535 {
 536   int retval, i, j, newsize, oldsize, index;
 537
 538   smpi_bench_end();
 539   if (group == MPI_GROUP_NULL) {
 540     retval = MPI_ERR_GROUP;
 541   } else if (newgroup == NULL) {
 542     retval = MPI_ERR_ARG;
 543   } else {
 544     if (n == 0) {
 545       *newgroup = group;
 546     } else if (n == smpi_group_size(group)) {
 547       *newgroup = MPI_GROUP_EMPTY;
 548     } else {
 549       oldsize=smpi_group_size(group);
 550       newsize = oldsize - n;
 551       *newgroup = smpi_group_new(newsize);
 552
 553       int* to_exclude=xbt_new(int, smpi_group_size(group));
 554       for(i=0; i<oldsize; i++)
 555         to_exclude[i]=0;
 556       for(i=0; i<n; i++)
 557         to_exclude[ranks[i]]=1;
 558
 559       j=0;
 560       for(i=0; i<oldsize; i++){
 561         if(to_exclude[i]==0){
 562           index = smpi_group_index(group, i);
 563           smpi_group_set_mapping(*newgroup, index, j);
 564           j++;
 565         }
 566       }
 567
 568       xbt_free(to_exclude);
 569     }
 570     smpi_group_use(*newgroup);
 571     retval = MPI_SUCCESS;
 572   }
 573   smpi_bench_begin();
 574   return retval;
 575 }
 576
 577 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3],
 578                          MPI_Group * newgroup)
 579 {
 580   int retval, i, j, rank, size, index;
 581
 582   smpi_bench_end();
 583   if (group == MPI_GROUP_NULL) {
 584     retval = MPI_ERR_GROUP;
 585   } else if (newgroup == NULL) {
 586     retval = MPI_ERR_ARG;
 587   } else {
 588     if (n == 0) {
 589       *newgroup = MPI_GROUP_EMPTY;
 590     } else {
 591       size = 0;
 592       for (i = 0; i < n; i++) {
 593         for (rank = ranges[i][0];       /* First */
 594              rank >= 0; /* Last */
 595               ) {
 596           size++;
 597
 598           rank += ranges[i][2]; /* Stride */
 599           if (ranges[i][0]<ranges[i][1]){
 600               if(rank > ranges[i][1])
 601                 break;
 602           }else{
 603               if(rank < ranges[i][1])
 604                 break;
 605           }
 606         }
 607       }
 608
 609         *newgroup = smpi_group_new(size);
 610         j = 0;
 611         for (i = 0; i < n; i++) {
 612           for (rank = ranges[i][0];     /* First */
 613                rank >= 0; /* Last */
 614                ) {
 615             index = smpi_group_index(group, rank);
 616             smpi_group_set_mapping(*newgroup, index, j);
 617             j++;
 618             rank += ranges[i][2]; /* Stride */
 619             if (ranges[i][0]<ranges[i][1]){
 620               if(rank > ranges[i][1])
 621                 break;
 622             }else{
 623               if(rank < ranges[i][1])
 624                 break;
 625             }
 626           }
 627         }
 628       //}
 629     }
 630     smpi_group_use(*newgroup);
 631     retval = MPI_SUCCESS;
 632   }
 633   smpi_bench_begin();
 634   return retval;
 635 }
 636
 637 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3],
 638                          MPI_Group * newgroup)
 639 {
 640   int retval, i, newrank, rank, size, index, add;
 641
 642   smpi_bench_end();
 643   if (group == MPI_GROUP_NULL) {
 644     retval = MPI_ERR_GROUP;
 645   } else if (newgroup == NULL) {
 646     retval = MPI_ERR_ARG;
 647   } else {
 648     if (n == 0) {
 649       *newgroup = group;
 650     } else {
 651       size = smpi_group_size(group);
 652       for (i = 0; i < n; i++) {
 653         for (rank = ranges[i][0];       /* First */
 654              rank >= 0 && rank <= ranges[i][1]; /* Last */
 655              rank += ranges[i][2] /* Stride */ ) {
 656           size--;
 657         }
 658       }
 659       if (size == 0) {
 660         *newgroup = MPI_GROUP_EMPTY;
 661       } else {
 662         *newgroup = smpi_group_new(size);
 663         newrank = 0;
 664         while (newrank < size) {
 665           for (i = 0; i < n; i++) {
 666             add = 1;
 667             for (rank = ranges[i][0];   /* First */
 668                  rank >= 0 && rank <= ranges[i][1];     /* Last */
 669                  rank += ranges[i][2] /* Stride */ ) {
 670               if (rank == newrank) {
 671                 add = 0;
 672                 break;
 673               }
 674             }
 675             if (add == 1) {
 676               index = smpi_group_index(group, newrank);
 677               smpi_group_set_mapping(*newgroup, index, newrank);
 678             }
 679           }
 680           newrank++; //added to avoid looping, need to be checked ..
 681         }
 682       }
 683     }
 684     smpi_group_use(*newgroup);
 685     retval = MPI_SUCCESS;
 686   }
 687   smpi_bench_begin();
 688   return retval;
 689 }
 690
 691 int PMPI_Comm_rank(MPI_Comm comm, int *rank)
 692 {
 693   int retval;
 694
 695   smpi_bench_end();
 696   if (comm == MPI_COMM_NULL) {
 697     retval = MPI_ERR_COMM;
 698   } else if (rank == NULL) {
 699     retval = MPI_ERR_ARG;
 700   } else {
 701     *rank = smpi_comm_rank(comm);
 702     retval = MPI_SUCCESS;
 703   }
 704   smpi_bench_begin();
 705   return retval;
 706 }
 707
 708 int PMPI_Comm_size(MPI_Comm comm, int *size)
 709 {
 710   int retval;
 711
 712   smpi_bench_end();
 713   if (comm == MPI_COMM_NULL) {
 714     retval = MPI_ERR_COMM;
 715   } else if (size == NULL) {
 716     retval = MPI_ERR_ARG;
 717   } else {
 718     *size = smpi_comm_size(comm);
 719     retval = MPI_SUCCESS;
 720   }
 721   smpi_bench_begin();
 722   return retval;
 723 }
 724
 725 int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 726 {
 727   int retval;
 728
 729   smpi_bench_end();
 730   if (comm == MPI_COMM_NULL)  {
 731     retval = MPI_ERR_COMM;
 732   } else if (name == NULL || len == NULL)  {
 733     retval = MPI_ERR_ARG;
 734   } else {
 735     smpi_comm_get_name(comm, name, len);
 736     retval = MPI_SUCCESS;
 737   }
 738   smpi_bench_begin();
 739   return retval;
 740 }
 741
 742 int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 743 {
 744   int retval;
 745
 746   smpi_bench_end();
 747   if (comm == MPI_COMM_NULL) {
 748     retval = MPI_ERR_COMM;
 749   } else if (group == NULL) {
 750     retval = MPI_ERR_ARG;
 751   } else {
 752     *group = smpi_comm_group(comm);
 753     retval = MPI_SUCCESS;
 754   }
 755   smpi_bench_begin();
 756   return retval;
 757 }
 758
 759 int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 760 {
 761   int retval;
 762
 763   smpi_bench_end();
 764   if (comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {
 765     retval = MPI_ERR_COMM;
 766   } else if (result == NULL) {
 767     retval = MPI_ERR_ARG;
 768   } else {
 769     if (comm1 == comm2) {       /* Same communicators means same groups */
 770       *result = MPI_IDENT;
 771     } else {
 772       *result =
 773           smpi_group_compare(smpi_comm_group(comm1),
 774                              smpi_comm_group(comm2));
 775       if (*result == MPI_IDENT) {
 776         *result = MPI_CONGRUENT;
 777       }
 778     }
 779     retval = MPI_SUCCESS;
 780   }
 781   smpi_bench_begin();
 782   return retval;
 783 }
 784
 785 int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 786 {
 787   int retval;
 788
 789   smpi_bench_end();
 790   if (comm == MPI_COMM_NULL) {
 791     retval = MPI_ERR_COMM;
 792   } else if (newcomm == NULL) {
 793     retval = MPI_ERR_ARG;
 794   } else {
 795     *newcomm = smpi_comm_new(smpi_comm_group(comm));
 796     retval = MPI_SUCCESS;
 797   }
 798   smpi_bench_begin();
 799   return retval;
 800 }
 801
 802 int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 803 {
 804   int retval;
 805
 806   smpi_bench_end();
 807   if (comm == MPI_COMM_NULL) {
 808     retval = MPI_ERR_COMM;
 809   } else if (group == MPI_GROUP_NULL) {
 810     retval = MPI_ERR_GROUP;
 811   } else if (newcomm == NULL) {
 812     retval = MPI_ERR_ARG;
 813   } else if(smpi_group_rank(group,smpi_process_index())==MPI_UNDEFINED){
 814     *newcomm= MPI_COMM_NULL;
 815     retval = MPI_SUCCESS;
 816   }else{
 817
 818     *newcomm = smpi_comm_new(group);
 819     retval = MPI_SUCCESS;
 820   }
 821   smpi_bench_begin();
 822   return retval;
 823 }
 824
 825 int PMPI_Comm_free(MPI_Comm * comm)
 826 {
 827   int retval;
 828
 829   smpi_bench_end();
 830   if (comm == NULL) {
 831     retval = MPI_ERR_ARG;
 832   } else if (*comm == MPI_COMM_NULL) {
 833     retval = MPI_ERR_COMM;
 834   } else {
 835     smpi_comm_destroy(*comm);
 836     *comm = MPI_COMM_NULL;
 837     retval = MPI_SUCCESS;
 838   }
 839   smpi_bench_begin();
 840   return retval;
 841 }
 842
 843 int PMPI_Comm_disconnect(MPI_Comm * comm)
 844 {
 845   /* TODO: wait until all communication in comm are done */
 846   int retval;
 847
 848   smpi_bench_end();
 849   if (comm == NULL) {
 850     retval = MPI_ERR_ARG;
 851   } else if (*comm == MPI_COMM_NULL) {
 852     retval = MPI_ERR_COMM;
 853   } else {
 854     smpi_comm_destroy(*comm);
 855     *comm = MPI_COMM_NULL;
 856     retval = MPI_SUCCESS;
 857   }
 858   smpi_bench_begin();
 859   return retval;
 860 }
 861
 862 int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 863 {
 864   int retval;
 865
 866   smpi_bench_end();
 867   if (comm_out == NULL) {
 868     retval = MPI_ERR_ARG;
 869   } else if (comm == MPI_COMM_NULL) {
 870     retval = MPI_ERR_COMM;
 871   } else {
 872     *comm_out = smpi_comm_split(comm, color, key);
 873     retval = MPI_SUCCESS;
 874   }
 875   smpi_bench_begin();
 876   return retval;
 877 }
 878
 879 int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
 880                   int tag, MPI_Comm comm, MPI_Request * request)
 881 {
 882   int retval;
 883
 884   smpi_bench_end();
 885   if (request == NULL) {
 886     retval = MPI_ERR_ARG;
 887   } else if (comm == MPI_COMM_NULL) {
 888     retval = MPI_ERR_COMM;
 889   } else if (dst == MPI_PROC_NULL) {
 890     retval = MPI_SUCCESS;
 891   } else {
 892     *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm);
 893     retval = MPI_SUCCESS;
 894   }
 895   smpi_bench_begin();
 896   return retval;
 897 }
 898
 899 int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
 900                   int tag, MPI_Comm comm, MPI_Request * request)
 901 {
 902   int retval;
 903
 904   smpi_bench_end();
 905   if (request == NULL) {
 906     retval = MPI_ERR_ARG;
 907   } else if (comm == MPI_COMM_NULL) {
 908     retval = MPI_ERR_COMM;
 909   } else if (src == MPI_PROC_NULL) {
 910       retval = MPI_SUCCESS;
 911   } else {
 912     *request = smpi_mpi_recv_init(buf, count, datatype, src, tag, comm);
 913     retval = MPI_SUCCESS;
 914   }
 915   smpi_bench_begin();
 916   return retval;
 917 }
 918
 919 int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
 920   int retval;
 921
 922     smpi_bench_end();
 923     if (request == NULL) {
 924       retval = MPI_ERR_ARG;
 925     } else if (comm == MPI_COMM_NULL) {
 926       retval = MPI_ERR_COMM;
 927     } else if (dst == MPI_PROC_NULL) {
 928       retval = MPI_SUCCESS;
 929     } else {
 930       *request = smpi_mpi_ssend_init(buf, count, datatype, dst, tag, comm);
 931       retval = MPI_SUCCESS;
 932     }
 933     smpi_bench_begin();
 934     return retval;
 935 }
 936
 937 int PMPI_Start(MPI_Request * request)
 938 {
 939   int retval;
 940
 941   smpi_bench_end();
 942   if (request == NULL || *request == MPI_REQUEST_NULL) {
 943     retval = MPI_ERR_ARG;
 944   } else {
 945     smpi_mpi_start(*request);
 946     retval = MPI_SUCCESS;
 947   }
 948   smpi_bench_begin();
 949   return retval;
 950 }
 951
 952 int PMPI_Startall(int count, MPI_Request * requests)
 953 {
 954   int retval;
 955
 956   smpi_bench_end();
 957   if (requests == NULL) {
 958     retval = MPI_ERR_ARG;
 959   } else {
 960     smpi_mpi_startall(count, requests);
 961     retval = MPI_SUCCESS;
 962   }
 963   smpi_bench_begin();
 964   return retval;
 965 }
 966
 967 int PMPI_Request_free(MPI_Request * request)
 968 {
 969   int retval;
 970
 971   smpi_bench_end();
 972   if (*request == MPI_REQUEST_NULL) {
 973     retval = MPI_ERR_ARG;
 974   } else {
 975     if((*request)->flags & PERSISTENT)(*request)->refcount--;
 976     smpi_mpi_request_free(request);
 977     retval = MPI_SUCCESS;
 978   }
 979   smpi_bench_begin();
 980   return retval;
 981 }
 982
 983 int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
 984               int tag, MPI_Comm comm, MPI_Request * request)
 985 {
 986   int retval;
 987
 988   smpi_bench_end();
 989
 990   if (request == NULL) {
 991     retval = MPI_ERR_ARG;
 992   } else if (comm == MPI_COMM_NULL) {
 993     retval = MPI_ERR_COMM;
 994   } else if (src == MPI_PROC_NULL) {
 995     *request = MPI_REQUEST_NULL;
 996     retval = MPI_SUCCESS;
 997   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
 998     retval = MPI_ERR_COMM;
 999   } else if (count < 0) {
1000     retval = MPI_ERR_COUNT;
1001   } else if (buf==NULL && count > 0) {
1002     retval = MPI_ERR_COUNT;
1003   } else if (datatype == MPI_DATATYPE_NULL){
1004     retval = MPI_ERR_TYPE;
1005   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1006     retval = MPI_ERR_TAG;
1007   } else {
1008
1009 #ifdef HAVE_TRACING
1010   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1011   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1012   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
1013 #endif
1014
1015     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
1016     retval = MPI_SUCCESS;
1017
1018 #ifdef HAVE_TRACING
1019   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1020   (*request)->recv = 1;
1021 #endif
1022   }
1023
1024   smpi_bench_begin();
1025   return retval;
1026 }
1027
1028
1029 int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
1030               int tag, MPI_Comm comm, MPI_Request * request)
1031 {
1032   int retval;
1033
1034   smpi_bench_end();
1035   if (request == NULL) {
1036     retval = MPI_ERR_ARG;
1037   } else if (comm == MPI_COMM_NULL) {
1038     retval = MPI_ERR_COMM;
1039   } else if (dst == MPI_PROC_NULL) {
1040     *request = MPI_REQUEST_NULL;
1041     retval = MPI_SUCCESS;
1042   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1043     retval = MPI_ERR_RANK;
1044   } else if (count < 0) {
1045     retval = MPI_ERR_COUNT;
1046   } else if (buf==NULL && count > 0) {
1047     retval = MPI_ERR_COUNT;
1048   } else if (datatype == MPI_DATATYPE_NULL){
1049     retval = MPI_ERR_TYPE;
1050   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1051     retval = MPI_ERR_TAG;
1052   } else {
1053
1054 #ifdef HAVE_TRACING
1055   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1056   TRACE_smpi_computing_out(rank);
1057   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1058   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1059   TRACE_smpi_send(rank, rank, dst_traced);
1060 #endif
1061
1062     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
1063     retval = MPI_SUCCESS;
1064
1065 #ifdef HAVE_TRACING
1066   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1067   (*request)->send = 1;
1068   TRACE_smpi_computing_in(rank);
1069 #endif
1070   }
1071
1072   smpi_bench_begin();
1073   return retval;
1074 }
1075
1076 int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
1077   int retval;
1078
1079   smpi_bench_end();
1080   if (request == NULL) {
1081     retval = MPI_ERR_ARG;
1082   } else if (comm == MPI_COMM_NULL) {
1083     retval = MPI_ERR_COMM;
1084   } else if (dst == MPI_PROC_NULL) {
1085     *request = MPI_REQUEST_NULL;
1086     retval = MPI_SUCCESS;
1087   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1088     retval = MPI_ERR_RANK;
1089   } else if (count < 0) {
1090     retval = MPI_ERR_COUNT;
1091   } else if (buf==NULL && count > 0) {
1092     retval = MPI_ERR_COUNT;
1093   } else if (datatype == MPI_DATATYPE_NULL){
1094     retval = MPI_ERR_TYPE;
1095   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1096     retval = MPI_ERR_TAG;
1097   } else {
1098
1099 #ifdef HAVE_TRACING
1100   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1101   TRACE_smpi_computing_out(rank);
1102   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1103   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1104   TRACE_smpi_send(rank, rank, dst_traced);
1105 #endif
1106
1107     *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
1108     retval = MPI_SUCCESS;
1109
1110 #ifdef HAVE_TRACING
1111   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1112   (*request)->send = 1;
1113   TRACE_smpi_computing_in(rank);
1114 #endif
1115   }
1116
1117   smpi_bench_begin();
1118   return retval;
1119 }
1120
1121 int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
1122              MPI_Comm comm, MPI_Status * status)
1123 {
1124   int retval;
1125
1126   smpi_bench_end();
1127   if (comm == MPI_COMM_NULL) {
1128     retval = MPI_ERR_COMM;
1129   } else if (src == MPI_PROC_NULL) {
1130     smpi_empty_status(status);
1131     status->MPI_SOURCE = MPI_PROC_NULL;
1132     retval = MPI_SUCCESS;
1133   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
1134     retval = MPI_ERR_RANK;
1135   } else if (count < 0) {
1136     retval = MPI_ERR_COUNT;
1137   } else if (buf==NULL && count > 0) {
1138     retval = MPI_ERR_COUNT;
1139   } else if (datatype == MPI_DATATYPE_NULL){
1140     retval = MPI_ERR_TYPE;
1141   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1142     retval = MPI_ERR_TAG;
1143   } else {
1144 #ifdef HAVE_TRACING
1145   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1146   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1147   TRACE_smpi_computing_out(rank);
1148
1149   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
1150 #endif
1151
1152     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
1153     retval = MPI_SUCCESS;
1154
1155 #ifdef HAVE_TRACING
1156   //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1157   if(status!=MPI_STATUS_IGNORE)src_traced = smpi_group_index(smpi_comm_group(comm), status->MPI_SOURCE);
1158   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1159   TRACE_smpi_recv(rank, src_traced, rank);
1160   TRACE_smpi_computing_in(rank);
1161 #endif
1162   }
1163
1164   smpi_bench_begin();
1165   return retval;
1166 }
1167
1168 int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
1169              MPI_Comm comm)
1170 {
1171   int retval;
1172
1173   smpi_bench_end();
1174
1175   if (comm == MPI_COMM_NULL) {
1176     retval = MPI_ERR_COMM;
1177   } else if (dst == MPI_PROC_NULL) {
1178     retval = MPI_SUCCESS;
1179   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1180     retval = MPI_ERR_RANK;
1181   } else if (count < 0) {
1182     retval = MPI_ERR_COUNT;
1183   } else if (buf==NULL && count > 0) {
1184     retval = MPI_ERR_COUNT;
1185   } else if (datatype == MPI_DATATYPE_NULL){
1186     retval = MPI_ERR_TYPE;
1187   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1188     retval = MPI_ERR_TAG;
1189   } else {
1190
1191 #ifdef HAVE_TRACING
1192   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1193   TRACE_smpi_computing_out(rank);
1194   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1195   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1196   TRACE_smpi_send(rank, rank, dst_traced);
1197 #endif
1198
1199     smpi_mpi_send(buf, count, datatype, dst, tag, comm);
1200     retval = MPI_SUCCESS;
1201
1202 #ifdef HAVE_TRACING
1203   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1204   TRACE_smpi_computing_in(rank);
1205 #endif
1206   }
1207
1208   smpi_bench_begin();
1209   return retval;
1210 }
1211
1212
1213
1214 int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
1215   int retval;
1216
1217    smpi_bench_end();
1218
1219    if (comm == MPI_COMM_NULL) {
1220      retval = MPI_ERR_COMM;
1221    } else if (dst == MPI_PROC_NULL) {
1222      retval = MPI_SUCCESS;
1223    } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1224      retval = MPI_ERR_RANK;
1225    } else if (count < 0) {
1226      retval = MPI_ERR_COUNT;
1227    } else if (buf==NULL && count > 0) {
1228      retval = MPI_ERR_COUNT;
1229    } else if (datatype == MPI_DATATYPE_NULL){
1230      retval = MPI_ERR_TYPE;
1231    } else if(tag<0 && tag !=  MPI_ANY_TAG){
1232      retval = MPI_ERR_TAG;
1233    } else {
1234
1235  #ifdef HAVE_TRACING
1236    int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1237    TRACE_smpi_computing_out(rank);
1238    int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1239    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1240    TRACE_smpi_send(rank, rank, dst_traced);
1241  #endif
1242
1243      smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
1244      retval = MPI_SUCCESS;
1245
1246  #ifdef HAVE_TRACING
1247    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1248    TRACE_smpi_computing_in(rank);
1249  #endif
1250    }
1251
1252    smpi_bench_begin();
1253    return retval;}
1254
1255
1256 int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1257                  int dst, int sendtag, void *recvbuf, int recvcount,
1258                  MPI_Datatype recvtype, int src, int recvtag,
1259                  MPI_Comm comm, MPI_Status * status)
1260 {
1261   int retval;
1262
1263   smpi_bench_end();
1264
1265   if (comm == MPI_COMM_NULL) {
1266     retval = MPI_ERR_COMM;
1267   } else if (sendtype == MPI_DATATYPE_NULL
1268              || recvtype == MPI_DATATYPE_NULL) {
1269     retval = MPI_ERR_TYPE;
1270   } else if (src == MPI_PROC_NULL || dst == MPI_PROC_NULL) {
1271       smpi_empty_status(status);
1272       status->MPI_SOURCE = MPI_PROC_NULL;
1273       retval = MPI_SUCCESS;
1274   }else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0 ||
1275       (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0))){
1276     retval = MPI_ERR_RANK;
1277   } else if (sendcount < 0 || recvcount<0) {
1278       retval = MPI_ERR_COUNT;
1279   } else if ((sendbuf==NULL && sendcount > 0)||(recvbuf==NULL && recvcount>0)) {
1280     retval = MPI_ERR_COUNT;
1281   } else if((sendtag<0 && sendtag !=  MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){
1282     retval = MPI_ERR_TAG;
1283   } else {
1284
1285 #ifdef HAVE_TRACING
1286   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1287   TRACE_smpi_computing_out(rank);
1288   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1289   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1290   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
1291   TRACE_smpi_send(rank, rank, dst_traced);
1292 #endif
1293
1294
1295     smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf,
1296                       recvcount, recvtype, src, recvtag, comm, status);
1297     retval = MPI_SUCCESS;
1298
1299 #ifdef HAVE_TRACING
1300   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1301   TRACE_smpi_recv(rank, src_traced, rank);
1302   TRACE_smpi_computing_in(rank);
1303 #endif
1304
1305   }
1306
1307   smpi_bench_begin();
1308   return retval;
1309 }
1310
1311 int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype,
1312                          int dst, int sendtag, int src, int recvtag,
1313                          MPI_Comm comm, MPI_Status * status)
1314 {
1315   //TODO: suboptimal implementation
1316   void *recvbuf;
1317   int retval;
1318   if (datatype == MPI_DATATYPE_NULL) {
1319       retval = MPI_ERR_TYPE;
1320   } else if (count < 0) {
1321       retval = MPI_ERR_COUNT;
1322   } else {
1323     int size = smpi_datatype_get_extent(datatype) * count;
1324     recvbuf = xbt_new(char, size);
1325     retval =
1326         MPI_Sendrecv(buf, count, datatype, dst, sendtag, recvbuf, count,
1327                      datatype, src, recvtag, comm, status);
1328     if(retval==MPI_SUCCESS){
1329         smpi_datatype_copy(recvbuf, count, datatype, buf, count, datatype);
1330     }
1331     xbt_free(recvbuf);
1332
1333   }
1334   return retval;
1335 }
1336
1337 int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
1338 {
1339   int retval;
1340
1341   smpi_bench_end();
1342   if (request == MPI_REQUEST_NULL || flag == NULL) {
1343     retval = MPI_ERR_ARG;
1344   } else if (*request == MPI_REQUEST_NULL) {
1345     *flag= TRUE;
1346     retval = MPI_ERR_REQUEST;
1347   } else {
1348     *flag = smpi_mpi_test(request, status);
1349     retval = MPI_SUCCESS;
1350   }
1351   smpi_bench_begin();
1352   return retval;
1353 }
1354
1355 int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
1356                 MPI_Status * status)
1357 {
1358   int retval;
1359
1360   smpi_bench_end();
1361   if (index == NULL || flag == NULL) {
1362     retval = MPI_ERR_ARG;
1363   } else {
1364     *flag = smpi_mpi_testany(count, requests, index, status);
1365     retval = MPI_SUCCESS;
1366   }
1367   smpi_bench_begin();
1368   return retval;
1369 }
1370
1371 int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses)
1372 {
1373   int retval;
1374
1375   smpi_bench_end();
1376   if (flag == NULL) {
1377     retval = MPI_ERR_ARG;
1378   } else {
1379     *flag = smpi_mpi_testall(count, requests, statuses);
1380     retval = MPI_SUCCESS;
1381   }
1382   smpi_bench_begin();
1383   return retval;
1384 }
1385
1386 int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
1387   int retval;
1388   smpi_bench_end();
1389
1390   if (status == NULL) {
1391     retval = MPI_ERR_ARG;
1392   } else if (comm == MPI_COMM_NULL) {
1393     retval = MPI_ERR_COMM;
1394   } else if (source == MPI_PROC_NULL) {
1395     smpi_empty_status(status);
1396     status->MPI_SOURCE = MPI_PROC_NULL;
1397     retval = MPI_SUCCESS;
1398   } else {
1399     smpi_mpi_probe(source, tag, comm, status);
1400     retval = MPI_SUCCESS;
1401   }
1402   smpi_bench_begin();
1403   return retval;
1404 }
1405
1406
1407 int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {
1408   int retval;
1409   smpi_bench_end();
1410
1411   if (flag == NULL) {
1412     retval = MPI_ERR_ARG;
1413   } else if (status == NULL) {
1414     retval = MPI_ERR_ARG;
1415   } else if (comm == MPI_COMM_NULL) {
1416     retval = MPI_ERR_COMM;
1417   } else if (source == MPI_PROC_NULL) {
1418     smpi_empty_status(status);
1419     status->MPI_SOURCE = MPI_PROC_NULL;
1420     retval = MPI_SUCCESS;
1421   } else {
1422     smpi_mpi_iprobe(source, tag, comm, flag, status);
1423     retval = MPI_SUCCESS;
1424   }
1425   smpi_bench_begin();
1426   return retval;
1427 }
1428
1429 int PMPI_Wait(MPI_Request * request, MPI_Status * status)
1430 {
1431   int retval;
1432
1433   smpi_bench_end();
1434
1435   if (request == NULL) {
1436     retval = MPI_ERR_ARG;
1437   } else if (*request == MPI_REQUEST_NULL) {
1438     retval = MPI_ERR_REQUEST;
1439   } else {
1440
1441 #ifdef HAVE_TRACING
1442   int rank = request && (*request)->comm != MPI_COMM_NULL
1443       ? smpi_process_index()
1444       : -1;
1445   TRACE_smpi_computing_out(rank);
1446
1447   int src_traced = (*request)->src;
1448   int dst_traced = (*request)->dst;
1449   int is_wait_for_receive = (*request)->recv;
1450   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
1451 #endif
1452
1453     smpi_mpi_wait(request, status);
1454     retval = MPI_SUCCESS;
1455
1456 #ifdef HAVE_TRACING
1457   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1458   if (is_wait_for_receive) {
1459     TRACE_smpi_recv(rank, src_traced, dst_traced);
1460   }
1461   TRACE_smpi_computing_in(rank);
1462 #endif
1463
1464   }
1465
1466   smpi_bench_begin();
1467   return retval;
1468 }
1469
1470 int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
1471 {
1472   int retval;
1473
1474   smpi_bench_end();
1475 #ifdef HAVE_TRACING
1476   //save requests information for tracing
1477   int i;
1478   int *srcs = xbt_new(int, count);
1479   int *dsts = xbt_new(int, count);
1480   int *recvs = xbt_new(int, count);
1481   for (i = 0; i < count; i++) {
1482     MPI_Request req = requests[i];      //already received requests are no longer valid
1483     if (req) {
1484       srcs[i] = req->src;
1485       dsts[i] = req->dst;
1486       recvs[i] = req->recv;
1487     }
1488   }
1489   int rank_traced = smpi_process_index();
1490   TRACE_smpi_computing_out(rank_traced);
1491
1492   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
1493
1494 #endif
1495   if (index == NULL) {
1496     retval = MPI_ERR_ARG;
1497   } else {
1498     *index = smpi_mpi_waitany(count, requests, status);
1499     retval = MPI_SUCCESS;
1500   }
1501 #ifdef HAVE_TRACING
1502   if(*index!=MPI_UNDEFINED){
1503     int src_traced = srcs[*index];
1504     int dst_traced = dsts[*index];
1505     int is_wait_for_receive = recvs[*index];
1506     if (is_wait_for_receive) {
1507       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1508     }
1509     TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
1510     xbt_free(srcs);
1511     xbt_free(dsts);
1512     xbt_free(recvs);
1513   }
1514   TRACE_smpi_computing_in(rank_traced);
1515 #endif
1516   smpi_bench_begin();
1517   return retval;
1518 }
1519
1520 int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
1521 {
1522
1523   smpi_bench_end();
1524 #ifdef HAVE_TRACING
1525   //save information from requests
1526   int i;
1527   int *srcs = xbt_new(int, count);
1528   int *dsts = xbt_new(int, count);
1529   int *recvs = xbt_new(int, count);
1530   int valid_count = 0;
1531   for (i = 0; i < count; i++) {
1532     MPI_Request req = requests[i];
1533     if(req!=MPI_REQUEST_NULL){
1534       srcs[valid_count] = req->src;
1535       dsts[valid_count] = req->dst;
1536       recvs[valid_count] = req->recv;
1537       valid_count++;
1538     }
1539   }
1540   int rank_traced = smpi_process_index();
1541   TRACE_smpi_computing_out(rank_traced);
1542
1543   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
1544 #endif
1545   int retval = smpi_mpi_waitall(count, requests, status);
1546 #ifdef HAVE_TRACING
1547   for (i = 0; i < valid_count; i++) {
1548     int src_traced = srcs[i];
1549     int dst_traced = dsts[i];
1550     int is_wait_for_receive = recvs[i];
1551     if (is_wait_for_receive) {
1552       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1553     }
1554   }
1555   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
1556   xbt_free(srcs);
1557   xbt_free(dsts);
1558   xbt_free(recvs);
1559   TRACE_smpi_computing_in(rank_traced);
1560 #endif
1561   smpi_bench_begin();
1562   return retval;
1563 }
1564
1565 int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
1566                  int *indices, MPI_Status status[])
1567 {
1568   int retval;
1569
1570   smpi_bench_end();
1571   if (outcount == NULL) {
1572     retval = MPI_ERR_ARG;
1573   } else {
1574     *outcount = smpi_mpi_waitsome(incount, requests, indices, status);
1575     retval = MPI_SUCCESS;
1576   }
1577   smpi_bench_begin();
1578   return retval;
1579 }
1580
1581 int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
1582                  int* indices, MPI_Status status[])
1583 {
1584   int retval;
1585
1586    smpi_bench_end();
1587    if (outcount == NULL) {
1588      retval = MPI_ERR_ARG;
1589    } else {
1590      *outcount = smpi_mpi_testsome(incount, requests, indices, status);
1591      retval = MPI_SUCCESS;
1592    }
1593    smpi_bench_begin();
1594    return retval;
1595 }
1596
1597
1598 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
1599 {
1600   int retval;
1601
1602   smpi_bench_end();
1603 #ifdef HAVE_TRACING
1604   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1605   TRACE_smpi_computing_out(rank);
1606   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1607   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1608 #endif
1609   if (comm == MPI_COMM_NULL) {
1610     retval = MPI_ERR_COMM;
1611   } else {
1612     mpi_coll_bcast_fun(buf, count, datatype, root, comm);
1613     retval = MPI_SUCCESS;
1614   }
1615 #ifdef HAVE_TRACING
1616   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1617   TRACE_smpi_computing_in(rank);
1618 #endif
1619   smpi_bench_begin();
1620   return retval;
1621 }
1622
1623 int PMPI_Barrier(MPI_Comm comm)
1624 {
1625   int retval;
1626
1627   smpi_bench_end();
1628 #ifdef HAVE_TRACING
1629   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1630   TRACE_smpi_computing_out(rank);
1631   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1632 #endif
1633   if (comm == MPI_COMM_NULL) {
1634     retval = MPI_ERR_COMM;
1635   } else {
1636     mpi_coll_barrier_fun(comm);
1637     retval = MPI_SUCCESS;
1638   }
1639 #ifdef HAVE_TRACING
1640   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1641   TRACE_smpi_computing_in(rank);
1642 #endif
1643   smpi_bench_begin();
1644   return retval;
1645 }
1646
1647 int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1648                void *recvbuf, int recvcount, MPI_Datatype recvtype,
1649                int root, MPI_Comm comm)
1650 {
1651   int retval;
1652
1653   smpi_bench_end();
1654 #ifdef HAVE_TRACING
1655   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1656   TRACE_smpi_computing_out(rank);
1657   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1658   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1659 #endif
1660   if (comm == MPI_COMM_NULL) {
1661     retval = MPI_ERR_COMM;
1662   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1663             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1664     retval = MPI_ERR_TYPE;
1665   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1666             ((smpi_comm_rank(comm) == root) && (recvcount <0))){
1667     retval = MPI_ERR_COUNT;
1668   } else {
1669
1670     char* sendtmpbuf = (char*) sendbuf;
1671     int sendtmpcount = sendcount;
1672     MPI_Datatype sendtmptype = sendtype;
1673     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1674       sendtmpcount=0;
1675       sendtmptype=recvtype;
1676     }
1677
1678     mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount,
1679                     recvtype, root, comm);
1680
1681
1682     retval = MPI_SUCCESS;
1683   }
1684 #ifdef HAVE_TRACING
1685   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1686   TRACE_smpi_computing_in(rank);
1687 #endif
1688   smpi_bench_begin();
1689   return retval;
1690 }
1691
1692 int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1693                 void *recvbuf, int *recvcounts, int *displs,
1694                 MPI_Datatype recvtype, int root, MPI_Comm comm)
1695 {
1696   int retval;
1697
1698   smpi_bench_end();
1699 #ifdef HAVE_TRACING
1700   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1701   TRACE_smpi_computing_out(rank);
1702   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1703   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1704 #endif
1705   if (comm == MPI_COMM_NULL) {
1706     retval = MPI_ERR_COMM;
1707   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1708             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1709     retval = MPI_ERR_TYPE;
1710   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1711     retval = MPI_ERR_COUNT;
1712   } else if (recvcounts == NULL || displs == NULL) {
1713     retval = MPI_ERR_ARG;
1714   } else {
1715
1716     char* sendtmpbuf = (char*) sendbuf;
1717     int sendtmpcount = sendcount;
1718     MPI_Datatype sendtmptype = sendtype;
1719     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1720       sendtmpcount=0;
1721       sendtmptype=recvtype;
1722     }
1723
1724     smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts,
1725                      displs, recvtype, root, comm);
1726     retval = MPI_SUCCESS;
1727   }
1728 #ifdef HAVE_TRACING
1729   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1730   TRACE_smpi_computing_in(rank);
1731 #endif
1732   smpi_bench_begin();
1733   return retval;
1734 }
1735
1736 int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1737                   void *recvbuf, int recvcount, MPI_Datatype recvtype,
1738                   MPI_Comm comm)
1739 {
1740   int retval;
1741
1742   smpi_bench_end();
1743 #ifdef HAVE_TRACING
1744   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1745   TRACE_smpi_computing_out(rank);
1746   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1747 #endif
1748   if (comm == MPI_COMM_NULL) {
1749     retval = MPI_ERR_COMM;
1750   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1751             (recvtype == MPI_DATATYPE_NULL)){
1752     retval = MPI_ERR_TYPE;
1753   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1754             (recvcount <0)){
1755     retval = MPI_ERR_COUNT;
1756   } else {
1757
1758     if(sendbuf == MPI_IN_PLACE) {
1759       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm);
1760       sendcount=recvcount;
1761       sendtype=recvtype;
1762     }
1763
1764     mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1765                            recvtype, comm);
1766     retval = MPI_SUCCESS;
1767   }
1768 #ifdef HAVE_TRACING
1769   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1770 #endif
1771   smpi_bench_begin();
1772   return retval;
1773 }
1774
1775 int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1776                    void *recvbuf, int *recvcounts, int *displs,
1777                    MPI_Datatype recvtype, MPI_Comm comm)
1778 {
1779   int retval;
1780
1781   smpi_bench_end();
1782 #ifdef HAVE_TRACING
1783   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1784   TRACE_smpi_computing_out(rank);
1785   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1786 #endif
1787   if (comm == MPI_COMM_NULL) {
1788     retval = MPI_ERR_COMM;
1789   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1790             (recvtype == MPI_DATATYPE_NULL)){
1791     retval = MPI_ERR_TYPE;
1792   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1793     retval = MPI_ERR_COUNT;
1794   } else if (recvcounts == NULL || displs == NULL) {
1795     retval = MPI_ERR_ARG;
1796   } else {
1797
1798     if(sendbuf == MPI_IN_PLACE) {
1799       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*displs[smpi_comm_rank(comm)];
1800       sendcount=recvcounts[smpi_comm_rank(comm)];
1801       sendtype=recvtype;
1802     }
1803
1804     mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts,
1805                         displs, recvtype, comm);
1806     retval = MPI_SUCCESS;
1807   }
1808 #ifdef HAVE_TRACING
1809   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1810   TRACE_smpi_computing_in(rank);
1811 #endif
1812   smpi_bench_begin();
1813   return retval;
1814 }
1815
1816 int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1817                 void *recvbuf, int recvcount, MPI_Datatype recvtype,
1818                 int root, MPI_Comm comm)
1819 {
1820   int retval;
1821
1822   smpi_bench_end();
1823 #ifdef HAVE_TRACING
1824   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1825   TRACE_smpi_computing_out(rank);
1826   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1827
1828   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1829 #endif
1830   if (comm == MPI_COMM_NULL) {
1831     retval = MPI_ERR_COMM;
1832   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
1833              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
1834     retval = MPI_ERR_TYPE;
1835   } else {
1836
1837     if(recvbuf==MPI_IN_PLACE){
1838         recvcount=0;
1839     }
1840     mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1841                      recvtype, root, comm);
1842     retval = MPI_SUCCESS;
1843   }
1844 #ifdef HAVE_TRACING
1845   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1846   TRACE_smpi_computing_in(rank);
1847 #endif
1848   smpi_bench_begin();
1849   return retval;
1850 }
1851
1852 int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
1853                  MPI_Datatype sendtype, void *recvbuf, int recvcount,
1854                  MPI_Datatype recvtype, int root, MPI_Comm comm)
1855 {
1856   int retval;
1857
1858   smpi_bench_end();
1859 #ifdef HAVE_TRACING
1860   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1861   TRACE_smpi_computing_out(rank);
1862   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1863   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1864 #endif
1865   if (comm == MPI_COMM_NULL) {
1866     retval = MPI_ERR_COMM;
1867   } else if (sendcounts == NULL || displs == NULL) {
1868     retval = MPI_ERR_ARG;
1869   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
1870              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
1871     retval = MPI_ERR_TYPE;
1872   } else {
1873
1874     if(recvbuf==MPI_IN_PLACE){
1875         recvcount=0;
1876     }
1877
1878     smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf,
1879                       recvcount, recvtype, root, comm);
1880     retval = MPI_SUCCESS;
1881   }
1882 #ifdef HAVE_TRACING
1883   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1884   TRACE_smpi_computing_in(rank);
1885 #endif
1886   smpi_bench_begin();
1887   return retval;
1888 }
1889
1890 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count,
1891                MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
1892 {
1893   int retval;
1894
1895   smpi_bench_end();
1896 #ifdef HAVE_TRACING
1897   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1898   TRACE_smpi_computing_out(rank);
1899   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1900   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1901 #endif
1902   if (comm == MPI_COMM_NULL) {
1903     retval = MPI_ERR_COMM;
1904   } else if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
1905     retval = MPI_ERR_ARG;
1906   } else {
1907
1908     char* sendtmpbuf = (char*) sendbuf;
1909     if( sendbuf == MPI_IN_PLACE ) {
1910       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
1911       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
1912     }
1913
1914     mpi_coll_reduce_fun(sendtmpbuf, recvbuf, count, datatype, op, root, comm);
1915
1916     if( sendbuf == MPI_IN_PLACE ) {
1917       xbt_free(sendtmpbuf);
1918     }
1919
1920     retval = MPI_SUCCESS;
1921   }
1922 #ifdef HAVE_TRACING
1923   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1924   TRACE_smpi_computing_in(rank);
1925 #endif
1926   smpi_bench_begin();
1927   return retval;
1928 }
1929
1930 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
1931     MPI_Datatype datatype, MPI_Op op){
1932   int retval;
1933
1934     smpi_bench_end();
1935     if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
1936       retval = MPI_ERR_ARG;
1937     } else {
1938       smpi_op_apply(op, inbuf, inoutbuf, &count, &datatype);
1939       retval=MPI_SUCCESS;
1940     }
1941     smpi_bench_begin();
1942     return retval;
1943 }
1944
1945 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
1946                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
1947 {
1948   int retval;
1949
1950   smpi_bench_end();
1951 #ifdef HAVE_TRACING
1952   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1953   TRACE_smpi_computing_out(rank);
1954   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1955 #endif
1956   if (comm == MPI_COMM_NULL) {
1957     retval = MPI_ERR_COMM;
1958   } else if (datatype == MPI_DATATYPE_NULL) {
1959     retval = MPI_ERR_TYPE;
1960   } else if (op == MPI_OP_NULL) {
1961     retval = MPI_ERR_OP;
1962   } else {
1963
1964     char* sendtmpbuf = (char*) sendbuf;
1965     if( sendbuf == MPI_IN_PLACE ) {
1966       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
1967       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
1968     }
1969
1970     mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm);
1971
1972     if( sendbuf == MPI_IN_PLACE ) {
1973       xbt_free(sendtmpbuf);
1974     }
1975
1976     retval = MPI_SUCCESS;
1977
1978   }
1979 #ifdef HAVE_TRACING
1980   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1981   TRACE_smpi_computing_in(rank);
1982 #endif
1983   smpi_bench_begin();
1984   return retval;
1985 }
1986
1987 int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
1988              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
1989 {
1990   int retval;
1991
1992   smpi_bench_end();
1993 #ifdef HAVE_TRACING
1994   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1995   TRACE_smpi_computing_out(rank);
1996   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1997 #endif
1998   if (comm == MPI_COMM_NULL) {
1999     retval = MPI_ERR_COMM;
2000   } else if (datatype == MPI_DATATYPE_NULL) {
2001     retval = MPI_ERR_TYPE;
2002   } else if (op == MPI_OP_NULL) {
2003     retval = MPI_ERR_OP;
2004   } else {
2005     smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
2006     retval = MPI_SUCCESS;
2007   }
2008 #ifdef HAVE_TRACING
2009   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2010   TRACE_smpi_computing_in(rank);
2011 #endif
2012   smpi_bench_begin();
2013   return retval;
2014 }
2015
2016 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
2017                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2018 {
2019   int retval;
2020   smpi_bench_end();
2021 #ifdef HAVE_TRACING
2022   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2023   TRACE_smpi_computing_out(rank);
2024   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2025 #endif
2026   if (comm == MPI_COMM_NULL) {
2027     retval = MPI_ERR_COMM;
2028   } else if (datatype == MPI_DATATYPE_NULL) {
2029     retval = MPI_ERR_TYPE;
2030   } else if (op == MPI_OP_NULL) {
2031     retval = MPI_ERR_OP;
2032   } else if (recvcounts == NULL) {
2033     retval = MPI_ERR_ARG;
2034   } else {
2035     void* sendtmpbuf=sendbuf;
2036     if(sendbuf==MPI_IN_PLACE){
2037       sendtmpbuf=recvbuf;
2038     }
2039
2040     mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts,
2041                        datatype,  op, comm);
2042     retval = MPI_SUCCESS;
2043   }
2044 #ifdef HAVE_TRACING
2045   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2046   TRACE_smpi_computing_in(rank);
2047 #endif
2048   smpi_bench_begin();
2049   return retval;
2050 }
2051
2052 int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
2053                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2054 {
2055   int retval,i;
2056   smpi_bench_end();
2057 #ifdef HAVE_TRACING
2058   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2059   TRACE_smpi_computing_out(rank);
2060   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2061 #endif
2062   if (comm == MPI_COMM_NULL) {
2063     retval = MPI_ERR_COMM;
2064   } else if (datatype == MPI_DATATYPE_NULL) {
2065     retval = MPI_ERR_TYPE;
2066   } else if (op == MPI_OP_NULL) {
2067     retval = MPI_ERR_OP;
2068   } else if (recvcount < 0) {
2069     retval = MPI_ERR_ARG;
2070   } else {
2071     int count=smpi_comm_size(comm);
2072     int* recvcounts=(int*)xbt_malloc(count);
2073     for (i=0; i<count;i++)recvcounts[i]=recvcount;
2074     mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts,
2075                        datatype,  op, comm);
2076     xbt_free(recvcounts);
2077     retval = MPI_SUCCESS;
2078   }
2079 #ifdef HAVE_TRACING
2080   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2081   TRACE_smpi_computing_in(rank);
2082 #endif
2083   smpi_bench_begin();
2084   return retval;
2085 }
2086
2087 int PMPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
2088                  void *recvbuf, int recvcount, MPI_Datatype recvtype,
2089                  MPI_Comm comm)
2090 {
2091   int retval;
2092
2093   smpi_bench_end();
2094 #ifdef HAVE_TRACING
2095   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2096   TRACE_smpi_computing_out(rank);
2097   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2098 #endif
2099   if (comm == MPI_COMM_NULL) {
2100     retval = MPI_ERR_COMM;
2101   } else if (sendtype == MPI_DATATYPE_NULL
2102              || recvtype == MPI_DATATYPE_NULL) {
2103     retval = MPI_ERR_TYPE;
2104   } else {
2105     retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
2106   }
2107 #ifdef HAVE_TRACING
2108   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2109   TRACE_smpi_computing_in(rank);
2110 #endif
2111   smpi_bench_begin();
2112   return retval;
2113 }
2114
2115 int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,
2116                   MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
2117                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
2118 {
2119   int retval;
2120
2121   smpi_bench_end();
2122 #ifdef HAVE_TRACING
2123   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2124   TRACE_smpi_computing_out(rank);
2125   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2126 #endif
2127   if (comm == MPI_COMM_NULL) {
2128     retval = MPI_ERR_COMM;
2129   } else if (sendtype == MPI_DATATYPE_NULL
2130              || recvtype == MPI_DATATYPE_NULL) {
2131     retval = MPI_ERR_TYPE;
2132   } else if (sendcounts == NULL || senddisps == NULL || recvcounts == NULL
2133              || recvdisps == NULL) {
2134     retval = MPI_ERR_ARG;
2135   } else {
2136     retval =
2137         mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype,
2138                                   recvbuf, recvcounts, recvdisps, recvtype,
2139                                   comm);
2140   }
2141 #ifdef HAVE_TRACING
2142   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2143   TRACE_smpi_computing_in(rank);
2144 #endif
2145   smpi_bench_begin();
2146   return retval;
2147 }
2148
2149
2150 int PMPI_Get_processor_name(char *name, int *resultlen)
2151 {
2152   int retval = MPI_SUCCESS;
2153
2154   smpi_bench_end();
2155   strncpy(name, SIMIX_host_get_name(SIMIX_host_self()),
2156           strlen(SIMIX_host_get_name(SIMIX_host_self())) < MPI_MAX_PROCESSOR_NAME - 1 ?
2157           strlen(SIMIX_host_get_name(SIMIX_host_self())) +1 :
2158           MPI_MAX_PROCESSOR_NAME - 1 );
2159   *resultlen =
2160       strlen(name) >
2161       MPI_MAX_PROCESSOR_NAME ? MPI_MAX_PROCESSOR_NAME : strlen(name);
2162
2163   smpi_bench_begin();
2164   return retval;
2165 }
2166
2167 int PMPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count)
2168 {
2169   int retval = MPI_SUCCESS;
2170   size_t size;
2171
2172   smpi_bench_end();
2173   if (status == NULL || count == NULL) {
2174     retval = MPI_ERR_ARG;
2175   } else if (datatype == MPI_DATATYPE_NULL) {
2176     retval = MPI_ERR_TYPE;
2177   } else {
2178     size = smpi_datatype_size(datatype);
2179     if (size == 0) {
2180       *count = 0;
2181     } else if (status->count % size != 0) {
2182       retval = MPI_UNDEFINED;
2183     } else {
2184       *count = smpi_mpi_get_count(status, datatype);
2185     }
2186   }
2187   smpi_bench_begin();
2188   return retval;
2189 }
2190
2191 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {
2192   int retval;
2193
2194   smpi_bench_end();
2195   if (old_type == MPI_DATATYPE_NULL) {
2196     retval = MPI_ERR_TYPE;
2197   } else if (count<0){
2198     retval = MPI_ERR_COUNT;
2199   } else {
2200     retval = smpi_datatype_contiguous(count, old_type, new_type, 0);
2201   }
2202   smpi_bench_begin();
2203   return retval;
2204 }
2205
2206 int PMPI_Type_commit(MPI_Datatype* datatype) {
2207   int retval;
2208
2209   smpi_bench_end();
2210   if (datatype == MPI_DATATYPE_NULL) {
2211     retval = MPI_ERR_TYPE;
2212   } else {
2213     smpi_datatype_commit(datatype);
2214     retval = MPI_SUCCESS;
2215   }
2216   smpi_bench_begin();
2217   return retval;
2218 }
2219
2220
2221 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2222   int retval;
2223
2224   smpi_bench_end();
2225   if (old_type == MPI_DATATYPE_NULL) {
2226     retval = MPI_ERR_TYPE;
2227   } else if (count<0 || blocklen<0){
2228     retval = MPI_ERR_COUNT;
2229   } else {
2230     retval = smpi_datatype_vector(count, blocklen, stride, old_type, new_type);
2231   }
2232   smpi_bench_begin();
2233   return retval;
2234 }
2235
2236 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2237   int retval;
2238
2239   smpi_bench_end();
2240   if (old_type == MPI_DATATYPE_NULL) {
2241     retval = MPI_ERR_TYPE;
2242   } else if (count<0 || blocklen<0){
2243     retval = MPI_ERR_COUNT;
2244   } else {
2245     retval = smpi_datatype_hvector(count, blocklen, stride, old_type, new_type);
2246   }
2247   smpi_bench_begin();
2248   return retval;
2249 }
2250
2251 int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2252   return MPI_Type_hvector(count, blocklen, stride, old_type, new_type);
2253 }
2254
2255 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2256   int retval;
2257
2258   smpi_bench_end();
2259   if (old_type == MPI_DATATYPE_NULL) {
2260     retval = MPI_ERR_TYPE;
2261   } else if (count<0){
2262     retval = MPI_ERR_COUNT;
2263   } else {
2264     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2265   }
2266   smpi_bench_begin();
2267   return retval;
2268 }
2269
2270 int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2271   int retval,i;
2272
2273   smpi_bench_end();
2274   if (old_type == MPI_DATATYPE_NULL) {
2275     retval = MPI_ERR_TYPE;
2276   } else if (count<0){
2277     retval = MPI_ERR_COUNT;
2278   } else {
2279     int* blocklens=(int*)xbt_malloc(blocklength*count);
2280     for (i=0; i<count;i++)blocklens[i]=blocklength;
2281     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2282     xbt_free(blocklens);
2283   }
2284   smpi_bench_begin();
2285   return retval;
2286 }
2287
2288
2289 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2290   int retval;
2291
2292   smpi_bench_end();
2293   if (old_type == MPI_DATATYPE_NULL) {
2294     retval = MPI_ERR_TYPE;
2295   } else if (count<0){
2296     retval = MPI_ERR_COUNT;
2297   } else {
2298     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2299   }
2300   smpi_bench_begin();
2301   return retval;
2302 }
2303
2304 int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2305   int retval,i;
2306
2307   smpi_bench_end();
2308   if (old_type == MPI_DATATYPE_NULL) {
2309     retval = MPI_ERR_TYPE;
2310   } else if (count<0){
2311     retval = MPI_ERR_COUNT;
2312   } else {
2313     int* blocklens=(int*)xbt_malloc(blocklength*count);
2314     for (i=0; i<count;i++)blocklens[i]=blocklength;
2315     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2316     xbt_free(blocklens);
2317   }
2318   smpi_bench_begin();
2319   return retval;
2320 }
2321
2322
2323 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2324   int retval;
2325
2326   smpi_bench_end();
2327   if (count<0){
2328     retval = MPI_ERR_COUNT;
2329   } else {
2330     retval = smpi_datatype_struct(count, blocklens, indices, old_types, new_type);
2331   }
2332   smpi_bench_begin();
2333   return retval;
2334 }
2335
2336 int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2337   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
2338 }
2339
2340
2341 int PMPI_Error_class(int errorcode, int* errorclass) {
2342   // assume smpi uses only standard mpi error codes
2343   *errorclass=errorcode;
2344   return MPI_SUCCESS;
2345 }
2346
2347
2348 int PMPI_Initialized(int* flag) {
2349    *flag=(smpi_process_data()!=NULL);
2350    return MPI_SUCCESS;
2351 }
2352
2353 /* The following calls are not yet implemented and will fail at runtime. */
2354 /* Once implemented, please move them above this notice. */
2355
2356 #define NOT_YET_IMPLEMENTED {\
2357         XBT_WARN("Not yet implemented : %s. Please contact the Simgrid team if support is needed", __FUNCTION__);\
2358         return MPI_SUCCESS;\
2359         }
2360
2361
2362 int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){
2363   NOT_YET_IMPLEMENTED
2364 }
2365
2366 int PMPI_Type_set_name(MPI_Datatype  datatype, char * name)
2367 {
2368   NOT_YET_IMPLEMENTED
2369 }
2370
2371 int PMPI_Type_get_name(MPI_Datatype  datatype, char * name, int* len)
2372 {
2373   NOT_YET_IMPLEMENTED
2374 }
2375
2376 int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
2377    NOT_YET_IMPLEMENTED
2378 }
2379
2380 int PMPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int* coords) {
2381    NOT_YET_IMPLEMENTED
2382 }
2383
2384 int PMPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder, MPI_Comm* comm_cart) {
2385    NOT_YET_IMPLEMENTED
2386 }
2387
2388 int PMPI_Cart_get(MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords) {
2389    NOT_YET_IMPLEMENTED
2390 }
2391
2392 int PMPI_Cart_map(MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank) {
2393    NOT_YET_IMPLEMENTED
2394 }
2395
2396 int PMPI_Cart_rank(MPI_Comm comm, int* coords, int* rank) {
2397    NOT_YET_IMPLEMENTED
2398 }
2399
2400 int PMPI_Cart_shift(MPI_Comm comm, int direction, int displ, int* source, int* dest) {
2401    NOT_YET_IMPLEMENTED
2402 }
2403
2404 int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) {
2405    NOT_YET_IMPLEMENTED
2406 }
2407
2408 int PMPI_Cartdim_get(MPI_Comm comm, int* ndims) {
2409    NOT_YET_IMPLEMENTED
2410 }
2411
2412 int PMPI_Graph_create(MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph) {
2413    NOT_YET_IMPLEMENTED
2414 }
2415
2416 int PMPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges) {
2417    NOT_YET_IMPLEMENTED
2418 }
2419
2420 int PMPI_Graph_map(MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank) {
2421    NOT_YET_IMPLEMENTED
2422 }
2423
2424 int PMPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int* neighbors) {
2425    NOT_YET_IMPLEMENTED
2426 }
2427
2428 int PMPI_Graph_neighbors_count(MPI_Comm comm, int rank, int* nneighbors) {
2429    NOT_YET_IMPLEMENTED
2430 }
2431
2432 int PMPI_Graphdims_get(MPI_Comm comm, int* nnodes, int* nedges) {
2433    NOT_YET_IMPLEMENTED
2434 }
2435
2436 int PMPI_Topo_test(MPI_Comm comm, int* top_type) {
2437    NOT_YET_IMPLEMENTED
2438 }
2439
2440 int PMPI_Errhandler_create(MPI_Handler_function* function, MPI_Errhandler* errhandler) {
2441    NOT_YET_IMPLEMENTED
2442 }
2443
2444 int PMPI_Errhandler_free(MPI_Errhandler* errhandler) {
2445    NOT_YET_IMPLEMENTED
2446 }
2447
2448 int PMPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler* errhandler) {
2449    NOT_YET_IMPLEMENTED
2450 }
2451
2452 int PMPI_Error_string(int errorcode, char* string, int* resultlen) {
2453    NOT_YET_IMPLEMENTED
2454 }
2455
2456 int PMPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler) {
2457    NOT_YET_IMPLEMENTED
2458 }
2459
2460 int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
2461    NOT_YET_IMPLEMENTED
2462 }
2463
2464 int PMPI_Cancel(MPI_Request* request) {
2465    NOT_YET_IMPLEMENTED
2466 }
2467
2468 int PMPI_Buffer_attach(void* buffer, int size) {
2469    NOT_YET_IMPLEMENTED
2470 }
2471
2472 int PMPI_Buffer_detach(void* buffer, int* size) {
2473    NOT_YET_IMPLEMENTED
2474 }
2475
2476 int PMPI_Comm_test_inter(MPI_Comm comm, int* flag) {
2477    NOT_YET_IMPLEMENTED
2478 }
2479
2480 int PMPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
2481 {
2482    NOT_YET_IMPLEMENTED
2483 }
2484
2485 int PMPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val)
2486 {
2487    NOT_YET_IMPLEMENTED
2488 }
2489
2490 int PMPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval)
2491 {
2492    NOT_YET_IMPLEMENTED
2493 }
2494
2495 int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state)
2496 {
2497    NOT_YET_IMPLEMENTED
2498 }
2499
2500 int PMPI_Comm_free_keyval(int* keyval) {
2501    NOT_YET_IMPLEMENTED
2502 }
2503
2504 int PMPI_Pcontrol(const int level )
2505 {
2506    NOT_YET_IMPLEMENTED
2507 }
2508
2509 int PMPI_Unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
2510    NOT_YET_IMPLEMENTED
2511 }
2512
2513 int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
2514 {
2515   NOT_YET_IMPLEMENTED
2516 }
2517
2518 int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
2519 {
2520   NOT_YET_IMPLEMENTED
2521 }
2522
2523 int PMPI_Type_delete_attr (MPI_Datatype type, int comm_keyval)
2524 {
2525   NOT_YET_IMPLEMENTED
2526 }
2527
2528 int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)
2529 {
2530   NOT_YET_IMPLEMENTED
2531 }
2532
2533 int PMPI_Type_free_keyval(int* keyval) {
2534   NOT_YET_IMPLEMENTED
2535 }
2536
2537 int PMPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out) {
2538    NOT_YET_IMPLEMENTED
2539 }
2540
2541 int PMPI_Intercomm_merge(MPI_Comm comm, int high, MPI_Comm* comm_out) {
2542    NOT_YET_IMPLEMENTED
2543 }
2544
2545 int PMPI_Bsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
2546    NOT_YET_IMPLEMENTED
2547 }
2548
2549 int PMPI_Bsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2550    NOT_YET_IMPLEMENTED
2551 }
2552
2553 int PMPI_Ibsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2554    NOT_YET_IMPLEMENTED
2555 }
2556
2557 int PMPI_Comm_remote_group(MPI_Comm comm, MPI_Group* group) {
2558    NOT_YET_IMPLEMENTED
2559 }
2560
2561 int PMPI_Comm_remote_size(MPI_Comm comm, int* size) {
2562    NOT_YET_IMPLEMENTED
2563 }
2564
2565 int PMPI_Attr_delete(MPI_Comm comm, int keyval) {
2566    NOT_YET_IMPLEMENTED
2567 }
2568
2569 int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) {
2570    NOT_YET_IMPLEMENTED
2571 }
2572
2573 int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) {
2574    NOT_YET_IMPLEMENTED
2575 }
2576
2577 int PMPI_Rsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
2578    NOT_YET_IMPLEMENTED
2579 }
2580
2581 int PMPI_Rsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2582    NOT_YET_IMPLEMENTED
2583 }
2584
2585 int PMPI_Irsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2586    NOT_YET_IMPLEMENTED
2587 }
2588
2589 int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) {
2590    NOT_YET_IMPLEMENTED
2591 }
2592
2593 int PMPI_Keyval_free(int* keyval) {
2594    NOT_YET_IMPLEMENTED
2595 }
2596
2597 int PMPI_Test_cancelled(MPI_Status* status, int* flag) {
2598    NOT_YET_IMPLEMENTED
2599 }
2600
2601 int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
2602    NOT_YET_IMPLEMENTED
2603 }
2604
2605 int PMPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size){
2606   NOT_YET_IMPLEMENTED
2607 }
2608
2609 int PMPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outcount, MPI_Aint *position){
2610   NOT_YET_IMPLEMENTED
2611 }
2612
2613 int PMPI_Unpack_external( char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount, MPI_Datatype datatype){
2614   NOT_YET_IMPLEMENTED
2615 }
2616
2617 int PMPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) {
2618    NOT_YET_IMPLEMENTED
2619 }
2620
2621 int PMPI_Dims_create(int nnodes, int ndims, int* dims) {
2622    NOT_YET_IMPLEMENTED
2623 }
2624
2625 int PMPI_Win_fence( int assert,  MPI_Win win){
2626    NOT_YET_IMPLEMENTED
2627 }
2628
2629 int PMPI_Win_free( MPI_Win* win){
2630    NOT_YET_IMPLEMENTED
2631 }
2632
2633 int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
2634   NOT_YET_IMPLEMENTED
2635 }
2636
2637 int PMPI_Info_create( MPI_Info *info){
2638   NOT_YET_IMPLEMENTED
2639 }
2640
2641 int PMPI_Info_set( MPI_Info info, char *key, char *value){
2642   NOT_YET_IMPLEMENTED
2643 }
2644
2645 int PMPI_Info_free( MPI_Info *info){
2646   NOT_YET_IMPLEMENTED
2647 }
2648
2649 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
2650     MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
2651   NOT_YET_IMPLEMENTED
2652 }
2653
2654 int PMPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers,
2655                           int *num_addresses, int *num_datatypes, int *combiner){
2656   NOT_YET_IMPLEMENTED
2657 }
2658
2659 int PMPI_Type_get_contents(MPI_Datatype datatype, int max_integers, int max_addresses,
2660                           int max_datatypes, int* array_of_integers, MPI_Aint* array_of_addresses,
2661                           MPI_Datatype* array_of_datatypes){
2662   NOT_YET_IMPLEMENTED
2663 }
2664
2665 int PMPI_Type_create_darray(int size, int rank, int ndims, int* array_of_gsizes,
2666                             int* array_of_distribs, int* array_of_dargs, int* array_of_psizes,
2667                             int order, MPI_Datatype oldtype, MPI_Datatype *newtype) {
2668   NOT_YET_IMPLEMENTED
2669 }
2670
2671 int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
2672   NOT_YET_IMPLEMENTED
2673 }
2674
2675 int PMPI_Type_create_subarray(int ndims,int *array_of_sizes, int *array_of_subsizes, int *array_of_starts, int order, MPI_Datatype oldtype, MPI_Datatype *newtype){
2676   NOT_YET_IMPLEMENTED
2677 }
2678
2679 int PMPI_Type_match_size(int typeclass,int size,MPI_Datatype *datatype){
2680   NOT_YET_IMPLEMENTED
2681 }
2682
2683 int PMPI_Alltoallw( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes,
2684                    void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes,
2685                    MPI_Comm comm){
2686   NOT_YET_IMPLEMENTED
2687 }
2688
2689 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
2690                 MPI_Op op, MPI_Comm comm){
2691   NOT_YET_IMPLEMENTED
2692 }
2693
2694 int PMPI_Comm_set_name(MPI_Comm comm, char* name){
2695   NOT_YET_IMPLEMENTED
2696 }
2697
2698 int PMPI_Comm_dup_with_info(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm){
2699   NOT_YET_IMPLEMENTED
2700 }
2701
2702 int PMPI_Comm_split_type(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm *newcomm){
2703   NOT_YET_IMPLEMENTED
2704 }
2705
2706 int PMPI_Comm_set_info (MPI_Comm comm, MPI_Info info){
2707   NOT_YET_IMPLEMENTED
2708 }
2709
2710 int PMPI_Comm_get_info (MPI_Comm comm, MPI_Info* info){
2711   NOT_YET_IMPLEMENTED
2712 }
2713
2714 int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){
2715   NOT_YET_IMPLEMENTED
2716 }
2717
2718 int PMPI_Comm_create_errhandler( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler){
2719   NOT_YET_IMPLEMENTED
2720 }
2721
2722 int PMPI_Add_error_class( int *errorclass){
2723   NOT_YET_IMPLEMENTED
2724 }
2725
2726 int PMPI_Add_error_code(  int errorclass, int *errorcode){
2727   NOT_YET_IMPLEMENTED
2728 }
2729
2730 int PMPI_Add_error_string( int errorcode, char *string){
2731   NOT_YET_IMPLEMENTED
2732 }
2733
2734 int PMPI_Comm_call_errhandler(MPI_Comm comm,int errorcode){
2735   NOT_YET_IMPLEMENTED
2736 }
2737
2738 int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){
2739   NOT_YET_IMPLEMENTED
2740 }
2741
2742 int PMPI_Info_delete(MPI_Info info, char *key){
2743   NOT_YET_IMPLEMENTED
2744 }
2745
2746 int PMPI_Info_get_nkeys( MPI_Info info, int *nkeys){
2747   NOT_YET_IMPLEMENTED
2748 }
2749
2750 int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){
2751   NOT_YET_IMPLEMENTED
2752 }
2753
2754 int PMPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){
2755   NOT_YET_IMPLEMENTED
2756 }
2757
2758 int PMPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
2759   NOT_YET_IMPLEMENTED
2760 }
2761
2762 int MPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
2763   NOT_YET_IMPLEMENTED
2764 }
2765
2766 int PMPI_Grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request){
2767   NOT_YET_IMPLEMENTED
2768 }
2769
2770 int PMPI_Grequest_complete( MPI_Request request){
2771   NOT_YET_IMPLEMENTED
2772 }
2773
2774 int PMPI_Status_set_cancelled(MPI_Status *status,int flag){
2775   NOT_YET_IMPLEMENTED
2776 }
2777
2778 int PMPI_Status_set_elements( MPI_Status *status, MPI_Datatype datatype, int count){
2779   NOT_YET_IMPLEMENTED
2780 }
2781
2782 int PMPI_Comm_connect( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
2783   NOT_YET_IMPLEMENTED
2784 }
2785
2786 int PMPI_Publish_name( char *service_name, MPI_Info info, char *port_name){
2787   NOT_YET_IMPLEMENTED
2788 }
2789
2790 int PMPI_Unpublish_name( char *service_name, MPI_Info info, char *port_name){
2791   NOT_YET_IMPLEMENTED
2792 }
2793
2794 int PMPI_Lookup_name( char *service_name, MPI_Info info, char *port_name){
2795   NOT_YET_IMPLEMENTED
2796 }
2797
2798 int PMPI_Comm_join( int fd, MPI_Comm *intercomm){
2799   NOT_YET_IMPLEMENTED
2800 }
2801
2802 int PMPI_Open_port( MPI_Info info, char *port_name){
2803   NOT_YET_IMPLEMENTED
2804 }
2805
2806 int PMPI_Close_port(char *port_name){
2807   NOT_YET_IMPLEMENTED
2808 }
2809
2810 int PMPI_Comm_accept( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
2811   NOT_YET_IMPLEMENTED
2812 }
2813
2814 int PMPI_Comm_spawn( char *command, char **argv, int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes){
2815   NOT_YET_IMPLEMENTED
2816 }
2817
2818 int PMPI_Comm_spawn_multiple( int count, char **array_of_commands, char*** array_of_argv,
2819                              int* array_of_maxprocs, MPI_Info* array_of_info, int root,
2820                              MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes){
2821   NOT_YET_IMPLEMENTED
2822 }
2823
2824 int PMPI_Comm_get_parent( MPI_Comm *parent){
2825   NOT_YET_IMPLEMENTED
2826 }