Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
revalidate the tesh files after the modifications of the energy_platform.xml file
[simgrid.git] / src / smpi / smpi_pmpi.c
1
2 /* Copyright (c) 2007-2015. The SimGrid Team.
3  * All rights reserved.                                                     */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "private.h"
9 #include "smpi_mpi_dt_private.h"
10
11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_pmpi, smpi,
12                                 "Logging specific to SMPI (pmpi)");
13
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
24 /* PMPI User level calls */
25
26 int PMPI_Init(int *argc, char ***argv)
27 {
28   smpi_process_init(argc, argv);
29   smpi_process_mark_as_initialized();
30   int rank = smpi_process_index();
31   TRACE_smpi_init(rank);
32   TRACE_smpi_computing_init(rank);
33   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
34   extra->type = TRACING_INIT;
35   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
36   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
37   smpi_bench_begin();
38   return MPI_SUCCESS;
39 }
40
41 int PMPI_Finalize(void)
42 {
43   smpi_bench_end();
44   int rank = smpi_process_index();
45   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
46   extra->type = TRACING_FINALIZE;
47   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
48
49   smpi_process_finalize();
50
51   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
52   TRACE_smpi_finalize(smpi_process_index());
53   smpi_process_destroy();
54   return MPI_SUCCESS;
55 }
56
57 int PMPI_Finalized(int* flag)
58 {
59   *flag=smpi_process_finalized();
60   return MPI_SUCCESS;
61 }
62
63 int PMPI_Get_version (int *version,int *subversion){
64   *version = MPI_VERSION;
65   *subversion= MPI_SUBVERSION;
66   return MPI_SUCCESS;
67 }
68
69 int PMPI_Get_library_version (char *version,int *len){
70   int retval = MPI_SUCCESS;
71   smpi_bench_end();
72   snprintf(version,MPI_MAX_LIBRARY_VERSION_STRING,"SMPI Version %d.%d. Copyright The Simgrid Team 2007-2015",SIMGRID_VERSION_MAJOR,
73           SIMGRID_VERSION_MINOR);
74   *len = strlen(version) > MPI_MAX_LIBRARY_VERSION_STRING ? MPI_MAX_LIBRARY_VERSION_STRING : strlen(version);
75   smpi_bench_begin();
76   return retval;
77 }
78
79 int PMPI_Init_thread(int *argc, char ***argv, int required, int *provided)
80 {
81   if (provided != NULL) {
82     *provided = MPI_THREAD_MULTIPLE;
83   }
84   return MPI_Init(argc, argv);
85 }
86
87 int PMPI_Query_thread(int *provided)
88 {
89   int retval = 0;
90
91   if (provided == NULL) {
92     retval = MPI_ERR_ARG;
93   } else {
94     *provided = MPI_THREAD_MULTIPLE;
95     retval = MPI_SUCCESS;
96   }
97   return retval;
98 }
99
100 int PMPI_Is_thread_main(int *flag)
101 {
102   int retval = 0;
103
104   if (flag == NULL) {
105     retval = MPI_ERR_ARG;
106   } else {
107     *flag = smpi_process_index() == 0;
108     retval = MPI_SUCCESS;
109   }
110   return retval;
111 }
112
113 int PMPI_Abort(MPI_Comm comm, int errorcode)
114 {
115   smpi_bench_end();
116   smpi_process_destroy();
117   // FIXME: should kill all processes in comm instead
118   simcall_process_kill(SIMIX_process_self());
119   return MPI_SUCCESS;
120 }
121
122 double PMPI_Wtime(void)
123 {
124   return smpi_mpi_wtime();
125 }
126
127 extern double sg_maxmin_precision;
128 double PMPI_Wtick(void)
129 {
130   return sg_maxmin_precision;
131 }
132
133 int PMPI_Address(void *location, MPI_Aint * address)
134 {
135   int retval = 0;
136
137   if (!address) {
138     retval = MPI_ERR_ARG;
139   } else {
140     *address = (MPI_Aint) location;
141     retval = MPI_SUCCESS;
142   }
143   return retval;
144 }
145
146 int PMPI_Get_address(void *location, MPI_Aint * address)
147 {
148   return PMPI_Address(location, address);
149 }
150
151 int PMPI_Type_free(MPI_Datatype * datatype)
152 {
153   int retval = 0;
154   /* Free a predefined datatype is an error according to the standard, and
155      should be checked for */
156   if (*datatype == MPI_DATATYPE_NULL) {
157     retval = MPI_ERR_ARG;
158   } else {
159     smpi_datatype_free(datatype);
160     retval = MPI_SUCCESS;
161   }
162   return retval;
163 }
164
165 int PMPI_Type_size(MPI_Datatype datatype, int *size)
166 {
167   int retval = 0;
168
169   if (datatype == MPI_DATATYPE_NULL) {
170     retval = MPI_ERR_TYPE;
171   } else if (size == NULL) {
172     retval = MPI_ERR_ARG;
173   } else {
174     *size = (int) smpi_datatype_size(datatype);
175     retval = MPI_SUCCESS;
176   }
177   return retval;
178 }
179
180 int PMPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
181 {
182   int retval = 0;
183
184   if (datatype == MPI_DATATYPE_NULL) {
185     retval = MPI_ERR_TYPE;
186   } else if (lb == NULL || extent == NULL) {
187     retval = MPI_ERR_ARG;
188   } else {
189     retval = smpi_datatype_extent(datatype, lb, extent);
190   }
191   return retval;
192 }
193
194 int PMPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)
195 {
196   return PMPI_Type_get_extent(datatype, lb, extent);
197 }
198
199 int PMPI_Type_extent(MPI_Datatype datatype, MPI_Aint * extent)
200 {
201   int retval = 0;
202
203   if (datatype == MPI_DATATYPE_NULL) {
204     retval = MPI_ERR_TYPE;
205   } else if (extent == NULL) {
206     retval = MPI_ERR_ARG;
207   } else {
208     *extent = smpi_datatype_get_extent(datatype);
209     retval = MPI_SUCCESS;
210   }
211   return retval;
212 }
213
214 int PMPI_Type_lb(MPI_Datatype datatype, MPI_Aint * disp)
215 {
216   int retval = 0;
217
218   if (datatype == MPI_DATATYPE_NULL) {
219     retval = MPI_ERR_TYPE;
220   } else if (disp == NULL) {
221     retval = MPI_ERR_ARG;
222   } else {
223     *disp = smpi_datatype_lb(datatype);
224     retval = MPI_SUCCESS;
225   }
226   return retval;
227 }
228
229 int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp)
230 {
231   int retval = 0;
232
233   if (datatype == MPI_DATATYPE_NULL) {
234     retval = MPI_ERR_TYPE;
235   } else if (disp == NULL) {
236     retval = MPI_ERR_ARG;
237   } else {
238     *disp = smpi_datatype_ub(datatype);
239     retval = MPI_SUCCESS;
240   }
241   return retval;
242 }
243
244 int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){
245   int retval = 0;
246
247   if (datatype == MPI_DATATYPE_NULL) {
248     retval = MPI_ERR_TYPE;
249   } else {
250     retval = smpi_datatype_dup(datatype, newtype);
251   }
252   return retval;
253 }
254
255 int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op)
256 {
257   int retval = 0;
258
259   if (function == NULL || op == NULL) {
260     retval = MPI_ERR_ARG;
261   } else {
262     *op = smpi_op_new(function, commute);
263     retval = MPI_SUCCESS;
264   }
265   return retval;
266 }
267
268 int PMPI_Op_free(MPI_Op * op)
269 {
270   int retval = 0;
271
272   if (op == NULL) {
273     retval = MPI_ERR_ARG;
274   } else if (*op == MPI_OP_NULL) {
275     retval = MPI_ERR_OP;
276   } else {
277     smpi_op_destroy(*op);
278     *op = MPI_OP_NULL;
279     retval = MPI_SUCCESS;
280   }
281   return retval;
282 }
283
284 int PMPI_Group_free(MPI_Group * group)
285 {
286   int retval = 0;
287
288   if (group == NULL) {
289     retval = MPI_ERR_ARG;
290   } else {
291     smpi_group_destroy(*group);
292     *group = MPI_GROUP_NULL;
293     retval = MPI_SUCCESS;
294   }
295   return retval;
296 }
297
298 int PMPI_Group_size(MPI_Group group, int *size)
299 {
300   int retval = 0;
301
302   if (group == MPI_GROUP_NULL) {
303     retval = MPI_ERR_GROUP;
304   } else if (size == NULL) {
305     retval = MPI_ERR_ARG;
306   } else {
307     *size = smpi_group_size(group);
308     retval = MPI_SUCCESS;
309   }
310   return retval;
311 }
312
313 int PMPI_Group_rank(MPI_Group group, int *rank)
314 {
315   int retval = 0;
316
317   if (group == MPI_GROUP_NULL) {
318     retval = MPI_ERR_GROUP;
319   } else if (rank == NULL) {
320     retval = MPI_ERR_ARG;
321   } else {
322     *rank = smpi_group_rank(group, smpi_process_index());
323     retval = MPI_SUCCESS;
324   }
325   return retval;
326 }
327
328 int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1,
329                               MPI_Group group2, int *ranks2)
330 {
331   int retval, i, index;
332   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
333     retval = MPI_ERR_GROUP;
334   } else {
335     for (i = 0; i < n; i++) {
336       if(ranks1[i]==MPI_PROC_NULL){
337         ranks2[i]=MPI_PROC_NULL;
338       }else{
339         index = smpi_group_index(group1, ranks1[i]);
340         ranks2[i] = smpi_group_rank(group2, index);
341       }
342     }
343     retval = MPI_SUCCESS;
344   }
345   return retval;
346 }
347
348 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
349 {
350   int retval = 0;
351
352   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
353     retval = MPI_ERR_GROUP;
354   } else if (result == NULL) {
355     retval = MPI_ERR_ARG;
356   } else {
357     *result = smpi_group_compare(group1, group2);
358     retval = MPI_SUCCESS;
359   }
360   return retval;
361 }
362
363 int PMPI_Group_union(MPI_Group group1, MPI_Group group2,
364                     MPI_Group * newgroup)
365 {
366   int retval, i, proc1, proc2, size, size2;
367
368   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
369     retval = MPI_ERR_GROUP;
370   } else if (newgroup == NULL) {
371     retval = MPI_ERR_ARG;
372   } else {
373     size = smpi_group_size(group1);
374     size2 = smpi_group_size(group2);
375     for (i = 0; i < size2; i++) {
376       proc2 = smpi_group_index(group2, i);
377       proc1 = smpi_group_rank(group1, proc2);
378       if (proc1 == MPI_UNDEFINED) {
379         size++;
380       }
381     }
382     if (size == 0) {
383       *newgroup = MPI_GROUP_EMPTY;
384     } else {
385       *newgroup = smpi_group_new(size);
386       size2 = smpi_group_size(group1);
387       for (i = 0; i < size2; i++) {
388         proc1 = smpi_group_index(group1, i);
389         smpi_group_set_mapping(*newgroup, proc1, i);
390       }
391       for (i = size2; i < size; i++) {
392         proc2 = smpi_group_index(group2, i - size2);
393         smpi_group_set_mapping(*newgroup, proc2, i);
394       }
395     }
396     retval = MPI_SUCCESS;
397   }
398   return retval;
399 }
400
401 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2,
402                            MPI_Group * newgroup)
403 {
404   int retval, i, proc1, proc2, size;
405
406   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
407     retval = MPI_ERR_GROUP;
408   } else if (newgroup == NULL) {
409     retval = MPI_ERR_ARG;
410   } else {
411     size = smpi_group_size(group2);
412     for (i = 0; i < size; i++) {
413       proc2 = smpi_group_index(group2, i);
414       proc1 = smpi_group_rank(group1, proc2);
415       if (proc1 == MPI_UNDEFINED) {
416         size--;
417       }
418     }
419     if (size == 0) {
420       *newgroup = MPI_GROUP_EMPTY;
421     } else {
422       *newgroup = smpi_group_new(size);
423       int j=0;
424       for (i = 0; i < smpi_group_size(group2); i++) {
425         proc2 = smpi_group_index(group2, i);
426         proc1 = smpi_group_rank(group1, proc2);
427         if (proc1 != MPI_UNDEFINED) {
428           smpi_group_set_mapping(*newgroup, proc2, j);
429           j++;
430         }
431       }
432     }
433     retval = MPI_SUCCESS;
434   }
435   return retval;
436 }
437
438 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
439 {
440   int retval, i, proc1, proc2, size, size2;
441
442   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
443     retval = MPI_ERR_GROUP;
444   } else if (newgroup == NULL) {
445     retval = MPI_ERR_ARG;
446   } else {
447     size = size2 = smpi_group_size(group1);
448     for (i = 0; i < size2; i++) {
449       proc1 = smpi_group_index(group1, i);
450       proc2 = smpi_group_rank(group2, proc1);
451       if (proc2 != MPI_UNDEFINED) {
452         size--;
453       }
454     }
455     if (size == 0) {
456       *newgroup = MPI_GROUP_EMPTY;
457     } else {
458       *newgroup = smpi_group_new(size);
459       for (i = 0; i < size2; i++) {
460         proc1 = smpi_group_index(group1, i);
461         proc2 = smpi_group_rank(group2, proc1);
462         if (proc2 == MPI_UNDEFINED) {
463           smpi_group_set_mapping(*newgroup, proc1, i);
464         }
465       }
466     }
467     retval = MPI_SUCCESS;
468   }
469   return retval;
470 }
471
472 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
473 {
474   int retval;
475
476   if (group == MPI_GROUP_NULL) {
477     retval = MPI_ERR_GROUP;
478   } else if (newgroup == NULL) {
479     retval = MPI_ERR_ARG;
480   } else {
481     retval = smpi_group_incl(group, n, ranks, newgroup);
482   }
483   return retval;
484 }
485
486 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
487 {
488   int retval, i, j, newsize, oldsize, index;
489
490   if (group == MPI_GROUP_NULL) {
491     retval = MPI_ERR_GROUP;
492   } else if (newgroup == NULL) {
493     retval = MPI_ERR_ARG;
494   } else {
495     if (n == 0) {
496       *newgroup = group;
497       if(group!= smpi_comm_group(MPI_COMM_WORLD)
498                 && group != MPI_GROUP_NULL
499                 && group != smpi_comm_group(MPI_COMM_SELF)
500                 && group != MPI_GROUP_EMPTY)
501       smpi_group_use(group);
502     } else if (n == smpi_group_size(group)) {
503       *newgroup = MPI_GROUP_EMPTY;
504     } else {
505       oldsize=smpi_group_size(group);
506       newsize = oldsize - n;
507       *newgroup = smpi_group_new(newsize);
508
509       int* to_exclude=xbt_new0(int, smpi_group_size(group));
510       for(i=0; i<oldsize; i++)
511         to_exclude[i]=0;
512       for(i=0; i<n; i++)
513         to_exclude[ranks[i]]=1;
514
515       j=0;
516       for(i=0; i<oldsize; i++){
517         if(to_exclude[i]==0){
518           index = smpi_group_index(group, i);
519           smpi_group_set_mapping(*newgroup, index, j);
520           j++;
521         }
522       }
523
524       xbt_free(to_exclude);
525     }
526     retval = MPI_SUCCESS;
527   }
528   return retval;
529 }
530
531 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3],
532                          MPI_Group * newgroup)
533 {
534   int retval, i, j, rank, size, index;
535
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 = MPI_GROUP_EMPTY;
543     } else {
544       size = 0;
545       for (i = 0; i < n; i++) {
546         for (rank = ranges[i][0];       /* First */
547              rank >= 0 && rank < smpi_group_size(group); /* Last */
548               ) {
549           size++;
550           if(rank == ranges[i][1]){/*already last ?*/
551             break;
552           }
553           rank += ranges[i][2]; /* Stride */
554           if (ranges[i][0]<ranges[i][1]){
555               if(rank > ranges[i][1])
556                 break;
557           }else{
558               if(rank < ranges[i][1])
559                 break;
560           }
561         }
562       }
563
564       *newgroup = smpi_group_new(size);
565       j = 0;
566       for (i = 0; i < n; i++) {
567         for (rank = ranges[i][0];     /* First */
568              rank >= 0 && rank < smpi_group_size(group); /* Last */
569              ) {
570           index = smpi_group_index(group, rank);
571           smpi_group_set_mapping(*newgroup, index, j);
572           j++;
573           if(rank == ranges[i][1]){/*already last ?*/
574             break;
575           }
576           rank += ranges[i][2]; /* Stride */
577           if (ranges[i][0]<ranges[i][1]){
578             if(rank > ranges[i][1])
579               break;
580           }else{
581             if(rank < ranges[i][1])
582               break;
583           }
584         }
585       }
586     }
587     retval = MPI_SUCCESS;
588   }
589   return retval;
590 }
591
592 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3],
593                          MPI_Group * newgroup)
594 {
595   int retval, i, rank, newrank,oldrank, size, index, add;
596
597   if (group == MPI_GROUP_NULL) {
598     retval = MPI_ERR_GROUP;
599   } else if (newgroup == NULL) {
600     retval = MPI_ERR_ARG;
601   } else {
602     if (n == 0) {
603       *newgroup = group;
604       if(group!= smpi_comm_group(MPI_COMM_WORLD)
605                 && group != MPI_GROUP_NULL
606                 && group != smpi_comm_group(MPI_COMM_SELF)
607                 && group != MPI_GROUP_EMPTY)
608       smpi_group_use(group);
609     } else {
610       size = smpi_group_size(group);
611       for (i = 0; i < n; i++) {
612         for (rank = ranges[i][0];       /* First */
613              rank >= 0 && rank < smpi_group_size(group); /* Last */
614               ) {
615           size--;
616           if(rank == ranges[i][1]){/*already last ?*/
617             break;
618           }
619           rank += ranges[i][2]; /* Stride */
620           if (ranges[i][0]<ranges[i][1]){
621               if(rank > ranges[i][1])
622                 break;
623           }else{
624               if(rank < ranges[i][1])
625                 break;
626           }
627         }
628       }
629       if (size == 0) {
630         *newgroup = MPI_GROUP_EMPTY;
631       } else {
632         *newgroup = smpi_group_new(size);
633         newrank=0;
634         oldrank=0;
635         while (newrank < size) {
636           add=1;
637           for (i = 0; i < n; i++) {
638             for (rank = ranges[i][0];
639                 rank >= 0 && rank < smpi_group_size(group);
640                 ){
641               if(rank==oldrank){
642                   add=0;
643                   break;
644               }
645               if(rank == ranges[i][1]){/*already last ?*/
646                 break;
647               }
648               rank += ranges[i][2]; /* Stride */
649               if (ranges[i][0]<ranges[i][1]){
650                   if(rank > ranges[i][1])
651                     break;
652               }else{
653                   if(rank < ranges[i][1])
654                     break;
655               }
656             }
657           }
658           if(add==1){
659             index = smpi_group_index(group, oldrank);
660             smpi_group_set_mapping(*newgroup, index, newrank);
661             newrank++;
662           }
663           oldrank++;
664         }
665       }
666     }
667
668     retval = MPI_SUCCESS;
669   }
670   return retval;
671 }
672
673 int PMPI_Comm_rank(MPI_Comm comm, int *rank)
674 {
675   int retval = 0;
676   if (comm == MPI_COMM_NULL) {
677     retval = MPI_ERR_COMM;
678   } else if (rank == NULL) {
679     retval = MPI_ERR_ARG;
680   } else {
681     *rank = smpi_comm_rank(comm);
682     retval = MPI_SUCCESS;
683   }
684   return retval;
685 }
686
687 int PMPI_Comm_size(MPI_Comm comm, int *size)
688 {
689   int retval = 0;
690   if (comm == MPI_COMM_NULL) {
691     retval = MPI_ERR_COMM;
692   } else if (size == NULL) {
693     retval = MPI_ERR_ARG;
694   } else {
695     *size = smpi_comm_size(comm);
696     retval = MPI_SUCCESS;
697   }
698   return retval;
699 }
700
701 int PMPI_Comm_get_name (MPI_Comm comm, char* name, int* len)
702 {
703   int retval = 0;
704
705   if (comm == MPI_COMM_NULL)  {
706     retval = MPI_ERR_COMM;
707   } else if (name == NULL || len == NULL)  {
708     retval = MPI_ERR_ARG;
709   } else {
710     smpi_comm_get_name(comm, name, len);
711     retval = MPI_SUCCESS;
712   }
713   return retval;
714 }
715
716 int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group)
717 {
718   int retval = 0;
719
720   if (comm == MPI_COMM_NULL) {
721     retval = MPI_ERR_COMM;
722   } else if (group == NULL) {
723     retval = MPI_ERR_ARG;
724   } else {
725     *group = smpi_comm_group(comm);
726     if(*group!= smpi_comm_group(MPI_COMM_WORLD)
727               && *group != MPI_GROUP_NULL
728               && *group != smpi_comm_group(MPI_COMM_SELF)
729               && *group != MPI_GROUP_EMPTY)
730     smpi_group_use(*group);
731     retval = MPI_SUCCESS;
732   }
733   return retval;
734 }
735
736 int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
737 {
738   int retval = 0;
739
740   if (comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {
741     retval = MPI_ERR_COMM;
742   } else if (result == NULL) {
743     retval = MPI_ERR_ARG;
744   } else {
745     if (comm1 == comm2) {       /* Same communicators means same groups */
746       *result = MPI_IDENT;
747     } else {
748       *result =
749           smpi_group_compare(smpi_comm_group(comm1),
750                              smpi_comm_group(comm2));
751       if (*result == MPI_IDENT) {
752         *result = MPI_CONGRUENT;
753       }
754     }
755     retval = MPI_SUCCESS;
756   }
757   return retval;
758 }
759
760 int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
761 {
762   int retval = 0;
763
764   if (comm == MPI_COMM_NULL) {
765     retval = MPI_ERR_COMM;
766   } else if (newcomm == NULL) {
767     retval = MPI_ERR_ARG;
768   } else {
769     retval = smpi_comm_dup(comm, newcomm);
770   }
771   return retval;
772 }
773
774 int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
775 {
776   int retval = 0;
777
778   if (comm == MPI_COMM_NULL) {
779     retval = MPI_ERR_COMM;
780   } else if (group == MPI_GROUP_NULL) {
781     retval = MPI_ERR_GROUP;
782   } else if (newcomm == NULL) {
783     retval = MPI_ERR_ARG;
784   } else if(smpi_group_rank(group,smpi_process_index())==MPI_UNDEFINED){
785     *newcomm= MPI_COMM_NULL;
786     retval = MPI_SUCCESS;
787   }else{
788
789     *newcomm = smpi_comm_new(group, NULL);
790     retval = MPI_SUCCESS;
791   }
792   return retval;
793 }
794
795 int PMPI_Comm_free(MPI_Comm * comm)
796 {
797   int retval = 0;
798
799   if (comm == NULL) {
800     retval = MPI_ERR_ARG;
801   } else if (*comm == MPI_COMM_NULL) {
802     retval = MPI_ERR_COMM;
803   } else {
804     smpi_comm_destroy(*comm);
805     *comm = MPI_COMM_NULL;
806     retval = MPI_SUCCESS;
807   }
808   return retval;
809 }
810
811 int PMPI_Comm_disconnect(MPI_Comm * comm)
812 {
813   /* TODO: wait until all communication in comm are done */
814   int retval = 0;
815
816   if (comm == NULL) {
817     retval = MPI_ERR_ARG;
818   } else if (*comm == MPI_COMM_NULL) {
819     retval = MPI_ERR_COMM;
820   } else {
821     smpi_comm_destroy(*comm);
822     *comm = MPI_COMM_NULL;
823     retval = MPI_SUCCESS;
824   }
825   return retval;
826 }
827
828 int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm* comm_out)
829 {
830   int retval = 0;
831   smpi_bench_end();
832
833   if (comm_out == NULL) {
834     retval = MPI_ERR_ARG;
835   } else if (comm == MPI_COMM_NULL) {
836     retval = MPI_ERR_COMM;
837   } else {
838     *comm_out = smpi_comm_split(comm, color, key);
839     retval = MPI_SUCCESS;
840   }
841   smpi_bench_begin();
842
843   return retval;
844 }
845
846 int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst,
847                    int tag, MPI_Comm comm, MPI_Request * request)
848 {
849   int retval = 0;
850
851   smpi_bench_end();
852   if (request == NULL) {
853       retval = MPI_ERR_ARG;
854   } else if (comm == MPI_COMM_NULL) {
855       retval = MPI_ERR_COMM;
856   } else if (!is_datatype_valid(datatype)) {
857       retval = MPI_ERR_TYPE;
858   } else if (dst == MPI_PROC_NULL) {
859       retval = MPI_SUCCESS;
860   } else {
861       *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm);
862       retval = MPI_SUCCESS;
863   }
864   smpi_bench_begin();
865   if (retval != MPI_SUCCESS && request)
866     *request = MPI_REQUEST_NULL;
867   return retval;
868 }
869
870 int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src,
871                    int tag, MPI_Comm comm, MPI_Request * request)
872 {
873   int retval = 0;
874
875   smpi_bench_end();
876   if (request == NULL) {
877     retval = MPI_ERR_ARG;
878   } else if (comm == MPI_COMM_NULL) {
879     retval = MPI_ERR_COMM;
880   } else if (!is_datatype_valid(datatype)) {
881       retval = MPI_ERR_TYPE;
882   } else if (src == MPI_PROC_NULL) {
883     retval = MPI_SUCCESS;
884   } else {
885     *request = smpi_mpi_recv_init(buf, count, datatype, src, tag, comm);
886     retval = MPI_SUCCESS;
887   }
888   smpi_bench_begin();
889   if (retval != MPI_SUCCESS && request)
890     *request = MPI_REQUEST_NULL;
891   return retval;
892 }
893
894 int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype,
895                     int dst, int tag, MPI_Comm comm, MPI_Request* request)
896 {
897   int retval = 0;
898
899   smpi_bench_end();
900   if (request == NULL) {
901     retval = MPI_ERR_ARG;
902   } else if (comm == MPI_COMM_NULL) {
903     retval = MPI_ERR_COMM;
904   } else if (!is_datatype_valid(datatype)) {
905       retval = MPI_ERR_TYPE;
906   } else if (dst == MPI_PROC_NULL) {
907     retval = MPI_SUCCESS;
908   } else {
909     *request = smpi_mpi_ssend_init(buf, count, datatype, dst, tag, comm);
910     retval = MPI_SUCCESS;
911   }
912   smpi_bench_begin();
913   if (retval != MPI_SUCCESS && request)
914     *request = MPI_REQUEST_NULL;
915   return retval;
916 }
917
918 int PMPI_Start(MPI_Request * request)
919 {
920   int retval = 0;
921
922   smpi_bench_end();
923   if (request == NULL || *request == MPI_REQUEST_NULL) {
924     retval = MPI_ERR_REQUEST;
925   } else {
926     smpi_mpi_start(*request);
927     retval = MPI_SUCCESS;
928   }
929   smpi_bench_begin();
930   return retval;
931 }
932
933 int PMPI_Startall(int count, MPI_Request * requests)
934 {
935   int retval;
936   int i = 0;
937   smpi_bench_end();
938   if (requests == NULL) {
939     retval = MPI_ERR_ARG;
940   } else {
941     retval = MPI_SUCCESS;
942     for (i = 0 ;  i < count ; i++) {
943       if(requests[i] == MPI_REQUEST_NULL) {
944         retval = MPI_ERR_REQUEST;
945       }
946     }
947     if(retval != MPI_ERR_REQUEST) {
948       smpi_mpi_startall(count, requests);
949     }
950   }
951   smpi_bench_begin();
952   return retval;
953 }
954
955 int PMPI_Request_free(MPI_Request * request)
956 {
957   int retval = 0;
958
959   smpi_bench_end();
960   if (*request == MPI_REQUEST_NULL) {
961     retval = MPI_ERR_ARG;
962   } else {
963     smpi_mpi_request_free(request);
964     retval = MPI_SUCCESS;
965   }
966   smpi_bench_begin();
967   return retval;
968 }
969
970 int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src,
971                int tag, MPI_Comm comm, MPI_Request * request)
972 {
973   int retval = 0;
974
975   smpi_bench_end();
976
977   if (request == NULL) {
978     retval = MPI_ERR_ARG;
979   } else if (comm == MPI_COMM_NULL) {
980     retval = MPI_ERR_COMM;
981   } else if (src == MPI_PROC_NULL) {
982     *request = MPI_REQUEST_NULL;
983     retval = MPI_SUCCESS;
984   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
985     retval = MPI_ERR_RANK;
986   } else if (count < 0) {
987     retval = MPI_ERR_COUNT;
988   } else if (buf==NULL && count > 0) {
989     retval = MPI_ERR_COUNT;
990   } else if (!is_datatype_valid(datatype)) {
991       retval = MPI_ERR_TYPE;
992   } else if(tag<0 && tag !=  MPI_ANY_TAG){
993     retval = MPI_ERR_TAG;
994   } else {
995
996     int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
997     int src_traced = smpi_group_index(smpi_comm_group(comm), src);
998
999     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1000     extra->type = TRACING_IRECV;
1001     extra->src = src_traced;
1002     extra->dst = rank;
1003     int known=0;
1004     extra->datatype1 = encode_datatype(datatype, &known);
1005     int dt_size_send = 1;
1006     if(!known)
1007       dt_size_send = smpi_datatype_size(datatype);
1008     extra->send_size = count*dt_size_send;
1009     TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
1010
1011     *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
1012     retval = MPI_SUCCESS;
1013
1014     TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1015     (*request)->recv = 1;
1016   }
1017
1018   smpi_bench_begin();
1019   if (retval != MPI_SUCCESS && request)
1020     *request = MPI_REQUEST_NULL;
1021   return retval;
1022 }
1023
1024
1025 int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst,
1026                int tag, MPI_Comm comm, MPI_Request * request)
1027 {
1028   int retval = 0;
1029
1030   smpi_bench_end();
1031   if (request == NULL) {
1032     retval = MPI_ERR_ARG;
1033   } else if (comm == MPI_COMM_NULL) {
1034     retval = MPI_ERR_COMM;
1035   } else if (dst == MPI_PROC_NULL) {
1036     *request = MPI_REQUEST_NULL;
1037     retval = MPI_SUCCESS;
1038   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1039     retval = MPI_ERR_RANK;
1040   } else if (count < 0) {
1041     retval = MPI_ERR_COUNT;
1042   } else if (buf==NULL && count > 0) {
1043     retval = MPI_ERR_COUNT;
1044   } else if (!is_datatype_valid(datatype)) {
1045       retval = MPI_ERR_TYPE;
1046   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1047     retval = MPI_ERR_TAG;
1048   } else {
1049
1050     int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1051     int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1052     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1053     extra->type = TRACING_ISEND;
1054     extra->src = rank;
1055     extra->dst = dst_traced;
1056     int known=0;
1057     extra->datatype1 = encode_datatype(datatype, &known);
1058     int dt_size_send = 1;
1059     if(!known)
1060       dt_size_send = smpi_datatype_size(datatype);
1061     extra->send_size = count*dt_size_send;
1062     TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
1063     TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));
1064
1065     *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
1066     retval = MPI_SUCCESS;
1067
1068     TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1069     (*request)->send = 1;
1070   }
1071
1072   smpi_bench_begin();
1073   if (retval != MPI_SUCCESS && request)
1074     *request = MPI_REQUEST_NULL;
1075   return retval;
1076 }
1077
1078 int PMPI_Issend(void* buf, int count, MPI_Datatype datatype,
1079                 int dst, int tag, MPI_Comm comm, MPI_Request* request)
1080 {
1081   int retval = 0;
1082
1083   smpi_bench_end();
1084   if (request == NULL) {
1085     retval = MPI_ERR_ARG;
1086   } else if (comm == MPI_COMM_NULL) {
1087     retval = MPI_ERR_COMM;
1088   } else if (dst == MPI_PROC_NULL) {
1089     *request = MPI_REQUEST_NULL;
1090     retval = MPI_SUCCESS;
1091   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1092     retval = MPI_ERR_RANK;
1093   } else if (count < 0) {
1094     retval = MPI_ERR_COUNT;
1095   } else if (buf==NULL && count > 0) {
1096     retval = MPI_ERR_COUNT;
1097   } else if (!is_datatype_valid(datatype)) {
1098       retval = MPI_ERR_TYPE;
1099   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1100     retval = MPI_ERR_TAG;
1101   } else {
1102
1103     int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1104     int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1105     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1106     extra->type = TRACING_ISSEND;
1107     extra->src = rank;
1108     extra->dst = dst_traced;
1109     int known=0;
1110     extra->datatype1 = encode_datatype(datatype, &known);
1111     int dt_size_send = 1;
1112     if(!known)
1113       dt_size_send = smpi_datatype_size(datatype);
1114     extra->send_size = count*dt_size_send;
1115     TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
1116     TRACE_smpi_send(rank, rank, dst_traced, count*smpi_datatype_size(datatype));
1117
1118     *request = smpi_mpi_issend(buf, count, datatype, dst, tag, comm);
1119     retval = MPI_SUCCESS;
1120
1121     TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1122     (*request)->send = 1;
1123   }
1124
1125   smpi_bench_begin();
1126   if (retval != MPI_SUCCESS && request)
1127     *request = MPI_REQUEST_NULL;
1128   return retval;
1129 }
1130
1131 int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag,
1132              MPI_Comm comm, MPI_Status * status)
1133 {
1134   int retval = 0;
1135
1136   smpi_bench_end();
1137   if (comm == MPI_COMM_NULL) {
1138     retval = MPI_ERR_COMM;
1139   } else if (src == MPI_PROC_NULL) {
1140     smpi_empty_status(status);
1141     status->MPI_SOURCE = MPI_PROC_NULL;
1142     retval = MPI_SUCCESS;
1143   } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){
1144     retval = MPI_ERR_RANK;
1145   } else if (count < 0) {
1146     retval = MPI_ERR_COUNT;
1147   } else if (buf==NULL && count > 0) {
1148     retval = MPI_ERR_COUNT;
1149   } else if (!is_datatype_valid(datatype)) {
1150       retval = MPI_ERR_TYPE;
1151   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1152     retval = MPI_ERR_TAG;
1153   } else {
1154   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1155   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1156   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1157   extra->type = TRACING_RECV;
1158   extra->src = src_traced;
1159   extra->dst = rank;
1160   int known=0;
1161   extra->datatype1 = encode_datatype(datatype, &known);
1162   int dt_size_send = 1;
1163   if(!known)
1164     dt_size_send = smpi_datatype_size(datatype);
1165   extra->send_size = count*dt_size_send;
1166   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
1167
1168     smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
1169     retval = MPI_SUCCESS;
1170
1171   //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1172   if(status!=MPI_STATUS_IGNORE){
1173     src_traced = smpi_group_index(smpi_comm_group(comm), status->MPI_SOURCE);
1174     if (!TRACE_smpi_view_internals()) {
1175       TRACE_smpi_recv(rank, src_traced, rank);
1176     }
1177   }
1178   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
1179   }
1180
1181   smpi_bench_begin();
1182   return retval;
1183 }
1184
1185 int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag,
1186              MPI_Comm comm)
1187 {
1188   int retval = 0;
1189
1190   smpi_bench_end();
1191
1192   if (comm == MPI_COMM_NULL) {
1193     retval = MPI_ERR_COMM;
1194   } else if (dst == MPI_PROC_NULL) {
1195     retval = MPI_SUCCESS;
1196   } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1197     retval = MPI_ERR_RANK;
1198   } else if (count < 0) {
1199     retval = MPI_ERR_COUNT;
1200   } else if (buf==NULL && count > 0) {
1201     retval = MPI_ERR_COUNT;
1202   } else if (!is_datatype_valid(datatype)) {
1203       retval = MPI_ERR_TYPE;
1204   } else if(tag<0 && tag !=  MPI_ANY_TAG){
1205     retval = MPI_ERR_TAG;
1206   } else {
1207
1208   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1209   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1210   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1211   extra->type = TRACING_SEND;
1212   extra->src = rank;
1213   extra->dst = dst_traced;
1214   int known=0;
1215   extra->datatype1 = encode_datatype(datatype, &known);
1216   int dt_size_send = 1;
1217   if(!known)
1218     dt_size_send = smpi_datatype_size(datatype);
1219   extra->send_size = count*dt_size_send;
1220   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
1221   if (!TRACE_smpi_view_internals()) {
1222     TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));
1223   }
1224
1225     smpi_mpi_send(buf, count, datatype, dst, tag, comm);
1226     retval = MPI_SUCCESS;
1227
1228   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1229   }
1230
1231   smpi_bench_begin();
1232   return retval;
1233 }
1234
1235
1236
1237 int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
1238   int retval = 0;
1239
1240    smpi_bench_end();
1241
1242    if (comm == MPI_COMM_NULL) {
1243      retval = MPI_ERR_COMM;
1244    } else if (dst == MPI_PROC_NULL) {
1245      retval = MPI_SUCCESS;
1246    } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){
1247      retval = MPI_ERR_RANK;
1248    } else if (count < 0) {
1249      retval = MPI_ERR_COUNT;
1250    } else if (buf==NULL && count > 0) {
1251      retval = MPI_ERR_COUNT;
1252    } else if (!is_datatype_valid(datatype)){
1253      retval = MPI_ERR_TYPE;
1254    } else if(tag<0 && tag !=  MPI_ANY_TAG){
1255      retval = MPI_ERR_TAG;
1256    } else {
1257
1258    int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1259    int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1260    instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1261    extra->type = TRACING_SSEND;
1262    extra->src = rank;
1263    extra->dst = dst_traced;
1264    int known=0;
1265    extra->datatype1 = encode_datatype(datatype, &known);
1266    int dt_size_send = 1;
1267    if(!known)
1268      dt_size_send = smpi_datatype_size(datatype);
1269    extra->send_size = count*dt_size_send;
1270    TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);   TRACE_smpi_send(rank, rank, dst_traced,count*smpi_datatype_size(datatype));
1271
1272      smpi_mpi_ssend(buf, count, datatype, dst, tag, comm);
1273      retval = MPI_SUCCESS;
1274
1275    TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
1276    }
1277
1278    smpi_bench_begin();
1279    return retval;}
1280
1281
1282 int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1283                  int dst, int sendtag, void *recvbuf, int recvcount,
1284                  MPI_Datatype recvtype, int src, int recvtag,
1285                  MPI_Comm comm, MPI_Status * status)
1286 {
1287   int retval = 0;
1288
1289   smpi_bench_end();
1290
1291   if (comm == MPI_COMM_NULL) {
1292     retval = MPI_ERR_COMM;
1293   } else if (!is_datatype_valid(sendtype)
1294              || !is_datatype_valid(recvtype)) {
1295     retval = MPI_ERR_TYPE;
1296   } else if (src == MPI_PROC_NULL || dst == MPI_PROC_NULL) {
1297       smpi_empty_status(status);
1298       status->MPI_SOURCE = MPI_PROC_NULL;
1299       retval = MPI_SUCCESS;
1300   }else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0 ||
1301       (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0))){
1302     retval = MPI_ERR_RANK;
1303   } else if (sendcount < 0 || recvcount<0) {
1304       retval = MPI_ERR_COUNT;
1305   } else if ((sendbuf==NULL && sendcount > 0)||(recvbuf==NULL && recvcount>0)) {
1306     retval = MPI_ERR_COUNT;
1307   } else if((sendtag<0 && sendtag !=  MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){
1308     retval = MPI_ERR_TAG;
1309   } else {
1310
1311   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1312   int dst_traced = smpi_group_index(smpi_comm_group(comm), dst);
1313   int src_traced = smpi_group_index(smpi_comm_group(comm), src);
1314   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1315   extra->type = TRACING_SENDRECV;
1316   extra->src = src_traced;
1317   extra->dst = dst_traced;
1318   int known=0;
1319   extra->datatype1 = encode_datatype(sendtype, &known);
1320   int dt_size_send = 1;
1321   if(!known)
1322     dt_size_send = smpi_datatype_size(sendtype);
1323   extra->send_size = sendcount*dt_size_send;
1324   extra->datatype2 = encode_datatype(recvtype, &known);
1325   int dt_size_recv = 1;
1326   if(!known)
1327     dt_size_recv = smpi_datatype_size(recvtype);
1328   extra->recv_size = recvcount*dt_size_recv;
1329
1330   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
1331   TRACE_smpi_send(rank, rank, dst_traced,sendcount*smpi_datatype_size(sendtype));
1332
1333     smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf,
1334                       recvcount, recvtype, src, recvtag, comm, status);
1335     retval = MPI_SUCCESS;
1336
1337   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1338   TRACE_smpi_recv(rank, src_traced, rank);
1339   }
1340
1341   smpi_bench_begin();
1342   return retval;
1343 }
1344
1345 int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype,
1346                          int dst, int sendtag, int src, int recvtag,
1347                          MPI_Comm comm, MPI_Status * status)
1348 {
1349   //TODO: suboptimal implementation
1350   void *recvbuf;
1351   int retval = 0;
1352   if (!is_datatype_valid(datatype)) {
1353       retval = MPI_ERR_TYPE;
1354   } else if (count < 0) {
1355       retval = MPI_ERR_COUNT;
1356   } else {
1357     int size = smpi_datatype_get_extent(datatype) * count;
1358     recvbuf = xbt_new0(char, size);
1359     retval =
1360         MPI_Sendrecv(buf, count, datatype, dst, sendtag, recvbuf, count,
1361                      datatype, src, recvtag, comm, status);
1362     if(retval==MPI_SUCCESS){
1363         smpi_datatype_copy(recvbuf, count, datatype, buf, count, datatype);
1364     }
1365     xbt_free(recvbuf);
1366
1367   }
1368   return retval;
1369 }
1370
1371 int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
1372 {
1373   int retval = 0;
1374   smpi_bench_end();
1375   if (request == NULL || flag == NULL) {
1376     retval = MPI_ERR_ARG;
1377   } else if (*request == MPI_REQUEST_NULL) {
1378     *flag= TRUE;
1379     smpi_empty_status(status);
1380     retval = MPI_SUCCESS;
1381   } else {
1382     int rank = request && (*request)->comm != MPI_COMM_NULL
1383       ? smpi_process_index()
1384       : -1;
1385
1386     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1387     extra->type = TRACING_TEST;
1388     TRACE_smpi_testing_in(rank, extra);
1389
1390     *flag = smpi_mpi_test(request, status);
1391
1392     TRACE_smpi_testing_out(rank);
1393     retval = MPI_SUCCESS;
1394   }
1395   smpi_bench_begin();
1396   return retval;
1397 }
1398
1399 int PMPI_Testany(int count, MPI_Request requests[], int *index, int *flag,
1400                 MPI_Status * status)
1401 {
1402   int retval = 0;
1403
1404   smpi_bench_end();
1405   if (index == NULL || flag == NULL) {
1406     retval = MPI_ERR_ARG;
1407   } else {
1408     *flag = smpi_mpi_testany(count, requests, index, status);
1409     retval = MPI_SUCCESS;
1410   }
1411   smpi_bench_begin();
1412   return retval;
1413 }
1414
1415 int PMPI_Testall(int count, MPI_Request* requests, int* flag, MPI_Status* statuses)
1416 {
1417   int retval = 0;
1418
1419   smpi_bench_end();
1420   if (flag == NULL) {
1421     retval = MPI_ERR_ARG;
1422   } else {
1423     *flag = smpi_mpi_testall(count, requests, statuses);
1424     retval = MPI_SUCCESS;
1425   }
1426   smpi_bench_begin();
1427   return retval;
1428 }
1429
1430 int PMPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status) {
1431   int retval = 0;
1432   smpi_bench_end();
1433
1434   if (status == NULL) {
1435     retval = MPI_ERR_ARG;
1436   } else if (comm == MPI_COMM_NULL) {
1437     retval = MPI_ERR_COMM;
1438   } else if (source == MPI_PROC_NULL) {
1439     smpi_empty_status(status);
1440     status->MPI_SOURCE = MPI_PROC_NULL;
1441     retval = MPI_SUCCESS;
1442   } else {
1443     smpi_mpi_probe(source, tag, comm, status);
1444     retval = MPI_SUCCESS;
1445   }
1446   smpi_bench_begin();
1447   return retval;
1448 }
1449
1450
1451 int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status) {
1452   int retval = 0;
1453   smpi_bench_end();
1454
1455   if (flag == NULL) {
1456     retval = MPI_ERR_ARG;
1457   } else if (status == NULL) {
1458     retval = MPI_ERR_ARG;
1459   } else if (comm == MPI_COMM_NULL) {
1460     retval = MPI_ERR_COMM;
1461   } else if (source == MPI_PROC_NULL) {
1462     *flag=TRUE;
1463     smpi_empty_status(status);
1464     status->MPI_SOURCE = MPI_PROC_NULL;
1465     retval = MPI_SUCCESS;
1466   } else {
1467     smpi_mpi_iprobe(source, tag, comm, flag, status);
1468     retval = MPI_SUCCESS;
1469   }
1470   smpi_bench_begin();
1471   return retval;
1472 }
1473
1474 int PMPI_Wait(MPI_Request * request, MPI_Status * status)
1475 {
1476   int retval = 0;
1477
1478   smpi_bench_end();
1479
1480   smpi_empty_status(status);
1481
1482   if (request == NULL) {
1483     retval = MPI_ERR_ARG;
1484   } else if (*request == MPI_REQUEST_NULL) {
1485     retval = MPI_SUCCESS;
1486   } else {
1487
1488     int rank = request && (*request)->comm != MPI_COMM_NULL
1489       ? smpi_process_index()
1490       : -1;
1491
1492     int src_traced = (*request)->src;
1493     int dst_traced = (*request)->dst;
1494     MPI_Comm comm = (*request)->comm;
1495     int is_wait_for_receive = (*request)->recv;
1496     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1497     extra->type = TRACING_WAIT;
1498     TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
1499
1500     smpi_mpi_wait(request, status);
1501     retval = MPI_SUCCESS;
1502
1503     //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1504     TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
1505     if (is_wait_for_receive) {
1506       if(src_traced==MPI_ANY_SOURCE)
1507         src_traced = (status!=MPI_STATUS_IGNORE) ?
1508           smpi_group_rank(smpi_comm_group(comm), status->MPI_SOURCE) :
1509           src_traced;
1510       TRACE_smpi_recv(rank, src_traced, dst_traced);
1511     }
1512   }
1513
1514   smpi_bench_begin();
1515   return retval;
1516 }
1517
1518 int PMPI_Waitany(int count, MPI_Request requests[], int *index, MPI_Status * status)
1519 {
1520   if (index == NULL)
1521     return MPI_ERR_ARG;
1522
1523   smpi_bench_end();
1524   //save requests information for tracing
1525   int i;
1526   int *srcs = xbt_new0(int, count);
1527   int *dsts = xbt_new0(int, count);
1528   int *recvs = xbt_new0(int, count);
1529   MPI_Comm *comms = xbt_new0(MPI_Comm, count);
1530
1531   for (i = 0; i < count; i++) {
1532     MPI_Request req = requests[i];      //already received requests are no longer valid
1533     if (req) {
1534       srcs[i] = req->src;
1535       dsts[i] = req->dst;
1536       recvs[i] = req->recv;
1537       comms[i] = req->comm;
1538     }
1539   }
1540   int rank_traced = smpi_process_index();
1541   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1542   extra->type = TRACING_WAITANY;
1543   extra->send_size=count;
1544   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
1545
1546   *index = smpi_mpi_waitany(count, requests, status);
1547
1548   if(*index!=MPI_UNDEFINED){
1549     int src_traced = srcs[*index];
1550     //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1551     int dst_traced = dsts[*index];
1552     int is_wait_for_receive = recvs[*index];
1553     if (is_wait_for_receive) {
1554       if(srcs[*index]==MPI_ANY_SOURCE)
1555         src_traced = (status!=MPI_STATUSES_IGNORE) ?
1556                       smpi_group_rank(smpi_comm_group(comms[*index]), status->MPI_SOURCE) :
1557                       srcs[*index];
1558       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1559     }
1560     TRACE_smpi_ptp_out(rank_traced, src_traced, dst_traced, __FUNCTION__);
1561     xbt_free(srcs);
1562     xbt_free(dsts);
1563     xbt_free(recvs);
1564     xbt_free(comms);
1565
1566   }
1567   smpi_bench_begin();
1568   return MPI_SUCCESS;
1569 }
1570
1571 int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[])
1572 {
1573
1574   smpi_bench_end();
1575   //save information from requests
1576   int i;
1577   int *srcs = xbt_new0(int, count);
1578   int *dsts = xbt_new0(int, count);
1579   int *recvs = xbt_new0(int, count);
1580   int *valid = xbt_new0(int, count);
1581   MPI_Comm *comms = xbt_new0(MPI_Comm, count);
1582
1583   //int valid_count = 0;
1584   for (i = 0; i < count; i++) {
1585     MPI_Request req = requests[i];
1586     if(req!=MPI_REQUEST_NULL){
1587       srcs[i] = req->src;
1588       dsts[i] = req->dst;
1589       recvs[i] = req->recv;
1590       comms[i] = req->comm;
1591       valid[i]=1;;
1592     }else{
1593       valid[i]=0;
1594     }
1595   }
1596   int rank_traced = smpi_process_index();
1597   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1598   extra->type = TRACING_WAITALL;
1599   extra->send_size=count;
1600   TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
1601
1602   int retval = smpi_mpi_waitall(count, requests, status);
1603
1604   for (i = 0; i < count; i++) {
1605     if(valid[i]){
1606     //int src_traced = srcs[*index];
1607     //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE)
1608       int src_traced = srcs[i];
1609       int dst_traced = dsts[i];
1610       int is_wait_for_receive = recvs[i];
1611       if (is_wait_for_receive) {
1612         if(src_traced==MPI_ANY_SOURCE)
1613         src_traced = (status!=MPI_STATUSES_IGNORE) ?
1614                           smpi_group_rank(smpi_comm_group(comms[i]), status[i].MPI_SOURCE) :
1615                           srcs[i];
1616         TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
1617       }
1618     }
1619   }
1620   TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
1621   xbt_free(srcs);
1622   xbt_free(dsts);
1623   xbt_free(recvs);
1624   xbt_free(valid);
1625   xbt_free(comms);
1626
1627   smpi_bench_begin();
1628   return retval;
1629 }
1630
1631 int PMPI_Waitsome(int incount, MPI_Request requests[], int *outcount,
1632                  int *indices, MPI_Status status[])
1633 {
1634   int retval = 0;
1635
1636   smpi_bench_end();
1637   if (outcount == NULL) {
1638     retval = MPI_ERR_ARG;
1639   } else {
1640     *outcount = smpi_mpi_waitsome(incount, requests, indices, status);
1641     retval = MPI_SUCCESS;
1642   }
1643   smpi_bench_begin();
1644   return retval;
1645 }
1646
1647 int PMPI_Testsome(int incount, MPI_Request requests[], int* outcount,
1648                  int* indices, MPI_Status status[])
1649 {
1650   int retval = 0;
1651
1652    smpi_bench_end();
1653    if (outcount == NULL) {
1654      retval = MPI_ERR_ARG;
1655    } else {
1656      *outcount = smpi_mpi_testsome(incount, requests, indices, status);
1657      retval = MPI_SUCCESS;
1658    }
1659    smpi_bench_begin();
1660    return retval;
1661 }
1662
1663
1664 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
1665 {
1666   int retval = 0;
1667
1668   smpi_bench_end();
1669
1670   if (comm == MPI_COMM_NULL) {
1671     retval = MPI_ERR_COMM;
1672   } else if (!is_datatype_valid(datatype)) {
1673       retval = MPI_ERR_ARG;
1674   } else {
1675   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1676   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1677
1678   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1679   extra->type = TRACING_BCAST;
1680   extra->root = root_traced;
1681   int known=0;
1682   extra->datatype1 = encode_datatype(datatype, &known);
1683   int dt_size_send = 1;
1684   if(!known)
1685     dt_size_send = smpi_datatype_size(datatype);
1686   extra->send_size = count*dt_size_send;
1687   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
1688
1689     mpi_coll_bcast_fun(buf, count, datatype, root, comm);
1690     retval = MPI_SUCCESS;
1691
1692     TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1693   }
1694
1695   smpi_bench_begin();
1696   return retval;
1697 }
1698
1699 int PMPI_Barrier(MPI_Comm comm)
1700 {
1701   int retval = 0;
1702
1703   smpi_bench_end();
1704
1705   if (comm == MPI_COMM_NULL) {
1706     retval = MPI_ERR_COMM;
1707   } else {
1708   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1709   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1710   extra->type = TRACING_BARRIER;
1711   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
1712
1713   mpi_coll_barrier_fun(comm);
1714   retval = MPI_SUCCESS;
1715
1716   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1717   }
1718
1719   smpi_bench_begin();
1720   return retval;
1721 }
1722
1723 int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1724                void *recvbuf, int recvcount, MPI_Datatype recvtype,
1725                int root, MPI_Comm comm)
1726 {
1727   int retval = 0;
1728
1729   smpi_bench_end();
1730
1731   if (comm == MPI_COMM_NULL) {
1732     retval = MPI_ERR_COMM;
1733   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1734             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1735     retval = MPI_ERR_TYPE;
1736   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1737             ((smpi_comm_rank(comm) == root) && (recvcount <0))){
1738     retval = MPI_ERR_COUNT;
1739   } else {
1740
1741     char* sendtmpbuf = (char*) sendbuf;
1742     int sendtmpcount = sendcount;
1743     MPI_Datatype sendtmptype = sendtype;
1744     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1745       sendtmpcount=0;
1746       sendtmptype=recvtype;
1747     }
1748   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1749   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1750   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1751   extra->type = TRACING_GATHER;
1752   extra->root = root_traced;
1753   int known=0;
1754   extra->datatype1 = encode_datatype(sendtmptype, &known);
1755   int dt_size_send = 1;
1756   if(!known)
1757     dt_size_send = smpi_datatype_size(sendtmptype);
1758   extra->send_size = sendtmpcount*dt_size_send;
1759   extra->datatype2 = encode_datatype(recvtype, &known);
1760   int dt_size_recv = 1;
1761   if((smpi_comm_rank(comm)==root) && !known)
1762     dt_size_recv = smpi_datatype_size(recvtype);
1763   extra->recv_size = recvcount*dt_size_recv;
1764
1765   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
1766
1767   mpi_coll_gather_fun(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount,
1768                     recvtype, root, comm);
1769
1770
1771     retval = MPI_SUCCESS;
1772   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1773   }
1774
1775   smpi_bench_begin();
1776   return retval;
1777 }
1778
1779 int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1780                 void *recvbuf, int *recvcounts, int *displs,
1781                 MPI_Datatype recvtype, int root, MPI_Comm comm)
1782 {
1783   int retval = 0;
1784
1785   smpi_bench_end();
1786
1787   if (comm == MPI_COMM_NULL) {
1788     retval = MPI_ERR_COMM;
1789   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1790             ((smpi_comm_rank(comm) == root) && (recvtype == MPI_DATATYPE_NULL))){
1791     retval = MPI_ERR_TYPE;
1792   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1793     retval = MPI_ERR_COUNT;
1794   } else if (recvcounts == NULL || displs == NULL) {
1795     retval = MPI_ERR_ARG;
1796   } else {
1797     char* sendtmpbuf = (char*) sendbuf;
1798     int sendtmpcount = sendcount;
1799     MPI_Datatype sendtmptype = sendtype;
1800     if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) {
1801       sendtmpcount=0;
1802       sendtmptype=recvtype;
1803     }
1804
1805   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1806   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1807   int i=0;
1808   int size = smpi_comm_size(comm);
1809   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1810   extra->type = TRACING_GATHERV;
1811   extra->num_processes = size;
1812   extra->root = root_traced;
1813   int known=0;
1814   extra->datatype1 = encode_datatype(sendtmptype, &known);
1815   int dt_size_send = 1;
1816   if(!known)
1817     dt_size_send = smpi_datatype_size(sendtype);
1818   extra->send_size = sendtmpcount*dt_size_send;
1819   extra->datatype2 = encode_datatype(recvtype, &known);
1820   int dt_size_recv = 1;
1821   if(!known)
1822     dt_size_recv = smpi_datatype_size(recvtype);
1823   extra->recvcounts= xbt_malloc(size*sizeof(int));
1824   for(i=0; i< size; i++)//copy data to avoid bad free
1825     extra->recvcounts[i] = recvcounts[i]*dt_size_recv;
1826
1827   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
1828
1829   smpi_mpi_gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts,
1830                      displs, recvtype, root, comm);
1831     retval = MPI_SUCCESS;
1832   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1833   }
1834
1835   smpi_bench_begin();
1836   return retval;
1837 }
1838
1839 int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1840                   void *recvbuf, int recvcount, MPI_Datatype recvtype,
1841                   MPI_Comm comm)
1842 {
1843   int retval = 0;
1844
1845   smpi_bench_end();
1846
1847   if (comm == MPI_COMM_NULL) {
1848     retval = MPI_ERR_COMM;
1849   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1850             (recvtype == MPI_DATATYPE_NULL)){
1851     retval = MPI_ERR_TYPE;
1852   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
1853             (recvcount <0)){
1854     retval = MPI_ERR_COUNT;
1855   } else {
1856     if(sendbuf == MPI_IN_PLACE) {
1857       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm);
1858       sendcount=recvcount;
1859       sendtype=recvtype;
1860     }
1861   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1862   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1863   extra->type = TRACING_ALLGATHER;
1864   int known=0;
1865   extra->datatype1 = encode_datatype(sendtype, &known);
1866   int dt_size_send = 1;
1867   if(!known)
1868     dt_size_send = smpi_datatype_size(sendtype);
1869   extra->send_size = sendcount*dt_size_send;
1870   extra->datatype2 = encode_datatype(recvtype, &known);
1871   int dt_size_recv = 1;
1872   if(!known)
1873     dt_size_recv = smpi_datatype_size(recvtype);
1874   extra->recv_size = recvcount*dt_size_recv;
1875
1876   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
1877
1878   mpi_coll_allgather_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1879                            recvtype, comm);
1880     retval = MPI_SUCCESS;
1881   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1882   }
1883   smpi_bench_begin();
1884   return retval;
1885 }
1886
1887 int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1888                    void *recvbuf, int *recvcounts, int *displs,
1889                    MPI_Datatype recvtype, MPI_Comm comm)
1890 {
1891   int retval = 0;
1892
1893   smpi_bench_end();
1894
1895   if (comm == MPI_COMM_NULL) {
1896     retval = MPI_ERR_COMM;
1897   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
1898             (recvtype == MPI_DATATYPE_NULL)){
1899     retval = MPI_ERR_TYPE;
1900   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
1901     retval = MPI_ERR_COUNT;
1902   } else if (recvcounts == NULL || displs == NULL) {
1903     retval = MPI_ERR_ARG;
1904   } else {
1905
1906     if(sendbuf == MPI_IN_PLACE) {
1907       sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*displs[smpi_comm_rank(comm)];
1908       sendcount=recvcounts[smpi_comm_rank(comm)];
1909       sendtype=recvtype;
1910     }
1911   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1912   int i=0;
1913   int size = smpi_comm_size(comm);
1914   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1915   extra->type = TRACING_ALLGATHERV;
1916   extra->num_processes = size;
1917   int known=0;
1918   extra->datatype1 = encode_datatype(sendtype, &known);
1919   int dt_size_send = 1;
1920   if(!known)
1921     dt_size_send = smpi_datatype_size(sendtype);
1922   extra->send_size = sendcount*dt_size_send;
1923   extra->datatype2 = encode_datatype(recvtype, &known);
1924   int dt_size_recv = 1;
1925   if(!known)
1926     dt_size_recv = smpi_datatype_size(recvtype);
1927   extra->recvcounts= xbt_malloc(size*sizeof(int));
1928   for(i=0; i< size; i++)//copy data to avoid bad free
1929     extra->recvcounts[i] = recvcounts[i]*dt_size_recv;
1930
1931   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
1932
1933     mpi_coll_allgatherv_fun(sendbuf, sendcount, sendtype, recvbuf, recvcounts,
1934                         displs, recvtype, comm);
1935     retval = MPI_SUCCESS;
1936   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1937   }
1938
1939   smpi_bench_begin();
1940   return retval;
1941 }
1942
1943 int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
1944                 void *recvbuf, int recvcount, MPI_Datatype recvtype,
1945                 int root, MPI_Comm comm)
1946 {
1947   int retval = 0;
1948
1949   smpi_bench_end();
1950
1951   if (comm == MPI_COMM_NULL) {
1952     retval = MPI_ERR_COMM;
1953   } else if (((smpi_comm_rank(comm)==root) && (!is_datatype_valid(sendtype)))
1954              || ((recvbuf !=MPI_IN_PLACE) && (!is_datatype_valid(recvtype)))){
1955     retval = MPI_ERR_TYPE;
1956   } else if ((sendbuf == recvbuf) ||
1957       ((smpi_comm_rank(comm)==root) && sendcount>0 && (sendbuf == NULL))){
1958     retval = MPI_ERR_BUFFER;
1959   }else {
1960
1961     if (recvbuf == MPI_IN_PLACE) {
1962         recvtype=sendtype;
1963         recvcount=sendcount;
1964     }
1965   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
1966   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
1967   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1968   extra->type = TRACING_SCATTER;
1969   extra->root = root_traced;
1970   int known=0;
1971   extra->datatype1 = encode_datatype(sendtype, &known);
1972   int dt_size_send = 1;
1973   if((smpi_comm_rank(comm)==root) && !known)
1974     dt_size_send = smpi_datatype_size(sendtype);
1975   extra->send_size = sendcount*dt_size_send;
1976   extra->datatype2 = encode_datatype(recvtype, &known);
1977   int dt_size_recv = 1;
1978   if(!known)
1979     dt_size_recv = smpi_datatype_size(recvtype);
1980   extra->recv_size = recvcount*dt_size_recv;
1981   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
1982
1983   mpi_coll_scatter_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount,
1984                      recvtype, root, comm);
1985     retval = MPI_SUCCESS;
1986   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
1987   }
1988
1989   smpi_bench_begin();
1990   return retval;
1991 }
1992
1993 int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
1994                  MPI_Datatype sendtype, void *recvbuf, int recvcount,
1995                  MPI_Datatype recvtype, int root, MPI_Comm comm)
1996 {
1997   int retval = 0;
1998
1999   smpi_bench_end();
2000
2001   if (comm == MPI_COMM_NULL) {
2002     retval = MPI_ERR_COMM;
2003   } else if (sendcounts == NULL || displs == NULL) {
2004     retval = MPI_ERR_ARG;
2005   } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL))
2006              || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
2007     retval = MPI_ERR_TYPE;
2008   } else {
2009     if (recvbuf == MPI_IN_PLACE) {
2010         recvtype=sendtype;
2011         recvcount=sendcounts[smpi_comm_rank(comm)];
2012     }
2013   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2014   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
2015   int i=0;
2016   int size = smpi_comm_size(comm);
2017   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2018   extra->type = TRACING_SCATTERV;
2019   extra->num_processes = size;
2020   extra->root = root_traced;
2021   int known=0;
2022   extra->datatype1 = encode_datatype(sendtype, &known);
2023   int dt_size_send = 1;
2024   if(!known)
2025     dt_size_send = smpi_datatype_size(sendtype);
2026   extra->sendcounts= xbt_malloc(size*sizeof(int));
2027   for(i=0; i< size; i++)//copy data to avoid bad free
2028     extra->sendcounts[i] = sendcounts[i]*dt_size_send;
2029   extra->datatype2 = encode_datatype(recvtype, &known);
2030   int dt_size_recv = 1;
2031   if(!known)
2032     dt_size_recv = smpi_datatype_size(recvtype);
2033   extra->recv_size = recvcount*dt_size_recv;
2034   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
2035
2036     smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf,
2037                       recvcount, recvtype, root, comm);
2038
2039     retval = MPI_SUCCESS;
2040   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
2041   }
2042
2043   smpi_bench_begin();
2044   return retval;
2045 }
2046
2047 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count,
2048                MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
2049 {
2050   int retval = 0;
2051
2052   smpi_bench_end();
2053
2054   if (comm == MPI_COMM_NULL) {
2055     retval = MPI_ERR_COMM;
2056   } else if (!is_datatype_valid(datatype) || op == MPI_OP_NULL) {
2057     retval = MPI_ERR_ARG;
2058   } else {
2059   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2060   int root_traced = smpi_group_index(smpi_comm_group(comm), root);
2061   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2062   extra->type = TRACING_REDUCE;
2063   int known=0;
2064   extra->datatype1 = encode_datatype(datatype, &known);
2065   int dt_size_send = 1;
2066   if(!known)
2067     dt_size_send = smpi_datatype_size(datatype);
2068   extra->send_size = count*dt_size_send;
2069   extra->root = root_traced;
2070
2071   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
2072
2073   mpi_coll_reduce_fun(sendbuf, recvbuf, count, datatype, op, root, comm);
2074
2075     retval = MPI_SUCCESS;
2076   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
2077   }
2078
2079   smpi_bench_begin();
2080   return retval;
2081 }
2082
2083 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count,
2084     MPI_Datatype datatype, MPI_Op op){
2085   int retval = 0;
2086
2087     smpi_bench_end();
2088     if (!is_datatype_valid(datatype) || op == MPI_OP_NULL) {
2089       retval = MPI_ERR_ARG;
2090     } else {
2091       smpi_op_apply(op, inbuf, inoutbuf, &count, &datatype);
2092       retval=MPI_SUCCESS;
2093     }
2094     smpi_bench_begin();
2095     return retval;
2096 }
2097
2098 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count,
2099                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2100 {
2101   int retval = 0;
2102
2103   smpi_bench_end();
2104
2105   if (comm == MPI_COMM_NULL) {
2106     retval = MPI_ERR_COMM;
2107   } else if (!is_datatype_valid(datatype)) {
2108     retval = MPI_ERR_TYPE;
2109   } else if (op == MPI_OP_NULL) {
2110     retval = MPI_ERR_OP;
2111   } else {
2112
2113     char* sendtmpbuf = (char*) sendbuf;
2114     if( sendbuf == MPI_IN_PLACE ) {
2115       sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype));
2116       smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
2117     }
2118   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2119   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2120   extra->type = TRACING_ALLREDUCE;
2121   int known=0;
2122   extra->datatype1 = encode_datatype(datatype, &known);
2123   int dt_size_send = 1;
2124   if(!known)
2125     dt_size_send = smpi_datatype_size(datatype);
2126   extra->send_size = count*dt_size_send;
2127
2128   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2129
2130   mpi_coll_allreduce_fun(sendtmpbuf, recvbuf, count, datatype, op, comm);
2131
2132     if( sendbuf == MPI_IN_PLACE )
2133       xbt_free(sendtmpbuf);
2134
2135     retval = MPI_SUCCESS;
2136   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2137   }
2138
2139   smpi_bench_begin();
2140   return retval;
2141 }
2142
2143 int PMPI_Scan(void *sendbuf, void *recvbuf, int count,
2144              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2145 {
2146   int retval = 0;
2147
2148   smpi_bench_end();
2149
2150   if (comm == MPI_COMM_NULL) {
2151     retval = MPI_ERR_COMM;
2152   } else if (!is_datatype_valid(datatype)) {
2153     retval = MPI_ERR_TYPE;
2154   } else if (op == MPI_OP_NULL) {
2155     retval = MPI_ERR_OP;
2156   } else {
2157   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2158   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2159   extra->type = TRACING_SCAN;
2160   int known=0;
2161   extra->datatype1 = encode_datatype(datatype, &known);
2162   int dt_size_send = 1;
2163   if(!known)
2164     dt_size_send = smpi_datatype_size(datatype);
2165   extra->send_size = count*dt_size_send;
2166
2167   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2168
2169   smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
2170
2171   retval = MPI_SUCCESS;
2172   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2173   }
2174
2175   smpi_bench_begin();
2176   return retval;
2177 }
2178
2179 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
2180                 MPI_Op op, MPI_Comm comm){
2181   int retval = 0;
2182
2183   smpi_bench_end();
2184
2185   if (comm == MPI_COMM_NULL) {
2186     retval = MPI_ERR_COMM;
2187   } else if (!is_datatype_valid(datatype)) {
2188     retval = MPI_ERR_TYPE;
2189   } else if (op == MPI_OP_NULL) {
2190     retval = MPI_ERR_OP;
2191   } else {
2192   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2193   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2194   extra->type = TRACING_EXSCAN;
2195   int known=0;
2196   extra->datatype1 = encode_datatype(datatype, &known);
2197   int dt_size_send = 1;
2198   if(!known)
2199     dt_size_send = smpi_datatype_size(datatype);
2200   extra->send_size = count*dt_size_send;
2201   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2202
2203   smpi_mpi_exscan(sendbuf, recvbuf, count, datatype, op, comm);
2204     retval = MPI_SUCCESS;
2205   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2206   }
2207
2208   smpi_bench_begin();
2209   return retval;
2210 }
2211
2212 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
2213                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2214 {
2215   int retval = 0;
2216   smpi_bench_end();
2217
2218   if (comm == MPI_COMM_NULL) {
2219     retval = MPI_ERR_COMM;
2220   } else if (!is_datatype_valid(datatype)) {
2221     retval = MPI_ERR_TYPE;
2222   } else if (op == MPI_OP_NULL) {
2223     retval = MPI_ERR_OP;
2224   } else if (recvcounts == NULL) {
2225     retval = MPI_ERR_ARG;
2226   } else {
2227   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2228   int i=0;
2229   int size = smpi_comm_size(comm);
2230   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2231   extra->type = TRACING_REDUCE_SCATTER;
2232   extra->num_processes = size;
2233   int known=0;
2234   extra->datatype1 = encode_datatype(datatype, &known);
2235   int dt_size_send = 1;
2236   if(!known)
2237     dt_size_send = smpi_datatype_size(datatype);
2238   extra->send_size = 0;
2239   extra->recvcounts= xbt_malloc(size*sizeof(int));
2240   for(i=0; i< size; i++)//copy data to avoid bad free
2241     extra->recvcounts[i] = recvcounts[i]*dt_size_send;
2242   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2243
2244   void* sendtmpbuf=sendbuf;
2245     if(sendbuf==MPI_IN_PLACE)
2246       sendtmpbuf=recvbuf;
2247
2248     mpi_coll_reduce_scatter_fun(sendtmpbuf, recvbuf, recvcounts,
2249                        datatype,  op, comm);
2250     retval = MPI_SUCCESS;
2251   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2252   }
2253
2254   smpi_bench_begin();
2255   return retval;
2256 }
2257
2258 int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
2259                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
2260 {
2261   int retval,i;
2262   smpi_bench_end();
2263
2264   if (comm == MPI_COMM_NULL) {
2265     retval = MPI_ERR_COMM;
2266   } else if (!is_datatype_valid(datatype)) {
2267     retval = MPI_ERR_TYPE;
2268   } else if (op == MPI_OP_NULL) {
2269     retval = MPI_ERR_OP;
2270   } else if (recvcount < 0) {
2271     retval = MPI_ERR_ARG;
2272   } else {
2273     int count=smpi_comm_size(comm);
2274
2275   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2276   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2277   extra->type = TRACING_REDUCE_SCATTER;
2278   extra->num_processes = count;
2279   int known=0;
2280   extra->datatype1 = encode_datatype(datatype, &known);
2281   int dt_size_send = 1;
2282   if(!known)
2283     dt_size_send = smpi_datatype_size(datatype);
2284   extra->send_size = 0;
2285   extra->recvcounts= xbt_malloc(count*sizeof(int));
2286   for(i=0; i< count; i++)//copy data to avoid bad free
2287     extra->recvcounts[i] = recvcount*dt_size_send;
2288
2289   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2290
2291   int* recvcounts=(int*)xbt_malloc(count);
2292     for (i=0; i<count;i++)recvcounts[i]=recvcount;
2293     mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts,
2294                        datatype,  op, comm);
2295     xbt_free(recvcounts);
2296     retval = MPI_SUCCESS;
2297
2298     TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2299   }
2300
2301   smpi_bench_begin();
2302   return retval;
2303 }
2304
2305 int PMPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
2306                  void *recvbuf, int recvcount, MPI_Datatype recvtype,
2307                  MPI_Comm comm)
2308 {
2309   int retval = 0;
2310
2311   smpi_bench_end();
2312
2313   if (comm == MPI_COMM_NULL) {
2314     retval = MPI_ERR_COMM;
2315   } else if (sendtype == MPI_DATATYPE_NULL
2316              || recvtype == MPI_DATATYPE_NULL) {
2317     retval = MPI_ERR_TYPE;
2318   } else {
2319   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2320   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2321   extra->type = TRACING_ALLTOALL;
2322   int known=0;
2323   extra->datatype1 = encode_datatype(sendtype, &known);
2324   if(!known)
2325     extra->send_size = sendcount*smpi_datatype_size(sendtype);
2326   else
2327     extra->send_size = sendcount;
2328   extra->datatype2 = encode_datatype(recvtype, &known);
2329   if(!known)
2330     extra->recv_size = recvcount*smpi_datatype_size(recvtype);
2331   else
2332     extra->recv_size = recvcount;
2333   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2334
2335   retval = mpi_coll_alltoall_fun(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
2336
2337   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2338   }
2339
2340   smpi_bench_begin();
2341   return retval;
2342 }
2343
2344 int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,
2345                   MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
2346                   int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
2347 {
2348   int retval = 0;
2349
2350   smpi_bench_end();
2351
2352   if (comm == MPI_COMM_NULL) {
2353     retval = MPI_ERR_COMM;
2354   } else if (sendtype == MPI_DATATYPE_NULL
2355              || recvtype == MPI_DATATYPE_NULL) {
2356     retval = MPI_ERR_TYPE;
2357   } else if (sendcounts == NULL || senddisps == NULL || recvcounts == NULL
2358              || recvdisps == NULL) {
2359     retval = MPI_ERR_ARG;
2360   } else {
2361   int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1;
2362   int i=0;
2363   int size = smpi_comm_size(comm);
2364   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
2365   extra->type = TRACING_ALLTOALLV;
2366   extra->send_size = 0;
2367   extra->recv_size = 0;
2368   extra->recvcounts= xbt_malloc(size*sizeof(int));
2369   extra->sendcounts= xbt_malloc(size*sizeof(int));
2370   int known=0;
2371   extra->datatype1 = encode_datatype(sendtype, &known);
2372   int dt_size_send = 1;
2373   if(!known)
2374     dt_size_send = smpi_datatype_size(sendtype);
2375   int dt_size_recv = 1;
2376   extra->datatype2 = encode_datatype(recvtype, &known);
2377   if(!known)
2378     dt_size_recv = smpi_datatype_size(recvtype);
2379   for(i=0; i< size; i++){//copy data to avoid bad free
2380     extra->send_size += sendcounts[i]*dt_size_send;
2381     extra->recv_size += recvcounts[i]*dt_size_recv;
2382
2383     extra->sendcounts[i] = sendcounts[i]*dt_size_send;
2384     extra->recvcounts[i] = recvcounts[i]*dt_size_recv;
2385   }
2386   extra->num_processes = size;
2387   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
2388
2389   retval =
2390         mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, sendtype,
2391                                   recvbuf, recvcounts, recvdisps, recvtype,
2392                                   comm);
2393   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2394   }
2395
2396   smpi_bench_begin();
2397   return retval;
2398 }
2399
2400
2401 int PMPI_Get_processor_name(char *name, int *resultlen)
2402 {
2403   int retval = MPI_SUCCESS;
2404
2405   strncpy(name, SIMIX_host_get_name(SIMIX_host_self()),
2406           strlen(SIMIX_host_get_name(SIMIX_host_self())) < MPI_MAX_PROCESSOR_NAME - 1 ?
2407           strlen(SIMIX_host_get_name(SIMIX_host_self())) +1 :
2408           MPI_MAX_PROCESSOR_NAME - 1 );
2409   *resultlen =
2410       strlen(name) >
2411       MPI_MAX_PROCESSOR_NAME ? MPI_MAX_PROCESSOR_NAME : strlen(name);
2412
2413   return retval;
2414 }
2415
2416 int PMPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count)
2417 {
2418   int retval = MPI_SUCCESS;
2419   size_t size;
2420
2421   if (status == NULL || count == NULL) {
2422     retval = MPI_ERR_ARG;
2423   } else if (!is_datatype_valid(datatype)) {
2424     retval = MPI_ERR_TYPE;
2425   } else {
2426     size = smpi_datatype_size(datatype);
2427     if (size == 0) {
2428       *count = 0;
2429     } else if (status->count % size != 0) {
2430       retval = MPI_UNDEFINED;
2431     } else {
2432       *count = smpi_mpi_get_count(status, datatype);
2433     }
2434   }
2435   return retval;
2436 }
2437
2438 int PMPI_Type_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) {
2439   int retval = 0;
2440
2441   if (old_type == MPI_DATATYPE_NULL) {
2442     retval = MPI_ERR_TYPE;
2443   } else if (count<0){
2444     retval = MPI_ERR_COUNT;
2445   } else {
2446     retval = smpi_datatype_contiguous(count, old_type, new_type, 0);
2447   }
2448   return retval;
2449 }
2450
2451 int PMPI_Type_commit(MPI_Datatype* datatype) {
2452   int retval = 0;
2453
2454   if (datatype == NULL || *datatype == MPI_DATATYPE_NULL) {
2455     retval = MPI_ERR_TYPE;
2456   } else {
2457     smpi_datatype_commit(datatype);
2458     retval = MPI_SUCCESS;
2459   }
2460   return retval;
2461 }
2462
2463
2464 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2465   int retval = 0;
2466
2467   if (old_type == MPI_DATATYPE_NULL) {
2468     retval = MPI_ERR_TYPE;
2469   } else if (count<0 || blocklen<0){
2470     retval = MPI_ERR_COUNT;
2471   } else {
2472     retval = smpi_datatype_vector(count, blocklen, stride, old_type, new_type);
2473   }
2474   return retval;
2475 }
2476
2477 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2478   int retval = 0;
2479
2480   if (old_type == MPI_DATATYPE_NULL) {
2481     retval = MPI_ERR_TYPE;
2482   } else if (count<0 || blocklen<0){
2483     retval = MPI_ERR_COUNT;
2484   } else {
2485     retval = smpi_datatype_hvector(count, blocklen, stride, old_type, new_type);
2486   }
2487   return retval;
2488 }
2489
2490 int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
2491   return MPI_Type_hvector(count, blocklen, stride, old_type, new_type);
2492 }
2493
2494 int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2495   int retval = 0;
2496
2497   if (old_type == MPI_DATATYPE_NULL) {
2498     retval = MPI_ERR_TYPE;
2499   } else if (count<0){
2500     retval = MPI_ERR_COUNT;
2501   } else {
2502     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2503   }
2504   return retval;
2505 }
2506
2507 int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2508   int retval = 0;
2509
2510   if (old_type == MPI_DATATYPE_NULL) {
2511     retval = MPI_ERR_TYPE;
2512   } else if (count<0){
2513     retval = MPI_ERR_COUNT;
2514   } else {
2515     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2516   }
2517   return retval;
2518 }
2519
2520 int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2521   int retval,i;
2522
2523   if (old_type == MPI_DATATYPE_NULL) {
2524     retval = MPI_ERR_TYPE;
2525   } else if (count<0){
2526     retval = MPI_ERR_COUNT;
2527   } else {
2528     int* blocklens=(int*)xbt_malloc(blocklength*count);
2529     for (i=0; i<count;i++)blocklens[i]=blocklength;
2530     retval = smpi_datatype_indexed(count, blocklens, indices, old_type, new_type);
2531     xbt_free(blocklens);
2532   }
2533   return retval;
2534 }
2535
2536
2537 int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2538   int retval = 0;
2539
2540   if (old_type == MPI_DATATYPE_NULL) {
2541     retval = MPI_ERR_TYPE;
2542   } else if (count<0){
2543     retval = MPI_ERR_COUNT;
2544   } else {
2545     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2546   }
2547   return retval;
2548 }
2549
2550 int PMPI_Type_create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2551   return PMPI_Type_hindexed(count, blocklens,indices,old_type,new_type);
2552 }
2553
2554 int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
2555   int retval,i;
2556
2557   if (old_type == MPI_DATATYPE_NULL) {
2558     retval = MPI_ERR_TYPE;
2559   } else if (count<0){
2560     retval = MPI_ERR_COUNT;
2561   } else {
2562     int* blocklens=(int*)xbt_malloc(blocklength*count);
2563     for (i=0; i<count;i++)blocklens[i]=blocklength;
2564     retval = smpi_datatype_hindexed(count, blocklens, indices, old_type, new_type);
2565     xbt_free(blocklens);
2566   }
2567   return retval;
2568 }
2569
2570
2571 int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2572   int retval = 0;
2573
2574   if (count<0){
2575     retval = MPI_ERR_COUNT;
2576   } else {
2577     retval = smpi_datatype_struct(count, blocklens, indices, old_types, new_type);
2578   }
2579   return retval;
2580 }
2581
2582 int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
2583   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
2584 }
2585
2586
2587 int PMPI_Error_class(int errorcode, int* errorclass) {
2588   // assume smpi uses only standard mpi error codes
2589   *errorclass=errorcode;
2590   return MPI_SUCCESS;
2591 }
2592
2593
2594 int PMPI_Initialized(int* flag) {
2595    *flag=smpi_process_initialized();
2596    return MPI_SUCCESS;
2597 }
2598
2599 /* The topo part of MPI_COMM_WORLD should always be NULL. When other topologies
2600  * will be implemented, not only should we check if the topology is NULL, but
2601  * we should check if it is the good topology type (so we have to add a
2602  *  MPIR_Topo_Type field, and replace the MPI_Topology field by an union)*/
2603
2604 int PMPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periodic, int reorder, MPI_Comm* comm_cart) {
2605   int retval = 0;
2606   if (comm_old == MPI_COMM_NULL){
2607     retval =  MPI_ERR_COMM;
2608   } else if (ndims < 0 ||
2609            (ndims > 0 && (dims == NULL ||
2610                           periodic == NULL)) ||
2611            comm_cart == NULL) {
2612     retval = MPI_ERR_ARG;
2613   } else{
2614     retval = smpi_mpi_cart_create(comm_old, ndims, dims, periodic, reorder, comm_cart);
2615   }
2616   return retval;
2617 }
2618
2619 int PMPI_Cart_rank(MPI_Comm comm, int* coords, int* rank) {
2620   if(comm == MPI_COMM_NULL || smpi_comm_topo(comm) == NULL) {
2621     return MPI_ERR_TOPOLOGY;
2622   }
2623   if (coords == NULL) {
2624     return MPI_ERR_ARG;
2625   }
2626   return smpi_mpi_cart_rank(comm, coords, rank);
2627 }
2628
2629 int PMPI_Cart_shift(MPI_Comm comm, int direction, int displ, int* source, int* dest) {
2630   if(comm == MPI_COMM_NULL || smpi_comm_topo(comm) == NULL) {
2631     return MPI_ERR_TOPOLOGY;
2632   }
2633   if (source == NULL || dest == NULL || direction < 0 ) {
2634     return MPI_ERR_ARG;
2635   }
2636   return smpi_mpi_cart_shift(comm, direction, displ, source, dest);
2637 }
2638
2639 int PMPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int* coords) {
2640   if(comm == MPI_COMM_NULL || smpi_comm_topo(comm) == NULL) {
2641     return MPI_ERR_TOPOLOGY;
2642   }
2643   if (rank < 0 || rank >= smpi_comm_size(comm)) {
2644     return MPI_ERR_RANK;
2645   }
2646   if (maxdims <= 0) {
2647     return MPI_ERR_ARG;
2648   }
2649   if(coords == NULL) {
2650     return MPI_ERR_ARG;
2651   }
2652   return smpi_mpi_cart_coords(comm, rank, maxdims, coords);
2653 }
2654
2655 int PMPI_Cart_get(MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords) {
2656   if(comm == NULL || smpi_comm_topo(comm) == NULL) {
2657     return MPI_ERR_TOPOLOGY;
2658   }
2659   if(maxdims <= 0 || dims == NULL || periods == NULL || coords == NULL) {
2660     return MPI_ERR_ARG;
2661   }
2662   return smpi_mpi_cart_get(comm, maxdims, dims, periods, coords);
2663 }
2664
2665 int PMPI_Cartdim_get(MPI_Comm comm, int* ndims) {
2666   if (comm == MPI_COMM_NULL || smpi_comm_topo(comm) == NULL) {
2667     return MPI_ERR_TOPOLOGY;
2668   }
2669   if (ndims == NULL) {
2670     return MPI_ERR_ARG;
2671   }
2672   return smpi_mpi_cartdim_get(comm, ndims);
2673 }
2674
2675 int PMPI_Dims_create(int nnodes, int ndims, int* dims) {
2676   if(dims == NULL) {
2677     return MPI_ERR_ARG;
2678   }
2679   if (ndims < 1 || nnodes < 1) {
2680     return MPI_ERR_DIMS;
2681   }
2682
2683   return smpi_mpi_dims_create(nnodes, ndims, dims);
2684 }
2685
2686 int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) {
2687   if(comm == MPI_COMM_NULL || smpi_comm_topo(comm) == NULL) {
2688     return MPI_ERR_TOPOLOGY;
2689   }
2690   if (comm_new == NULL) {
2691     return MPI_ERR_ARG;
2692   }
2693   return smpi_mpi_cart_sub(comm, remain_dims, comm_new);
2694 }
2695
2696 int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
2697     if(oldtype == MPI_DATATYPE_NULL) {
2698         return MPI_ERR_TYPE;
2699     }
2700     int blocks[3] = { 1, 1, 1 };
2701     MPI_Aint disps[3] = { lb, 0, lb+extent };
2702     MPI_Datatype types[3] = { MPI_LB, oldtype, MPI_UB };
2703
2704     s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocks,
2705                                                                 disps,
2706                                                                 3,
2707                                                                 types
2708                                                                 );
2709     smpi_datatype_create(newtype,oldtype->size, lb, lb + extent, 1 , subtype, DT_FLAG_VECTOR);
2710
2711     (*newtype)->flags &= ~DT_FLAG_COMMITED;
2712     return MPI_SUCCESS;
2713 }
2714
2715
2716
2717 int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
2718   int retval = 0;
2719   smpi_bench_end();
2720   if (comm == MPI_COMM_NULL) {
2721     retval= MPI_ERR_COMM;
2722   }else if ((base == NULL && size != 0)
2723             || disp_unit <= 0 || size < 0 ){
2724     retval= MPI_ERR_OTHER;
2725   }else{
2726     *win = smpi_mpi_win_create( base, size, disp_unit, info, comm);
2727     retval = MPI_SUCCESS;
2728   }
2729   smpi_bench_begin();
2730   return retval;
2731 }
2732
2733 int PMPI_Win_free( MPI_Win* win){
2734   int retval = 0;
2735   smpi_bench_end();
2736   if (win == NULL || *win == MPI_WIN_NULL) {
2737     retval = MPI_ERR_WIN;
2738   }else{
2739     retval=smpi_mpi_win_free(win);
2740   }
2741   smpi_bench_begin();
2742   return retval;
2743 }
2744
2745 int PMPI_Win_set_name(MPI_Win  win, char * name)
2746 {
2747   int retval = 0;
2748   if (win == MPI_WIN_NULL)  {
2749     retval = MPI_ERR_TYPE;
2750   } else if (name == NULL)  {
2751     retval = MPI_ERR_ARG;
2752   } else {
2753     smpi_mpi_win_set_name(win, name);
2754     retval = MPI_SUCCESS;
2755   }
2756   return retval;
2757 }
2758
2759 int PMPI_Win_get_name(MPI_Win  win, char * name, int* len)
2760 {
2761   int retval = MPI_SUCCESS;
2762
2763   if (win == MPI_WIN_NULL)  {
2764     retval = MPI_ERR_WIN;
2765   } else if (name == NULL)  {
2766     retval = MPI_ERR_ARG;
2767   } else {
2768     smpi_mpi_win_get_name(win, name, len);
2769   }
2770   return retval;
2771 }
2772
2773 int PMPI_Win_get_group(MPI_Win  win, MPI_Group * group){
2774   int retval = MPI_SUCCESS;
2775   if (win == MPI_WIN_NULL)  {
2776     retval = MPI_ERR_WIN;
2777   }else {
2778     smpi_mpi_win_get_group(win, group);
2779   }
2780   return retval;
2781 }
2782
2783
2784 int PMPI_Win_fence( int assert,  MPI_Win win){
2785   int retval = 0;
2786   smpi_bench_end();
2787   if (win == MPI_WIN_NULL) {
2788     retval = MPI_ERR_WIN;
2789   } else {
2790   int rank = smpi_process_index();
2791   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL);
2792   retval = smpi_mpi_win_fence(assert, win);
2793   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2794
2795   }
2796   smpi_bench_begin();
2797   return retval;
2798 }
2799
2800 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
2801               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
2802   int retval = 0;
2803   smpi_bench_end();
2804   if (win == MPI_WIN_NULL) {
2805     retval = MPI_ERR_WIN;
2806   } else if (target_rank == MPI_PROC_NULL) {
2807     retval = MPI_SUCCESS;
2808   } else if (target_rank <0){
2809     retval = MPI_ERR_RANK;
2810   } else if (target_disp <0){
2811       retval = MPI_ERR_ARG;
2812   } else if (origin_count < 0 || target_count < 0) {
2813     retval = MPI_ERR_COUNT;
2814   } else if (origin_addr==NULL && origin_count > 0){
2815     retval = MPI_ERR_COUNT;
2816   } else if ((!is_datatype_valid(origin_datatype)) ||
2817             (!is_datatype_valid(target_datatype))) {
2818     retval = MPI_ERR_TYPE;
2819   } else {
2820     int rank = smpi_process_index();
2821     MPI_Group group;
2822     smpi_mpi_win_get_group(win, &group);
2823     int src_traced = smpi_group_index(group, target_rank);
2824     TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, NULL);
2825
2826     retval = smpi_mpi_get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win);
2827
2828     TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
2829   }
2830   smpi_bench_begin();
2831   return retval;
2832 }
2833
2834 int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
2835               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
2836   int retval = 0;
2837   smpi_bench_end();
2838   if (win == MPI_WIN_NULL) {
2839     retval = MPI_ERR_WIN;
2840   } else if (target_rank == MPI_PROC_NULL) {
2841     retval = MPI_SUCCESS;
2842   } else if (target_rank <0){
2843     retval = MPI_ERR_RANK;
2844   } else if (target_disp <0){
2845     retval = MPI_ERR_ARG;
2846   } else if (origin_count < 0 || target_count < 0) {
2847     retval = MPI_ERR_COUNT;
2848   } else if (origin_addr==NULL && origin_count > 0){
2849     retval = MPI_ERR_COUNT;
2850   } else if ((!is_datatype_valid(origin_datatype)) ||
2851             (!is_datatype_valid(target_datatype))) {
2852     retval = MPI_ERR_TYPE;
2853   } else {
2854     int rank = smpi_process_index();
2855     MPI_Group group;
2856     smpi_mpi_win_get_group(win, &group);
2857     int dst_traced = smpi_group_index(group, target_rank);
2858     TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, NULL);
2859     TRACE_smpi_send(rank, rank, dst_traced, origin_count*smpi_datatype_size(origin_datatype));
2860
2861     retval = smpi_mpi_put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win);
2862
2863     TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
2864   }
2865   smpi_bench_begin();
2866   return retval;
2867 }
2868
2869
2870 int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
2871               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
2872   int retval = 0;
2873   smpi_bench_end();
2874   if (win == MPI_WIN_NULL) {
2875     retval = MPI_ERR_WIN;
2876   } else if (target_rank == MPI_PROC_NULL) {
2877     retval = MPI_SUCCESS;
2878   } else if (target_rank <0){
2879     retval = MPI_ERR_RANK;
2880   } else if (target_disp <0){
2881     retval = MPI_ERR_ARG;
2882   } else if (origin_count < 0 || target_count < 0) {
2883     retval = MPI_ERR_COUNT;
2884   } else if (origin_addr==NULL && origin_count > 0){
2885     retval = MPI_ERR_COUNT;
2886   } else if ((!is_datatype_valid(origin_datatype)) ||
2887             (!is_datatype_valid(target_datatype))) {
2888     retval = MPI_ERR_TYPE;
2889   } else if (op == MPI_OP_NULL) {
2890     retval = MPI_ERR_OP;
2891   } else {
2892     int rank = smpi_process_index();
2893     MPI_Group group;
2894     smpi_mpi_win_get_group(win, &group);
2895     int src_traced = smpi_group_index(group, target_rank);
2896     TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, NULL);
2897
2898     retval = smpi_mpi_accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win);
2899
2900     TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
2901   }
2902   smpi_bench_begin();
2903   return retval;
2904 }
2905
2906
2907 int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
2908   int retval = 0;
2909   smpi_bench_end();
2910   if (win == MPI_WIN_NULL) {
2911     retval = MPI_ERR_WIN;
2912   } else if (group==MPI_GROUP_NULL){
2913     retval = MPI_ERR_GROUP;
2914   }
2915   else {
2916     int rank = smpi_process_index();
2917     TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL);
2918     retval = smpi_mpi_win_post(group,assert,win);
2919     TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2920   }
2921   smpi_bench_begin();
2922   return retval;
2923 }
2924
2925 int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
2926   int retval = 0;
2927   smpi_bench_end();
2928   if (win == MPI_WIN_NULL) {
2929     retval = MPI_ERR_WIN;
2930   } else if (group==MPI_GROUP_NULL){
2931     retval = MPI_ERR_GROUP;
2932   }
2933   else {
2934     int rank = smpi_process_index();
2935     TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL);
2936     retval = smpi_mpi_win_start(group,assert,win);
2937     TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2938   }
2939   smpi_bench_begin();
2940   return retval;
2941 }
2942
2943
2944 int PMPI_Win_complete(MPI_Win win){
2945   int retval = 0;
2946   smpi_bench_end();
2947   if (win == MPI_WIN_NULL) {
2948     retval = MPI_ERR_WIN;
2949   }
2950   else {
2951     int rank = smpi_process_index();
2952     TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL);
2953
2954     retval = smpi_mpi_win_complete(win);
2955
2956     TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2957   }
2958   smpi_bench_begin();
2959   return retval;
2960 }
2961
2962 int PMPI_Win_wait(MPI_Win win){
2963   int retval = 0;
2964   smpi_bench_end();
2965   if (win == MPI_WIN_NULL) {
2966     retval = MPI_ERR_WIN;
2967   }
2968   else {
2969     int rank = smpi_process_index();
2970     TRACE_smpi_collective_in(rank, -1, __FUNCTION__, NULL);
2971
2972     retval = smpi_mpi_win_wait(win);
2973
2974     TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
2975   }
2976   smpi_bench_begin();
2977   return retval;
2978 }
2979
2980 int PMPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr){
2981   void *ptr = xbt_malloc(size);
2982   if(!ptr)
2983     return MPI_ERR_NO_MEM;
2984   else {
2985     *(void **)baseptr = ptr;
2986     return MPI_SUCCESS;
2987   }
2988 }
2989
2990 int PMPI_Free_mem(void *baseptr){
2991   xbt_free(baseptr);
2992   return MPI_SUCCESS;
2993 }
2994
2995 int PMPI_Type_set_name(MPI_Datatype  datatype, char * name)
2996 {
2997   int retval = 0;
2998   if (datatype == MPI_DATATYPE_NULL)  {
2999     retval = MPI_ERR_TYPE;
3000   } else if (name == NULL)  {
3001     retval = MPI_ERR_ARG;
3002   } else {
3003     smpi_datatype_set_name(datatype, name);
3004     retval = MPI_SUCCESS;
3005   }
3006   return retval;
3007 }
3008
3009 int PMPI_Type_get_name(MPI_Datatype  datatype, char * name, int* len)
3010 {
3011   int retval = 0;
3012
3013   if (datatype == MPI_DATATYPE_NULL)  {
3014     retval = MPI_ERR_TYPE;
3015   } else if (name == NULL)  {
3016     retval = MPI_ERR_ARG;
3017   } else {
3018     smpi_datatype_get_name(datatype, name, len);
3019     retval = MPI_SUCCESS;
3020   }
3021   return retval;
3022 }
3023
3024
3025 MPI_Datatype PMPI_Type_f2c(MPI_Fint datatype){
3026   return smpi_type_f2c(datatype);
3027 }
3028
3029 MPI_Fint PMPI_Type_c2f(MPI_Datatype datatype){
3030   return smpi_type_c2f( datatype);
3031 }
3032
3033 MPI_Group PMPI_Group_f2c(MPI_Fint group){
3034   return smpi_group_f2c( group);
3035 }
3036
3037 MPI_Fint PMPI_Group_c2f(MPI_Group group){
3038   return smpi_group_c2f(group);
3039 }
3040
3041 MPI_Request PMPI_Request_f2c(MPI_Fint request){
3042   return smpi_request_f2c(request);
3043 }
3044
3045 MPI_Fint PMPI_Request_c2f(MPI_Request request) {
3046   return smpi_request_c2f(request);
3047 }
3048
3049 MPI_Win PMPI_Win_f2c(MPI_Fint win){
3050   return smpi_win_f2c(win);
3051 }
3052
3053 MPI_Fint PMPI_Win_c2f(MPI_Win win){
3054   return smpi_win_c2f(win);
3055 }
3056
3057 MPI_Op PMPI_Op_f2c(MPI_Fint op){
3058   return smpi_op_f2c(op);
3059 }
3060
3061 MPI_Fint PMPI_Op_c2f(MPI_Op op){
3062   return smpi_op_c2f(op);
3063 }
3064
3065 MPI_Comm PMPI_Comm_f2c(MPI_Fint comm){
3066   return smpi_comm_f2c(comm);
3067 }
3068
3069 MPI_Fint PMPI_Comm_c2f(MPI_Comm comm){
3070   return smpi_comm_c2f(comm);
3071 }
3072
3073 MPI_Info PMPI_Info_f2c(MPI_Fint info){
3074   return smpi_info_f2c(info);
3075 }
3076
3077 MPI_Fint PMPI_Info_c2f(MPI_Info info){
3078   return smpi_info_c2f(info);
3079 }
3080
3081 int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) {
3082   return smpi_comm_keyval_create(copy_fn, delete_fn, keyval, extra_state);
3083 }
3084
3085 int PMPI_Keyval_free(int* keyval) {
3086   return smpi_comm_keyval_free(keyval);
3087 }
3088
3089 int PMPI_Attr_delete(MPI_Comm comm, int keyval) {
3090   if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO
3091        ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM
3092        ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE)
3093     return MPI_ERR_ARG;
3094   else if (comm==MPI_COMM_NULL)
3095     return MPI_ERR_COMM;
3096   else
3097     return smpi_comm_attr_delete(comm, keyval);
3098 }
3099
3100 int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) {
3101   static int one = 1;
3102   static int zero = 0;
3103   static int tag_ub = 1000000;
3104   static int last_used_code = MPI_ERR_LASTCODE;
3105
3106   if (comm==MPI_COMM_NULL){
3107     *flag = 0;
3108     return MPI_ERR_COMM;
3109   }
3110
3111   switch (keyval) {
3112   case MPI_HOST:
3113   case MPI_IO:
3114   case MPI_APPNUM:
3115     *flag = 1;
3116     *(int**)attr_value = &zero;
3117     return MPI_SUCCESS;
3118
3119   case MPI_UNIVERSE_SIZE:
3120     *flag = 1;
3121     *(int**)attr_value = &smpi_universe_size;
3122     return MPI_SUCCESS;
3123
3124   case MPI_LASTUSEDCODE:
3125     *flag = 1;
3126     *(int**)attr_value = &last_used_code;
3127     return MPI_SUCCESS;
3128
3129   case MPI_TAG_UB:
3130     *flag=1;
3131     *(int**)attr_value = &tag_ub;
3132     return MPI_SUCCESS;
3133
3134   case MPI_WTIME_IS_GLOBAL:
3135     *flag = 1;
3136     *(int**)attr_value = &one;
3137     return MPI_SUCCESS;
3138
3139   default:
3140     return smpi_comm_attr_get(comm, keyval, attr_value, flag);
3141   }
3142 }
3143
3144 int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) {
3145   if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO
3146        ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM
3147        ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE)
3148     return MPI_ERR_ARG;
3149   else if (comm==MPI_COMM_NULL)
3150     return MPI_ERR_COMM;
3151   else
3152   return smpi_comm_attr_put(comm, keyval, attr_value);
3153 }
3154
3155 int PMPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
3156 {
3157   return PMPI_Attr_get(comm, comm_keyval, attribute_val,flag);
3158 }
3159
3160 int PMPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val)
3161 {
3162   return PMPI_Attr_put(comm, comm_keyval, attribute_val);
3163 }
3164
3165 int PMPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval)
3166 {
3167   return PMPI_Attr_delete(comm, comm_keyval);
3168 }
3169
3170 int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state)
3171 {
3172   return PMPI_Keyval_create(copy_fn, delete_fn, keyval, extra_state);
3173 }
3174
3175 int PMPI_Comm_free_keyval(int* keyval) {
3176   return PMPI_Keyval_free(keyval);
3177 }
3178
3179
3180 int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
3181 {
3182   if (type==MPI_DATATYPE_NULL)
3183     return MPI_ERR_TYPE;
3184   else
3185     return smpi_type_attr_get(type, type_keyval, attribute_val, flag);
3186 }
3187
3188 int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
3189 {
3190   if (type==MPI_DATATYPE_NULL)
3191     return MPI_ERR_TYPE;
3192   else
3193     return smpi_type_attr_put(type, type_keyval, attribute_val);
3194 }
3195
3196 int PMPI_Type_delete_attr (MPI_Datatype type, int type_keyval)
3197 {
3198   if (type==MPI_DATATYPE_NULL)
3199     return MPI_ERR_TYPE;
3200   else
3201     return smpi_type_attr_delete(type, type_keyval);
3202 }
3203
3204 int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)
3205 {
3206   return smpi_type_keyval_create(copy_fn, delete_fn, keyval, extra_state);
3207 }
3208
3209 int PMPI_Type_free_keyval(int* keyval) {
3210   return smpi_type_keyval_free(keyval);
3211 }
3212
3213 int PMPI_Info_create( MPI_Info *info){
3214   if (info == NULL)
3215     return MPI_ERR_ARG;
3216   *info = xbt_new(s_smpi_mpi_info_t, 1);
3217   (*info)->info_dict= xbt_dict_new_homogeneous(NULL);
3218   (*info)->refcount=1;
3219   return MPI_SUCCESS;
3220 }
3221
3222 int PMPI_Info_set( MPI_Info info, char *key, char *value){
3223   if (info == NULL || key == NULL || value == NULL)
3224     return MPI_ERR_ARG;
3225
3226   xbt_dict_set(info->info_dict, key, (void*)value, NULL);
3227   return MPI_SUCCESS;
3228 }
3229
3230 int PMPI_Info_free( MPI_Info *info){
3231   if (info == NULL || *info==NULL)
3232     return MPI_ERR_ARG;
3233   (*info)->refcount--;
3234   if((*info)->refcount==0){
3235     xbt_dict_free(&((*info)->info_dict));
3236     xbt_free(*info);
3237   }
3238   *info=MPI_INFO_NULL;
3239   return MPI_SUCCESS;
3240 }
3241
3242 int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){
3243   if (info == NULL || key == NULL || valuelen <0)
3244     return MPI_ERR_ARG;
3245   if (value == NULL)
3246     return MPI_ERR_INFO_VALUE;
3247   *flag=FALSE;
3248   char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key);
3249   if(tmpvalue){
3250     memcpy(value,tmpvalue, (strlen(tmpvalue) + 1 < valuelen) ?
3251                          strlen(tmpvalue) + 1 : valuelen);
3252     *flag=TRUE;
3253   }
3254   return MPI_SUCCESS;
3255 }
3256
3257 int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){
3258   if (info == NULL || newinfo==NULL)
3259     return MPI_ERR_ARG;
3260   *newinfo = xbt_new(s_smpi_mpi_info_t, 1);
3261   (*newinfo)->info_dict= xbt_dict_new_homogeneous(NULL);
3262   xbt_dict_cursor_t cursor = NULL;
3263   int *key;
3264   void* data;
3265   xbt_dict_foreach(info->info_dict,cursor,key,data){
3266     xbt_dict_set((*newinfo)->info_dict, (char*)key, data, NULL);
3267   }
3268   return MPI_SUCCESS;
3269 }
3270
3271 int PMPI_Info_delete(MPI_Info info, char *key){
3272   xbt_ex_t e;
3273   if (info == NULL || key==NULL)
3274     return MPI_ERR_ARG;
3275   TRY {
3276   xbt_dict_remove(info->info_dict, key);
3277   }CATCH(e){
3278     xbt_ex_free(e);
3279     return MPI_ERR_INFO_NOKEY;
3280   }
3281   return MPI_SUCCESS;
3282 }
3283
3284 int PMPI_Info_get_nkeys( MPI_Info info, int *nkeys){
3285   if (info == NULL || nkeys==NULL)
3286     return MPI_ERR_ARG;
3287   *nkeys=xbt_dict_size(info->info_dict);
3288   return MPI_SUCCESS;
3289 }
3290
3291 int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){
3292   if (info == NULL || key==NULL || n<0 || n> MPI_MAX_INFO_KEY)
3293     return MPI_ERR_ARG;
3294
3295   xbt_dict_cursor_t cursor = NULL;
3296   char *keyn;
3297   void* data;
3298   int num=0;
3299   xbt_dict_foreach(info->info_dict,cursor,keyn,data){
3300     if(num==n){
3301      strcpy(key,keyn);
3302       return MPI_SUCCESS;
3303     }
3304     num++;
3305   }
3306   return MPI_ERR_ARG;
3307 }
3308
3309 int PMPI_Info_get_valuelen( MPI_Info info, char *key, int *valuelen, int *flag){
3310   if (info == NULL || key == NULL || valuelen <0)
3311     return MPI_ERR_ARG;
3312   *flag=FALSE;
3313   char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key);
3314   if(tmpvalue){
3315     *valuelen=strlen(tmpvalue);
3316     *flag=TRUE;
3317   }
3318   return MPI_SUCCESS;
3319 }
3320
3321 int PMPI_Unpack(void* inbuf, int incount, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
3322   if(incount<0 || outcount < 0 || inbuf==NULL || outbuf==NULL)
3323     return MPI_ERR_ARG;
3324   if(!is_datatype_valid(type))
3325     return MPI_ERR_TYPE;
3326   if(comm==MPI_COMM_NULL)
3327     return MPI_ERR_COMM;
3328   return smpi_mpi_unpack(inbuf, incount, position, outbuf,outcount,type, comm);
3329 }
3330
3331 int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
3332   if(incount<0 || outcount < 0|| inbuf==NULL || outbuf==NULL)
3333     return MPI_ERR_ARG;
3334   if(!is_datatype_valid(type))
3335     return MPI_ERR_TYPE;
3336   if(comm==MPI_COMM_NULL)
3337     return MPI_ERR_COMM;
3338   return smpi_mpi_pack(inbuf, incount, type, outbuf,outcount,position, comm);
3339 }
3340
3341 int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
3342   if(incount<0)
3343     return MPI_ERR_ARG;
3344   if(!is_datatype_valid(datatype))
3345     return MPI_ERR_TYPE;
3346   if(comm==MPI_COMM_NULL)
3347     return MPI_ERR_COMM;
3348
3349   *size=incount*smpi_datatype_size(datatype);
3350
3351   return MPI_SUCCESS;
3352 }
3353
3354
3355 /* The following calls are not yet implemented and will fail at runtime. */
3356 /* Once implemented, please move them above this notice. */
3357
3358 #define NOT_YET_IMPLEMENTED {                                           \
3359     XBT_WARN("Not yet implemented : %s. Please contact the Simgrid team if support is needed", __FUNCTION__); \
3360     return MPI_SUCCESS;                                                 \
3361   }
3362
3363 MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){
3364   NOT_YET_IMPLEMENTED
3365 }
3366
3367 MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhandler){
3368   NOT_YET_IMPLEMENTED
3369 }
3370
3371 int PMPI_Cart_map(MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank) {
3372   NOT_YET_IMPLEMENTED
3373 }
3374
3375 int PMPI_Graph_create(MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph) {
3376   NOT_YET_IMPLEMENTED
3377 }
3378
3379 int PMPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges) {
3380   NOT_YET_IMPLEMENTED
3381 }
3382
3383 int PMPI_Graph_map(MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank) {
3384   NOT_YET_IMPLEMENTED
3385 }
3386
3387 int PMPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int* neighbors) {
3388   NOT_YET_IMPLEMENTED
3389 }
3390
3391 int PMPI_Graph_neighbors_count(MPI_Comm comm, int rank, int* nneighbors) {
3392   NOT_YET_IMPLEMENTED
3393 }
3394
3395 int PMPI_Graphdims_get(MPI_Comm comm, int* nnodes, int* nedges) {
3396   NOT_YET_IMPLEMENTED
3397 }
3398
3399 int PMPI_Topo_test(MPI_Comm comm, int* top_type) {
3400   NOT_YET_IMPLEMENTED
3401 }
3402
3403 int PMPI_Errhandler_create(MPI_Handler_function* function, MPI_Errhandler* errhandler) {
3404   NOT_YET_IMPLEMENTED
3405 }
3406
3407 int PMPI_Errhandler_free(MPI_Errhandler* errhandler) {
3408   NOT_YET_IMPLEMENTED
3409 }
3410
3411 int PMPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler* errhandler) {
3412   NOT_YET_IMPLEMENTED
3413 }
3414
3415 int PMPI_Error_string(int errorcode, char* string, int* resultlen) {
3416   NOT_YET_IMPLEMENTED
3417 }
3418
3419 int PMPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler) {
3420   NOT_YET_IMPLEMENTED
3421 }
3422
3423 int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
3424   NOT_YET_IMPLEMENTED
3425 }
3426
3427 int PMPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler) {
3428   NOT_YET_IMPLEMENTED
3429 }
3430
3431 int PMPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler* errhandler) {
3432   NOT_YET_IMPLEMENTED
3433 }
3434
3435 int PMPI_Cancel(MPI_Request* request) {
3436   NOT_YET_IMPLEMENTED
3437 }
3438
3439 int PMPI_Buffer_attach(void* buffer, int size) {
3440   NOT_YET_IMPLEMENTED
3441 }
3442
3443 int PMPI_Buffer_detach(void* buffer, int* size) {
3444   NOT_YET_IMPLEMENTED
3445 }
3446
3447 int PMPI_Comm_test_inter(MPI_Comm comm, int* flag) {
3448   NOT_YET_IMPLEMENTED
3449 }
3450
3451 int PMPI_Pcontrol(const int level )
3452 {
3453   NOT_YET_IMPLEMENTED
3454 }
3455
3456
3457 int PMPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out) {
3458   NOT_YET_IMPLEMENTED
3459 }
3460
3461 int PMPI_Intercomm_merge(MPI_Comm comm, int high, MPI_Comm* comm_out) {
3462   NOT_YET_IMPLEMENTED
3463 }
3464
3465 int PMPI_Bsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
3466   NOT_YET_IMPLEMENTED
3467 }
3468
3469 int PMPI_Bsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
3470   NOT_YET_IMPLEMENTED
3471 }
3472
3473 int PMPI_Ibsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
3474   NOT_YET_IMPLEMENTED
3475 }
3476
3477 int PMPI_Comm_remote_group(MPI_Comm comm, MPI_Group* group) {
3478   NOT_YET_IMPLEMENTED
3479 }
3480
3481 int PMPI_Comm_remote_size(MPI_Comm comm, int* size) {
3482   NOT_YET_IMPLEMENTED
3483 }
3484
3485 int PMPI_Rsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) {
3486   NOT_YET_IMPLEMENTED
3487 }
3488
3489 int PMPI_Rsend_init(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
3490   NOT_YET_IMPLEMENTED
3491 }
3492
3493 int PMPI_Irsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request) {
3494   NOT_YET_IMPLEMENTED
3495 }
3496
3497 int PMPI_Test_cancelled(MPI_Status* status, int* flag) {
3498   NOT_YET_IMPLEMENTED
3499 }
3500
3501
3502
3503 int PMPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size){
3504   NOT_YET_IMPLEMENTED
3505 }
3506
3507 int PMPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outcount, MPI_Aint *position){
3508   NOT_YET_IMPLEMENTED
3509 }
3510
3511 int PMPI_Unpack_external( char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount, MPI_Datatype datatype){
3512   NOT_YET_IMPLEMENTED
3513 }
3514
3515 int PMPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) {
3516   NOT_YET_IMPLEMENTED
3517 }
3518
3519
3520
3521 int PMPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers,
3522                             int *num_addresses, int *num_datatypes, int *combiner){
3523   NOT_YET_IMPLEMENTED
3524 }
3525
3526 int PMPI_Type_get_contents(MPI_Datatype datatype, int max_integers, int max_addresses,
3527                            int max_datatypes, int* array_of_integers, MPI_Aint* array_of_addresses,
3528                            MPI_Datatype* array_of_datatypes){
3529   NOT_YET_IMPLEMENTED
3530 }
3531
3532 int PMPI_Type_create_darray(int size, int rank, int ndims, int* array_of_gsizes,
3533                             int* array_of_distribs, int* array_of_dargs, int* array_of_psizes,
3534                             int order, MPI_Datatype oldtype, MPI_Datatype *newtype) {
3535   NOT_YET_IMPLEMENTED
3536 }
3537
3538 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){
3539   NOT_YET_IMPLEMENTED
3540 }
3541
3542 int PMPI_Type_match_size(int typeclass,int size,MPI_Datatype *datatype){
3543   NOT_YET_IMPLEMENTED
3544 }
3545
3546 int PMPI_Alltoallw( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes,
3547                     void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes,
3548                     MPI_Comm comm){
3549   NOT_YET_IMPLEMENTED
3550 }
3551
3552 int PMPI_Comm_set_name(MPI_Comm comm, char* name){
3553   NOT_YET_IMPLEMENTED
3554 }
3555
3556 int PMPI_Comm_dup_with_info(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm){
3557   NOT_YET_IMPLEMENTED
3558 }
3559
3560 int PMPI_Comm_split_type(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm *newcomm){
3561   NOT_YET_IMPLEMENTED
3562 }
3563
3564 int PMPI_Comm_set_info (MPI_Comm comm, MPI_Info info){
3565   NOT_YET_IMPLEMENTED
3566 }
3567
3568 int PMPI_Comm_get_info (MPI_Comm comm, MPI_Info* info){
3569   NOT_YET_IMPLEMENTED
3570 }
3571
3572 int PMPI_Comm_create_errhandler( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler){
3573   NOT_YET_IMPLEMENTED
3574 }
3575
3576 int PMPI_Add_error_class( int *errorclass){
3577   NOT_YET_IMPLEMENTED
3578 }
3579
3580 int PMPI_Add_error_code(  int errorclass, int *errorcode){
3581   NOT_YET_IMPLEMENTED
3582 }
3583
3584 int PMPI_Add_error_string( int errorcode, char *string){
3585   NOT_YET_IMPLEMENTED
3586 }
3587
3588 int PMPI_Comm_call_errhandler(MPI_Comm comm,int errorcode){
3589   NOT_YET_IMPLEMENTED
3590 }
3591
3592 int PMPI_Request_get_status( MPI_Request request, int *flag, MPI_Status *status){
3593   NOT_YET_IMPLEMENTED
3594 }
3595
3596 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){
3597   NOT_YET_IMPLEMENTED
3598 }
3599
3600 int PMPI_Grequest_complete( MPI_Request request){
3601   NOT_YET_IMPLEMENTED
3602 }
3603
3604 int PMPI_Status_set_cancelled(MPI_Status *status,int flag){
3605   NOT_YET_IMPLEMENTED
3606 }
3607
3608 int PMPI_Status_set_elements( MPI_Status *status, MPI_Datatype datatype, int count){
3609   NOT_YET_IMPLEMENTED
3610 }
3611
3612 int PMPI_Comm_connect( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
3613   NOT_YET_IMPLEMENTED
3614 }
3615
3616 int PMPI_Publish_name( char *service_name, MPI_Info info, char *port_name){
3617   NOT_YET_IMPLEMENTED
3618 }
3619
3620 int PMPI_Unpublish_name( char *service_name, MPI_Info info, char *port_name){
3621   NOT_YET_IMPLEMENTED
3622 }
3623
3624 int PMPI_Lookup_name( char *service_name, MPI_Info info, char *port_name){
3625   NOT_YET_IMPLEMENTED
3626 }
3627
3628 int PMPI_Comm_join( int fd, MPI_Comm *intercomm){
3629   NOT_YET_IMPLEMENTED
3630 }
3631
3632 int PMPI_Open_port( MPI_Info info, char *port_name){
3633   NOT_YET_IMPLEMENTED
3634 }
3635
3636 int PMPI_Close_port(char *port_name){
3637   NOT_YET_IMPLEMENTED
3638 }
3639
3640 int PMPI_Comm_accept( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm){
3641   NOT_YET_IMPLEMENTED
3642 }
3643
3644 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){
3645   NOT_YET_IMPLEMENTED
3646 }
3647
3648 int PMPI_Comm_spawn_multiple( int count, char **array_of_commands, char*** array_of_argv,
3649                               int* array_of_maxprocs, MPI_Info* array_of_info, int root,
3650                               MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes){
3651   NOT_YET_IMPLEMENTED
3652 }
3653
3654 int PMPI_Comm_get_parent( MPI_Comm *parent){
3655   NOT_YET_IMPLEMENTED
3656 }
3657
3658 int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win) {
3659   NOT_YET_IMPLEMENTED
3660 }
3661
3662 int PMPI_Win_test(MPI_Win win, int *flag){
3663   NOT_YET_IMPLEMENTED
3664 }
3665
3666 int PMPI_Win_unlock(int rank, MPI_Win win){
3667   NOT_YET_IMPLEMENTED
3668 }