Logo AND Algorithmique Numérique Distribuée

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