source: XIOS/dev/branch_openmp/extern/ep_dev/main.cpp @ 1527

Last change on this file since 1527 was 1527, checked in by yushan, 3 years ago

save dev

File size: 43.2 KB
Line 
1#include "ep_lib.hpp"
2
3#include <stdio.h>
4#include <assert.h>
5#include "ep_declaration.hpp"
6#include <omp.h>
7#include <time.h>       /* time */
8#include <ctime>
9#include <ratio>
10#include <chrono>
11
12using namespace ep_lib;
13using namespace std::chrono;
14
15
16
17int main(int argc, char **argv)
18{
19  srand (time(NULL));
20
21  //printf("Testing ep_lib\n");
22  int required=3, provided;
23
24  MPI_Init_thread(&argc, &argv, required, &provided);
25
26  assert(required==provided);
27
28  int mpi_rank;
29  int mpi_size;
30
31  MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
32  MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
33
34  #pragma omp parallel default(shared)
35  {
36    MPI_Comm_rank(MPI_COMM_WORLD , &mpi_rank);
37
38    int num_ep = omp_get_num_threads();
39    MPI_Info info;
40
41    //printf("mpi_rank = %d, thread_num = %d\n", mpi_rank, omp_get_thread_num());
42
43    MPI_Comm *ep_comm;
44    #pragma omp master
45    {
46      MPI_Comm *ep_comm;
47      MPI_Comm_create_endpoints(MPI_COMM_WORLD->mpi_comm, num_ep, info, ep_comm);
48      passage = ep_comm; 
49    }
50
51    #pragma omp barrier
52
53    MPI_Comm comm; // this should act as EP_COMM_WORLD
54       
55    comm = passage[omp_get_thread_num()];
56
57    // TEST OF COMM_SPLIT
58    {
59
60      MPI_Barrier(comm);
61      int rank, size;
62      MPI_Comm_rank(comm, &rank);
63      MPI_Comm_size(comm, &size);
64   
65      int tab_color[16] = {2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1}; // used for config 1
66      int tab_key[16]   = {2, 1, 4, 1, 0, 4, 3, 3, 4, 3, 4, 4, 4, 0, 0, 2}; // used for config 1
67
68      int color = tab_color[rank];
69      int key = tab_key[rank];
70     
71 
72      MPI_Comm split_comm;
73      MPI_Comm_split(comm, color, key, &split_comm);
74
75
76   
77      int split_rank, split_size;
78      MPI_Comm_rank(split_comm, &split_rank);
79      MPI_Comm_size(split_comm, &split_size);
80   
81#ifdef _Memory_check   
82      printf("rank = %d, color = %d, key = %d, split_rank = %d, local_rank=%d\n", rank, color, key, split_rank, split_comm->ep_comm_ptr->size_rank_info[1].first);
83#endif
84
85      MPI_Barrier(comm);
86      MPI_Barrier(comm);
87      MPI_Barrier(comm);
88     
89      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n");
90
91
92      int local_leader = 0;
93      int remote_leader = color==2? 13: 4; // used for config 1
94
95      MPI_Comm peer_comm = comm;
96
97      MPI_Comm inter_comm;
98      MPI_Intercomm_create(split_comm, local_leader, peer_comm, remote_leader, 99, &inter_comm);
99
100      int inter_rank, inter_size, remote_size;
101      MPI_Comm_rank(inter_comm, &inter_rank);
102      MPI_Comm_size(inter_comm, &inter_size);
103      MPI_Comm_remote_size(inter_comm, &remote_size);
104     
105     
106      MPI_Barrier(comm);
107      MPI_Barrier(comm);
108
109      if(rank == 0) printf("            \t MPI_Intercomm_create \t OK\n");
110
111      //printf("rank = %d, split_rank = %d, split_size = %d, inter_rank=%d, inter_size=%d, remote_size=%d\n", rank, split_rank, split_size, inter_rank, inter_size, remote_size);
112
113
114      MPI_Comm_free(&split_comm);
115
116     
117      MPI_Barrier(comm);
118
119
120      if(color==2 && split_rank==0)
121      {
122        double sendbuf[9]={1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9};
123        MPI_Request send_request;
124        MPI_Status send_status;
125        MPI_Isend(sendbuf, 9, MPI_DOUBLE, 0, 10, inter_comm, &send_request);
126        MPI_Wait(&send_request, &send_status);
127      }
128
129      if(color==1 && split_rank==0)
130      {
131        double recvbuf[9];
132        MPI_Request recv_request;
133        MPI_Status recv_status;
134        MPI_Irecv(recvbuf, 9, MPI_DOUBLE, 0, 10, inter_comm, &recv_request);
135        MPI_Wait(&recv_request, &recv_status);
136        for(int i=0; i<9; i++)
137        {
138          printf("recvbuf[%d] = %lf\n", i, recvbuf[i]);
139        }
140      }
141
142      MPI_Barrier(comm);
143      MPI_Barrier(comm);
144
145      if(rank == 0) printf("            \t Test iP2P for intercomm \t OK\n");
146
147
148      MPI_Comm inter_comm_dup;
149      MPI_Comm_dup(inter_comm, &inter_comm_dup);
150      int inter_dup_rank, inter_dup_size;
151      MPI_Comm_rank(inter_comm_dup, &inter_dup_rank);
152      MPI_Comm_size(inter_comm_dup, &inter_dup_size);
153
154      //printf("rank = %d, split_rank = %d, split_size = %d, inter_dup_rank=%d, inter_dup_size=%d\n", rank, split_rank, split_size, inter_dup_rank, inter_dup_size);
155
156
157
158      MPI_Comm inter_comm_dup_merged;
159      bool high;
160      if(color==2) high=true;
161      else high = false;
162
163      MPI_Intercomm_merge(inter_comm_dup, high, &inter_comm_dup_merged);
164      int merged_rank, merged_size;
165      MPI_Comm_rank(inter_comm_dup_merged, &merged_rank);
166      MPI_Comm_size(inter_comm_dup_merged, &merged_size);
167
168      //printf("merged_rank=%d, merged_rank_loc=%d, root_ep_loc = %d\n", merged_rank, inter_comm_dup_merged->ep_comm_ptr->size_rank_info[1].first, inter_comm_dup_merged->ep_rank_map->at(0).first);
169
170      MPI_Barrier(comm);
171      MPI_Barrier(comm);
172           
173      int sendbuf=0;
174      if(merged_rank == 0) sendbuf = 99;
175      MPI_Bcast(&sendbuf, 1, MPI_INT, 0, inter_comm_dup_merged);
176      printf("merged_rank = %d, sendbuf = %d\n", merged_rank, sendbuf);
177
178
179
180      MPI_Barrier(comm);
181
182      MPI_Comm_free(&inter_comm_dup_merged);
183      MPI_Comm_free(&inter_comm_dup);
184
185
186
187
188      MPI_Comm_free(&inter_comm);
189           
190    }
191   
192   
193
194    MPI_Barrier(comm);
195    MPI_Comm_free(&comm);
196  }
197
198  //MPI_Finalize();
199  //return 0;
200
201
202
203 
204 
205
206  #pragma omp parallel default(shared)
207  {
208    MPI_Comm_rank(MPI_COMM_WORLD , &mpi_rank);
209
210    int num_ep = omp_get_num_threads();
211    MPI_Info info;
212
213    //printf("mpi_rank = %d, thread_num = %d\n", mpi_rank, omp_get_thread_num());
214
215    MPI_Comm *ep_comm;
216    #pragma omp master
217    {
218      MPI_Comm *ep_comm;
219      MPI_Comm_create_endpoints(MPI_COMM_WORLD->mpi_comm, num_ep, info, ep_comm);
220      passage = ep_comm; 
221    }
222
223    #pragma omp barrier
224
225
226    MPI_Comm comm_for_dup; // this should act as EP_COMM_WORLD
227    MPI_Comm comm; // this should act as EP_COMM_WORLD
228       
229    comm_for_dup = passage[omp_get_thread_num()];
230    MPI_Comm_dup(comm_for_dup, &comm);
231   
232    MPI_Comm_free(&comm_for_dup);
233   
234    MPI_Barrier(comm);
235
236    int rank, size;
237    MPI_Comm_rank(comm, &rank);
238    MPI_Comm_size(comm, &size);
239   
240    if(rank == 0) printf("           \t test MPI_Comm_dup \t OK \n");
241
242    // TIMING SYCHRONIZATION
243    {
244      int n=100000;
245
246      MPI_Barrier(comm);
247     
248      high_resolution_clock::time_point t1 = high_resolution_clock::now();
249
250      for(int i=0; i<n; i++)
251        MPI_Barrier_local(comm);
252
253      high_resolution_clock::time_point t2 = high_resolution_clock::now();
254      duration<double> time_span = duration_cast<duration<double>>(t2 - t1);
255      #pragma omp master
256      std::cout << "proc "<< mpi_rank <<" ep_barrier "<< time_span.count() << " seconds."<<std::endl;
257
258      t1 = high_resolution_clock::now();
259
260      for(int i=0; i<n; i++)
261      {
262        #pragma omp barrier
263      }
264
265      t2 = high_resolution_clock::now();
266      time_span = duration_cast<duration<double>>(t2 - t1);
267     
268      #pragma omp master
269      std::cout << "proc "<< mpi_rank <<" omp_barrier "<< time_span.count() << " seconds."<<std::endl;
270
271      t1 = high_resolution_clock::now();
272
273      for(int i=0; i<n; i++)
274      {
275        //#pragma omp barrier
276      }
277
278      t2 = high_resolution_clock::now();
279      time_span = duration_cast<duration<double>>(t2 - t1);
280     
281      MPI_Barrier(comm);
282
283      #pragma omp master
284      std::cout << "proc "<< mpi_rank <<" for_loop "<< time_span.count() << " seconds."<<std::endl;
285    }// END TIMING SYCHRONIZATION
286   
287    // TEST of p2p blocking communication
288    {
289      MPI_Barrier(comm);
290      MPI_Barrier(comm);
291     
292      MPI_Comm equal_comm = comm;
293     
294     
295     
296     
297      double sendbuf[10];
298      double recvbuf[20];
299     
300      int sender;
301      if(rank == 0) sender = rand() % size;
302      MPI_Bcast(&sender, 1, MPI_INT, 0, comm);
303     
304      int receiver = sender;
305      if(rank == 0) while(sender == receiver) {receiver = rand() % size;}
306      MPI_Bcast(&receiver, 1, MPI_INT, 0, comm);
307     
308     
309     
310     
311      if(rank == sender)
312      {
313        for(int i=0; i<10; i++) sendbuf[i] = 99.99;
314        MPI_Send(sendbuf, 10, MPI_DOUBLE, receiver, 99, equal_comm);
315        for(int i=0; i<10; i++) sendbuf[i] = -99.99;
316        MPI_Send(sendbuf, 10, MPI_DOUBLE, receiver, 11, equal_comm);
317      }
318     
319      if(rank == receiver)
320      {
321        MPI_Status status;
322        for(int i=0; i<20; i++) recvbuf[i] = 0.0;
323        MPI_Recv(&recvbuf[10], 10, MPI_DOUBLE, sender, 99, comm, &status);
324        MPI_Recv(recvbuf, 10, MPI_DOUBLE, sender, 11, comm, &status);
325       
326        for(int i=0; i<20; i++) std::cout << "recvbuf["<< i <<"] = "<< recvbuf[i] << std::endl;
327        printf("sender = %d\nreceiver = %d \tTEST of p2p blocking communication\tOK\n", sender, receiver);
328      }
329     
330      MPI_Barrier(comm);
331   
332    }//TEST of p2p blocking communication
333   
334    // TEST of p2p non-blocking communication
335    {
336      MPI_Barrier(comm);
337      MPI_Barrier(comm);
338     
339      double sendbuf[10];
340      double recvbuf[20];
341     
342      int sender;
343      if(rank == 0) sender = rand() % size;
344      MPI_Bcast(&sender, 1, MPI_INT, 0, comm);
345     
346      int receiver = sender;
347      if(rank == 0) receiver = rand() % size;
348      MPI_Bcast(&receiver, 1, MPI_INT, 0, comm);
349
350
351           
352      MPI_Request request[2];
353     
354      if(rank == sender)
355      {
356       
357        for(int i=0; i<10; i++) sendbuf[i] = 99.99;
358        MPI_Isend(sendbuf, 10, MPI_DOUBLE, receiver, 99, comm, &request[0]);
359        for(int i=0; i<10; i++) sendbuf[i] = -99.99;
360        MPI_Isend(sendbuf, 10, MPI_DOUBLE, receiver, 11, comm, &request[1]);
361      }
362     
363      if(rank == receiver)
364      {
365        for(int i=0; i<20; i++) recvbuf[i] = 0.0;
366        MPI_Irecv(&recvbuf[10], 10, MPI_DOUBLE, sender, 11, comm, &request[0]);
367        MPI_Irecv(recvbuf, 10, MPI_DOUBLE, sender, 99, comm, &request[1]);
368      }
369     
370      MPI_Barrier(comm);
371     
372      if(rank == receiver || rank == sender)
373      {
374        MPI_Status status[2];
375        MPI_Waitall(2, request, status);
376      }
377     
378      MPI_Barrier(comm);
379     
380      if(rank == receiver)
381      {
382        for(int i=0; i<20; i++) std::cout << "recvbuf["<< i <<"] = "<< recvbuf[i] << std::endl;
383        printf("sender = %d\nreceiver = %d \tTEST of p2p non-blocking communication\tOK\n", sender, receiver);
384      }
385   
386    }//TEST of p2p blocking communication
387   
388
389    // TEST OF BCAST FROM A RANDOM ROOT
390    {
391      int bcast_root;
392 
393      if(rank == 0) bcast_root = rand() % size;
394 
395      MPI_Bcast(&bcast_root, 1, MPI_INT, 0, comm);
396 
397      int sendbuf[2];
398
399      sendbuf[0] = rank;
400      sendbuf[1] = size;
401 
402      MPI_Bcast(sendbuf, 2, MPI_INT, bcast_root, comm);
403 
404      int bcast_test = 0;
405      if(sendbuf[0] ==  bcast_root && sendbuf[1] == size) bcast_test = 1;
406 
407      int bcast_result;
408 
409      MPI_Reduce(&bcast_test, &bcast_result, 1, MPI_INT, MPI_MIN, bcast_root, comm);
410 
411      if(bcast_result && rank == bcast_root)  printf("root = %d : \t test MPI_Bcast \t OK\n", bcast_root);
412      if(!bcast_result && rank == bcast_root) printf("root = %d : \t test MPI_Bcast \t FAILED %d\n", bcast_root, bcast_result);
413    }
414
415    MPI_Barrier(comm);
416
417    // TEST OF GATHER FROM A RAMDOM ROOT
418    {
419      int gather_root;
420 
421      if(rank == 0) gather_root = rand() % size;
422 
423      MPI_Bcast(&gather_root, 1, MPI_INT, 0, comm);
424
425      double sendbuf[2];
426      sendbuf[0] = rank * 1.0;
427      sendbuf[1] = size * (-1.0);
428
429      std::vector<double>recvbuf(2*size, 0);
430
431      MPI_Gather(sendbuf, 2, MPI_DOUBLE, recvbuf.data(), 2, MPI_DOUBLE, gather_root, comm);
432
433      bool gather_result = true;
434
435      if(rank == gather_root)
436      {
437        for(int i=0; i<size; i++)
438        {
439          if(abs(recvbuf[2*i] - i) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
440          {
441            gather_result = false;
442            break;
443          } 
444        }
445
446        if(gather_result) printf("root = %d : \t test MPI_Gather \t OK \n", gather_root);
447        else              printf("root = %d : \t test MPI_Gather \t FAILED\n", gather_root);
448      }
449    }
450
451    MPI_Barrier(comm);
452
453    // TEST OF GATHERV FROM A RAMDOM ROOT
454    {
455      int gatherv_root;
456 
457      if(rank == 0) gatherv_root = rand() % size;
458 
459      MPI_Bcast(&gatherv_root, 1, MPI_INT, 0, comm);
460
461      int sendbuf[2];
462      sendbuf[0] = rank;
463      sendbuf[1] = -size;
464
465      std::vector<int>recvbuf(2*size, 0);
466
467      std::vector<int>recvcounts(size, 2);
468      std::vector<int>displs(size, 0);
469
470      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
471
472      MPI_Gatherv(sendbuf, 2, MPI_INT, recvbuf.data(), recvcounts.data(), displs.data(), MPI_INT, gatherv_root, comm);
473
474      bool gatherv_result = true;
475
476      if(rank == gatherv_root)
477      {
478        for(int i=0; i<size; i++)
479        {
480          if(abs(recvbuf[2*i] - (size-1-i)) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
481          {
482            gatherv_result = false; printf("%lf %lf root = %d, i = %d\n", recvbuf[2*i], recvbuf[2*i+1], gatherv_root, i);
483            break;
484          } 
485        }
486       
487        //for(int i=0; i<size*2; i++) printf("%lf\t", recvbuf[i]);
488        //printf("\n");
489
490        if(gatherv_result) printf("root = %d : \t test MPI_Gatherv \t OK\n", gatherv_root);
491        else               printf("root = %d : \t test MPI_Gatherv \t FAILED\n", gatherv_root);
492      }
493    }
494
495    MPI_Barrier(comm);
496
497    // TEST OF ALLGATHER
498    {
499      double sendbuf[2];
500      sendbuf[0] = rank * 1.0;
501      sendbuf[1] = size * (-1.0);
502
503      std::vector<double>recvbuf(2*size, 0);
504
505      MPI_Allgather(sendbuf, 2, MPI_DOUBLE, recvbuf.data(), 2, MPI_DOUBLE, comm);
506
507      int allgather_test = 1;
508
509      for(int i=0; i<size; i++)
510      {
511        if(abs(recvbuf[2*i] - i) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
512        {
513          allgather_test = 0;
514          break;
515        } 
516      }
517
518      int allgather_result;
519      MPI_Reduce(&allgather_test, &allgather_result, 1, MPI_INT, MPI_MIN, 0, comm);
520
521      if(rank == 0 && allgather_result)  printf("           \t test MPI_Allgather \t OK \n");
522      if(rank == 0 && !allgather_result) printf("           \t test MPI_Allgather \t OK \n");
523     
524    }
525
526    MPI_Barrier(comm);
527
528    // TEST OF ALLGATHERV
529    {
530      int sendbuf[2];
531      sendbuf[0] = rank;
532      sendbuf[1] = -size;
533
534      std::vector<int>recvbuf(2*size, 0);
535
536      std::vector<int>recvcounts(size, 2);
537      std::vector<int>displs(size, 0);
538
539      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
540
541      MPI_Allgatherv(sendbuf, 2, MPI_INT, recvbuf.data(), recvcounts.data(), displs.data(), MPI_INT, comm);
542
543      int allgatherv_test = 1;
544
545     
546     
547      for(int i=0; i<size; i++)
548      {
549        if(abs(recvbuf[2*i] - (size-1-i)) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
550        {
551          allgatherv_test = 0; printf("ID : %d %d %d %d %d\n", rank, recvbuf[2*i], recvbuf[2*i+1] , recvbuf[2*i] - (size-1-i), recvbuf[2*i+1] + size);
552          break;
553        } 
554      }
555       
556     
557      int allgatherv_result;
558      MPI_Reduce(&allgatherv_test, &allgatherv_result, 1, MPI_INT, MPI_MIN, 0, comm);
559
560      if(rank == 0 && allgatherv_result)  printf("           \t test MPI_Allgatherv \t OK \n");
561      if(rank == 0 && !allgatherv_result) printf("           \t test MPI_Allgatherv \t FAILED %d\n", allgatherv_result);
562     
563    }
564
565    MPI_Barrier(comm);
566
567    // TEST OF REDUCE
568    {
569      int reduce_root;
570 
571      if(rank == 0) reduce_root = rand() % size;
572 
573      MPI_Bcast(&reduce_root, 1, MPI_INT, 0, comm);
574
575      int sendbuf[2];
576      sendbuf[0] = rank;
577      sendbuf[1] = -size;
578
579      std::vector<int>recvbuf(2, 0);
580
581      MPI_Op op = MPI_MIN;
582
583      MPI_Reduce(sendbuf, recvbuf.data(), 2, MPI_INT, op, reduce_root, comm);
584
585
586      bool reduce_result = true;
587
588      if(rank == reduce_root)
589      {
590        for(int i=0; i<2; i++)
591        {
592          if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[1] + size * size) > 1.e-10) ) ||
593             (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) )               ||
594             (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) ) )
595          {
596            reduce_result = false; printf("%d %d root = %d, i = %d\n", recvbuf[0], recvbuf[1], reduce_root, i);
597            break;
598          } 
599        }
600      }
601
602      if(rank == reduce_root && reduce_result)  printf("root = %d : \t test MPI_Reduce \t OK\n", reduce_root);
603      if(rank == reduce_root && !reduce_result) printf("root = %d : \t test MPI_Reduce \t FAILED\n", reduce_root);
604    }
605   
606
607    MPI_Barrier(comm);
608
609    // TEST OF ALLREDUCE
610    {
611 
612      int sendbuf[2];
613      sendbuf[0] = rank;
614      sendbuf[1] = -size;
615
616      std::vector<int>recvbuf(2, 0);
617
618      MPI_Op op = MPI_MIN;
619
620      MPI_Allreduce(sendbuf, recvbuf.data(), 2, MPI_INT, op, comm);
621
622
623      int allreduce_test = 1;
624
625     
626      if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[1] + size * size) > 1.e-10) ) ||
627         (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) )               ||
628         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) ) )
629      {
630        allreduce_test = 0; printf("%d %d\n", recvbuf[0], recvbuf[1]);
631      } 
632     
633
634      int allreduce_result;
635      MPI_Reduce(&allreduce_test, &allreduce_result, 1, MPI_INT, MPI_MIN, 0, comm);
636
637      if(rank == 0 && allreduce_result)  printf("            \t test MPI_Allreduce \t OK\n");
638      if(rank == 0 && !allreduce_result) printf("            \t test MPI_Allreduce \t FAILED\n");
639    }
640
641
642    MPI_Barrier(comm);
643
644    // TEST OF REDUCE_SCATTER
645    {
646 
647      std::vector<int>sendbuf(2*size, rank);
648      std::vector<int>recvbuf(2, -1);
649      std::vector<int>recvcounts(size, 2);
650
651      MPI_Op op = MPI_MIN;
652
653      MPI_Reduce_scatter(sendbuf.data(), recvbuf.data(), recvcounts.data(), MPI_INT, op, comm);
654
655
656      int reduce_scatter_test = 1;
657
658     
659      if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[0]-(size-1)*size/2) > 1.e-10) ) ||
660         (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1]-(size-1)) > 1.e-10) )               ||
661         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] ) > 1.e-10) ) )
662      {
663        reduce_scatter_test = 0; //printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
664      } 
665   
666
667      int reduce_scatter_result;
668      MPI_Reduce(&reduce_scatter_test, &reduce_scatter_result, 1, MPI_INT, MPI_MIN, 0, comm);
669
670      if(rank == 0 && reduce_scatter_result)  printf("            \t test MPI_Reduce_scatter OK\n");
671      if(rank == 0 && !reduce_scatter_result) printf("            \t test MPI_Reduce_scatter FAILED\n");
672    }
673
674    MPI_Barrier(comm);
675
676    // TEST OF SCATTER
677    {
678
679      int scatter_root;
680 
681      if(rank == 0) scatter_root = rand() % size;
682 
683      MPI_Bcast(&scatter_root, 1, MPI_INT, 0, comm);
684 
685      std::vector<int>sendbuf(2*size, rank);
686      std::vector<int>recvbuf(2, -1);
687      std::vector<int>recvcounts(size, 2);
688
689      if(rank == scatter_root) 
690      {
691        for(int i=0; i<size; i++) 
692        {
693          sendbuf[2*i] = i;
694          sendbuf[2*i+1] = size;
695        }
696        //for(int i=0; i<size*2; i++) printf("%d\t", sendbuf[i]);
697      }
698
699
700      MPI_Scatter(sendbuf.data(), 2, MPI_INT, recvbuf.data(), 2, MPI_INT, scatter_root, comm);
701
702      //printf("ID = %d : %d %d\n", rank, recvbuf[0], recvbuf[1]);
703
704      int scatter_test = 1;
705
706     
707      if( abs(recvbuf[0]-rank) > 1.e-10 || abs(recvbuf[1]-size) > 1.e-10 )
708      {
709        scatter_test = 0; //printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
710      } 
711   
712
713      int scatter_result;
714      MPI_Reduce(&scatter_test, &scatter_result, 1, MPI_INT, MPI_MIN, scatter_root, comm);
715
716      if(rank == scatter_root && scatter_result)  printf("root = %d : \t test MPI_Scatter \t OK\n", scatter_root);
717      if(rank == scatter_root && !scatter_result) printf("root = %d : \t test MPI_Scatter \t FAILED\n", scatter_root);
718    }
719   
720    MPI_Barrier(comm);
721
722    // TEST OF SCATTERV
723    {
724
725      int scatterv_root;
726 
727      if(rank == 0) scatterv_root = rand() % size;
728 
729      MPI_Bcast(&scatterv_root, 1, MPI_INT, 0, comm);
730 
731      std::vector<int>sendbuf(2*size, rank);
732      std::vector<int>recvbuf(2, -1);
733      std::vector<int>sendcounts(size, 2);
734      std::vector<int>displs(size, 0);
735
736      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
737
738      if(rank == scatterv_root) 
739      {
740        for(int i=0; i<size; i++) 
741        {
742          sendbuf[2*i] = i;
743          sendbuf[2*i+1] = size;
744        }
745      }
746
747
748      MPI_Scatterv(sendbuf.data(), sendcounts.data(), displs.data(), MPI_INT, recvbuf.data(), 2, MPI_INT, scatterv_root, comm);
749
750      //printf("ID = %d : %d %d\n", rank, recvbuf[0], recvbuf[1]);
751
752      int scatterv_test = 1;
753
754     
755      if( abs(recvbuf[0]-(size-1-rank)) > 1.e-10 || abs(recvbuf[1]-size) > 1.e-10 )
756      {
757        scatterv_test = 0; printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
758      } 
759   
760
761      int scatterv_result;
762      MPI_Reduce(&scatterv_test, &scatterv_result, 1, MPI_INT, MPI_MIN, scatterv_root, comm);
763
764      if(rank == scatterv_root && scatterv_result)  printf("root = %d : \t test MPI_Scatterv \t OK\n", scatterv_root);
765      if(rank == scatterv_root && !scatterv_result) printf("root = %d : \t test MPI_Scatterv \t FAILED\n", scatterv_root);
766    }
767
768    MPI_Barrier(comm);
769
770    // TEST OF ALLTOALL
771    {
772
773      std::vector<int>sendbuf(size, rank);
774      std::vector<int>recvbuf(size, -1);
775           
776
777      MPI_Alltoall(sendbuf.data(), 1, MPI_INT, recvbuf.data(), 1, MPI_INT, comm);
778
779      int alltoall_result = 1;
780
781     
782      for(int i=0; i<size; i++)
783      if( abs(recvbuf[i]-i) > 1.e-10 )
784      {
785        alltoall_result = 0; printf("%d  id = %d\n", recvbuf[i], rank);
786      } 
787   
788      if(rank == 0 && alltoall_result)  printf("            \t test MPI_Alltoall \t OK\n");
789      if(rank == 0 && !alltoall_result) printf("            \t test MPI_Alltoall \t FAILED\n");
790    }
791
792    // TEST OF SCAN
793    {
794 
795      std::vector<int>sendbuf(2, rank);
796      std::vector<int>recvbuf(2, -1);
797
798      MPI_Op op = MPI_SUM;
799           
800
801      MPI_Scan(sendbuf.data(), recvbuf.data(), 2, MPI_INT, op, comm);
802
803      int scan_test = 1;
804
805      // printf(" ID=%d : %d  %d \n", rank, recvbuf[0], recvbuf[1]);
806     
807      if((op == MPI_SUM && (abs(recvbuf[0]-rank*(rank+1)/2) > 1.e-10 || abs(recvbuf[1]-rank*(rank+1)/2) > 1.e-10) ) ||
808         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1]) > 1.e-10) )  || 
809         (op == MPI_MAX && (abs(recvbuf[0] - rank) > 1.e-10 || abs(recvbuf[1] - rank) > 1.e-10) ) )
810      {
811        scan_test = 0; //printf("%d  id = %d\n", recvbuf[i], rank);
812      } 
813
814      int scan_result;
815      MPI_Reduce(&scan_test, &scan_result, 1, MPI_INT, MPI_MIN, 0, comm);
816   
817      if(rank == 0 && scan_result)  printf("            \t test MPI_Scan \t\t OK\n");
818      if(rank == 0 && !scan_result) printf("            \t test MPI_Scan \t\t FAILED\n");
819    }
820
821
822    // TEST OF EXSCAN
823    {
824 
825      std::vector<int>sendbuf(2, rank);
826      std::vector<int>recvbuf(2, -1);
827
828      MPI_Op op = MPI_SUM;
829           
830
831      MPI_Exscan(sendbuf.data(), recvbuf.data(), 2, MPI_INT, op, comm);
832
833      int exscan_test = 1;
834
835      // printf(" ID=%d : %d  %d \n", rank, recvbuf[0], recvbuf[1]);
836     
837      if(rank >0)
838      if((op == MPI_SUM && (abs(recvbuf[0]-rank*(rank-1)/2) > 1.e-10 || abs(recvbuf[1]-rank*(rank-1)/2) > 1.e-10) ) ||
839         (op == MPI_MIN && (abs(recvbuf[0] ) > 1.e-10 || abs(recvbuf[1]) > 1.e-10) )  || 
840         (op == MPI_MAX && (abs(recvbuf[0] - rank+1) > 1.e-10 || abs(recvbuf[1] - rank+1) > 1.e-10) ) )
841      {
842        exscan_test = 0; //printf("%d  id = %d\n", recvbuf[i], rank);
843      } 
844
845      int exscan_result;
846      MPI_Reduce(&exscan_test, &exscan_result, 1, MPI_INT, MPI_MIN, 0, comm);
847   
848      if(rank == 0 && exscan_result)  printf("            \t test MPI_Exscan \t OK\n");
849      if(rank == 0 && !exscan_result) printf("            \t test MPI_Exscan \t FAILED\n");
850    }
851
852
853
854    // TEST OF COMM_SPLIT
855    {
856
857      MPI_Barrier(comm);
858      int rank, size;
859      MPI_Comm_rank(comm, &rank);
860      MPI_Comm_size(comm, &size);
861   
862      int color = rand()%3;
863      int key = rand()%5;
864     
865      int color2 = rand()%3;
866      int key2 = rand()%5;
867 
868      MPI_Comm split_comm;
869      MPI_Comm_split(comm, color, key, &split_comm);
870
871     
872      MPI_Comm split_comm2;
873      MPI_Comm_split(comm, color2, key2, &split_comm2);
874
875
876   
877      int split_rank, split_size;
878      MPI_Comm_rank(split_comm, &split_rank);
879      MPI_Comm_size(split_comm, &split_size);
880   
881#ifdef _Memory_check   
882      printf("rank = %d, color = %d, key = %d, split_rank = %d, local_rank=%d\n", rank, color, key, split_rank, split_comm->ep_comm_ptr->size_rank_info[1].first);
883#endif
884
885      MPI_Barrier(comm);
886      MPI_Barrier(comm);
887      MPI_Barrier(comm);
888     
889      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n");
890     
891      MPI_Barrier(comm);
892      MPI_Barrier(comm);
893     
894      int bcast_buf_size=100;
895     
896      std::vector<int> bcast_buf(bcast_buf_size, 0);
897     
898      if(split_rank==0) bcast_buf.assign(bcast_buf_size, (color+1)*split_size);
899     
900      MPI_Bcast(bcast_buf.data(), bcast_buf_size, MPI_INT, 0, split_comm);
901     
902      int bcast_test = 0;
903      for(int i=0; i<bcast_buf_size; i++)
904      {
905        if(bcast_buf[i] != (color+1)*split_size)
906          bcast_test = 1;
907      }
908 
909      int bcast_result;
910 
911      MPI_Reduce(&bcast_test, &bcast_result, 1, MPI_INT, MPI_SUM, 0, comm);
912 
913      MPI_Barrier(split_comm);
914      MPI_Comm_free(&split_comm);
915     
916      MPI_Barrier(split_comm2);
917      MPI_Comm_free(&split_comm2);
918
919     
920     
921      if(bcast_result == 0 && rank == 0)  printf("            \t test MPI_Bcast for split comm\t OK\n");
922      if(bcast_result != 0 && rank == 0)  printf("            \t test MPI_Bcast for split comm\t FAILED %d\n", bcast_result);
923     
924    }
925   
926    MPI_Barrier(comm);
927    MPI_Barrier(comm);
928    MPI_Barrier(comm);
929   
930    // TESE OF INTERCOMM_CREATE
931    {
932      MPI_Barrier(comm);
933     
934      int rank, size;
935      MPI_Comm_rank(comm, &rank);
936      MPI_Comm_size(comm, &size);
937
938      int config = 1;
939      if(config=1)
940      {
941        assert(size == 16 && omp_get_num_threads()==4);
942      }
943     
944      int tab_color[16] = {2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1}; // used for config 1
945      int tab_key[16]   = {2, 1, 4, 1, 0, 4, 3, 3, 4, 3, 4, 4, 4, 0, 0, 2}; // used for config 1
946
947      int color = tab_color[rank];
948      int key = tab_key[rank];
949     
950 
951      MPI_Comm split_comm;
952      MPI_Comm_split(comm, color, key, &split_comm);
953
954   
955      int split_rank, split_size;
956      MPI_Comm_rank(split_comm, &split_rank);
957      MPI_Comm_size(split_comm, &split_size);
958
959
960     
961
962      MPI_Barrier(comm);
963      MPI_Barrier(comm);
964     
965      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n");
966     
967      MPI_Barrier(comm);
968      MPI_Barrier(comm);
969     
970     
971     
972     
973     
974      int local_leader = 0;
975      int remote_leader = color==2? 13: 4; // used for config 1
976
977      MPI_Comm peer_comm = comm;
978
979      MPI_Comm inter_comm;
980      MPI_Intercomm_create(split_comm, local_leader, peer_comm, remote_leader, 99, &inter_comm);
981
982      int inter_rank, inter_size, remote_size;
983      MPI_Comm_rank(inter_comm, &inter_rank);
984      MPI_Comm_size(inter_comm, &inter_size);
985      MPI_Comm_remote_size(inter_comm, &remote_size);
986     
987     
988      MPI_Barrier(comm);
989      MPI_Barrier(comm);
990
991      if(rank == 0) printf("            \t MPI_Intercomm_create \t OK\n");
992
993      printf("rank = %d, split_rank = %d, split_size = %d, inter_rank=%d, inter_size=%d, remote_size=%d\n", rank, split_rank, split_size, inter_rank, inter_size, remote_size);
994
995     
996      MPI_Barrier(comm);
997      MPI_Barrier(comm);
998
999
1000      if(color==2 && split_rank==0)
1001      {
1002        double sendbuf[9]={1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9};
1003        MPI_Request send_request;
1004        MPI_Status send_status;
1005        MPI_Isend(sendbuf, 9, MPI_DOUBLE, 0, 10, inter_comm, &send_request);
1006        MPI_Wait(&send_request, &send_status);
1007      }
1008
1009      if(color==1 && split_rank==0)
1010      {
1011        double recvbuf[9];
1012        MPI_Request recv_request;
1013        MPI_Status recv_status;
1014        MPI_Irecv(recvbuf, 9, MPI_DOUBLE, 0, 10, inter_comm, &recv_request);
1015        MPI_Wait(&recv_request, &recv_status);
1016        for(int i=0; i<9; i++)
1017        {
1018          printf("recvbuf[%d] = %lf\n", i, recvbuf[i]);
1019        }
1020      }
1021
1022      MPI_Barrier(comm);
1023      MPI_Barrier(comm);
1024
1025      if(rank == 0) printf("            \t Test iP2P for intercomm \t OK\n");
1026     
1027     
1028
1029
1030      MPI_Barrier(comm);
1031      MPI_Barrier(comm);
1032
1033      MPI_Barrier(split_comm);
1034      MPI_Comm_free(&split_comm);
1035
1036
1037      MPI_Barrier(comm);
1038      MPI_Barrier(comm);
1039
1040      MPI_Comm inter_comm_dup;
1041      MPI_Comm_dup(inter_comm, &inter_comm_dup);
1042
1043      int inter_comm_dup_size;
1044      int inter_comm_dup_remote_size;
1045      MPI_Comm_size(inter_comm_dup, &inter_comm_dup_size);
1046
1047      MPI_Comm_remote_size(inter_comm_dup, &inter_comm_dup_remote_size);
1048
1049      bool high = inter_comm_dup_size>inter_comm_dup_remote_size;
1050
1051
1052      printf("rank = %d, high = %d, inter_comm_dup_size = %d, inter_comm_dup_remote_size = %d\n", rank, high, inter_comm_dup_size, inter_comm_dup_remote_size);
1053
1054      MPI_Comm inter_comm_dup_merged;
1055
1056      MPI_Intercomm_merge(inter_comm_dup, high, &inter_comm_dup_merged);
1057     
1058      int inter_comm_dup_merged_rank;
1059      MPI_Comm_rank(inter_comm_dup_merged, &inter_comm_dup_merged_rank);
1060
1061      int inter_comm_dup_merged_size;
1062      MPI_Comm_size(inter_comm_dup_merged, &inter_comm_dup_merged_size);
1063
1064      //printf("rank = %d, inter_comm_dup_merged_rank = %d, inter_comm_dup_merged_size = %d\n", rank, inter_comm_dup_merged_rank, inter_comm_dup_merged_size);
1065     
1066     
1067      MPI_Barrier(inter_comm_dup_merged);
1068
1069      // TEST OF GATHER
1070      {
1071        int inter_comm_dup_merged_rank;
1072        MPI_Comm_rank(inter_comm_dup_merged, &inter_comm_dup_merged_rank);
1073
1074        int inter_comm_dup_merged_size;
1075        MPI_Comm_size(inter_comm_dup_merged, &inter_comm_dup_merged_size);
1076       
1077       
1078
1079        int gather_root = 99;
1080 
1081        if(inter_comm_dup_merged_rank == 0) 
1082        {
1083          gather_root = rand() % inter_comm_dup_merged_size;
1084        }
1085
1086
1087 
1088        MPI_Bcast(&gather_root, 1, MPI_INT, 0, inter_comm_dup_merged);
1089
1090        printf("rank = %d, inter_comm_dup_merged_rank = %d, inter_comm_dup_merged_size = %d, gather_root = %d\n", rank, inter_comm_dup_merged_rank, inter_comm_dup_merged_size, gather_root);
1091
1092
1093        double sendbuf[2];
1094        sendbuf[0] = inter_comm_dup_merged_rank * 1.0;
1095        sendbuf[1] = inter_comm_dup_merged_size * (-1.0);
1096
1097        std::vector<double>recvbuf(2*inter_comm_dup_merged_size, 0);
1098
1099        MPI_Gather(sendbuf, 2, MPI_DOUBLE, recvbuf.data(), 2, MPI_DOUBLE, gather_root, inter_comm_dup_merged);
1100
1101        bool gather_result = true;
1102
1103        if(inter_comm_dup_merged_rank == gather_root)
1104        {
1105          for(int i=0; i<inter_comm_dup_merged_size; i++)
1106          {
1107            if(abs(recvbuf[2*i] - i) > 1.e-10 || abs(recvbuf[2*i+1] + inter_comm_dup_merged_size) > 1.e-10)
1108            {
1109              gather_result = false;
1110              break;
1111            } 
1112          }
1113
1114          if(gather_result) printf("root = %d : \t test MPI_Gather for merged comm\t OK \n", gather_root);
1115          else              printf("root = %d : \t test MPI_Gather for merged comm\t FAILED\n", gather_root);
1116        }
1117      }
1118
1119      MPI_Barrier(inter_comm_dup_merged);
1120
1121      // TEST OF ALLREDUCE
1122      {
1123 
1124        int sendbuf[2];
1125        sendbuf[0] = inter_comm_dup_merged_rank;
1126        sendbuf[1] = -inter_comm_dup_merged_size;
1127
1128        std::vector<int>recvbuf(2, 0);
1129
1130        MPI_Op op = MPI_MIN;
1131
1132        MPI_Allreduce(sendbuf, recvbuf.data(), 2, MPI_INT, op, inter_comm_dup_merged);
1133
1134
1135        int allreduce_test = 1;
1136
1137     
1138        if((op == MPI_SUM && (abs(recvbuf[0]-(inter_comm_dup_merged_size-1)*inter_comm_dup_merged_size/2) > 1.e-10 || abs(recvbuf[1] + inter_comm_dup_merged_size * inter_comm_dup_merged_size) > 1.e-10) ) ||
1139           (op == MPI_MAX && (abs(recvbuf[0]-(inter_comm_dup_merged_size-1)) > 1.e-10 || abs(recvbuf[1] + inter_comm_dup_merged_size) > 1.e-10) )               ||
1140           (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] + inter_comm_dup_merged_size) > 1.e-10) ) )
1141        {
1142          allreduce_test = 0; printf("%d %d\n", recvbuf[0], recvbuf[1]);
1143        } 
1144     
1145
1146        int allreduce_result;
1147        MPI_Reduce(&allreduce_test, &allreduce_result, 1, MPI_INT, MPI_MIN, 0, inter_comm_dup_merged);
1148
1149        if(inter_comm_dup_merged_rank == 0 && allreduce_result)  printf("            \t test MPI_Allreduce for merged comm \t OK\n");
1150        if(inter_comm_dup_merged_rank == 0 && !allreduce_result) printf("            \t test MPI_Allreduce for merged comm \t FAILED\n");
1151   
1152      }
1153
1154      MPI_Barrier(inter_comm_dup_merged);
1155
1156      // TEST OF EXSCAN
1157      {
1158 
1159        std::vector<int>sendbuf(2, inter_comm_dup_merged_rank);
1160        std::vector<int>recvbuf(2, -1);
1161
1162        MPI_Op op = MPI_SUM;
1163           
1164
1165        MPI_Exscan(sendbuf.data(), recvbuf.data(), 2, MPI_INT, op, inter_comm_dup_merged);
1166
1167        int exscan_test = 1;
1168
1169        if(inter_comm_dup_merged_rank >0)
1170        if((op == MPI_SUM && (abs(recvbuf[0]-inter_comm_dup_merged_rank*(inter_comm_dup_merged_rank-1)/2) > 1.e-10 || abs(recvbuf[1]-inter_comm_dup_merged_rank*(inter_comm_dup_merged_rank-1)/2) > 1.e-10) ) ||
1171           (op == MPI_MIN && (abs(recvbuf[0] ) > 1.e-10 || abs(recvbuf[1]) > 1.e-10) )  || 
1172           (op == MPI_MAX && (abs(recvbuf[0] - inter_comm_dup_merged_rank+1) > 1.e-10 || abs(recvbuf[1] - inter_comm_dup_merged_rank+1) > 1.e-10) ) )
1173        {
1174          exscan_test = 0; 
1175        }
1176       
1177        int exscan_result;
1178        MPI_Reduce(&exscan_test, &exscan_result, 1, MPI_INT, MPI_MIN, 0, inter_comm_dup_merged);
1179   
1180        if(inter_comm_dup_merged_rank == 0 && exscan_result)  printf("            \t test MPI_Exscan for merged comm \t OK\n");
1181        if(inter_comm_dup_merged_rank == 0 && !exscan_result) printf("            \t test MPI_Exscan for merged comm \t FAILED %d\n", exscan_result);
1182      }
1183
1184      MPI_Barrier(inter_comm_dup_merged);
1185
1186      // TEST OF SCATTERV
1187      {
1188
1189        int scatterv_root;
1190 
1191        if(inter_comm_dup_merged_rank == 0) scatterv_root = rand() % inter_comm_dup_merged_size;
1192 
1193        MPI_Bcast(&scatterv_root, 1, MPI_INT, 0, inter_comm_dup_merged);
1194 
1195        std::vector<int>sendbuf(2*inter_comm_dup_merged_size, inter_comm_dup_merged_rank);
1196        std::vector<int>recvbuf(2, -1);
1197        std::vector<int>sendcounts(inter_comm_dup_merged_size, 2);
1198        std::vector<int>displs(inter_comm_dup_merged_size, 0);
1199
1200        for(int i=0; i<inter_comm_dup_merged_size; i++) displs[i] = 2*(inter_comm_dup_merged_size-1-i);
1201
1202        if(inter_comm_dup_merged_rank == scatterv_root) 
1203        {
1204          for(int i=0; i<inter_comm_dup_merged_size; i++) 
1205          {
1206            sendbuf[2*i] = i;
1207            sendbuf[2*i+1] = inter_comm_dup_merged_size;
1208          }
1209        }
1210
1211
1212        MPI_Scatterv(sendbuf.data(), sendcounts.data(), displs.data(), MPI_INT, recvbuf.data(), 2, MPI_INT, scatterv_root, inter_comm_dup_merged);
1213
1214        int scatterv_test = 1;
1215
1216     
1217        if( abs(recvbuf[0]-(inter_comm_dup_merged_size-1-inter_comm_dup_merged_rank)) > 1.e-10 || abs(recvbuf[1]-inter_comm_dup_merged_size) > 1.e-10 )
1218        {
1219          scatterv_test = 0; printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], inter_comm_dup_merged_rank);
1220        } 
1221   
1222
1223        int scatterv_result;
1224        MPI_Reduce(&scatterv_test, &scatterv_result, 1, MPI_INT, MPI_MIN, scatterv_root, inter_comm_dup_merged);
1225
1226        if(inter_comm_dup_merged_rank == scatterv_root && scatterv_result)  printf("root = %d : \t test MPI_Scatterv for merged comm \t OK\n", scatterv_root);
1227        if(inter_comm_dup_merged_rank == scatterv_root && !scatterv_result) printf("root = %d : \t test MPI_Scatterv for merged comm \t FAILED\n", scatterv_root);
1228      }
1229
1230      MPI_Barrier(inter_comm_dup_merged);
1231
1232      // TEST OF TESTALL
1233      {
1234        int merged_size, merged_rank;
1235        MPI_Comm_rank(inter_comm_dup_merged, &merged_rank);
1236        MPI_Comm_size(inter_comm_dup_merged, &merged_size);
1237       
1238        int left = merged_rank>0? merged_rank-1 : merged_size-1;
1239        int right = (merged_rank+1) % merged_size;
1240               
1241        int N=10000;
1242        int *left_buf = new int[N];
1243        int *right_buf = new int[N];
1244               
1245        for(int i=0; i<N; i++)
1246        {
1247          right_buf[i] = merged_rank*100000+i;
1248        }
1249       
1250        MPI_Request request[2];
1251        MPI_Status status[2];
1252       
1253        MPI_Irecv(left_buf, N, MPI_INT, left, 0, inter_comm_dup_merged, &request[0]);
1254        MPI_Isend(right_buf, N, MPI_INT, right, 0, inter_comm_dup_merged, &request[1]);
1255       
1256       
1257        int flag;
1258        MPI_Testall(2, request, &flag, status);
1259     
1260        printf("rank = %d, flag = %d\n", merged_rank, flag);
1261       
1262        while(!flag) MPI_Testall(2, request, &flag, status);
1263       
1264        int recv_count;
1265        MPI_Get_count(&status[0], MPI_INT, &recv_count);
1266       
1267        MPI_Barrier(inter_comm_dup_merged);
1268       
1269        printf("rank = %d, recv_count = %d, left_buf[5-10] = %d\t%d\t%d\t%d\t%d\t%d\n", merged_rank, recv_count, left_buf[5], left_buf[6], left_buf[7], left_buf[8], left_buf[9], left_buf[10]);
1270                       
1271        delete[] left_buf;
1272        delete[] right_buf;
1273      }
1274     
1275      MPI_Barrier(inter_comm_dup_merged);
1276
1277      // TEST WAITALL
1278      {
1279        int merged_rank;
1280        int merged_size;
1281
1282        MPI_Comm_rank(inter_comm_dup_merged, &merged_rank);
1283        MPI_Comm_size(inter_comm_dup_merged, &merged_size);
1284
1285        int left = merged_rank>0? merged_rank-1 : merged_size-1;
1286        int right = (merged_rank+1)%merged_size;
1287
1288        printf("merged_rank = %d, left = %d, right = %d\n", merged_rank, left, right);
1289
1290        int NN=10000;
1291
1292        double *left_buf = new double[NN];
1293        double *right_buf = new double[NN];
1294
1295        for(int i=0; i<NN; i++)
1296        {
1297          right_buf[i] = merged_rank*1000000 + i;
1298        }
1299
1300        MPI_Request request[2];
1301        MPI_Status  status[2];
1302
1303        MPI_Irecv(left_buf,  NN, MPI_DOUBLE, left,  0, inter_comm_dup_merged, &request[0]);
1304        MPI_Isend(right_buf, NN, MPI_DOUBLE, right, 0, inter_comm_dup_merged, &request[1]);
1305       
1306
1307        MPI_Waitall(2, request, status);
1308
1309        printf("merged_rank = %d, left_buf[0-4] = %lf\t%lf\t%lf\t%lf\t%lf\n", merged_rank, left_buf[0], left_buf[1], left_buf[2], left_buf[3], left_buf[4]);
1310
1311
1312        delete left_buf;
1313        delete right_buf;
1314      }
1315
1316
1317      MPI_Barrier(comm);
1318      MPI_Barrier(comm);
1319
1320
1321      MPI_Comm_free(&inter_comm_dup);
1322
1323      MPI_Barrier(comm);
1324      MPI_Barrier(comm);
1325
1326
1327      MPI_Comm_free(&inter_comm_dup_merged);
1328
1329
1330
1331      MPI_Barrier(comm);
1332      MPI_Barrier(comm);
1333
1334      MPI_Barrier(inter_comm);
1335      MPI_Comm_free(&inter_comm);
1336     
1337    }
1338
1339    // TESE OF INTERCOMM_CREATE
1340    {
1341      MPI_Barrier(comm);
1342     
1343      int rank, size;
1344      MPI_Comm_rank(comm, &rank);
1345      MPI_Comm_size(comm, &size);
1346
1347      int config = 1;
1348      if(config=1)
1349      {
1350        assert(size == 16 && omp_get_num_threads()==4);
1351      }
1352     
1353      int tab_color[16] = {2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1}; // used for config 1
1354      int tab_key[16]   = {2, 1, 4, 1, 0, 4, 3, 3, 4, 3, 4, 4, 4, 0, 0, 2}; // used for config 1
1355
1356      int color = tab_color[rank];
1357      int key = tab_key[rank];
1358     
1359 
1360      MPI_Comm split_comm;
1361      MPI_Comm_split(comm, color, key, &split_comm);
1362
1363   
1364      int split_rank, split_size;
1365      MPI_Comm_rank(split_comm, &split_rank);
1366      MPI_Comm_size(split_comm, &split_size);
1367
1368
1369     
1370
1371      MPI_Barrier(comm);
1372      MPI_Barrier(comm);
1373     
1374      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n");
1375     
1376      MPI_Barrier(comm);
1377      MPI_Barrier(comm);
1378     
1379           
1380      int local_leader = 5;
1381      int remote_leader = color==2? 5: 2; // used for config 1
1382
1383      MPI_Comm peer_comm = comm;
1384
1385      MPI_Comm inter_comm;
1386      MPI_Intercomm_create(split_comm, local_leader, peer_comm, remote_leader, 99, &inter_comm);
1387
1388      int inter_rank;
1389      int inter_size;
1390      MPI_Comm_rank(inter_comm, &inter_rank);
1391      MPI_Comm_size(inter_comm, &inter_size);
1392
1393      printf("split_rank = %d, inter_rank = %d / %d\n", split_rank, inter_rank, inter_size);
1394
1395      MPI_Barrier(split_comm);
1396      MPI_Comm_free(&split_comm);
1397
1398      MPI_Barrier(inter_comm);
1399      MPI_Comm_free(&inter_comm);
1400     
1401    }
1402 
1403    MPI_Barrier(comm);
1404    MPI_Comm_free(&comm);
1405  }
1406
1407/*
1408  int num_threads;
1409  if(mpi_rank < mpi_size-2)
1410  {
1411    printf("Proc %d is client\n", mpi_rank);
1412    num_threads = 2;//+mpi_rank;
1413  }
1414  else
1415  {
1416    printf("Proc %d is server\n", mpi_rank);
1417    num_threads = 1;
1418  }
1419 
1420  omp_set_num_threads(num_threads);
1421
1422  #pragma omp parallel default(shared) firstprivate(num_threads)
1423  {
1424    int num_ep = num_threads;
1425    MPI_Info info;
1426
1427    //printf("omp_get_thread_num() = %d, omp_get_num_threads() = %d, num_threads = %d\n", omp_get_thread_num(), omp_get_num_threads(), num_threads);
1428    MPI_Comm *ep_comm;
1429    #pragma omp master
1430    {
1431      MPI_Comm *ep_comm;
1432      MPI_Comm_create_endpoints(MPI_COMM_WORLD->mpi_comm, num_ep, info, ep_comm);
1433      passage = ep_comm; 
1434    }
1435
1436    #pragma omp barrier
1437
1438
1439    MPI_Comm comm; // this should act as EP_COMM_WORLD
1440    comm = passage[omp_get_thread_num()];
1441   
1442    int rank, size;
1443    MPI_Comm_rank(comm, &rank);
1444    MPI_Comm_size(comm, &size);
1445   
1446   
1447
1448    bool isClient = false;
1449    bool isServer = false;
1450
1451    if(omp_get_num_threads()>1) isClient = true;
1452    else isServer = true;
1453
1454    printf("mpi_rank = %d, ep_rank = %d, isClient = %d\n", mpi_rank, rank, isClient);
1455
1456    MPI_Win ep_win;
1457    MPI_Aint buf_size=1;
1458    int buf = rank;
1459    int local_buf = rank;
1460    int result_buf = -1;
1461    MPI_Win_create(&buf, buf_size, sizeof(int), info, comm, &ep_win);
1462    MPI_Barrier(comm);
1463   
1464    // MPI_Win_fence(MPI_MODE_NOPRECEDE, ep_win);
1465
1466    MPI_Barrier(comm);
1467    sleep(0.2);
1468    MPI_Barrier(comm);
1469
1470    MPI_Win_fence(0, ep_win);
1471
1472    if(rank == 0)
1473    {
1474      local_buf = 99;
1475      MPI_Aint displs=0;
1476      MPI_Put(&local_buf, 1, MPI_INT, size-1, displs, 1, MPI_INT, ep_win);
1477    }
1478
1479    if(rank == size-2)
1480    {
1481      MPI_Aint displs(0);
1482      MPI_Get(&local_buf, 1, MPI_INT, 2, displs, 1, MPI_INT, ep_win);
1483    }
1484
1485    MPI_Win_fence(0, ep_win);
1486
1487    if(rank == 1)
1488    {
1489      MPI_Aint displs=0;
1490      MPI_Accumulate(&local_buf, 1, MPI_INT, size-1, displs, 1, MPI_INT, MPI_REPLACE, ep_win);
1491    }
1492
1493
1494    MPI_Barrier(comm);
1495
1496    MPI_Win_fence(0, ep_win);
1497
1498    if(rank == 2)
1499    {
1500      MPI_Aint displs = 0;
1501      MPI_Get_accumulate(&local_buf, 1, MPI_INT, &result_buf,
1502                         1, MPI_INT, size-2, displs,
1503                         1, MPI_INT, MPI_SUM, ep_win);
1504    }
1505   
1506    MPI_Win_fence(0, ep_win);
1507   
1508    if(rank == 6)
1509    {
1510      MPI_Aint displs = 0;
1511      MPI_Fetch_and_op(&local_buf, &result_buf, MPI_INT, size-1, displs,
1512                       MPI_SUM, ep_win);
1513    }
1514
1515    MPI_Win_fence(0, ep_win);
1516
1517    if(rank == 7)
1518    {
1519      MPI_Aint displs = 0;
1520      MPI_Compare_and_swap(&local_buf, &buf, &result_buf, MPI_INT, size-1, displs, ep_win);
1521    }
1522
1523    MPI_Win_fence(0, ep_win);
1524
1525    //::MPI_Compare_and_swap(origin_addr, compare_addr, result_addr, to_mpi_type(datatype), target_mpi_rank, to_mpi_aint(target_disp), to_mpi_win(win.server_win[target_local_rank]));
1526
1527    MPI_Win ep_win_allocated;
1528    int* baseptr = new int[10];
1529    MPI_Aint base_size = 4;
1530
1531    MPI_Win_allocate (base_size, sizeof(int), info, comm, baseptr, &ep_win_allocated);
1532
1533    MPI_Win_fence(0, ep_win_allocated);
1534
1535    MPI_Win_free(&ep_win_allocated);
1536    delete[] baseptr;
1537
1538    MPI_Win_free(&ep_win);
1539    printf("rank = %d, buf = %d, local_buf = %d, result_buf = %d\n", rank, buf, local_buf, result_buf);
1540   
1541    MPI_Comm_free(&comm);
1542
1543  }
1544*/
1545  MPI_Finalize();
1546
1547}
Note: See TracBrowser for help on using the repository browser.