4 #include "smpi_coll_private.h"
5 #include "smpi_mpi_dt_private.h"
7 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi, smpi,
8 "Logging specific to SMPI (mpi)");
10 /* MPI User level calls */
12 int MPI_Init(int* argc, char*** argv) {
13 smpi_process_init(argc, argv);
14 smpi_bench_begin(-1, NULL);
18 int MPI_Finalize(void) {
19 smpi_bench_end(-1, NULL);
20 smpi_process_destroy();
24 int MPI_Init_thread(int* argc, char*** argv, int required, int* provided) {
25 if(provided != NULL) {
26 *provided = MPI_THREAD_MULTIPLE;
28 return MPI_Init(argc, argv);
31 int MPI_Query_thread(int* provided) {
34 smpi_bench_end(-1, NULL);
35 if(provided == NULL) {
38 *provided = MPI_THREAD_MULTIPLE;
41 smpi_bench_begin(-1, NULL);
45 int MPI_Is_thread_main(int* flag) {
48 smpi_bench_end(-1, NULL);
52 *flag = smpi_process_index() == 0;
55 smpi_bench_begin(-1, NULL);
59 int MPI_Abort(MPI_Comm comm, int errorcode) {
60 smpi_bench_end(-1, NULL);
61 smpi_process_destroy();
62 // FIXME: should kill all processes in comm instead
63 SIMIX_process_kill(SIMIX_process_self());
67 double MPI_Wtime(void) {
70 smpi_bench_end(-1, NULL);
71 time = SIMIX_get_clock();
72 smpi_bench_begin(-1, NULL);
76 int MPI_Address(void *location, MPI_Aint *address) {
79 smpi_bench_end(-1, NULL);
83 *address = (MPI_Aint)location;
85 smpi_bench_begin(-1, NULL);
89 int MPI_Type_free(MPI_Datatype* datatype) {
92 smpi_bench_end(-1, NULL);
96 // FIXME: always fail for now
97 retval = MPI_ERR_TYPE;
99 smpi_bench_begin(-1, NULL);
103 int MPI_Type_size(MPI_Datatype datatype, size_t* size) {
106 smpi_bench_end(-1, NULL);
107 if(datatype == MPI_DATATYPE_NULL) {
108 retval = MPI_ERR_TYPE;
109 } else if(size == NULL) {
110 retval = MPI_ERR_ARG;
112 *size = smpi_datatype_size(datatype);
113 retval = MPI_SUCCESS;
115 smpi_bench_begin(-1, NULL);
119 int MPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint* lb, MPI_Aint* extent) {
122 smpi_bench_end(-1, NULL);
123 if(datatype == MPI_DATATYPE_NULL) {
124 retval = MPI_ERR_TYPE;
125 } else if(lb == NULL || extent == NULL) {
126 retval = MPI_ERR_ARG;
128 retval = smpi_datatype_extent(datatype, lb, extent);
130 smpi_bench_begin(-1, NULL);
134 int MPI_Type_extent(MPI_Datatype datatype, MPI_Aint* extent) {
138 smpi_bench_end(-1, NULL);
139 if(datatype == MPI_DATATYPE_NULL) {
140 retval = MPI_ERR_TYPE;
141 } else if(extent == NULL) {
142 retval = MPI_ERR_ARG;
144 retval = smpi_datatype_extent(datatype, &dummy, extent);
146 smpi_bench_begin(-1, NULL);
150 int MPI_Type_lb(MPI_Datatype datatype, MPI_Aint* disp) {
153 smpi_bench_end(-1, NULL);
154 if(datatype == MPI_DATATYPE_NULL) {
155 retval = MPI_ERR_TYPE;
156 } else if(disp == NULL) {
157 retval = MPI_ERR_ARG;
159 *disp = smpi_datatype_lb(datatype);
160 retval = MPI_SUCCESS;
162 smpi_bench_begin(-1, NULL);
166 int MPI_Type_ub(MPI_Datatype datatype, MPI_Aint* disp) {
169 smpi_bench_end(-1, NULL);
170 if(datatype == MPI_DATATYPE_NULL) {
171 retval = MPI_ERR_TYPE;
172 } else if(disp == NULL) {
173 retval = MPI_ERR_ARG;
175 *disp = smpi_datatype_ub(datatype);
176 retval = MPI_SUCCESS;
178 smpi_bench_begin(-1, NULL);
182 int MPI_Op_create(MPI_User_function* function, int commute, MPI_Op* op) {
185 smpi_bench_end(-1, NULL);
186 if(function == NULL || op == NULL) {
187 retval = MPI_ERR_ARG;
189 *op = smpi_op_new(function, commute);
190 retval = MPI_SUCCESS;
192 smpi_bench_begin(-1, NULL);
196 int MPI_Op_free(MPI_Op* op) {
199 smpi_bench_end(-1, NULL);
201 retval = MPI_ERR_ARG;
202 } else if(*op == MPI_OP_NULL) {
205 smpi_op_destroy(*op);
207 retval = MPI_SUCCESS;
209 smpi_bench_begin(-1, NULL);
213 int MPI_Group_free(MPI_Group *group) {
216 smpi_bench_end(-1, NULL);
218 retval = MPI_ERR_ARG;
220 smpi_group_destroy(*group);
221 *group = MPI_GROUP_NULL;
222 retval = MPI_SUCCESS;
224 smpi_bench_begin(-1, NULL);
228 int MPI_Group_size(MPI_Group group, int* size) {
231 smpi_bench_end(-1, NULL);
232 if(group == MPI_GROUP_NULL) {
233 retval = MPI_ERR_GROUP;
234 } else if(size == NULL) {
235 retval = MPI_ERR_ARG;
237 *size = smpi_group_size(group);
238 retval = MPI_SUCCESS;
240 smpi_bench_begin(-1, NULL);
244 int MPI_Group_rank(MPI_Group group, int* rank) {
247 smpi_bench_end(-1, NULL);
248 if(group == MPI_GROUP_NULL) {
249 retval = MPI_ERR_GROUP;
250 } else if(rank == NULL) {
251 retval = MPI_ERR_ARG;
253 *rank = smpi_group_rank(group, smpi_process_index());
254 retval = MPI_SUCCESS;
256 smpi_bench_begin(-1, NULL);
260 int MPI_Group_translate_ranks (MPI_Group group1, int n, int* ranks1, MPI_Group group2, int* ranks2) {
261 int retval, i, index;
263 smpi_bench_end(-1, NULL);
264 if(group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
265 retval = MPI_ERR_GROUP;
267 for(i = 0; i < n; i++) {
268 index = smpi_group_index(group1, ranks1[i]);
269 ranks2[i] = smpi_group_rank(group2, index);
271 retval = MPI_SUCCESS;
273 smpi_bench_begin(-1, NULL);
277 int MPI_Group_compare(MPI_Group group1, MPI_Group group2, int* result) {
280 smpi_bench_end(-1, NULL);
281 if(group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
282 retval = MPI_ERR_GROUP;
283 } else if(result == NULL) {
284 retval = MPI_ERR_ARG;
286 *result = smpi_group_compare(group1, group2);
287 retval = MPI_SUCCESS;
289 smpi_bench_begin(-1, NULL);
293 int MPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group* newgroup) {
294 int retval, i, proc1, proc2, size, size2;
296 smpi_bench_end(-1, NULL);
297 if(group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
298 retval = MPI_ERR_GROUP;
299 } else if(newgroup == NULL) {
300 retval = MPI_ERR_ARG;
302 size = smpi_group_size(group1);
303 size2 = smpi_group_size(group2);
304 for(i = 0; i < size2; i++) {
305 proc2 = smpi_group_index(group2, i);
306 proc1 = smpi_group_rank(group1, proc2);
307 if(proc1 == MPI_UNDEFINED) {
312 *newgroup = MPI_GROUP_EMPTY;
314 *newgroup = smpi_group_new(size);
315 size2 = smpi_group_size(group1);
316 for(i = 0; i < size2; i++) {
317 proc1 = smpi_group_index(group1, i);
318 smpi_group_set_mapping(*newgroup, proc1, i);
320 for(i = size2; i < size; i++) {
321 proc2 = smpi_group_index(group2, i - size2);
322 smpi_group_set_mapping(*newgroup, proc2, i);
325 smpi_group_use(*newgroup);
326 retval = MPI_SUCCESS;
328 smpi_bench_begin(-1, NULL);
332 int MPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group* newgroup) {
333 int retval, i, proc1, proc2, size, size2;
335 smpi_bench_end(-1, NULL);
336 if(group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
337 retval = MPI_ERR_GROUP;
338 } else if(newgroup == NULL) {
339 retval = MPI_ERR_ARG;
341 size = smpi_group_size(group1);
342 size2 = smpi_group_size(group2);
343 for(i = 0; i < size2; i++) {
344 proc2 = smpi_group_index(group2, i);
345 proc1 = smpi_group_rank(group1, proc2);
346 if(proc1 == MPI_UNDEFINED) {
351 *newgroup = MPI_GROUP_EMPTY;
353 *newgroup = smpi_group_new(size);
354 size2 = smpi_group_size(group1);
355 for(i = 0; i < size2; i++) {
356 proc1 = smpi_group_index(group1, i);
357 proc2 = smpi_group_rank(group2, proc1);
358 if(proc2 != MPI_UNDEFINED) {
359 smpi_group_set_mapping(*newgroup, proc1, i);
363 smpi_group_use(*newgroup);
364 retval = MPI_SUCCESS;
366 smpi_bench_begin(-1, NULL);
370 int MPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group* newgroup) {
371 int retval, i, proc1, proc2, size, size2;
373 smpi_bench_end(-1, NULL);
374 if(group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
375 retval = MPI_ERR_GROUP;
376 } else if(newgroup == NULL) {
377 retval = MPI_ERR_ARG;
379 size = size2 = smpi_group_size(group1);
380 for(i = 0; i < size2; i++) {
381 proc1 = smpi_group_index(group1, i);
382 proc2 = smpi_group_rank(group2, proc1);
383 if(proc2 != MPI_UNDEFINED) {
388 *newgroup = MPI_GROUP_EMPTY;
390 *newgroup = smpi_group_new(size);
391 for(i = 0; i < size2; i++) {
392 proc1 = smpi_group_index(group1, i);
393 proc2 = smpi_group_rank(group2, proc1);
394 if(proc2 == MPI_UNDEFINED) {
395 smpi_group_set_mapping(*newgroup, proc1, i);
399 smpi_group_use(*newgroup);
400 retval = MPI_SUCCESS;
402 smpi_bench_begin(-1, NULL);
406 int MPI_Group_incl(MPI_Group group, int n, int* ranks, MPI_Group* newgroup) {
407 int retval, i, index;
409 smpi_bench_end(-1, NULL);
410 if(group == MPI_GROUP_NULL) {
411 retval = MPI_ERR_GROUP;
412 } else if(newgroup == NULL) {
413 retval = MPI_ERR_ARG;
416 *newgroup = MPI_GROUP_EMPTY;
417 } else if(n == smpi_group_size(group)) {
420 *newgroup = smpi_group_new(n);
421 for(i = 0; i < n; i++) {
422 index = smpi_group_index(group, ranks[i]);
423 smpi_group_set_mapping(*newgroup, index, i);
426 smpi_group_use(*newgroup);
427 retval = MPI_SUCCESS;
429 smpi_bench_begin(-1, NULL);
433 int MPI_Group_excl(MPI_Group group, int n, int* ranks, MPI_Group* newgroup) {
434 int retval, i, size, rank, index;
436 smpi_bench_end(-1, NULL);
437 if(group == MPI_GROUP_NULL) {
438 retval = MPI_ERR_GROUP;
439 } else if(newgroup == NULL) {
440 retval = MPI_ERR_ARG;
444 } else if(n == smpi_group_size(group)) {
445 *newgroup = MPI_GROUP_EMPTY;
447 size = smpi_group_size(group) - n;
448 *newgroup = smpi_group_new(size);
451 for(i = 0; i < n; i++) {
452 if(ranks[i] == rank) {
457 index = smpi_group_index(group, rank);
458 smpi_group_set_mapping(*newgroup, index, rank);
463 smpi_group_use(*newgroup);
464 retval = MPI_SUCCESS;
466 smpi_bench_begin(-1, NULL);
470 int MPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group* newgroup) {
471 int retval, i, j, rank, size, index;
473 smpi_bench_end(-1, NULL);
474 if(group == MPI_GROUP_NULL) {
475 retval = MPI_ERR_GROUP;
476 } else if(newgroup == NULL) {
477 retval = MPI_ERR_ARG;
480 *newgroup = MPI_GROUP_EMPTY;
483 for(i = 0; i < n; i++) {
484 for(rank = ranges[i][0]; /* First */
485 rank >= 0 && rank <= ranges[i][1]; /* Last */
486 rank += ranges[i][2] /* Stride */) {
490 if(size == smpi_group_size(group)) {
493 *newgroup = smpi_group_new(size);
495 for(i = 0; i < n; i++) {
496 for(rank = ranges[i][0]; /* First */
497 rank >= 0 && rank <= ranges[i][1]; /* Last */
498 rank += ranges[i][2] /* Stride */) {
499 index = smpi_group_index(group, rank);
500 smpi_group_set_mapping(*newgroup, index, j);
506 smpi_group_use(*newgroup);
507 retval = MPI_SUCCESS;
509 smpi_bench_begin(-1, NULL);
513 int MPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group* newgroup) {
514 int retval, i, newrank, rank, size, index, add;
516 smpi_bench_end(-1, NULL);
517 if(group == MPI_GROUP_NULL) {
518 retval = MPI_ERR_GROUP;
519 } else if(newgroup == NULL) {
520 retval = MPI_ERR_ARG;
525 size = smpi_group_size(group);
526 for(i = 0; i < n; i++) {
527 for(rank = ranges[i][0]; /* First */
528 rank >= 0 && rank <= ranges[i][1]; /* Last */
529 rank += ranges[i][2] /* Stride */) {
534 *newgroup = MPI_GROUP_EMPTY;
536 *newgroup = smpi_group_new(size);
538 while(newrank < size) {
539 for(i = 0; i < n; i++) {
541 for(rank = ranges[i][0]; /* First */
542 rank >= 0 && rank <= ranges[i][1]; /* Last */
543 rank += ranges[i][2] /* Stride */) {
544 if(rank == newrank) {
550 index = smpi_group_index(group, newrank);
551 smpi_group_set_mapping(*newgroup, index, newrank);
557 smpi_group_use(*newgroup);
558 retval = MPI_SUCCESS;
560 smpi_bench_begin(-1, NULL);
564 int MPI_Comm_rank(MPI_Comm comm, int* rank) {
567 smpi_bench_end(-1, NULL);
568 if(comm == MPI_COMM_NULL) {
569 retval = MPI_ERR_COMM;
571 *rank = smpi_comm_rank(comm);
572 retval = MPI_SUCCESS;
574 smpi_bench_begin(-1, NULL);
578 int MPI_Comm_size(MPI_Comm comm, int* size) {
581 smpi_bench_end(-1, NULL);
582 if(comm == MPI_COMM_NULL) {
583 retval = MPI_ERR_COMM;
584 } else if(size == NULL) {
585 retval = MPI_ERR_ARG;
587 *size = smpi_comm_size(comm);
588 retval = MPI_SUCCESS;
590 smpi_bench_begin(-1, NULL);
594 int MPI_Comm_group(MPI_Comm comm, MPI_Group* group) {
597 smpi_bench_end(-1, NULL);
598 if(comm == MPI_COMM_NULL) {
599 retval = MPI_ERR_COMM;
600 } else if(group == NULL) {
601 retval = MPI_ERR_ARG;
603 *group = smpi_comm_group(comm);
604 retval = MPI_SUCCESS;
606 smpi_bench_begin(-1, NULL);
610 int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int* result) {
613 smpi_bench_end(-1, NULL);
614 if(comm1 == MPI_COMM_NULL || comm2 == MPI_COMM_NULL) {
615 retval = MPI_ERR_COMM;
616 } else if(result == NULL) {
617 retval = MPI_ERR_ARG;
619 if(comm1 == comm2) { /* Same communicators means same groups */
622 *result = smpi_group_compare(smpi_comm_group(comm1), smpi_comm_group(comm2));
623 if(*result == MPI_IDENT) {
624 *result = MPI_CONGRUENT;
627 retval = MPI_SUCCESS;
629 smpi_bench_begin(-1, NULL);
633 int MPI_Comm_dup(MPI_Comm comm, MPI_Comm* newcomm) {
636 smpi_bench_end(-1, NULL);
637 if(comm == MPI_COMM_NULL) {
638 retval = MPI_ERR_COMM;
639 } else if(newcomm == NULL) {
640 retval = MPI_ERR_ARG;
642 *newcomm = smpi_comm_new(smpi_comm_group(comm));
643 retval = MPI_SUCCESS;
645 smpi_bench_begin(-1, NULL);
649 int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm* newcomm) {
652 smpi_bench_end(-1, NULL);
653 if(comm == MPI_COMM_NULL) {
654 retval = MPI_ERR_COMM;
655 } else if(group == MPI_GROUP_NULL) {
656 retval = MPI_ERR_GROUP;
657 } else if(newcomm == NULL) {
658 retval = MPI_ERR_ARG;
660 *newcomm = smpi_comm_new(group);
661 retval = MPI_SUCCESS;
663 smpi_bench_begin(-1, NULL);
667 int MPI_Comm_free(MPI_Comm* comm) {
670 smpi_bench_end(-1, NULL);
672 retval = MPI_ERR_ARG;
673 } else if(*comm == MPI_COMM_NULL) {
674 retval = MPI_ERR_COMM;
676 smpi_comm_destroy(*comm);
677 *comm = MPI_COMM_NULL;
678 retval = MPI_SUCCESS;
680 smpi_bench_begin(-1, NULL);
684 int MPI_Irecv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request) {
686 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
688 smpi_bench_end(rank, "Irecv");
689 if(request == NULL) {
690 retval = MPI_ERR_ARG;
691 } else if (comm == MPI_COMM_NULL) {
692 retval = MPI_ERR_COMM;
694 *request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
695 retval = MPI_SUCCESS;
697 smpi_bench_begin(rank, "Irecv");
701 int MPI_Isend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request) {
703 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
705 smpi_bench_end(rank, "Isend");
706 if(request == NULL) {
707 retval = MPI_ERR_ARG;
708 } else if (comm == MPI_COMM_NULL) {
709 retval = MPI_ERR_COMM;
711 *request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
712 retval = MPI_SUCCESS;
714 smpi_bench_begin(rank, "Isend");
718 int MPI_Recv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status* status) {
720 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
722 smpi_bench_end(rank, "Recv");
723 if (comm == MPI_COMM_NULL) {
724 retval = MPI_ERR_COMM;
726 smpi_mpi_recv(buf, count, datatype, src, tag, comm, status);
727 retval = MPI_SUCCESS;
729 smpi_bench_begin(rank, "Recv");
733 int MPI_Send(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
735 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
737 smpi_bench_end(rank, "Send");
738 if (comm == MPI_COMM_NULL) {
739 retval = MPI_ERR_COMM;
741 smpi_mpi_send(buf, count, datatype, dst, tag, comm);
742 retval = MPI_SUCCESS;
744 smpi_bench_begin(rank, "Send");
748 int MPI_Sendrecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int sendtag, void* recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status* status) {
750 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
752 smpi_bench_end(rank, "Sendrecv");
753 if (comm == MPI_COMM_NULL) {
754 retval = MPI_ERR_COMM;
755 } else if (sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
756 retval = MPI_ERR_TYPE;
758 smpi_mpi_sendrecv(sendbuf, sendcount, sendtype, dst, sendtag, recvbuf, recvcount, recvtype, src, recvtag, comm, status);
759 retval = MPI_SUCCESS;
761 smpi_bench_begin(rank, "Sendrecv");
765 int MPI_Sendrecv_replace(void* buf, int count, MPI_Datatype datatype, int dst, int sendtag, int src, int recvtag, MPI_Comm comm, MPI_Status* status) {
766 //TODO: suboptimal implementation
770 size = smpi_datatype_size(datatype) * count;
771 recvbuf = xbt_new(char, size);
772 retval = MPI_Sendrecv(buf, count, datatype, dst, sendtag, recvbuf, count, datatype, src, recvtag, comm, status);
773 memcpy(buf, recvbuf, size * sizeof(char));
778 int MPI_Test(MPI_Request* request, int* flag, MPI_Status* status) {
780 int rank = request && (*request)->comm != MPI_COMM_NULL
781 ? smpi_comm_rank((*request)->comm)
784 smpi_bench_end(rank, "Test");
785 if(request == NULL || flag == NULL) {
786 retval = MPI_ERR_ARG;
787 } else if(*request == MPI_REQUEST_NULL) {
788 retval = MPI_ERR_REQUEST;
790 *flag = smpi_mpi_test(request, status);
791 retval = MPI_SUCCESS;
793 smpi_bench_begin(rank, "Test");
797 int MPI_Testany(int count, MPI_Request requests[], int* index, int* flag, MPI_Status* status) {
800 smpi_bench_end(-1, NULL); //FIXME
801 if(index == NULL || flag == NULL) {
802 retval = MPI_ERR_ARG;
804 *flag = smpi_mpi_testany(count, requests, index, status);
805 retval = MPI_SUCCESS;
807 smpi_bench_begin(-1, NULL);
811 int MPI_Wait(MPI_Request* request, MPI_Status* status) {
813 int rank = request && (*request)->comm != MPI_COMM_NULL
814 ? smpi_comm_rank((*request)->comm)
817 smpi_bench_end(rank, "Wait");
818 if(request == NULL) {
819 retval = MPI_ERR_ARG;
820 } else if(*request == MPI_REQUEST_NULL) {
821 retval = MPI_ERR_REQUEST;
823 smpi_mpi_wait(request, status);
824 retval = MPI_SUCCESS;
826 smpi_bench_begin(rank, "Wait");
830 int MPI_Waitany(int count, MPI_Request requests[], int* index, MPI_Status* status) {
833 smpi_bench_end(-1, NULL); //FIXME
835 retval = MPI_ERR_ARG;
837 *index = smpi_mpi_waitany(count, requests, status);
838 retval = MPI_SUCCESS;
840 smpi_bench_begin(-1, NULL);
844 int MPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) {
845 smpi_bench_end(-1, NULL); //FIXME
846 smpi_mpi_waitall(count, requests, status);
847 smpi_bench_begin(-1, NULL);
851 int MPI_Waitsome(int incount, MPI_Request requests[], int* outcount, int* indices, MPI_Status status[]) {
854 smpi_bench_end(-1, NULL); //FIXME
855 if(outcount == NULL || indices == NULL) {
856 retval = MPI_ERR_ARG;
858 *outcount = smpi_mpi_waitsome(incount, requests, indices, status);
859 retval = MPI_SUCCESS;
861 smpi_bench_begin(-1, NULL);
865 int MPI_Bcast(void* buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm) {
867 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
869 smpi_bench_end(rank, "Bcast");
870 if(comm == MPI_COMM_NULL) {
871 retval = MPI_ERR_COMM;
873 smpi_mpi_bcast(buf, count, datatype, root, comm);
874 retval = MPI_SUCCESS;
876 smpi_bench_begin(rank, "Bcast");
880 int MPI_Barrier(MPI_Comm comm) {
882 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
884 smpi_bench_end(rank, "Barrier");
885 if(comm == MPI_COMM_NULL) {
886 retval = MPI_ERR_COMM;
888 smpi_mpi_barrier(comm);
889 retval = MPI_SUCCESS;
891 smpi_bench_begin(rank, "Barrier");
895 int MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm) {
897 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
899 smpi_bench_end(rank, "Gather");
900 if(comm == MPI_COMM_NULL) {
901 retval = MPI_ERR_COMM;
902 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
903 retval = MPI_ERR_TYPE;
905 smpi_mpi_gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
906 retval = MPI_SUCCESS;
908 smpi_bench_begin(rank, "Gather");
912 int MPI_Gatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int* recvcounts, int* displs, MPI_Datatype recvtype, int root, MPI_Comm comm) {
914 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
916 smpi_bench_end(rank, "Gatherv");
917 if(comm == MPI_COMM_NULL) {
918 retval = MPI_ERR_COMM;
919 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
920 retval = MPI_ERR_TYPE;
921 } else if(recvcounts == NULL || displs == NULL) {
922 retval = MPI_ERR_ARG;
924 smpi_mpi_gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm);
925 retval = MPI_SUCCESS;
927 smpi_bench_begin(rank, "Gatherv");
931 int MPI_Allgather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm) {
933 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
935 smpi_bench_end(rank, "Allgather");
936 if(comm == MPI_COMM_NULL) {
937 retval = MPI_ERR_COMM;
938 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
939 retval = MPI_ERR_TYPE;
941 smpi_mpi_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
942 retval = MPI_SUCCESS;
944 smpi_bench_begin(rank, "Allgather");
948 int MPI_Allgatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int* recvcounts, int* displs, MPI_Datatype recvtype, MPI_Comm comm) {
950 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
952 smpi_bench_end(rank, "Allgatherv");
953 if(comm == MPI_COMM_NULL) {
954 retval = MPI_ERR_COMM;
955 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
956 retval = MPI_ERR_TYPE;
957 } else if(recvcounts == NULL || displs == NULL) {
958 retval = MPI_ERR_ARG;
960 smpi_mpi_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
961 retval = MPI_SUCCESS;
963 smpi_bench_begin(rank, "Allgatherv");
967 int MPI_Scatter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm) {
969 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
971 smpi_bench_end(rank, "Scatter");
972 if(comm == MPI_COMM_NULL) {
973 retval = MPI_ERR_COMM;
974 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
975 retval = MPI_ERR_TYPE;
977 smpi_mpi_scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
978 retval = MPI_SUCCESS;
980 smpi_bench_begin(rank, "Scatter");
984 int MPI_Scatterv(void* sendbuf, int* sendcounts, int* displs, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm) {
986 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
988 smpi_bench_end(rank, "Scatterv");
989 if(comm == MPI_COMM_NULL) {
990 retval = MPI_ERR_COMM;
991 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
992 retval = MPI_ERR_TYPE;
993 } else if(sendcounts == NULL || displs == NULL) {
994 retval = MPI_ERR_ARG;
996 smpi_mpi_scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
997 retval = MPI_SUCCESS;
999 smpi_bench_begin(rank, "Scatterv");
1003 int MPI_Reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm) {
1005 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1007 smpi_bench_end(rank, "Reduce");
1008 if(comm == MPI_COMM_NULL) {
1009 retval = MPI_ERR_COMM;
1010 } else if(datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) {
1011 retval = MPI_ERR_ARG;
1013 smpi_mpi_reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
1014 retval = MPI_SUCCESS;
1016 smpi_bench_begin(rank, "Reduce");
1020 int MPI_Allreduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm) {
1022 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1024 smpi_bench_end(rank, "Allreduce");
1025 if(comm == MPI_COMM_NULL) {
1026 retval = MPI_ERR_COMM;
1027 } else if(datatype == MPI_DATATYPE_NULL) {
1028 retval = MPI_ERR_TYPE;
1029 } else if(op == MPI_OP_NULL) {
1030 retval = MPI_ERR_OP;
1032 smpi_mpi_allreduce(sendbuf, recvbuf, count, datatype, op, comm);
1033 retval = MPI_SUCCESS;
1035 smpi_bench_begin(rank, "Allreduce");
1039 int MPI_Scan(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm) {
1041 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1043 smpi_bench_end(rank, "Scan");
1044 if(comm == MPI_COMM_NULL) {
1045 retval = MPI_ERR_COMM;
1046 } else if(datatype == MPI_DATATYPE_NULL) {
1047 retval = MPI_ERR_TYPE;
1048 } else if(op == MPI_OP_NULL) {
1049 retval = MPI_ERR_OP;
1051 smpi_mpi_scan(sendbuf, recvbuf, count, datatype, op, comm);
1052 retval = MPI_SUCCESS;
1054 smpi_bench_begin(rank, "Scan");
1058 int MPI_Reduce_scatter(void* sendbuf, void* recvbuf, int* recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm) {
1059 int retval, i, size, count;
1061 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1063 smpi_bench_end(rank, "Reduce_scatter");
1064 if(comm == MPI_COMM_NULL) {
1065 retval = MPI_ERR_COMM;
1066 } else if(datatype == MPI_DATATYPE_NULL) {
1067 retval = MPI_ERR_TYPE;
1068 } else if(op == MPI_OP_NULL) {
1069 retval = MPI_ERR_OP;
1070 } else if(recvcounts == NULL) {
1071 retval = MPI_ERR_ARG;
1073 /* arbitrarily choose root as rank 0 */
1074 /* TODO: faster direct implementation ? */
1075 size = smpi_comm_size(comm);
1077 displs = xbt_new(int, size);
1078 for(i = 0; i < size; i++) {
1079 count += recvcounts[i];
1082 smpi_mpi_reduce(sendbuf, recvbuf, count, datatype, op, 0, comm);
1083 smpi_mpi_scatterv(recvbuf, recvcounts, displs, datatype, recvbuf, recvcounts[rank], datatype, 0, comm);
1085 retval = MPI_SUCCESS;
1087 smpi_bench_begin(rank, "Reduce_scatter");
1091 int MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm) {
1092 int retval, size, sendsize;
1093 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1095 smpi_bench_end(rank, "Alltoall");
1096 if(comm == MPI_COMM_NULL) {
1097 retval = MPI_ERR_COMM;
1098 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
1099 retval = MPI_ERR_TYPE;
1101 size = smpi_comm_size(comm);
1102 sendsize = smpi_datatype_size(sendtype) * sendcount;
1103 if(sendsize < 200 && size > 12) {
1104 retval = smpi_coll_tuned_alltoall_bruck(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
1105 } else if(sendsize < 3000) {
1106 retval = smpi_coll_tuned_alltoall_basic_linear(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
1108 retval = smpi_coll_tuned_alltoall_pairwise(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
1111 smpi_bench_begin(rank, "Alltoall");
1115 int MPI_Alltoallv(void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int* recvdisps, MPI_Datatype recvtype, MPI_Comm comm) {
1117 int rank = comm != MPI_COMM_NULL ? smpi_comm_rank(comm) : -1;
1119 smpi_bench_end(rank, "Alltoallv");
1120 if(comm == MPI_COMM_NULL) {
1121 retval = MPI_ERR_COMM;
1122 } else if(sendtype == MPI_DATATYPE_NULL || recvtype == MPI_DATATYPE_NULL) {
1123 retval = MPI_ERR_TYPE;
1124 } else if(sendcounts == NULL || senddisps == NULL || recvcounts == NULL || recvdisps == NULL) {
1125 retval = MPI_ERR_ARG;
1127 retval = smpi_coll_basic_alltoallv(sendbuf, sendcounts, senddisps, sendtype, recvbuf, recvcounts, recvdisps, recvtype, comm);
1129 smpi_bench_begin(rank, "Alltoallv");
1134 int MPI_Get_processor_name( char *name, int *resultlen ) {
1135 int retval = MPI_SUCCESS;
1136 smpi_bench_end(-1, NULL);
1137 strncpy( name , SIMIX_host_get_name(SIMIX_host_self()), MPI_MAX_PROCESSOR_NAME-1);
1138 *resultlen= strlen(name) > MPI_MAX_PROCESSOR_NAME ? MPI_MAX_PROCESSOR_NAME : strlen(name);
1140 smpi_bench_begin(-1, NULL);