Logo AND Algorithmique Numérique Distribuée

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