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     smpi_group_use(*newgroup);
 630     retval = MPI_SUCCESS;
 631   }
 632   smpi_bench_begin();
 633   return retval;
 634 }
 635
 636 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3],
 637                          MPI_Group * newgroup)
 638 {
 639   int retval, i, rank, newrank,oldrank, size, index, add;
 640
 641   smpi_bench_end();
 642   if (group == MPI_GROUP_NULL) {
 643     retval = MPI_ERR_GROUP;
 644   } else if (newgroup == NULL) {
 645     retval = MPI_ERR_ARG;
 646   } else {
 647     if (n == 0) {
 648       *newgroup = group;
 649     } else {
 650       size = smpi_group_size(group);
 651       for (i = 0; i < n; i++) {
 652         for (rank = ranges[i][0];       /* First */
 653              rank >= 0; /* Last */
 654               ) {
 655           size--;
 656
 657           rank += ranges[i][2]; /* Stride */
 658           if (ranges[i][0]<ranges[i][1]){
 659               if(rank > ranges[i][1])
 660                 break;
 661           }else{
 662               if(rank < ranges[i][1])
 663                 break;
 664           }
 665         }
 666       }
 667       if (size == 0) {
 668         *newgroup = MPI_GROUP_EMPTY;
 669       } else {
 670         *newgroup = smpi_group_new(size);
 671         newrank=0;
 672         oldrank=0;
 673         while (newrank < size) {
 674           add=1;
 675           for (i = 0; i < n; i++) {
 676             for (rank = ranges[i][0];rank >= 0;){
 677               if(rank==oldrank){
 678                   add=0;
 679                   break;
 680               }
 681
 682               rank += ranges[i][2]; /* Stride */
 683
 684               if (ranges[i][0]<ranges[i][1]){
 685                   if(rank > ranges[i][1])
 686                     break;
 687               }else{
 688                   if(rank < ranges[i][1])
 689                     break;
 690               }
 691             }
 692           }
 693           if(add==1){
 694             index = smpi_group_index(group, oldrank);
 695             smpi_group_set_mapping(*newgroup, index, newrank);
 696             newrank++;
 697           }
 698           oldrank++;
 699         }
 700       }
 701     }
 702     smpi_group_use(*newgroup);
 703
 704     retval = MPI_SUCCESS;
 705   }
 706   smpi_bench_begin();
 707   return retval;
 708 }
 709
 710 int PMPI_Comm_rank(MPI_Comm comm, int *rank)
 711 {
 712   int retval;
 713
 714   smpi_bench_end();
 715   if (comm == MPI_COMM_NULL) {
 716     retval = MPI_ERR_COMM;
 717   } else if (rank == NULL) {
 718     retval = MPI_ERR_ARG;
 719   } else {
 720     *rank = smpi_comm_rank(comm);
 721     retval = MPI_SUCCESS;
 722   }
 723   smpi_bench_begin();
 724   return retval;
 725 }
 726
 727 int PMPI_Comm_size(MPI_Comm comm, int *size)
 728 {
 729   int retval;
 730
 731   smpi_bench_end();
 732   if (comm == MPI_COMM_NULL) {
 733     retval = MPI_ERR_COMM;
 734   } else if (size == NULL) {
 735     retval = MPI_ERR_ARG;
 736   } else {
 737     *size = smpi_comm_size(comm);
 738     retval = MPI_SUCCESS;
 739   }
 740   smpi_bench_begin();
 741   return retval;
 742 }
 743
 744 int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
 745 {
 746   int retval;
 747
 748   smpi_bench_end();
 749   if (comm == MPI_COMM_NULL)  {
 750     retval = MPI_ERR_COMM;
 751   } else if (name == NULL || len == NULL)  {
 752     retval = MPI_ERR_ARG;
 753   } else {
 754     smpi_comm_get_name(comm, name, len);
 755     retval = MPI_SUCCESS;
 756   }
 757   smpi_bench_begin();
 758   return retval;
 759 }
 760
 761 int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
 762 {
 763   int retval;
 764
 765   smpi_bench_end();
 766   if (comm == MPI_COMM_NULL) {
 767     retval = MPI_ERR_COMM;
 768   } else if (group == NULL) {
 769     retval = MPI_ERR_ARG;
 770   } else {
 771     *group = smpi_comm_group(comm);
 772     retval = MPI_SUCCESS;
 773   }
 774   smpi_bench_begin();
 775   return retval;
 776 }
 777
 778 int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
 779 {
 780   int retval;
 781
 782   smpi_bench_end();
 783   if (comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {
 784     retval = MPI_ERR_COMM;
 785   } else if (result == NULL) {
 786     retval = MPI_ERR_ARG;
 787   } else {
 788     if (comm1 == comm2) {       /* Same communicators means same groups */
 789       *result = MPI_IDENT;
 790     } else {
 791       *result =
 792           smpi_group_compare(smpi_comm_group(comm1),
 793                              smpi_comm_group(comm2));
 794       if (*result == MPI_IDENT) {
 795         *result = MPI_CONGRUENT;
 796       }
 797     }
 798     retval = MPI_SUCCESS;
 799   }
 800   smpi_bench_begin();
 801   return retval;
 802 }
 803
 804 int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
 805 {
 806   int retval;
 807
 808   smpi_bench_end();
 809   if (comm == MPI_COMM_NULL) {
 810     retval = MPI_ERR_COMM;
 811   } else if (newcomm == NULL) {
 812     retval = MPI_ERR_ARG;
 813   } else {
 814     *newcomm = smpi_comm_new(smpi_comm_group(comm));
 815     retval = MPI_SUCCESS;
 816   }
 817   smpi_bench_begin();
 818   return retval;
 819 }
 820
 821 int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
 822 {
 823   int retval;
 824
 825   smpi_bench_end();
 826   if (comm == MPI_COMM_NULL) {
 827     retval = MPI_ERR_COMM;
 828   } else if (group == MPI_GROUP_NULL) {
 829     retval = MPI_ERR_GROUP;
 830   } else if (newcomm == NULL) {
 831     retval = MPI_ERR_ARG;
 832   } else if(smpi_group_rank(group,smpi_process_index())==MPI_UNDEFINED){
 833     *newcomm= MPI_COMM_NULL;
 834     retval = MPI_SUCCESS;
 835   }else{
 836
 837     *newcomm = smpi_comm_new(group);
 838     retval = MPI_SUCCESS;
 839   }
 840   smpi_bench_begin();
 841   return retval;
 842 }
 843
 844 int PMPI_Comm_free(MPI_Comm * comm)
 845 {
 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_disconnect(MPI_Comm * comm)
 863 {
 864   /* TODO: wait until all communication in comm are done */
 865   int retval;
 866
 867   smpi_bench_end();
 868   if (comm == NULL) {
 869     retval = MPI_ERR_ARG;
 870   } else if (*comm == MPI_COMM_NULL) {
 871     retval = MPI_ERR_COMM;
 872   } else {
 873     smpi_comm_destroy(*comm);
 874     *comm = MPI_COMM_NULL;
 875     retval = MPI_SUCCESS;
 876   }
 877   smpi_bench_begin();
 878   return retval;
 879 }
 880
 881 int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
 882 {
 883   int retval;
 884
 885   smpi_bench_end();
 886   if (comm_out == NULL) {
 887     retval = MPI_ERR_ARG;
 888   } else if (comm == MPI_COMM_NULL) {
 889     retval = MPI_ERR_COMM;
 890   } else {
 891     *comm_out = smpi_comm_split(comm, color, key);
 892     retval = MPI_SUCCESS;
 893   }
 894   smpi_bench_begin();
 895   return retval;
 896 }
 897
 898 int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
 899                   int tag, MPI_Comm comm, MPI_Request * request)
 900 {
 901   int retval;
 902
 903   smpi_bench_end();
 904   if (request == NULL) {
 905     retval = MPI_ERR_ARG;
 906   } else if (comm == MPI_COMM_NULL) {
 907     retval = MPI_ERR_COMM;
 908   } else if (dst == MPI_PROC_NULL) {
 909     retval = MPI_SUCCESS;
 910   } else {
 911     *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm);
 912     retval = MPI_SUCCESS;
 913   }
 914   smpi_bench_begin();
 915   return retval;
 916 }
 917
 918 int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
 919                   int tag, MPI_Comm comm, MPI_Request * request)
 920 {
 921   int retval;
 922
 923   smpi_bench_end();
 924   if (request == NULL) {
 925     retval = MPI_ERR_ARG;
 926   } else if (comm == MPI_COMM_NULL) {
 927     retval = MPI_ERR_COMM;
 928   } else if (src == MPI_PROC_NULL) {
 929       retval = MPI_SUCCESS;
 930   } else {
 931     *request = smpi_mpi_recv_init(buf, count, datatype, src, tag, comm);
 932     retval = MPI_SUCCESS;
 933   }
 934   smpi_bench_begin();
 935   return retval;
 936 }
 937
 938 int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
 939   int retval;
 940
 941     smpi_bench_end();
 942     if (request == NULL) {
 943       retval = MPI_ERR_ARG;
 944     } else if (comm == MPI_COMM_NULL) {
 945       retval = MPI_ERR_COMM;
 946     } else if (dst == MPI_PROC_NULL) {
 947       retval = MPI_SUCCESS;
 948     } else {
 949       *request = smpi_mpi_ssend_init(buf, count, datatype, dst, tag, comm);
 950       retval = MPI_SUCCESS;
 951     }
 952     smpi_bench_begin();
 953     return retval;
 954 }
 955
 956 int PMPI_Start(MPI_Request * request)
 957 {
 958   int retval;
 959
 960   smpi_bench_end();
 961   if (request == NULL || *request == MPI_REQUEST_NULL) {
 962     retval = MPI_ERR_ARG;
 963   } else {
 964     smpi_mpi_start(*request);
 965     retval = MPI_SUCCESS;
 966   }
 967   smpi_bench_begin();
 968   return retval;
 969 }
 970
 971 int PMPI_Startall(int count, MPI_Request * requests)
 972 {
 973   int retval;
 974
 975   smpi_bench_end();
 976   if (requests == NULL) {
 977     retval = MPI_ERR_ARG;
 978   } else {
 979     smpi_mpi_startall(count, requests);
 980     retval = MPI_SUCCESS;
 981   }
 982   smpi_bench_begin();
 983   return retval;
 984 }
 985
 986 int PMPI_Request_free(MPI_Request * request)
 987 {
 988   int retval;
 989
 990   smpi_bench_end();
 991   if (*request == MPI_REQUEST_NULL) {
 992     retval = MPI_ERR_ARG;
 993   } else {
 994     if((*request)->flags & PERSISTENT)(*request)->refcount--;
 995     smpi_mpi_request_free(request);
 996     retval = MPI_SUCCESS;
 997   }
 998   smpi_bench_begin();
 999   return retval;
1000 }
1001
1002 int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
1003               int tag, MPI_Comm comm, MPI_Request * request)
1004 {
1005   int retval;
1006
1007   smpi_bench_end();
1008
1009   if (request == NULL) {
1010     retval = MPI_ERR_ARG;
1011   } else if (comm == MPI_COMM_NULL) {
1012     retval = MPI_ERR_COMM;
1013   } else if (src == MPI_PROC_NULL) {
1014     *request = MPI_REQUEST_NULL;
1015     retval = MPI_SUCCESS;
1016   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
1017     retval = MPI_ERR_COMM;
1018   } else if (count < 0) {
1019     retval = MPI_ERR_COUNT;
1020   } else if (buf==NULL && count > 0) {
1021     retval = MPI_ERR_COUNT;
1022   } else if (datatype == MPI_DATATYPE_NULL){
1023     retval = MPI_ERR_TYPE;
1024   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1025     retval = MPI_ERR_TAG;
1026   } else {
1027
1028 #ifdef HAVE_TRACING
1029   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1030   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1031   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
1032 #endif
1033
1034     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
1035     retval = MPI_SUCCESS;
1036
1037 #ifdef HAVE_TRACING
1038   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1039   (*request)->recv = 1;
1040 #endif
1041   }
1042
1043   smpi_bench_begin();
1044   return retval;
1045 }
1046
1047
1048 int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
1049               int tag, MPI_Comm comm, MPI_Request * request)
1050 {
1051   int retval;
1052
1053   smpi_bench_end();
1054   if (request == NULL) {
1055     retval = MPI_ERR_ARG;
1056   } else if (comm == MPI_COMM_NULL) {
1057     retval = MPI_ERR_COMM;
1058   } else if (dst == MPI_PROC_NULL) {
1059     *request = MPI_REQUEST_NULL;
1060     retval = MPI_SUCCESS;
1061   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1062     retval = MPI_ERR_RANK;
1063   } else if (count < 0) {
1064     retval = MPI_ERR_COUNT;
1065   } else if (buf==NULL && count > 0) {
1066     retval = MPI_ERR_COUNT;
1067   } else if (datatype == MPI_DATATYPE_NULL){
1068     retval = MPI_ERR_TYPE;
1069   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1070     retval = MPI_ERR_TAG;
1071   } else {
1072
1073 #ifdef HAVE_TRACING
1074   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1075   TRACE_smpi_computing_out(rank);
1076   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1077   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1078   TRACE_smpi_send(rank, rank, dst_traced);
1079 #endif
1080
1081     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
1082     retval = MPI_SUCCESS;
1083
1084 #ifdef HAVE_TRACING
1085   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1086   (*request)->send = 1;
1087   TRACE_smpi_computing_in(rank);
1088 #endif
1089   }
1090
1091   smpi_bench_begin();
1092   return retval;
1093 }
1094
1095 int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
1096   int retval;
1097
1098   smpi_bench_end();
1099   if (request == NULL) {
1100     retval = MPI_ERR_ARG;
1101   } else if (comm == MPI_COMM_NULL) {
1102     retval = MPI_ERR_COMM;
1103   } else if (dst == MPI_PROC_NULL) {
1104     *request = MPI_REQUEST_NULL;
1105     retval = MPI_SUCCESS;
1106   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1107     retval = MPI_ERR_RANK;
1108   } else if (count < 0) {
1109     retval = MPI_ERR_COUNT;
1110   } else if (buf==NULL && count > 0) {
1111     retval = MPI_ERR_COUNT;
1112   } else if (datatype == MPI_DATATYPE_NULL){
1113     retval = MPI_ERR_TYPE;
1114   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1115     retval = MPI_ERR_TAG;
1116   } else {
1117
1118 #ifdef HAVE_TRACING
1119   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1120   TRACE_smpi_computing_out(rank);
1121   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1122   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1123   TRACE_smpi_send(rank, rank, dst_traced);
1124 #endif
1125
1126     *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
1127     retval = MPI_SUCCESS;
1128
1129 #ifdef HAVE_TRACING
1130   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1131   (*request)->send = 1;
1132   TRACE_smpi_computing_in(rank);
1133 #endif
1134   }
1135
1136   smpi_bench_begin();
1137   return retval;
1138 }
1139
1140 int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
1141              MPI_Comm comm, MPI_Status * status)
1142 {
1143   int retval;
1144
1145   smpi_bench_end();
1146   if (comm == MPI_COMM_NULL) {
1147     retval = MPI_ERR_COMM;
1148   } else if (src == MPI_PROC_NULL) {
1149     smpi_empty_status(status);
1150     status->MPI_SOURCE = MPI_PROC_NULL;
1151     retval = MPI_SUCCESS;
1152   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
1153     retval = MPI_ERR_RANK;
1154   } else if (count < 0) {
1155     retval = MPI_ERR_COUNT;
1156   } else if (buf==NULL && count > 0) {
1157     retval = MPI_ERR_COUNT;
1158   } else if (datatype == MPI_DATATYPE_NULL){
1159     retval = MPI_ERR_TYPE;
1160   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1161     retval = MPI_ERR_TAG;
1162   } else {
1163 #ifdef HAVE_TRACING
1164   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1165   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1166   TRACE_smpi_computing_out(rank);
1167
1168   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__);
1169 #endif
1170
1171     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
1172     retval = MPI_SUCCESS;
1173
1174 #ifdef HAVE_TRACING
1175   //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1176   if(status!=MPI_STATUS_IGNORE)src_traced = smpi_group_index(smpi_comm_group(comm), status->MPI_SOURCE);
1177   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1178   TRACE_smpi_recv(rank, src_traced, rank);
1179   TRACE_smpi_computing_in(rank);
1180 #endif
1181   }
1182
1183   smpi_bench_begin();
1184   return retval;
1185 }
1186
1187 int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
1188              MPI_Comm comm)
1189 {
1190   int retval;
1191
1192   smpi_bench_end();
1193
1194   if (comm == MPI_COMM_NULL) {
1195     retval = MPI_ERR_COMM;
1196   } else if (dst == MPI_PROC_NULL) {
1197     retval = MPI_SUCCESS;
1198   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1199     retval = MPI_ERR_RANK;
1200   } else if (count < 0) {
1201     retval = MPI_ERR_COUNT;
1202   } else if (buf==NULL && count > 0) {
1203     retval = MPI_ERR_COUNT;
1204   } else if (datatype == MPI_DATATYPE_NULL){
1205     retval = MPI_ERR_TYPE;
1206   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1207     retval = MPI_ERR_TAG;
1208   } else {
1209
1210 #ifdef HAVE_TRACING
1211   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1212   TRACE_smpi_computing_out(rank);
1213   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1214   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1215   TRACE_smpi_send(rank, rank, dst_traced);
1216 #endif
1217
1218     smpi_mpi_send(buf, count, datatype, dst, tag, comm);
1219     retval = MPI_SUCCESS;
1220
1221 #ifdef HAVE_TRACING
1222   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1223   TRACE_smpi_computing_in(rank);
1224 #endif
1225   }
1226
1227   smpi_bench_begin();
1228   return retval;
1229 }
1230
1231
1232
1233 int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
1234   int retval;
1235
1236    smpi_bench_end();
1237
1238    if (comm == MPI_COMM_NULL) {
1239      retval = MPI_ERR_COMM;
1240    } else if (dst == MPI_PROC_NULL) {
1241      retval = MPI_SUCCESS;
1242    } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1243      retval = MPI_ERR_RANK;
1244    } else if (count < 0) {
1245      retval = MPI_ERR_COUNT;
1246    } else if (buf==NULL && count > 0) {
1247      retval = MPI_ERR_COUNT;
1248    } else if (datatype == MPI_DATATYPE_NULL){
1249      retval = MPI_ERR_TYPE;
1250    } else if(tag<0 && tag !=  MPI_ANY_TAG){
1251      retval = MPI_ERR_TAG;
1252    } else {
1253
1254  #ifdef HAVE_TRACING
1255    int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1256    TRACE_smpi_computing_out(rank);
1257    int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1258    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__);
1259    TRACE_smpi_send(rank, rank, dst_traced);
1260  #endif
1261
1262      smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
1263      retval = MPI_SUCCESS;
1264
1265  #ifdef HAVE_TRACING
1266    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1267    TRACE_smpi_computing_in(rank);
1268  #endif
1269    }
1270
1271    smpi_bench_begin();
1272    return retval;}
1273
1274
1275 int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1276                  int dst, int sendtag, void *recvbuf, int recvcount,
1277                  MPI_Datatype recvtype, int src, int recvtag,
1278                  MPI_Comm comm, MPI_Status * status)
1279 {
1280   int retval;
1281
1282   smpi_bench_end();
1283
1284   if (comm == MPI_COMM_NULL) {
1285     retval = MPI_ERR_COMM;
1286   } else if (sendtype == MPI_DATATYPE_NULL
1287              || recvtype == MPI_DATATYPE_NULL) {
1288     retval = MPI_ERR_TYPE;
1289   } else if (src == MPI_PROC_NULL || dst == MPI_PROC_NULL) {
1290       smpi_empty_status(status);
1291       status->MPI_SOURCE = MPI_PROC_NULL;
1292       retval = MPI_SUCCESS;
1293   }else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0 ||
1294       (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0))){
1295     retval = MPI_ERR_RANK;
1296   } else if (sendcount < 0 || recvcount<0) {
1297       retval = MPI_ERR_COUNT;
1298   } else if ((sendbuf==NULL && sendcount > 0)||(recvbuf==NULL && recvcount>0)) {
1299     retval = MPI_ERR_COUNT;
1300   } else if((sendtag<0 && sendtag !=  MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){
1301     retval = MPI_ERR_TAG;
1302   } else {
1303
1304 #ifdef HAVE_TRACING
1305   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1306   TRACE_smpi_computing_out(rank);
1307   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1308   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1309   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
1310   TRACE_smpi_send(rank, rank, dst_traced);
1311 #endif
1312
1313
1314     smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf,
1315                       recvcount, recvtype, src, recvtag, comm, status);
1316     retval = MPI_SUCCESS;
1317
1318 #ifdef HAVE_TRACING
1319   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1320   TRACE_smpi_recv(rank, src_traced, rank);
1321   TRACE_smpi_computing_in(rank);
1322 #endif
1323
1324   }
1325
1326   smpi_bench_begin();
1327   return retval;
1328 }
1329
1330 int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype,
1331                          int dst, int sendtag, int src, int recvtag,
1332                          MPI_Comm comm, MPI_Status * status)
1333 {
1334   //TODO: suboptimal implementation
1335   void *recvbuf;
1336   int retval;
1337   if (datatype == MPI_DATATYPE_NULL) {
1338       retval = MPI_ERR_TYPE;
1339   } else if (count < 0) {
1340       retval = MPI_ERR_COUNT;
1341   } else {
1342     int size = smpi_datatype_get_extent(datatype) * count;
1343     recvbuf = xbt_new(char, size);
1344     retval =
1345         MPI_Sendrecv(buf, count, datatype, dst, sendtag, recvbuf, count,
1346                      datatype, src, recvtag, comm, status);
1347     if(retval==MPI_SUCCESS){
1348         smpi_datatype_copy(recvbuf, count, datatype, buf, count, datatype);
1349     }
1350     xbt_free(recvbuf);
1351
1352   }
1353   return retval;
1354 }
1355
1356 int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
1357 {
1358   int retval;
1359
1360   smpi_bench_end();
1361   if (request == MPI_REQUEST_NULL || flag == NULL) {
1362     retval = MPI_ERR_ARG;
1363   } else if (*request == MPI_REQUEST_NULL) {
1364     *flag= TRUE;
1365     retval = MPI_ERR_REQUEST;
1366   } else {
1367     *flag = smpi_mpi_test(request, status);
1368     retval = MPI_SUCCESS;
1369   }
1370   smpi_bench_begin();
1371   return retval;
1372 }
1373
1374 int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
1375                 MPI_Status * status)
1376 {
1377   int retval;
1378
1379   smpi_bench_end();
1380   if (index == NULL || flag == NULL) {
1381     retval = MPI_ERR_ARG;
1382   } else {
1383     *flag = smpi_mpi_testany(count, requests, index, status);
1384     retval = MPI_SUCCESS;
1385   }
1386   smpi_bench_begin();
1387   return retval;
1388 }
1389
1390 int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses)
1391 {
1392   int retval;
1393
1394   smpi_bench_end();
1395   if (flag == NULL) {
1396     retval = MPI_ERR_ARG;
1397   } else {
1398     *flag = smpi_mpi_testall(count, requests, statuses);
1399     retval = MPI_SUCCESS;
1400   }
1401   smpi_bench_begin();
1402   return retval;
1403 }
1404
1405 int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
1406   int retval;
1407   smpi_bench_end();
1408
1409   if (status == NULL) {
1410     retval = MPI_ERR_ARG;
1411   } else if (comm == MPI_COMM_NULL) {
1412     retval = MPI_ERR_COMM;
1413   } else if (source == MPI_PROC_NULL) {
1414     smpi_empty_status(status);
1415     status->MPI_SOURCE = MPI_PROC_NULL;
1416     retval = MPI_SUCCESS;
1417   } else {
1418     smpi_mpi_probe(source, tag, comm, status);
1419     retval = MPI_SUCCESS;
1420   }
1421   smpi_bench_begin();
1422   return retval;
1423 }
1424
1425
1426 int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {
1427   int retval;
1428   smpi_bench_end();
1429
1430   if (flag == NULL) {
1431     retval = MPI_ERR_ARG;
1432   } else if (status == NULL) {
1433     retval = MPI_ERR_ARG;
1434   } else if (comm == MPI_COMM_NULL) {
1435     retval = MPI_ERR_COMM;
1436   } else if (source == MPI_PROC_NULL) {
1437     *flag=TRUE;
1438     smpi_empty_status(status);
1439     status->MPI_SOURCE = MPI_PROC_NULL;
1440     retval = MPI_SUCCESS;
1441   } else {
1442     smpi_mpi_iprobe(source, tag, comm, flag, status);
1443     retval = MPI_SUCCESS;
1444   }
1445   smpi_bench_begin();
1446   return retval;
1447 }
1448
1449 int PMPI_Wait(MPI_Request * request, MPI_Status * status)
1450 {
1451   int retval;
1452
1453   smpi_bench_end();
1454
1455   if (request == NULL) {
1456     retval = MPI_ERR_ARG;
1457   } else if (*request == MPI_REQUEST_NULL) {
1458     retval = MPI_ERR_REQUEST;
1459   } else {
1460
1461 #ifdef HAVE_TRACING
1462   int rank = request && (*request)->comm != MPI_COMM_NULL
1463       ? smpi_process_index()
1464       : -1;
1465   TRACE_smpi_computing_out(rank);
1466
1467   int src_traced = (*request)->src;
1468   int dst_traced = (*request)->dst;
1469   int is_wait_for_receive = (*request)->recv;
1470   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
1471 #endif
1472
1473     smpi_mpi_wait(request, status);
1474     retval = MPI_SUCCESS;
1475
1476 #ifdef HAVE_TRACING
1477   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1478   if (is_wait_for_receive) {
1479     TRACE_smpi_recv(rank, src_traced, dst_traced);
1480   }
1481   TRACE_smpi_computing_in(rank);
1482 #endif
1483
1484   }
1485
1486   smpi_bench_begin();
1487   return retval;
1488 }
1489
1490 int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
1491 {
1492   int retval;
1493
1494   smpi_bench_end();
1495 #ifdef HAVE_TRACING
1496   //save requests information for tracing
1497   int i;
1498   int *srcs = xbt_new(int, count);
1499   int *dsts = xbt_new(int, count);
1500   int *recvs = xbt_new(int, count);
1501   for (i = 0; i < count; i++) {
1502     MPI_Request req = requests[i];      //already received requests are no longer valid
1503     if (req) {
1504       srcs[i] = req->src;
1505       dsts[i] = req->dst;
1506       recvs[i] = req->recv;
1507     }
1508   }
1509   int rank_traced = smpi_process_index();
1510   TRACE_smpi_computing_out(rank_traced);
1511
1512   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
1513
1514 #endif
1515   if (index == NULL) {
1516     retval = MPI_ERR_ARG;
1517   } else {
1518     *index = smpi_mpi_waitany(count, requests, status);
1519     retval = MPI_SUCCESS;
1520   }
1521 #ifdef HAVE_TRACING
1522   if(*index!=MPI_UNDEFINED){
1523     int src_traced = srcs[*index];
1524     int dst_traced = dsts[*index];
1525     int is_wait_for_receive = recvs[*index];
1526     if (is_wait_for_receive) {
1527       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1528     }
1529     TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
1530     xbt_free(srcs);
1531     xbt_free(dsts);
1532     xbt_free(recvs);
1533   }
1534   TRACE_smpi_computing_in(rank_traced);
1535 #endif
1536   smpi_bench_begin();
1537   return retval;
1538 }
1539
1540 int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
1541 {
1542
1543   smpi_bench_end();
1544 #ifdef HAVE_TRACING
1545   //save information from requests
1546   int i;
1547   int *srcs = xbt_new(int, count);
1548   int *dsts = xbt_new(int, count);
1549   int *recvs = xbt_new(int, count);
1550   int valid_count = 0;
1551   for (i = 0; i < count; i++) {
1552     MPI_Request req = requests[i];
1553     if(req!=MPI_REQUEST_NULL){
1554       srcs[valid_count] = req->src;
1555       dsts[valid_count] = req->dst;
1556       recvs[valid_count] = req->recv;
1557       valid_count++;
1558     }
1559   }
1560   int rank_traced = smpi_process_index();
1561   TRACE_smpi_computing_out(rank_traced);
1562
1563   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__);
1564 #endif
1565   int retval = smpi_mpi_waitall(count, requests, status);
1566 #ifdef HAVE_TRACING
1567   for (i = 0; i < valid_count; i++) {
1568     int src_traced = srcs[i];
1569     int dst_traced = dsts[i];
1570     int is_wait_for_receive = recvs[i];
1571     if (is_wait_for_receive) {
1572       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1573     }
1574   }
1575   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
1576   xbt_free(srcs);
1577   xbt_free(dsts);
1578   xbt_free(recvs);
1579   TRACE_smpi_computing_in(rank_traced);
1580 #endif
1581   smpi_bench_begin();
1582   return retval;
1583 }
1584
1585 int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
1586                  int *indices, MPI_Status status[])
1587 {
1588   int retval;
1589
1590   smpi_bench_end();
1591   if (outcount == NULL) {
1592     retval = MPI_ERR_ARG;
1593   } else {
1594     *outcount = smpi_mpi_waitsome(incount, requests, indices, status);
1595     retval = MPI_SUCCESS;
1596   }
1597   smpi_bench_begin();
1598   return retval;
1599 }
1600
1601 int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
1602                  int* indices, MPI_Status status[])
1603 {
1604   int retval;
1605
1606    smpi_bench_end();
1607    if (outcount == NULL) {
1608      retval = MPI_ERR_ARG;
1609    } else {
1610      *outcount = smpi_mpi_testsome(incount, requests, indices, status);
1611      retval = MPI_SUCCESS;
1612    }
1613    smpi_bench_begin();
1614    return retval;
1615 }
1616
1617
1618 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
1619 {
1620   int retval;
1621
1622   smpi_bench_end();
1623 #ifdef HAVE_TRACING
1624   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1625   TRACE_smpi_computing_out(rank);
1626   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1627   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1628 #endif
1629   if (comm == MPI_COMM_NULL) {
1630     retval = MPI_ERR_COMM;
1631   } else {
1632     mpi_coll_bcast_fun(buf, count, datatype, root, comm);
1633     retval = MPI_SUCCESS;
1634   }
1635 #ifdef HAVE_TRACING
1636   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1637   TRACE_smpi_computing_in(rank);
1638 #endif
1639   smpi_bench_begin();
1640   return retval;
1641 }
1642
1643 int PMPI_Barrier(MPI_Comm comm)
1644 {
1645   int retval;
1646
1647   smpi_bench_end();
1648 #ifdef HAVE_TRACING
1649   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1650   TRACE_smpi_computing_out(rank);
1651   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1652 #endif
1653   if (comm == MPI_COMM_NULL) {
1654     retval = MPI_ERR_COMM;
1655   } else {
1656     mpi_coll_barrier_fun(comm);
1657     retval = MPI_SUCCESS;
1658   }
1659 #ifdef HAVE_TRACING
1660   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1661   TRACE_smpi_computing_in(rank);
1662 #endif
1663   smpi_bench_begin();
1664   return retval;
1665 }
1666
1667 int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1668                void *recvbuf, int recvcount, MPI_Datatype recvtype,
1669                int root, MPI_Comm comm)
1670 {
1671   int retval;
1672
1673   smpi_bench_end();
1674 #ifdef HAVE_TRACING
1675   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1676   TRACE_smpi_computing_out(rank);
1677   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1678   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1679 #endif
1680   if (comm == MPI_COMM_NULL) {
1681     retval = MPI_ERR_COMM;
1682   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1683             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1684     retval = MPI_ERR_TYPE;
1685   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1686             ((smpi_comm_rank(comm) == root) && (recvcount <0))){
1687     retval = MPI_ERR_COUNT;
1688   } else {
1689
1690     char* sendtmpbuf = (char*) sendbuf;
1691     int sendtmpcount = sendcount;
1692     MPI_Datatype sendtmptype = sendtype;
1693     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1694       sendtmpcount=0;
1695       sendtmptype=recvtype;
1696     }
1697
1698     mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount,
1699                     recvtype, root, comm);
1700
1701
1702     retval = MPI_SUCCESS;
1703   }
1704 #ifdef HAVE_TRACING
1705   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1706   TRACE_smpi_computing_in(rank);
1707 #endif
1708   smpi_bench_begin();
1709   return retval;
1710 }
1711
1712 int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1713                 void *recvbuf, int *recvcounts, int *displs,
1714                 MPI_Datatype recvtype, int root, MPI_Comm comm)
1715 {
1716   int retval;
1717
1718   smpi_bench_end();
1719 #ifdef HAVE_TRACING
1720   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1721   TRACE_smpi_computing_out(rank);
1722   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1723   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1724 #endif
1725   if (comm == MPI_COMM_NULL) {
1726     retval = MPI_ERR_COMM;
1727   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1728             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1729     retval = MPI_ERR_TYPE;
1730   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1731     retval = MPI_ERR_COUNT;
1732   } else if (recvcounts == NULL || displs == NULL) {
1733     retval = MPI_ERR_ARG;
1734   } else {
1735
1736     char* sendtmpbuf = (char*) sendbuf;
1737     int sendtmpcount = sendcount;
1738     MPI_Datatype sendtmptype = sendtype;
1739     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1740       sendtmpcount=0;
1741       sendtmptype=recvtype;
1742     }
1743
1744     smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts,
1745                      displs, recvtype, root, comm);
1746     retval = MPI_SUCCESS;
1747   }
1748 #ifdef HAVE_TRACING
1749   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1750   TRACE_smpi_computing_in(rank);
1751 #endif
1752   smpi_bench_begin();
1753   return retval;
1754 }
1755
1756 int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1757                   void *recvbuf, int recvcount, MPI_Datatype recvtype,
1758                   MPI_Comm comm)
1759 {
1760   int retval;
1761
1762   smpi_bench_end();
1763 #ifdef HAVE_TRACING
1764   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1765   TRACE_smpi_computing_out(rank);
1766   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1767 #endif
1768   if (comm == MPI_COMM_NULL) {
1769     retval = MPI_ERR_COMM;
1770   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1771             (recvtype == MPI_DATATYPE_NULL)){
1772     retval = MPI_ERR_TYPE;
1773   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1774             (recvcount <0)){
1775     retval = MPI_ERR_COUNT;
1776   } else {
1777
1778     if(sendbuf == MPI_IN_PLACE) {
1779       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm);
1780       sendcount=recvcount;
1781       sendtype=recvtype;
1782     }
1783
1784     mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1785                            recvtype, comm);
1786     retval = MPI_SUCCESS;
1787   }
1788 #ifdef HAVE_TRACING
1789   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1790 #endif
1791   smpi_bench_begin();
1792   return retval;
1793 }
1794
1795 int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1796                    void *recvbuf, int *recvcounts, int *displs,
1797                    MPI_Datatype recvtype, MPI_Comm comm)
1798 {
1799   int retval;
1800
1801   smpi_bench_end();
1802 #ifdef HAVE_TRACING
1803   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1804   TRACE_smpi_computing_out(rank);
1805   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1806 #endif
1807   if (comm == MPI_COMM_NULL) {
1808     retval = MPI_ERR_COMM;
1809   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1810             (recvtype == MPI_DATATYPE_NULL)){
1811     retval = MPI_ERR_TYPE;
1812   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1813     retval = MPI_ERR_COUNT;
1814   } else if (recvcounts == NULL || displs == NULL) {
1815     retval = MPI_ERR_ARG;
1816   } else {
1817
1818     if(sendbuf == MPI_IN_PLACE) {
1819       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*displs[smpi_comm_rank(comm)];
1820       sendcount=recvcounts[smpi_comm_rank(comm)];
1821       sendtype=recvtype;
1822     }
1823
1824     mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts,
1825                         displs, recvtype, comm);
1826     retval = MPI_SUCCESS;
1827   }
1828 #ifdef HAVE_TRACING
1829   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1830   TRACE_smpi_computing_in(rank);
1831 #endif
1832   smpi_bench_begin();
1833   return retval;
1834 }
1835
1836 int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1837                 void *recvbuf, int recvcount, MPI_Datatype recvtype,
1838                 int root, MPI_Comm comm)
1839 {
1840   int retval;
1841
1842   smpi_bench_end();
1843 #ifdef HAVE_TRACING
1844   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1845   TRACE_smpi_computing_out(rank);
1846   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1847
1848   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1849 #endif
1850   if (comm == MPI_COMM_NULL) {
1851     retval = MPI_ERR_COMM;
1852   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
1853              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
1854     retval = MPI_ERR_TYPE;
1855   } else {
1856
1857     if(recvbuf==MPI_IN_PLACE){
1858         recvcount=0;
1859     }
1860     mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1861                      recvtype, root, comm);
1862     retval = MPI_SUCCESS;
1863   }
1864 #ifdef HAVE_TRACING
1865   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1866   TRACE_smpi_computing_in(rank);
1867 #endif
1868   smpi_bench_begin();
1869   return retval;
1870 }
1871
1872 int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
1873                  MPI_Datatype sendtype, void *recvbuf, int recvcount,
1874                  MPI_Datatype recvtype, int root, MPI_Comm comm)
1875 {
1876   int retval;
1877
1878   smpi_bench_end();
1879 #ifdef HAVE_TRACING
1880   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1881   TRACE_smpi_computing_out(rank);
1882   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1883   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1884 #endif
1885   if (comm == MPI_COMM_NULL) {
1886     retval = MPI_ERR_COMM;
1887   } else if (sendcounts == NULL || displs == NULL) {
1888     retval = MPI_ERR_ARG;
1889   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
1890              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
1891     retval = MPI_ERR_TYPE;
1892   } else {
1893
1894     if(recvbuf==MPI_IN_PLACE){
1895         recvcount=0;
1896     }
1897
1898     smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf,
1899                       recvcount, recvtype, root, comm);
1900     retval = MPI_SUCCESS;
1901   }
1902 #ifdef HAVE_TRACING
1903   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1904   TRACE_smpi_computing_in(rank);
1905 #endif
1906   smpi_bench_begin();
1907   return retval;
1908 }
1909
1910 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count,
1911                MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
1912 {
1913   int retval;
1914
1915   smpi_bench_end();
1916 #ifdef HAVE_TRACING
1917   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1918   TRACE_smpi_computing_out(rank);
1919   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1920   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__);
1921 #endif
1922   if (comm == MPI_COMM_NULL) {
1923     retval = MPI_ERR_COMM;
1924   } else if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
1925     retval = MPI_ERR_ARG;
1926   } else {
1927
1928     char* sendtmpbuf = (char*) sendbuf;
1929     if( sendbuf == MPI_IN_PLACE ) {
1930       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
1931       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
1932     }
1933
1934     mpi_coll_reduce_fun(sendtmpbuf, recvbuf, count, datatype, op, root, comm);
1935
1936     if( sendbuf == MPI_IN_PLACE ) {
1937       xbt_free(sendtmpbuf);
1938     }
1939
1940     retval = MPI_SUCCESS;
1941   }
1942 #ifdef HAVE_TRACING
1943   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1944   TRACE_smpi_computing_in(rank);
1945 #endif
1946   smpi_bench_begin();
1947   return retval;
1948 }
1949
1950 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
1951     MPI_Datatype datatype, MPI_Op op){
1952   int retval;
1953
1954     smpi_bench_end();
1955     if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
1956       retval = MPI_ERR_ARG;
1957     } else {
1958       smpi_op_apply(op, inbuf, inoutbuf, &count, &datatype);
1959       retval=MPI_SUCCESS;
1960     }
1961     smpi_bench_begin();
1962     return retval;
1963 }
1964
1965 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
1966                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
1967 {
1968   int retval;
1969
1970   smpi_bench_end();
1971 #ifdef HAVE_TRACING
1972   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1973   TRACE_smpi_computing_out(rank);
1974   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
1975 #endif
1976   if (comm == MPI_COMM_NULL) {
1977     retval = MPI_ERR_COMM;
1978   } else if (datatype == MPI_DATATYPE_NULL) {
1979     retval = MPI_ERR_TYPE;
1980   } else if (op == MPI_OP_NULL) {
1981     retval = MPI_ERR_OP;
1982   } else {
1983
1984     char* sendtmpbuf = (char*) sendbuf;
1985     if( sendbuf == MPI_IN_PLACE ) {
1986       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
1987       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
1988     }
1989
1990     mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm);
1991
1992     if( sendbuf == MPI_IN_PLACE ) {
1993       xbt_free(sendtmpbuf);
1994     }
1995
1996     retval = MPI_SUCCESS;
1997
1998   }
1999 #ifdef HAVE_TRACING
2000   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2001   TRACE_smpi_computing_in(rank);
2002 #endif
2003   smpi_bench_begin();
2004   return retval;
2005 }
2006
2007 int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
2008              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2009 {
2010   int retval;
2011
2012   smpi_bench_end();
2013 #ifdef HAVE_TRACING
2014   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2015   TRACE_smpi_computing_out(rank);
2016   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2017 #endif
2018   if (comm == MPI_COMM_NULL) {
2019     retval = MPI_ERR_COMM;
2020   } else if (datatype == MPI_DATATYPE_NULL) {
2021     retval = MPI_ERR_TYPE;
2022   } else if (op == MPI_OP_NULL) {
2023     retval = MPI_ERR_OP;
2024   } else {
2025     smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
2026     retval = MPI_SUCCESS;
2027   }
2028 #ifdef HAVE_TRACING
2029   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2030   TRACE_smpi_computing_in(rank);
2031 #endif
2032   smpi_bench_begin();
2033   return retval;
2034 }
2035
2036 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
2037                 MPI_Op op, MPI_Comm comm){
2038   int retval;
2039
2040   smpi_bench_end();
2041 #ifdef HAVE_TRACING
2042   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2043   TRACE_smpi_computing_out(rank);
2044   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2045 #endif
2046   if (comm == MPI_COMM_NULL) {
2047     retval = MPI_ERR_COMM;
2048   } else if (datatype == MPI_DATATYPE_NULL) {
2049     retval = MPI_ERR_TYPE;
2050   } else if (op == MPI_OP_NULL) {
2051     retval = MPI_ERR_OP;
2052   } else {
2053     smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm);
2054     retval = MPI_SUCCESS;
2055   }
2056 #ifdef HAVE_TRACING
2057   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2058   TRACE_smpi_computing_in(rank);
2059 #endif
2060   smpi_bench_begin();
2061   return retval;
2062 }
2063
2064 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
2065                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2066 {
2067   int retval;
2068   smpi_bench_end();
2069 #ifdef HAVE_TRACING
2070   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2071   TRACE_smpi_computing_out(rank);
2072   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2073 #endif
2074   if (comm == MPI_COMM_NULL) {
2075     retval = MPI_ERR_COMM;
2076   } else if (datatype == MPI_DATATYPE_NULL) {
2077     retval = MPI_ERR_TYPE;
2078   } else if (op == MPI_OP_NULL) {
2079     retval = MPI_ERR_OP;
2080   } else if (recvcounts == NULL) {
2081     retval = MPI_ERR_ARG;
2082   } else {
2083     void* sendtmpbuf=sendbuf;
2084     if(sendbuf==MPI_IN_PLACE){
2085       sendtmpbuf=recvbuf;
2086     }
2087
2088     mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts,
2089                        datatype,  op, comm);
2090     retval = MPI_SUCCESS;
2091   }
2092 #ifdef HAVE_TRACING
2093   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2094   TRACE_smpi_computing_in(rank);
2095 #endif
2096   smpi_bench_begin();
2097   return retval;
2098 }
2099
2100 int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
2101                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2102 {
2103   int retval,i;
2104   smpi_bench_end();
2105 #ifdef HAVE_TRACING
2106   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2107   TRACE_smpi_computing_out(rank);
2108   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2109 #endif
2110   if (comm == MPI_COMM_NULL) {
2111     retval = MPI_ERR_COMM;
2112   } else if (datatype == MPI_DATATYPE_NULL) {
2113     retval = MPI_ERR_TYPE;
2114   } else if (op == MPI_OP_NULL) {
2115     retval = MPI_ERR_OP;
2116   } else if (recvcount < 0) {
2117     retval = MPI_ERR_ARG;
2118   } else {
2119     int count=smpi_comm_size(comm);
2120     int* recvcounts=(int*)xbt_malloc(count);
2121     for (i=0; i<count;i++)recvcounts[i]=recvcount;
2122     mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts,
2123                        datatype,  op, comm);
2124     xbt_free(recvcounts);
2125     retval = MPI_SUCCESS;
2126   }
2127 #ifdef HAVE_TRACING
2128   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2129   TRACE_smpi_computing_in(rank);
2130 #endif
2131   smpi_bench_begin();
2132   return retval;
2133 }
2134
2135 int PMPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
2136                  void *recvbuf, int recvcount, MPI_Datatype recvtype,
2137                  MPI_Comm comm)
2138 {
2139   int retval;
2140
2141   smpi_bench_end();
2142 #ifdef HAVE_TRACING
2143   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2144   TRACE_smpi_computing_out(rank);
2145   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2146 #endif
2147   if (comm == MPI_COMM_NULL) {
2148     retval = MPI_ERR_COMM;
2149   } else if (sendtype == MPI_DATATYPE_NULL
2150              || recvtype == MPI_DATATYPE_NULL) {
2151     retval = MPI_ERR_TYPE;
2152   } else {
2153     retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
2154   }
2155 #ifdef HAVE_TRACING
2156   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2157   TRACE_smpi_computing_in(rank);
2158 #endif
2159   smpi_bench_begin();
2160   return retval;
2161 }
2162
2163 int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,
2164                   MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
2165                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
2166 {
2167   int retval;
2168
2169   smpi_bench_end();
2170 #ifdef HAVE_TRACING
2171   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2172   TRACE_smpi_computing_out(rank);
2173   TRACE_smpi_collective_in(rank, -1, __FUNCTION__);
2174 #endif
2175   if (comm == MPI_COMM_NULL) {
2176     retval = MPI_ERR_COMM;
2177   } else if (sendtype == MPI_DATATYPE_NULL
2178              || recvtype == MPI_DATATYPE_NULL) {
2179     retval = MPI_ERR_TYPE;
2180   } else if (sendcounts == NULL || senddisps == NULL || recvcounts == NULL
2181              || recvdisps == NULL) {
2182     retval = MPI_ERR_ARG;
2183   } else {
2184     retval =
2185         mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype,
2186                                   recvbuf, recvcounts, recvdisps, recvtype,
2187                                   comm);
2188   }
2189 #ifdef HAVE_TRACING
2190   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2191   TRACE_smpi_computing_in(rank);
2192 #endif
2193   smpi_bench_begin();
2194   return retval;
2195 }
2196
2197
2198 int PMPI_Get_processor_name(char *name, int *resultlen)
2199 {
2200   int retval = MPI_SUCCESS;
2201
2202   smpi_bench_end();
2203   strncpy(name, SIMIX_host_get_name(SIMIX_host_self()),
2204           strlen(SIMIX_host_get_name(SIMIX_host_self())) < MPI_MAX_PROCESSOR_NAME - 1 ?
2205           strlen(SIMIX_host_get_name(SIMIX_host_self())) +1 :
2206           MPI_MAX_PROCESSOR_NAME - 1 );
2207   *resultlen =
2208       strlen(name) >
2209       MPI_MAX_PROCESSOR_NAME ? MPI_MAX_PROCESSOR_NAME : strlen(name);
2210
2211   smpi_bench_begin();
2212   return retval;
2213 }
2214
2215 int PMPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count)
2216 {
2217   int retval = MPI_SUCCESS;
2218   size_t size;
2219
2220   smpi_bench_end();
2221   if (status == NULL || count == NULL) {
2222     retval = MPI_ERR_ARG;
2223   } else if (datatype == MPI_DATATYPE_NULL) {
2224     retval = MPI_ERR_TYPE;
2225   } else {
2226     size = smpi_datatype_size(datatype);
2227     if (size == 0) {
2228       *count = 0;
2229     } else if (status->count % size != 0) {
2230       retval = MPI_UNDEFINED;
2231     } else {
2232       *count = smpi_mpi_get_count(status, datatype);
2233     }
2234   }
2235   smpi_bench_begin();
2236   return retval;
2237 }
2238
2239 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {
2240   int retval;
2241
2242   smpi_bench_end();
2243   if (old_type == MPI_DATATYPE_NULL) {
2244     retval = MPI_ERR_TYPE;
2245   } else if (count<0){
2246     retval = MPI_ERR_COUNT;
2247   } else {
2248     retval = smpi_datatype_contiguous(count, old_type, new_type, 0);
2249   }
2250   smpi_bench_begin();
2251   return retval;
2252 }
2253
2254 int PMPI_Type_commit(MPI_Datatype* datatype) {
2255   int retval;
2256
2257   smpi_bench_end();
2258   if (datatype == MPI_DATATYPE_NULL) {
2259     retval = MPI_ERR_TYPE;
2260   } else {
2261     smpi_datatype_commit(datatype);
2262     retval = MPI_SUCCESS;
2263   }
2264   smpi_bench_begin();
2265   return retval;
2266 }
2267
2268
2269 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2270   int retval;
2271
2272   smpi_bench_end();
2273   if (old_type == MPI_DATATYPE_NULL) {
2274     retval = MPI_ERR_TYPE;
2275   } else if (count<0 || blocklen<0){
2276     retval = MPI_ERR_COUNT;
2277   } else {
2278     retval = smpi_datatype_vector(count, blocklen, stride, old_type, new_type);
2279   }
2280   smpi_bench_begin();
2281   return retval;
2282 }
2283
2284 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2285   int retval;
2286
2287   smpi_bench_end();
2288   if (old_type == MPI_DATATYPE_NULL) {
2289     retval = MPI_ERR_TYPE;
2290   } else if (count<0 || blocklen<0){
2291     retval = MPI_ERR_COUNT;
2292   } else {
2293     retval = smpi_datatype_hvector(count, blocklen, stride, old_type, new_type);
2294   }
2295   smpi_bench_begin();
2296   return retval;
2297 }
2298
2299 int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2300   return MPI_Type_hvector(count, blocklen, stride, old_type, new_type);
2301 }
2302
2303 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2304   int retval;
2305
2306   smpi_bench_end();
2307   if (old_type == MPI_DATATYPE_NULL) {
2308     retval = MPI_ERR_TYPE;
2309   } else if (count<0){
2310     retval = MPI_ERR_COUNT;
2311   } else {
2312     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2313   }
2314   smpi_bench_begin();
2315   return retval;
2316 }
2317
2318 int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2319   int retval,i;
2320
2321   smpi_bench_end();
2322   if (old_type == MPI_DATATYPE_NULL) {
2323     retval = MPI_ERR_TYPE;
2324   } else if (count<0){
2325     retval = MPI_ERR_COUNT;
2326   } else {
2327     int* blocklens=(int*)xbt_malloc(blocklength*count);
2328     for (i=0; i<count;i++)blocklens[i]=blocklength;
2329     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2330     xbt_free(blocklens);
2331   }
2332   smpi_bench_begin();
2333   return retval;
2334 }
2335
2336
2337 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2338   int retval;
2339
2340   smpi_bench_end();
2341   if (old_type == MPI_DATATYPE_NULL) {
2342     retval = MPI_ERR_TYPE;
2343   } else if (count<0){
2344     retval = MPI_ERR_COUNT;
2345   } else {
2346     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2347   }
2348   smpi_bench_begin();
2349   return retval;
2350 }
2351
2352 int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2353   int retval,i;
2354
2355   smpi_bench_end();
2356   if (old_type == MPI_DATATYPE_NULL) {
2357     retval = MPI_ERR_TYPE;
2358   } else if (count<0){
2359     retval = MPI_ERR_COUNT;
2360   } else {
2361     int* blocklens=(int*)xbt_malloc(blocklength*count);
2362     for (i=0; i<count;i++)blocklens[i]=blocklength;
2363     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2364     xbt_free(blocklens);
2365   }
2366   smpi_bench_begin();
2367   return retval;
2368 }
2369
2370
2371 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2372   int retval;
2373
2374   smpi_bench_end();
2375   if (count<0){
2376     retval = MPI_ERR_COUNT;
2377   } else {
2378     retval = smpi_datatype_struct(count, blocklens, indices, old_types, new_type);
2379   }
2380   smpi_bench_begin();
2381   return retval;
2382 }
2383
2384 int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2385   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
2386 }
2387
2388
2389 int PMPI_Error_class(int errorcode, int* errorclass) {
2390   // assume smpi uses only standard mpi error codes
2391   *errorclass=errorcode;
2392   return MPI_SUCCESS;
2393 }
2394
2395
2396 int PMPI_Initialized(int* flag) {
2397    *flag=(smpi_process_data()!=NULL);
2398    return MPI_SUCCESS;
2399 }
2400
2401 /* The following calls are not yet implemented and will fail at runtime. */
2402 /* Once implemented, please move them above this notice. */
2403
2404 #define NOT_YET_IMPLEMENTED {\
2405         XBT_WARN("Not yet implemented : %s. Please contact the Simgrid team if support is needed", __FUNCTION__);\
2406         return MPI_SUCCESS;\
2407         }
2408
2409
2410 int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){
2411   NOT_YET_IMPLEMENTED
2412 }
2413
2414 int PMPI_Type_set_name(MPI_Datatype  datatype, char * name)
2415 {
2416   NOT_YET_IMPLEMENTED
2417 }
2418
2419 int PMPI_Type_get_name(MPI_Datatype  datatype, char * name, int* len)
2420 {
2421   NOT_YET_IMPLEMENTED
2422 }
2423
2424 int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
2425    NOT_YET_IMPLEMENTED
2426 }
2427
2428 int PMPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int* coords) {
2429    NOT_YET_IMPLEMENTED
2430 }
2431
2432 int PMPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder, MPI_Comm* comm_cart) {
2433    NOT_YET_IMPLEMENTED
2434 }
2435
2436 int PMPI_Cart_get(MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords) {
2437    NOT_YET_IMPLEMENTED
2438 }
2439
2440 int PMPI_Cart_map(MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank) {
2441    NOT_YET_IMPLEMENTED
2442 }
2443
2444 int PMPI_Cart_rank(MPI_Comm comm, int* coords, int* rank) {
2445    NOT_YET_IMPLEMENTED
2446 }
2447
2448 int PMPI_Cart_shift(MPI_Comm comm, int direction, int displ, int* source, int* dest) {
2449    NOT_YET_IMPLEMENTED
2450 }
2451
2452 int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) {
2453    NOT_YET_IMPLEMENTED
2454 }
2455
2456 int PMPI_Cartdim_get(MPI_Comm comm, int* ndims) {
2457    NOT_YET_IMPLEMENTED
2458 }
2459
2460 int PMPI_Graph_create(MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph) {
2461    NOT_YET_IMPLEMENTED
2462 }
2463
2464 int PMPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges) {
2465    NOT_YET_IMPLEMENTED
2466 }
2467
2468 int PMPI_Graph_map(MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank) {
2469    NOT_YET_IMPLEMENTED
2470 }
2471
2472 int PMPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int* neighbors) {
2473    NOT_YET_IMPLEMENTED
2474 }
2475
2476 int PMPI_Graph_neighbors_count(MPI_Comm comm, int rank, int* nneighbors) {
2477    NOT_YET_IMPLEMENTED
2478 }
2479
2480 int PMPI_Graphdims_get(MPI_Comm comm, int* nnodes, int* nedges) {
2481    NOT_YET_IMPLEMENTED
2482 }
2483
2484 int PMPI_Topo_test(MPI_Comm comm, int* top_type) {
2485    NOT_YET_IMPLEMENTED
2486 }
2487
2488 int PMPI_Errhandler_create(MPI_Handler_function* function, MPI_Errhandler* errhandler) {
2489    NOT_YET_IMPLEMENTED
2490 }
2491
2492 int PMPI_Errhandler_free(MPI_Errhandler* errhandler) {
2493    NOT_YET_IMPLEMENTED
2494 }
2495
2496 int PMPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler* errhandler) {
2497    NOT_YET_IMPLEMENTED
2498 }
2499
2500 int PMPI_Error_string(int errorcode, char* string, int* resultlen) {
2501    NOT_YET_IMPLEMENTED
2502 }
2503
2504 int PMPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler) {
2505    NOT_YET_IMPLEMENTED
2506 }
2507
2508 int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
2509    NOT_YET_IMPLEMENTED
2510 }
2511
2512 int PMPI_Cancel(MPI_Request* request) {
2513    NOT_YET_IMPLEMENTED
2514 }
2515
2516 int PMPI_Buffer_attach(void* buffer, int size) {
2517    NOT_YET_IMPLEMENTED
2518 }
2519
2520 int PMPI_Buffer_detach(void* buffer, int* size) {
2521    NOT_YET_IMPLEMENTED
2522 }
2523
2524 int PMPI_Comm_test_inter(MPI_Comm comm, int* flag) {
2525    NOT_YET_IMPLEMENTED
2526 }
2527
2528 int PMPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
2529 {
2530    NOT_YET_IMPLEMENTED
2531 }
2532
2533 int PMPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val)
2534 {
2535    NOT_YET_IMPLEMENTED
2536 }
2537
2538 int PMPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval)
2539 {
2540    NOT_YET_IMPLEMENTED
2541 }
2542
2543 int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state)
2544 {
2545    NOT_YET_IMPLEMENTED
2546 }
2547
2548 int PMPI_Comm_free_keyval(int* keyval) {
2549    NOT_YET_IMPLEMENTED
2550 }
2551
2552 int PMPI_Pcontrol(const int level )
2553 {
2554    NOT_YET_IMPLEMENTED
2555 }
2556
2557 int PMPI_Unpack(void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
2558    NOT_YET_IMPLEMENTED
2559 }
2560
2561 int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
2562 {
2563   NOT_YET_IMPLEMENTED
2564 }
2565
2566 int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
2567 {
2568   NOT_YET_IMPLEMENTED
2569 }
2570
2571 int PMPI_Type_delete_attr (MPI_Datatype type, int comm_keyval)
2572 {
2573   NOT_YET_IMPLEMENTED
2574 }
2575
2576 int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)
2577 {
2578   NOT_YET_IMPLEMENTED
2579 }
2580
2581 int PMPI_Type_free_keyval(int* keyval) {
2582   NOT_YET_IMPLEMENTED
2583 }
2584
2585 int PMPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out) {
2586    NOT_YET_IMPLEMENTED
2587 }
2588
2589 int PMPI_Intercomm_merge(MPI_Comm comm, int high, MPI_Comm* comm_out) {
2590    NOT_YET_IMPLEMENTED
2591 }
2592
2593 int PMPI_Bsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
2594    NOT_YET_IMPLEMENTED
2595 }
2596
2597 int PMPI_Bsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2598    NOT_YET_IMPLEMENTED
2599 }
2600
2601 int PMPI_Ibsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2602    NOT_YET_IMPLEMENTED
2603 }
2604
2605 int PMPI_Comm_remote_group(MPI_Comm comm, MPI_Group* group) {
2606    NOT_YET_IMPLEMENTED
2607 }
2608
2609 int PMPI_Comm_remote_size(MPI_Comm comm, int* size) {
2610    NOT_YET_IMPLEMENTED
2611 }
2612
2613 int PMPI_Attr_delete(MPI_Comm comm, int keyval) {
2614    NOT_YET_IMPLEMENTED
2615 }
2616
2617 int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) {
2618    NOT_YET_IMPLEMENTED
2619 }
2620
2621 int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) {
2622    NOT_YET_IMPLEMENTED
2623 }
2624
2625 int PMPI_Rsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
2626    NOT_YET_IMPLEMENTED
2627 }
2628
2629 int PMPI_Rsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2630    NOT_YET_IMPLEMENTED
2631 }
2632
2633 int PMPI_Irsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
2634    NOT_YET_IMPLEMENTED
2635 }
2636
2637 int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) {
2638    NOT_YET_IMPLEMENTED
2639 }
2640
2641 int PMPI_Keyval_free(int* keyval) {
2642    NOT_YET_IMPLEMENTED
2643 }
2644
2645 int PMPI_Test_cancelled(MPI_Status* status, int* flag) {
2646    NOT_YET_IMPLEMENTED
2647 }
2648
2649 int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
2650    NOT_YET_IMPLEMENTED
2651 }
2652
2653 int PMPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size){
2654   NOT_YET_IMPLEMENTED
2655 }
2656
2657 int PMPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outcount, MPI_Aint *position){
2658   NOT_YET_IMPLEMENTED
2659 }
2660
2661 int PMPI_Unpack_external( char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount, MPI_Datatype datatype){
2662   NOT_YET_IMPLEMENTED
2663 }
2664
2665 int PMPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) {
2666    NOT_YET_IMPLEMENTED
2667 }
2668
2669 int PMPI_Dims_create(int nnodes, int ndims, int* dims) {
2670    NOT_YET_IMPLEMENTED
2671 }
2672
2673 int PMPI_Win_fence( int assert,  MPI_Win win){
2674    NOT_YET_IMPLEMENTED
2675 }
2676
2677 int PMPI_Win_free( MPI_Win* win){
2678    NOT_YET_IMPLEMENTED
2679 }
2680
2681 int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
2682   NOT_YET_IMPLEMENTED
2683 }
2684
2685 int PMPI_Info_create( MPI_Info *info){
2686   NOT_YET_IMPLEMENTED
2687 }
2688
2689 int PMPI_Info_set( MPI_Info info, char *key, char *value){
2690   NOT_YET_IMPLEMENTED
2691 }
2692
2693 int PMPI_Info_free( MPI_Info *info){
2694   NOT_YET_IMPLEMENTED
2695 }
2696
2697 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
2698     MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
2699   NOT_YET_IMPLEMENTED
2700 }
2701
2702 int PMPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers,
2703                           int *num_addresses, int *num_datatypes, int *combiner){
2704   NOT_YET_IMPLEMENTED
2705 }
2706
2707 int PMPI_Type_get_contents(MPI_Datatype datatype, int max_integers, int max_addresses,
2708                           int max_datatypes, int* array_of_integers, MPI_Aint* array_of_addresses,
2709                           MPI_Datatype* array_of_datatypes){
2710   NOT_YET_IMPLEMENTED
2711 }
2712
2713 int PMPI_Type_create_darray(int size, int rank, int ndims, int* array_of_gsizes,
2714                             int* array_of_distribs, int* array_of_dargs, int* array_of_psizes,
2715                             int order, MPI_Datatype oldtype, MPI_Datatype *newtype) {
2716   NOT_YET_IMPLEMENTED
2717 }
2718
2719 int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
2720   NOT_YET_IMPLEMENTED
2721 }
2722
2723 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){
2724   NOT_YET_IMPLEMENTED
2725 }
2726
2727 int PMPI_Type_match_size(int typeclass,int size,MPI_Datatype *datatype){
2728   NOT_YET_IMPLEMENTED
2729 }
2730
2731 int PMPI_Alltoallw( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes,
2732                    void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes,
2733                    MPI_Comm comm){
2734   NOT_YET_IMPLEMENTED
2735 }
2736
2737 int PMPI_Comm_set_name(MPI_Comm comm, char* name){
2738   NOT_YET_IMPLEMENTED
2739 }
2740
2741 int PMPI_Comm_dup_with_info(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm){
2742   NOT_YET_IMPLEMENTED
2743 }
2744
2745 int PMPI_Comm_split_type(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm *newcomm){
2746   NOT_YET_IMPLEMENTED
2747 }
2748
2749 int PMPI_Comm_set_info (MPI_Comm comm, MPI_Info info){
2750   NOT_YET_IMPLEMENTED
2751 }
2752
2753 int PMPI_Comm_get_info (MPI_Comm comm, MPI_Info* info){
2754   NOT_YET_IMPLEMENTED
2755 }
2756
2757 int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){
2758   NOT_YET_IMPLEMENTED
2759 }
2760
2761 int PMPI_Comm_create_errhandler( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler){
2762   NOT_YET_IMPLEMENTED
2763 }
2764
2765 int PMPI_Add_error_class( int *errorclass){
2766   NOT_YET_IMPLEMENTED
2767 }
2768
2769 int PMPI_Add_error_code(  int errorclass, int *errorcode){
2770   NOT_YET_IMPLEMENTED
2771 }
2772
2773 int PMPI_Add_error_string( int errorcode, char *string){
2774   NOT_YET_IMPLEMENTED
2775 }
2776
2777 int PMPI_Comm_call_errhandler(MPI_Comm comm,int errorcode){
2778   NOT_YET_IMPLEMENTED
2779 }
2780
2781 int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){
2782   NOT_YET_IMPLEMENTED
2783 }
2784
2785 int PMPI_Info_delete(MPI_Info info, char *key){
2786   NOT_YET_IMPLEMENTED
2787 }
2788
2789 int PMPI_Info_get_nkeys( MPI_Info info, int *nkeys){
2790   NOT_YET_IMPLEMENTED
2791 }
2792
2793 int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){
2794   NOT_YET_IMPLEMENTED
2795 }
2796
2797 int PMPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){
2798   NOT_YET_IMPLEMENTED
2799 }
2800
2801 int PMPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
2802   NOT_YET_IMPLEMENTED
2803 }
2804
2805 int MPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
2806   NOT_YET_IMPLEMENTED
2807 }
2808
2809 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){
2810   NOT_YET_IMPLEMENTED
2811 }
2812
2813 int PMPI_Grequest_complete( MPI_Request request){
2814   NOT_YET_IMPLEMENTED
2815 }
2816
2817 int PMPI_Status_set_cancelled(MPI_Status *status,int flag){
2818   NOT_YET_IMPLEMENTED
2819 }
2820
2821 int PMPI_Status_set_elements( MPI_Status *status, MPI_Datatype datatype, int count){
2822   NOT_YET_IMPLEMENTED
2823 }
2824
2825 int PMPI_Comm_connect( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
2826   NOT_YET_IMPLEMENTED
2827 }
2828
2829 int PMPI_Publish_name( char *service_name, MPI_Info info, char *port_name){
2830   NOT_YET_IMPLEMENTED
2831 }
2832
2833 int PMPI_Unpublish_name( char *service_name, MPI_Info info, char *port_name){
2834   NOT_YET_IMPLEMENTED
2835 }
2836
2837 int PMPI_Lookup_name( char *service_name, MPI_Info info, char *port_name){
2838   NOT_YET_IMPLEMENTED
2839 }
2840
2841 int PMPI_Comm_join( int fd, MPI_Comm *intercomm){
2842   NOT_YET_IMPLEMENTED
2843 }
2844
2845 int PMPI_Open_port( MPI_Info info, char *port_name){
2846   NOT_YET_IMPLEMENTED
2847 }
2848
2849 int PMPI_Close_port(char *port_name){
2850   NOT_YET_IMPLEMENTED
2851 }
2852
2853 int PMPI_Comm_accept( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
2854   NOT_YET_IMPLEMENTED
2855 }
2856
2857 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){
2858   NOT_YET_IMPLEMENTED
2859 }
2860
2861 int PMPI_Comm_spawn_multiple( int count, char **array_of_commands, char*** array_of_argv,
2862                              int* array_of_maxprocs, MPI_Info* array_of_info, int root,
2863                              MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes){
2864   NOT_YET_IMPLEMENTED
2865 }
2866
2867 int PMPI_Comm_get_parent( MPI_Comm *parent){
2868   NOT_YET_IMPLEMENTED
2869 }