Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
e5a7089ab2243d43441cfdbb9db1dec2d06ce599
[simgrid.git] / src / smpi / bindings / smpi_pmpi_coll.cpp
1 /* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "private.hpp"
7 #include "smpi_coll.hpp"
8 #include "smpi_comm.hpp"
9 #include "smpi_datatype_derived.hpp"
10 #include "smpi_op.hpp"
11 #include "smpi_process.hpp"
12
13 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
14
15 /* PMPI User level calls */
16 extern "C" { // Obviously, the C MPI interface should use the C linkage
17
18 int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
19 {
20   int retval = 0;
21
22   smpi_bench_end();
23
24   if (comm == MPI_COMM_NULL) {
25     retval = MPI_ERR_COMM;
26   } else if (not datatype->is_valid()) {
27     retval = MPI_ERR_ARG;
28   } else {
29     int rank        = smpi_process()->index();
30     int root_traced = comm->group()->index(root);
31
32     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
33     extra->type            = TRACING_BCAST;
34     extra->root            = root_traced;
35     extra->datatype1       = encode_datatype(datatype);
36     extra->send_size       = datatype->is_basic() ? count : count * datatype->size();
37     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
38     if (comm->size() > 1)
39       simgrid::smpi::Colls::bcast(buf, count, datatype, root, comm);
40     retval = MPI_SUCCESS;
41
42     TRACE_smpi_collective_out(rank);
43   }
44   smpi_bench_begin();
45   return retval;
46 }
47
48 int PMPI_Barrier(MPI_Comm comm)
49 {
50   int retval = 0;
51
52   smpi_bench_end();
53
54   if (comm == MPI_COMM_NULL) {
55     retval = MPI_ERR_COMM;
56   } else {
57     int rank               = smpi_process()->index();
58     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
59     extra->type            = TRACING_BARRIER;
60     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
61
62     simgrid::smpi::Colls::barrier(comm);
63
64     //Barrier can be used to synchronize RMA calls. Finish all requests from comm before.
65     comm->finish_rma_calls();
66
67     retval = MPI_SUCCESS;
68
69     TRACE_smpi_collective_out(rank);
70   }
71
72   smpi_bench_begin();
73   return retval;
74 }
75
76 int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbuf, int recvcount, MPI_Datatype recvtype,
77                 int root, MPI_Comm comm)
78 {
79   int retval = 0;
80
81   smpi_bench_end();
82
83   if (comm == MPI_COMM_NULL) {
84     retval = MPI_ERR_COMM;
85   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
86             ((comm->rank() == root) && (recvtype == MPI_DATATYPE_NULL))){
87     retval = MPI_ERR_TYPE;
88   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) || ((comm->rank() == root) && (recvcount <0))){
89     retval = MPI_ERR_COUNT;
90   } else {
91
92     char* sendtmpbuf = static_cast<char*>(sendbuf);
93     int sendtmpcount = sendcount;
94     MPI_Datatype sendtmptype = sendtype;
95     if( (comm->rank() == root) && (sendbuf == MPI_IN_PLACE )) {
96       sendtmpcount=0;
97       sendtmptype=recvtype;
98     }
99     int rank               = smpi_process()->index();
100     int root_traced        = comm->group()->index(root);
101     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
102     extra->type            = TRACING_GATHER;
103     extra->root            = root_traced;
104
105     extra->datatype1 = encode_datatype(sendtmptype);
106     extra->send_size = sendtmptype->is_basic() ? sendtmpcount : sendtmpcount * sendtmptype->size();
107     extra->datatype2 = encode_datatype(recvtype);
108     extra->recv_size = (comm->rank() != root || recvtype->is_basic()) ? recvcount : recvcount * recvtype->size();
109
110     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
111
112     simgrid::smpi::Colls::gather(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, root, comm);
113
114     retval = MPI_SUCCESS;
115     TRACE_smpi_collective_out(rank);
116   }
117
118   smpi_bench_begin();
119   return retval;
120 }
121
122 int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs,
123                 MPI_Datatype recvtype, int root, MPI_Comm comm)
124 {
125   int retval = 0;
126
127   smpi_bench_end();
128
129   if (comm == MPI_COMM_NULL) {
130     retval = MPI_ERR_COMM;
131   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
132             ((comm->rank() == root) && (recvtype == MPI_DATATYPE_NULL))){
133     retval = MPI_ERR_TYPE;
134   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
135     retval = MPI_ERR_COUNT;
136   } else if (recvcounts == nullptr || displs == nullptr) {
137     retval = MPI_ERR_ARG;
138   } else {
139     char* sendtmpbuf = static_cast<char*>(sendbuf);
140     int sendtmpcount = sendcount;
141     MPI_Datatype sendtmptype = sendtype;
142     if( (comm->rank() == root) && (sendbuf == MPI_IN_PLACE )) {
143       sendtmpcount=0;
144       sendtmptype=recvtype;
145     }
146
147     int rank               = smpi_process()->index();
148     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
149     extra->type            = TRACING_GATHERV;
150     extra->num_processes   = comm->size();
151     extra->root            = comm->group()->index(root);
152
153     extra->datatype1 = encode_datatype(sendtmptype);
154     extra->send_size = sendtmptype->is_basic() ? sendtmpcount : sendtmpcount * sendtmptype->size();
155     extra->datatype2 = encode_datatype(recvtype);
156     int dt_size_recv = recvtype->is_basic() ? 1 : recvtype->size();
157
158     if (comm->rank() == root) {
159       extra->recvcounts = new int[extra->num_processes];
160       for (int i             = 0; i < extra->num_processes; i++) // copy data to avoid bad free
161         extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
162     }
163
164     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
165     retval = simgrid::smpi::Colls::gatherv(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcounts, displs, recvtype, root, comm);
166     TRACE_smpi_collective_out(rank);
167   }
168
169   smpi_bench_begin();
170   return retval;
171 }
172
173 int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
174                    void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
175 {
176   int retval = 0;
177
178   smpi_bench_end();
179
180   if (comm == MPI_COMM_NULL) {
181     retval = MPI_ERR_COMM;
182   } else if ((( sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) ||
183             (recvtype == MPI_DATATYPE_NULL)){
184     retval = MPI_ERR_TYPE;
185   } else if ((( sendbuf != MPI_IN_PLACE) && (sendcount <0)) ||
186             (recvcount <0)){
187     retval = MPI_ERR_COUNT;
188   } else {
189     if(sendbuf == MPI_IN_PLACE) {
190       sendbuf=static_cast<char*>(recvbuf)+recvtype->get_extent()*recvcount*comm->rank();
191       sendcount=recvcount;
192       sendtype=recvtype;
193     }
194     int rank               = smpi_process()->index();
195     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
196     extra->type            = TRACING_ALLGATHER;
197
198     extra->datatype1 = encode_datatype(sendtype);
199     extra->send_size = sendtype->is_basic() ? sendcount : sendcount * sendtype->size();
200     extra->datatype2 = encode_datatype(recvtype);
201     extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
202
203     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
204
205     simgrid::smpi::Colls::allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
206     retval = MPI_SUCCESS;
207     TRACE_smpi_collective_out(rank);
208   }
209   smpi_bench_begin();
210   return retval;
211 }
212
213 int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
214                    void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, MPI_Comm comm)
215 {
216   int retval = 0;
217
218   smpi_bench_end();
219
220   if (comm == MPI_COMM_NULL) {
221     retval = MPI_ERR_COMM;
222   } else if (((sendbuf != MPI_IN_PLACE) && (sendtype == MPI_DATATYPE_NULL)) || (recvtype == MPI_DATATYPE_NULL)) {
223     retval = MPI_ERR_TYPE;
224   } else if (( sendbuf != MPI_IN_PLACE) && (sendcount <0)){
225     retval = MPI_ERR_COUNT;
226   } else if (recvcounts == nullptr || displs == nullptr) {
227     retval = MPI_ERR_ARG;
228   } else {
229
230     if(sendbuf == MPI_IN_PLACE) {
231       sendbuf=static_cast<char*>(recvbuf)+recvtype->get_extent()*displs[comm->rank()];
232       sendcount=recvcounts[comm->rank()];
233       sendtype=recvtype;
234     }
235     int rank               = smpi_process()->index();
236     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
237     extra->type            = TRACING_ALLGATHERV;
238     extra->num_processes   = comm->size();
239     extra->datatype1       = encode_datatype(sendtype);
240     extra->send_size       = sendtype->is_basic() ? sendcount : sendcount * sendtype->size();
241     extra->datatype2       = encode_datatype(recvtype);
242     int dt_size_recv       = recvtype->is_basic() ? 1 : recvtype->size();
243
244     extra->recvcounts = new int[extra->num_processes];
245     for (int i             = 0; i < extra->num_processes; i++) // copy data to avoid bad free
246       extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
247
248     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
249
250     simgrid::smpi::Colls::allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
251     retval = MPI_SUCCESS;
252     TRACE_smpi_collective_out(rank);
253   }
254
255   smpi_bench_begin();
256   return retval;
257 }
258
259 int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
260                 void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
261 {
262   int retval = 0;
263
264   smpi_bench_end();
265
266   if (comm == MPI_COMM_NULL) {
267     retval = MPI_ERR_COMM;
268   } else if (((comm->rank() == root) && (not sendtype->is_valid())) ||
269              ((recvbuf != MPI_IN_PLACE) && (not recvtype->is_valid()))) {
270     retval = MPI_ERR_TYPE;
271   } else if ((sendbuf == recvbuf) ||
272       ((comm->rank()==root) && sendcount>0 && (sendbuf == nullptr))){
273     retval = MPI_ERR_BUFFER;
274   }else {
275
276     if (recvbuf == MPI_IN_PLACE) {
277       recvtype  = sendtype;
278       recvcount = sendcount;
279     }
280     int rank               = smpi_process()->index();
281     int root_traced        = comm->group()->index(root);
282     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
283     extra->type            = TRACING_SCATTER;
284     extra->root            = root_traced;
285
286     extra->datatype1 = encode_datatype(sendtype);
287     extra->send_size = (comm->rank() != root || sendtype->is_basic()) ? sendcount : sendcount * sendtype->size();
288     extra->datatype2 = encode_datatype(recvtype);
289     extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
290
291     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
292
293     simgrid::smpi::Colls::scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
294     retval = MPI_SUCCESS;
295     TRACE_smpi_collective_out(rank);
296   }
297
298   smpi_bench_begin();
299   return retval;
300 }
301
302 int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs,
303                  MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
304 {
305   int retval = 0;
306
307   smpi_bench_end();
308
309   if (comm == MPI_COMM_NULL) {
310     retval = MPI_ERR_COMM;
311   } else if (sendcounts == nullptr || displs == nullptr) {
312     retval = MPI_ERR_ARG;
313   } else if (((comm->rank() == root) && (sendtype == MPI_DATATYPE_NULL)) ||
314              ((recvbuf != MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) {
315     retval = MPI_ERR_TYPE;
316   } else {
317     if (recvbuf == MPI_IN_PLACE) {
318       recvtype  = sendtype;
319       recvcount = sendcounts[comm->rank()];
320     }
321     int rank               = smpi_process()->index();
322     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
323     extra->type            = TRACING_SCATTERV;
324     extra->num_processes   = comm->size();
325     extra->root            = comm->group()->index(root);
326     extra->datatype1       = encode_datatype(sendtype);
327     extra->datatype2       = encode_datatype(recvtype);
328     int dt_size_send       = sendtype->is_basic() ? 1 : sendtype->size();
329     extra->recv_size       = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
330     if (comm->rank() == root) {
331       extra->sendcounts = new int[extra->num_processes];
332       for (int i             = 0; i < extra->num_processes; i++) // copy data to avoid bad free
333         extra->sendcounts[i] = sendcounts[i] * dt_size_send;
334     }
335
336     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
337
338     retval = simgrid::smpi::Colls::scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
339
340     TRACE_smpi_collective_out(rank);
341   }
342
343   smpi_bench_begin();
344   return retval;
345 }
346
347 int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
348 {
349   int retval = 0;
350
351   smpi_bench_end();
352
353   if (comm == MPI_COMM_NULL) {
354     retval = MPI_ERR_COMM;
355   } else if (not datatype->is_valid() || op == MPI_OP_NULL) {
356     retval = MPI_ERR_ARG;
357   } else {
358     int rank               = smpi_process()->index();
359
360     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
361     extra->root            = comm->group()->index(root);
362     extra->type            = TRACING_REDUCE;
363     extra->datatype1       = encode_datatype(datatype);
364     extra->send_size       = datatype->is_basic() ? count : count * datatype->size();
365
366     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
367
368     simgrid::smpi::Colls::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
369
370     retval = MPI_SUCCESS;
371     TRACE_smpi_collective_out(rank);
372   }
373
374   smpi_bench_begin();
375   return retval;
376 }
377
378 int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op){
379   int retval = 0;
380
381   smpi_bench_end();
382   if (not datatype->is_valid() || op == MPI_OP_NULL) {
383     retval = MPI_ERR_ARG;
384   } else {
385     op->apply(inbuf, inoutbuf, &count, datatype);
386     retval = MPI_SUCCESS;
387   }
388   smpi_bench_begin();
389   return retval;
390 }
391
392 int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
393 {
394   int retval = 0;
395
396   smpi_bench_end();
397
398   if (comm == MPI_COMM_NULL) {
399     retval = MPI_ERR_COMM;
400   } else if (not datatype->is_valid()) {
401     retval = MPI_ERR_TYPE;
402   } else if (op == MPI_OP_NULL) {
403     retval = MPI_ERR_OP;
404   } else {
405
406     char* sendtmpbuf = static_cast<char*>(sendbuf);
407     if( sendbuf == MPI_IN_PLACE ) {
408       sendtmpbuf = static_cast<char*>(xbt_malloc(count*datatype->get_extent()));
409       simgrid::smpi::Datatype::copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
410     }
411     int rank               = smpi_process()->index();
412     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
413     extra->type            = TRACING_ALLREDUCE;
414
415     extra->datatype1 = encode_datatype(datatype);
416     extra->send_size = datatype->is_basic() ? count : count * datatype->size();
417
418     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
419
420     simgrid::smpi::Colls::allreduce(sendtmpbuf, recvbuf, count, datatype, op, comm);
421
422     if( sendbuf == MPI_IN_PLACE )
423       xbt_free(sendtmpbuf);
424
425     retval = MPI_SUCCESS;
426     TRACE_smpi_collective_out(rank);
427   }
428
429   smpi_bench_begin();
430   return retval;
431 }
432
433 int PMPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
434 {
435   int retval = 0;
436
437   smpi_bench_end();
438
439   if (comm == MPI_COMM_NULL) {
440     retval = MPI_ERR_COMM;
441   } else if (not datatype->is_valid()) {
442     retval = MPI_ERR_TYPE;
443   } else if (op == MPI_OP_NULL) {
444     retval = MPI_ERR_OP;
445   } else {
446     int rank               = smpi_process()->index();
447     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
448     extra->type            = TRACING_SCAN;
449
450     extra->datatype1 = encode_datatype(datatype);
451     extra->send_size = datatype->is_basic() ? count : count * datatype->size();
452
453     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
454
455     retval = simgrid::smpi::Colls::scan(sendbuf, recvbuf, count, datatype, op, comm);
456
457     TRACE_smpi_collective_out(rank);
458   }
459
460   smpi_bench_begin();
461   return retval;
462 }
463
464 int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm){
465   int retval = 0;
466
467   smpi_bench_end();
468
469   if (comm == MPI_COMM_NULL) {
470     retval = MPI_ERR_COMM;
471   } else if (not datatype->is_valid()) {
472     retval = MPI_ERR_TYPE;
473   } else if (op == MPI_OP_NULL) {
474     retval = MPI_ERR_OP;
475   } else {
476     int rank               = smpi_process()->index();
477     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
478     extra->type            = TRACING_EXSCAN;
479     extra->datatype1       = encode_datatype(datatype);
480     extra->send_size       = datatype->is_basic() ? count : count * datatype->size();
481     void* sendtmpbuf = sendbuf;
482     if (sendbuf == MPI_IN_PLACE) {
483       sendtmpbuf = static_cast<void*>(xbt_malloc(count * datatype->size()));
484       memcpy(sendtmpbuf, recvbuf, count * datatype->size());
485     }
486     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
487
488     retval = simgrid::smpi::Colls::exscan(sendtmpbuf, recvbuf, count, datatype, op, comm);
489
490     TRACE_smpi_collective_out(rank);
491     if (sendbuf == MPI_IN_PLACE)
492       xbt_free(sendtmpbuf);
493   }
494
495   smpi_bench_begin();
496   return retval;
497 }
498
499 int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
500 {
501   int retval = 0;
502   smpi_bench_end();
503
504   if (comm == MPI_COMM_NULL) {
505     retval = MPI_ERR_COMM;
506   } else if (not datatype->is_valid()) {
507     retval = MPI_ERR_TYPE;
508   } else if (op == MPI_OP_NULL) {
509     retval = MPI_ERR_OP;
510   } else if (recvcounts == nullptr) {
511     retval = MPI_ERR_ARG;
512   } else {
513     int rank               = smpi_process()->index();
514     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
515     extra->type            = TRACING_REDUCE_SCATTER;
516     extra->num_processes   = comm->size();
517     ;
518     extra->type            = TRACING_EXSCAN;
519     extra->datatype1       = encode_datatype(datatype);
520     extra->send_size       = datatype->is_basic() ? 1 : datatype->size();
521
522     extra->recvcounts = new int[extra->num_processes];
523     int totalcount    = 0;
524     for (int i = 0; i < extra->num_processes; i++) { // copy data to avoid bad free
525       extra->recvcounts[i] = recvcounts[i] * extra->send_size;
526       totalcount += recvcounts[i];
527     }
528     void* sendtmpbuf = sendbuf;
529     if (sendbuf == MPI_IN_PLACE) {
530       sendtmpbuf = static_cast<void*>(xbt_malloc(totalcount * datatype->size()));
531       memcpy(sendtmpbuf, recvbuf, totalcount * datatype->size());
532     }
533
534     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
535
536     simgrid::smpi::Colls::reduce_scatter(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm);
537     retval = MPI_SUCCESS;
538     TRACE_smpi_collective_out(rank);
539
540     if (sendbuf == MPI_IN_PLACE)
541       xbt_free(sendtmpbuf);
542   }
543
544   smpi_bench_begin();
545   return retval;
546 }
547
548 int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount,
549                               MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
550 {
551   int retval;
552   smpi_bench_end();
553
554   if (comm == MPI_COMM_NULL) {
555     retval = MPI_ERR_COMM;
556   } else if (not datatype->is_valid()) {
557     retval = MPI_ERR_TYPE;
558   } else if (op == MPI_OP_NULL) {
559     retval = MPI_ERR_OP;
560   } else if (recvcount < 0) {
561     retval = MPI_ERR_ARG;
562   } else {
563     int count = comm->size();
564
565     int rank               = smpi_process()->index();
566     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
567     extra->type            = TRACING_REDUCE_SCATTER;
568     extra->num_processes   = count;
569     extra->datatype1       = encode_datatype(datatype);
570     int dt_size_send       = datatype->is_basic() ? 1 : datatype->size();
571     extra->send_size       = 0;
572     extra->recvcounts      = new int[extra->num_processes];
573     for (int i             = 0; i < extra->num_processes; i++) // copy data to avoid bad free
574       extra->recvcounts[i] = recvcount * dt_size_send;
575     void* sendtmpbuf       = sendbuf;
576     if (sendbuf == MPI_IN_PLACE) {
577       sendtmpbuf = static_cast<void*>(xbt_malloc(recvcount * count * datatype->size()));
578       memcpy(sendtmpbuf, recvbuf, recvcount * count * datatype->size());
579     }
580
581     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
582
583     int* recvcounts = new int[count];
584     for (int i      = 0; i < count; i++)
585       recvcounts[i] = recvcount;
586     simgrid::smpi::Colls::reduce_scatter(sendtmpbuf, recvbuf, recvcounts, datatype, op, comm);
587     delete[] recvcounts;
588     retval = MPI_SUCCESS;
589
590     TRACE_smpi_collective_out(rank);
591
592     if (sendbuf == MPI_IN_PLACE)
593       xbt_free(sendtmpbuf);
594   }
595
596   smpi_bench_begin();
597   return retval;
598 }
599
600 int PMPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
601                   MPI_Datatype recvtype, MPI_Comm comm)
602 {
603   int retval = 0;
604   smpi_bench_end();
605
606   if (comm == MPI_COMM_NULL) {
607     retval = MPI_ERR_COMM;
608   } else if ((sendbuf != MPI_IN_PLACE && sendtype == MPI_DATATYPE_NULL) || recvtype == MPI_DATATYPE_NULL) {
609     retval = MPI_ERR_TYPE;
610   } else {
611     int rank               = smpi_process()->index();
612     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
613     extra->type            = TRACING_ALLTOALL;
614
615     void* sendtmpbuf         = static_cast<char*>(sendbuf);
616     int sendtmpcount         = sendcount;
617     MPI_Datatype sendtmptype = sendtype;
618     if (sendbuf == MPI_IN_PLACE) {
619       sendtmpbuf = static_cast<void*>(xbt_malloc(recvcount * comm->size() * recvtype->size()));
620       memcpy(sendtmpbuf, recvbuf, recvcount * comm->size() * recvtype->size());
621       sendtmpcount = recvcount;
622       sendtmptype  = recvtype;
623     }
624
625     extra->datatype1 = encode_datatype(sendtmptype);
626     extra->send_size = sendtmptype->is_basic() ? sendtmpcount : sendtmpcount * sendtmptype->size();
627     extra->datatype2 = encode_datatype(recvtype);
628     extra->recv_size = recvtype->is_basic() ? recvcount : recvcount * recvtype->size();
629
630     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
631
632     retval = simgrid::smpi::Colls::alltoall(sendtmpbuf, sendtmpcount, sendtmptype, recvbuf, recvcount, recvtype, comm);
633
634     TRACE_smpi_collective_out(rank);
635
636     if (sendbuf == MPI_IN_PLACE)
637       xbt_free(sendtmpbuf);
638   }
639
640   smpi_bench_begin();
641   return retval;
642 }
643
644 int PMPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype sendtype, void* recvbuf,
645                    int* recvcounts, int* recvdisps, MPI_Datatype recvtype, MPI_Comm comm)
646 {
647   int retval = 0;
648
649   smpi_bench_end();
650
651   if (comm == MPI_COMM_NULL) {
652     retval = MPI_ERR_COMM;
653   } else if (sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
654     retval = MPI_ERR_TYPE;
655   } else if ((sendbuf != MPI_IN_PLACE && (sendcounts == nullptr || senddisps == nullptr)) || recvcounts == nullptr ||
656              recvdisps == nullptr) {
657     retval = MPI_ERR_ARG;
658   } else {
659     int rank               = smpi_process()->index();
660     int i                  = 0;
661     int size               = comm->size();
662     instr_extra_data extra = xbt_new0(s_instr_extra_data_t, 1);
663     extra->type            = TRACING_ALLTOALLV;
664     extra->send_size       = 0;
665     extra->recv_size       = 0;
666     extra->recvcounts      = new int[size];
667     extra->sendcounts      = new int[size];
668     extra->datatype2       = encode_datatype(recvtype);
669     int dt_size_recv       = recvtype->size();
670
671     void* sendtmpbuf         = static_cast<char*>(sendbuf);
672     int* sendtmpcounts       = sendcounts;
673     int* sendtmpdisps        = senddisps;
674     MPI_Datatype sendtmptype = sendtype;
675     int maxsize              = 0;
676     for (i = 0; i < size; i++) { // copy data to avoid bad free
677       extra->recv_size += recvcounts[i] * dt_size_recv;
678       extra->recvcounts[i] = recvcounts[i] * dt_size_recv;
679       if (((recvdisps[i] + recvcounts[i]) * dt_size_recv) > maxsize)
680         maxsize = (recvdisps[i] + recvcounts[i]) * dt_size_recv;
681     }
682
683     if (sendbuf == MPI_IN_PLACE) {
684       sendtmpbuf = static_cast<void*>(xbt_malloc(maxsize));
685       memcpy(sendtmpbuf, recvbuf, maxsize);
686       sendtmpcounts = static_cast<int*>(xbt_malloc(size * sizeof(int)));
687       memcpy(sendtmpcounts, recvcounts, size * sizeof(int));
688       sendtmpdisps = static_cast<int*>(xbt_malloc(size * sizeof(int)));
689       memcpy(sendtmpdisps, recvdisps, size * sizeof(int));
690       sendtmptype = recvtype;
691     }
692
693     extra->datatype1 = encode_datatype(sendtmptype);
694     int dt_size_send = sendtmptype->size();
695
696     for (i = 0; i < size; i++) { // copy data to avoid bad free
697       extra->send_size += sendtmpcounts[i] * dt_size_send;
698       extra->sendcounts[i] = sendtmpcounts[i] * dt_size_send;
699     }
700     extra->num_processes = size;
701     TRACE_smpi_collective_in(rank, __FUNCTION__, extra);
702     retval = simgrid::smpi::Colls::alltoallv(sendtmpbuf, sendtmpcounts, sendtmpdisps, sendtmptype, recvbuf, recvcounts,
703                                     recvdisps, recvtype, comm);
704     TRACE_smpi_collective_out(rank);
705
706     if (sendbuf == MPI_IN_PLACE) {
707       xbt_free(sendtmpbuf);
708       xbt_free(sendtmpcounts);
709       xbt_free(sendtmpdisps);
710     }
711   }
712
713   smpi_bench_begin();
714   return retval;
715 }
716
717 }