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

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

save dev

File size: 27.6 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
54    MPI_Comm comm_for_dup; // this should act as EP_COMM_WORLD
55    MPI_Comm comm; // this should act as EP_COMM_WORLD
56       
57    comm_for_dup = passage[omp_get_thread_num()];
58    MPI_Comm_dup(comm_for_dup, &comm);
59   
60    MPI_Comm_free(&comm_for_dup);
61   
62    MPI_Barrier(comm);
63
64    int rank, size;
65    MPI_Comm_rank(comm, &rank);
66    MPI_Comm_size(comm, &size);
67   
68    if(rank == 0) printf("           \t test MPI_Comm_dup \t OK \n");
69
70    // TIMING SYCHRONIZATION
71    {
72      int n=100000;
73
74      MPI_Barrier(comm);
75     
76      high_resolution_clock::time_point t1 = high_resolution_clock::now();
77
78      for(int i=0; i<n; i++)
79        MPI_Barrier_local(comm);
80
81      high_resolution_clock::time_point t2 = high_resolution_clock::now();
82      duration<double> time_span = duration_cast<duration<double>>(t2 - t1);
83      #pragma omp master
84      std::cout << "proc "<< mpi_rank <<" ep_barrier "<< time_span.count() << " seconds."<<std::endl;
85
86      t1 = high_resolution_clock::now();
87
88      for(int i=0; i<n; i++)
89      {
90        #pragma omp barrier
91      }
92
93      t2 = high_resolution_clock::now();
94      time_span = duration_cast<duration<double>>(t2 - t1);
95     
96      #pragma omp master
97      std::cout << "proc "<< mpi_rank <<" omp_barrier "<< time_span.count() << " seconds."<<std::endl;
98
99      t1 = high_resolution_clock::now();
100
101      for(int i=0; i<n; i++)
102      {
103        //#pragma omp barrier
104      }
105
106      t2 = high_resolution_clock::now();
107      time_span = duration_cast<duration<double>>(t2 - t1);
108     
109      MPI_Barrier(comm);
110
111      #pragma omp master
112      std::cout << "proc "<< mpi_rank <<" for_loop "<< time_span.count() << " seconds."<<std::endl;
113    }// END TIMING SYCHRONIZATION
114   
115    // TEST of p2p blocking communication
116    {
117      MPI_Barrier(comm);
118      MPI_Barrier(comm);
119     
120      MPI_Comm equal_comm = comm;
121     
122     
123     
124     
125      double sendbuf[10];
126      double recvbuf[20];
127     
128      int sender;
129      if(rank == 0) sender = rand() % size;
130      MPI_Bcast(&sender, 1, MPI_INT, 0, comm);
131     
132      int receiver = sender;
133      if(rank == 0) while(sender == receiver) {receiver = rand() % size;}
134      MPI_Bcast(&receiver, 1, MPI_INT, 0, comm);
135     
136     
137     
138     
139      if(rank == sender)
140      {
141        for(int i=0; i<10; i++) sendbuf[i] = 99.99;
142        MPI_Send(sendbuf, 10, MPI_DOUBLE, receiver, 99, equal_comm);
143        for(int i=0; i<10; i++) sendbuf[i] = -99.99;
144        MPI_Send(sendbuf, 10, MPI_DOUBLE, receiver, 11, equal_comm);
145      }
146     
147      if(rank == receiver)
148      {
149        MPI_Status status;
150        for(int i=0; i<20; i++) recvbuf[i] = 0.0;
151        MPI_Recv(&recvbuf[10], 10, MPI_DOUBLE, sender, 99, comm, &status);
152        MPI_Recv(recvbuf, 10, MPI_DOUBLE, sender, 11, comm, &status);
153       
154        for(int i=0; i<20; i++) std::cout << "recvbuf["<< i <<"] = "<< recvbuf[i] << std::endl;
155        printf("sender = %d\nreceiver = %d \tTEST of p2p blocking communication\tOK\n", sender, receiver);
156      }
157     
158      MPI_Barrier(comm);
159   
160    }//TEST of p2p blocking communication
161   
162    // TEST of p2p non-blocking communication
163    {
164      MPI_Barrier(comm);
165      MPI_Barrier(comm);
166     
167      double sendbuf[10];
168      double recvbuf[20];
169     
170      int sender;
171      if(rank == 0) sender = rand() % size;
172      MPI_Bcast(&sender, 1, MPI_INT, 0, comm);
173     
174      int receiver = sender;
175      if(rank == 0) receiver = rand() % size;
176      MPI_Bcast(&receiver, 1, MPI_INT, 0, comm);
177
178
179           
180      MPI_Request request[2];
181     
182      if(rank == sender)
183      {
184       
185        for(int i=0; i<10; i++) sendbuf[i] = 99.99;
186        MPI_Isend(sendbuf, 10, MPI_DOUBLE, receiver, 99, comm, &request[0]);
187        for(int i=0; i<10; i++) sendbuf[i] = -99.99;
188        MPI_Isend(sendbuf, 10, MPI_DOUBLE, receiver, 11, comm, &request[1]);
189      }
190     
191      if(rank == receiver)
192      {
193        for(int i=0; i<20; i++) recvbuf[i] = 0.0;
194        MPI_Irecv(&recvbuf[10], 10, MPI_DOUBLE, sender, 11, comm, &request[0]);
195        MPI_Irecv(recvbuf, 10, MPI_DOUBLE, sender, 99, comm, &request[1]);
196      }
197     
198      MPI_Barrier(comm);
199     
200      if(rank == receiver || rank == sender)
201      {
202        MPI_Status status[2];
203        MPI_Waitall(2, request, status);
204      }
205     
206      MPI_Barrier(comm);
207     
208      if(rank == receiver)
209      {
210        for(int i=0; i<20; i++) std::cout << "recvbuf["<< i <<"] = "<< recvbuf[i] << std::endl;
211        printf("sender = %d\nreceiver = %d \tTEST of p2p non-blocking communication\tOK\n", sender, receiver);
212      }
213   
214    }//TEST of p2p blocking communication
215   
216
217    // TEST OF BCAST FROM A RANDOM ROOT
218    {
219      int bcast_root;
220 
221      if(rank == 0) bcast_root = rand() % size;
222 
223      MPI_Bcast(&bcast_root, 1, MPI_INT, 0, comm);
224 
225      int sendbuf[2];
226
227      sendbuf[0] = rank;
228      sendbuf[1] = size;
229 
230      MPI_Bcast(sendbuf, 2, MPI_INT, bcast_root, comm);
231 
232      int bcast_test = 0;
233      if(sendbuf[0] ==  bcast_root && sendbuf[1] == size) bcast_test = 1;
234 
235      int bcast_result;
236 
237      MPI_Reduce(&bcast_test, &bcast_result, 1, MPI_INT, MPI_MIN, bcast_root, comm);
238 
239      if(bcast_result && rank == bcast_root)  printf("root = %d : \t test MPI_Bcast \t OK\n", bcast_root);
240      if(!bcast_result && rank == bcast_root) printf("root = %d : \t test MPI_Bcast \t FAILED %d\n", bcast_root, bcast_result);
241    }
242
243    MPI_Barrier(comm);
244
245    // TEST OF GATHER FROM A RAMDOM ROOT
246    {
247      int gather_root;
248 
249      if(rank == 0) gather_root = rand() % size;
250 
251      MPI_Bcast(&gather_root, 1, MPI_INT, 0, comm);
252
253      double sendbuf[2];
254      sendbuf[0] = rank * 1.0;
255      sendbuf[1] = size * (-1.0);
256
257      std::vector<double>recvbuf(2*size, 0);
258
259      MPI_Gather(sendbuf, 2, MPI_DOUBLE, recvbuf.data(), 2, MPI_DOUBLE, gather_root, comm);
260
261      bool gather_result = true;
262
263      if(rank == gather_root)
264      {
265        for(int i=0; i<size; i++)
266        {
267          if(abs(recvbuf[2*i] - i) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
268          {
269            gather_result = false;
270            break;
271          } 
272        }
273
274        if(gather_result) printf("root = %d : \t test MPI_Gather \t OK \n", gather_root);
275        else              printf("root = %d : \t test MPI_Gather \t FAILED\n", gather_root);
276      }
277    }
278
279    MPI_Barrier(comm);
280
281    // TEST OF GATHERV FROM A RAMDOM ROOT
282    {
283      int gatherv_root;
284 
285      if(rank == 0) gatherv_root = rand() % size;
286 
287      MPI_Bcast(&gatherv_root, 1, MPI_INT, 0, comm);
288
289      int sendbuf[2];
290      sendbuf[0] = rank;
291      sendbuf[1] = -size;
292
293      std::vector<int>recvbuf(2*size, 0);
294
295      std::vector<int>recvcounts(size, 2);
296      std::vector<int>displs(size, 0);
297
298      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
299
300      MPI_Gatherv(sendbuf, 2, MPI_INT, recvbuf.data(), recvcounts.data(), displs.data(), MPI_INT, gatherv_root, comm);
301
302      bool gatherv_result = true;
303
304      if(rank == gatherv_root)
305      {
306        for(int i=0; i<size; i++)
307        {
308          if(abs(recvbuf[2*i] - (size-1-i)) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
309          {
310            gatherv_result = false; printf("%lf %lf root = %d, i = %d\n", recvbuf[2*i], recvbuf[2*i+1], gatherv_root, i);
311            break;
312          } 
313        }
314       
315        //for(int i=0; i<size*2; i++) printf("%lf\t", recvbuf[i]);
316        //printf("\n");
317
318        if(gatherv_result) printf("root = %d : \t test MPI_Gatherv \t OK\n", gatherv_root);
319        else               printf("root = %d : \t test MPI_Gatherv \t FAILED\n", gatherv_root);
320      }
321    }
322
323    MPI_Barrier(comm);
324
325    // TEST OF ALLGATHER
326    {
327      double sendbuf[2];
328      sendbuf[0] = rank * 1.0;
329      sendbuf[1] = size * (-1.0);
330
331      std::vector<double>recvbuf(2*size, 0);
332
333      MPI_Allgather(sendbuf, 2, MPI_DOUBLE, recvbuf.data(), 2, MPI_DOUBLE, comm);
334
335      int allgather_test = 1;
336
337      for(int i=0; i<size; i++)
338      {
339        if(abs(recvbuf[2*i] - i) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
340        {
341          allgather_test = 0;
342          break;
343        } 
344      }
345
346      int allgather_result;
347      MPI_Reduce(&allgather_test, &allgather_result, 1, MPI_INT, MPI_MIN, 0, comm);
348
349      if(rank == 0 && allgather_result)  printf("           \t test MPI_Allgather \t OK \n");
350      if(rank == 0 && !allgather_result) printf("           \t test MPI_Allgather \t OK \n");
351     
352    }
353
354    MPI_Barrier(comm);
355
356    // TEST OF ALLGATHERV
357    {
358      int sendbuf[2];
359      sendbuf[0] = rank;
360      sendbuf[1] = -size;
361
362      std::vector<int>recvbuf(2*size, 0);
363
364      std::vector<int>recvcounts(size, 2);
365      std::vector<int>displs(size, 0);
366
367      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
368
369      MPI_Allgatherv(sendbuf, 2, MPI_INT, recvbuf.data(), recvcounts.data(), displs.data(), MPI_INT, comm);
370
371      int allgatherv_test = 1;
372
373     
374     
375      for(int i=0; i<size; i++)
376      {
377        if(abs(recvbuf[2*i] - (size-1-i)) > 1.e-10 || abs(recvbuf[2*i+1] + size) > 1.e-10)
378        {
379          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);
380          break;
381        } 
382      }
383       
384     
385      int allgatherv_result;
386      MPI_Reduce(&allgatherv_test, &allgatherv_result, 1, MPI_INT, MPI_MIN, 0, comm);
387
388      if(rank == 0 && allgatherv_result)  printf("           \t test MPI_Allgatherv \t OK \n");
389      if(rank == 0 && !allgatherv_result) printf("           \t test MPI_Allgatherv \t FAILED %d\n", allgatherv_result);
390     
391    }
392
393    MPI_Barrier(comm);
394
395    // TEST OF REDUCE
396    {
397      int reduce_root;
398 
399      if(rank == 0) reduce_root = rand() % size;
400 
401      MPI_Bcast(&reduce_root, 1, MPI_INT, 0, comm);
402
403      int sendbuf[2];
404      sendbuf[0] = rank;
405      sendbuf[1] = -size;
406
407      std::vector<int>recvbuf(2, 0);
408
409      MPI_Op op = MPI_MIN;
410
411      MPI_Reduce(sendbuf, recvbuf.data(), 2, MPI_INT, op, reduce_root, comm);
412
413
414      bool reduce_result = true;
415
416      if(rank == reduce_root)
417      {
418        for(int i=0; i<2; i++)
419        {
420          if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[1] + size * size) > 1.e-10) ) ||
421             (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) )               ||
422             (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) ) )
423          {
424            reduce_result = false; printf("%d %d root = %d, i = %d\n", recvbuf[0], recvbuf[1], reduce_root, i);
425            break;
426          } 
427        }
428      }
429
430      if(rank == reduce_root && reduce_result)  printf("root = %d : \t test MPI_Reduce \t OK\n", reduce_root);
431      if(rank == reduce_root && !reduce_result) printf("root = %d : \t test MPI_Reduce \t FAILED\n", reduce_root);
432    }
433   
434
435    MPI_Barrier(comm);
436
437    // TEST OF ALLREDUCE
438    {
439 
440      int sendbuf[2];
441      sendbuf[0] = rank;
442      sendbuf[1] = -size;
443
444      std::vector<int>recvbuf(2, 0);
445
446      MPI_Op op = MPI_MIN;
447
448      MPI_Allreduce(sendbuf, recvbuf.data(), 2, MPI_INT, op, comm);
449
450
451      int allreduce_test = 1;
452
453     
454      if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[1] + size * size) > 1.e-10) ) ||
455         (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) )               ||
456         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] + size) > 1.e-10) ) )
457      {
458        allreduce_test = 0; printf("%d %d\n", recvbuf[0], recvbuf[1]);
459      } 
460     
461
462      int allreduce_result;
463      MPI_Reduce(&allreduce_test, &allreduce_result, 1, MPI_INT, MPI_MIN, 0, comm);
464
465      if(rank == 0 && allreduce_result)  printf("            \t test MPI_Allreduce \t OK\n");
466      if(rank == 0 && !allreduce_result) printf("            \t test MPI_Allreduce \t FAILED\n");
467    }
468
469
470    MPI_Barrier(comm);
471
472    // TEST OF REDUCE_SCATTER
473    {
474 
475      std::vector<int>sendbuf(2*size, rank);
476      std::vector<int>recvbuf(2, -1);
477      std::vector<int>recvcounts(size, 2);
478
479      MPI_Op op = MPI_MIN;
480
481      MPI_Reduce_scatter(sendbuf.data(), recvbuf.data(), recvcounts.data(), MPI_INT, op, comm);
482
483
484      int reduce_scatter_test = 1;
485
486     
487      if((op == MPI_SUM && (abs(recvbuf[0]-(size-1)*size/2) > 1.e-10 || abs(recvbuf[0]-(size-1)*size/2) > 1.e-10) ) ||
488         (op == MPI_MAX && (abs(recvbuf[0]-(size-1)) > 1.e-10 || abs(recvbuf[1]-(size-1)) > 1.e-10) )               ||
489         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1] ) > 1.e-10) ) )
490      {
491        reduce_scatter_test = 0; //printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
492      } 
493   
494
495      int reduce_scatter_result;
496      MPI_Reduce(&reduce_scatter_test, &reduce_scatter_result, 1, MPI_INT, MPI_MIN, 0, comm);
497
498      if(rank == 0 && reduce_scatter_result)  printf("            \t test MPI_Reduce_scatter OK\n");
499      if(rank == 0 && !reduce_scatter_result) printf("            \t test MPI_Reduce_scatter FAILED\n");
500    }
501
502    MPI_Barrier(comm);
503
504    // TEST OF SCATTER
505    {
506
507      int scatter_root;
508 
509      if(rank == 0) scatter_root = rand() % size;
510 
511      MPI_Bcast(&scatter_root, 1, MPI_INT, 0, comm);
512 
513      std::vector<int>sendbuf(2*size, rank);
514      std::vector<int>recvbuf(2, -1);
515      std::vector<int>recvcounts(size, 2);
516
517      if(rank == scatter_root) 
518      {
519        for(int i=0; i<size; i++) 
520        {
521          sendbuf[2*i] = i;
522          sendbuf[2*i+1] = size;
523        }
524        //for(int i=0; i<size*2; i++) printf("%d\t", sendbuf[i]);
525      }
526
527
528      MPI_Scatter(sendbuf.data(), 2, MPI_INT, recvbuf.data(), 2, MPI_INT, scatter_root, comm);
529
530      //printf("ID = %d : %d %d\n", rank, recvbuf[0], recvbuf[1]);
531
532      int scatter_test = 1;
533
534     
535      if( abs(recvbuf[0]-rank) > 1.e-10 || abs(recvbuf[1]-size) > 1.e-10 )
536      {
537        scatter_test = 0; //printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
538      } 
539   
540
541      int scatter_result;
542      MPI_Reduce(&scatter_test, &scatter_result, 1, MPI_INT, MPI_MIN, scatter_root, comm);
543
544      if(rank == scatter_root && scatter_result)  printf("root = %d : \t test MPI_Scatter \t OK\n", scatter_root);
545      if(rank == scatter_root && !scatter_result) printf("root = %d : \t test MPI_Scatter \t FAILED\n", scatter_root);
546    }
547   
548    MPI_Barrier(comm);
549
550    // TEST OF SCATTERV
551    {
552
553      int scatterv_root;
554 
555      if(rank == 0) scatterv_root = rand() % size;
556 
557      MPI_Bcast(&scatterv_root, 1, MPI_INT, 0, comm);
558 
559      std::vector<int>sendbuf(2*size, rank);
560      std::vector<int>recvbuf(2, -1);
561      std::vector<int>sendcounts(size, 2);
562      std::vector<int>displs(size, 0);
563
564      for(int i=0; i<size; i++) displs[i] = 2*(size-1-i);
565
566      if(rank == scatterv_root) 
567      {
568        for(int i=0; i<size; i++) 
569        {
570          sendbuf[2*i] = i;
571          sendbuf[2*i+1] = size;
572        }
573      }
574
575
576      MPI_Scatterv(sendbuf.data(), sendcounts.data(), displs.data(), MPI_INT, recvbuf.data(), 2, MPI_INT, scatterv_root, comm);
577
578      //printf("ID = %d : %d %d\n", rank, recvbuf[0], recvbuf[1]);
579
580      int scatterv_test = 1;
581
582     
583      if( abs(recvbuf[0]-(size-1-rank)) > 1.e-10 || abs(recvbuf[1]-size) > 1.e-10 )
584      {
585        scatterv_test = 0; printf("%d %d  id = %d\n", recvbuf[0], recvbuf[1], rank);
586      } 
587   
588
589      int scatterv_result;
590      MPI_Reduce(&scatterv_test, &scatterv_result, 1, MPI_INT, MPI_MIN, scatterv_root, comm);
591
592      if(rank == scatterv_root && scatterv_result)  printf("root = %d : \t test MPI_Scatterv \t OK\n", scatterv_root);
593      if(rank == scatterv_root && !scatterv_result) printf("root = %d : \t test MPI_Scatterv \t FAILED\n", scatterv_root);
594    }
595
596    MPI_Barrier(comm);
597
598    // TEST OF ALLTOALL
599    {
600
601      std::vector<int>sendbuf(size, rank);
602      std::vector<int>recvbuf(size, -1);
603           
604
605      MPI_Alltoall(sendbuf.data(), 1, MPI_INT, recvbuf.data(), 1, MPI_INT, comm);
606
607      int alltoall_result = 1;
608
609     
610      for(int i=0; i<size; i++)
611      if( abs(recvbuf[i]-i) > 1.e-10 )
612      {
613        alltoall_result = 0; printf("%d  id = %d\n", recvbuf[i], rank);
614      } 
615   
616      if(rank == 0 && alltoall_result)  printf("            \t test MPI_Alltoall \t OK\n");
617      if(rank == 0 && !alltoall_result) printf("            \t test MPI_Alltoall \t FAILED\n");
618    }
619
620    // TEST OF SCAN
621    {
622 
623      std::vector<int>sendbuf(2, rank);
624      std::vector<int>recvbuf(2, -1);
625
626      MPI_Op op = MPI_SUM;
627           
628
629      MPI_Scan(sendbuf.data(), recvbuf.data(), 2, MPI_INT, op, comm);
630
631      int scan_test = 1;
632
633      // printf(" ID=%d : %d  %d \n", rank, recvbuf[0], recvbuf[1]);
634     
635      if((op == MPI_SUM && (abs(recvbuf[0]-rank*(rank+1)/2) > 1.e-10 || abs(recvbuf[1]-rank*(rank+1)/2) > 1.e-10) ) ||
636         (op == MPI_MIN && (abs(recvbuf[0]) > 1.e-10 || abs(recvbuf[1]) > 1.e-10) )  || 
637         (op == MPI_MAX && (abs(recvbuf[0] - rank) > 1.e-10 || abs(recvbuf[1] - rank) > 1.e-10) ) )
638      {
639        scan_test = 0; //printf("%d  id = %d\n", recvbuf[i], rank);
640      } 
641
642      int scan_result;
643      MPI_Reduce(&scan_test, &scan_result, 1, MPI_INT, MPI_MIN, 0, comm);
644   
645      if(rank == 0 && scan_result)  printf("            \t test MPI_Scan \t\t OK\n");
646      if(rank == 0 && !scan_result) printf("            \t test MPI_Scan \t\t FAILED\n");
647    }
648
649
650    // TEST OF EXSCAN
651    {
652 
653      std::vector<int>sendbuf(2, rank);
654      std::vector<int>recvbuf(2, -1);
655
656      MPI_Op op = MPI_SUM;
657           
658
659      MPI_Exscan(sendbuf.data(), recvbuf.data(), 2, MPI_INT, op, comm);
660
661      int exscan_test = 1;
662
663      // printf(" ID=%d : %d  %d \n", rank, recvbuf[0], recvbuf[1]);
664     
665      if(rank >0)
666      if((op == MPI_SUM && (abs(recvbuf[0]-rank*(rank-1)/2) > 1.e-10 || abs(recvbuf[1]-rank*(rank-1)/2) > 1.e-10) ) ||
667         (op == MPI_MIN && (abs(recvbuf[0] ) > 1.e-10 || abs(recvbuf[1]) > 1.e-10) )  || 
668         (op == MPI_MAX && (abs(recvbuf[0] - rank+1) > 1.e-10 || abs(recvbuf[1] - rank+1) > 1.e-10) ) )
669      {
670        exscan_test = 0; //printf("%d  id = %d\n", recvbuf[i], rank);
671      } 
672
673      int exscan_result;
674      MPI_Reduce(&exscan_test, &exscan_result, 1, MPI_INT, MPI_MIN, 0, comm);
675   
676      if(rank == 0 && exscan_result)  printf("            \t test MPI_Exscan \t OK\n");
677      if(rank == 0 && !exscan_result) printf("            \t test MPI_Exscan \t FAILED\n");
678    }
679
680
681
682    // TEST OF COMM_SPLIT
683    {
684
685      MPI_Barrier(comm);
686      int rank, size;
687      MPI_Comm_rank(comm, &rank);
688      MPI_Comm_size(comm, &size);
689   
690      int color = rand()%3;
691      int key = rand()%5;
692     
693      int color2 = rand()%3;
694      int key2 = rand()%5;
695 
696      MPI_Comm split_comm;
697      MPI_Comm_split(comm, color, key, &split_comm);
698
699     
700      MPI_Comm split_comm2;
701      MPI_Comm_split(comm, color2, key2, &split_comm2);
702
703
704   
705      int split_rank, split_size;
706      MPI_Comm_rank(split_comm, &split_rank);
707      MPI_Comm_size(split_comm, &split_size);
708   
709#ifdef _Memory_check   
710      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);
711#endif
712
713      MPI_Barrier(comm);
714      MPI_Barrier(comm);
715      MPI_Barrier(comm);
716     
717      if(rank == 0) printf("            \t tMPI_Comm_split \t OK\n");
718     
719      MPI_Barrier(comm);
720      MPI_Barrier(comm);
721     
722      int bcast_buf_size=100;
723     
724      std::vector<int> bcast_buf(bcast_buf_size, 0);
725     
726      if(split_rank==0) bcast_buf.assign(bcast_buf_size, (color+1)*split_size);
727     
728      MPI_Bcast(bcast_buf.data(), bcast_buf_size, MPI_INT, 0, split_comm);
729     
730      int bcast_test = 0;
731      for(int i=0; i<bcast_buf_size; i++)
732      {
733        if(bcast_buf[i] != (color+1)*split_size)
734          bcast_test = 1;
735      }
736 
737      int bcast_result;
738 
739      MPI_Reduce(&bcast_test, &bcast_result, 1, MPI_INT, MPI_SUM, 0, comm);
740 
741      MPI_Barrier(split_comm);
742      MPI_Comm_free(&split_comm);
743     
744      MPI_Barrier(split_comm2);
745      MPI_Comm_free(&split_comm2);
746     
747     
748      if(bcast_result == 0 && rank == 0)  printf("            \t test MPI_Bcast for split comm\t OK\n");
749      if(bcast_result != 0 && rank == 0)  printf("            \t test MPI_Bcast for split comm\t FAILED %d\n", bcast_result);
750     
751    }
752   
753    MPI_Barrier(comm);
754    MPI_Barrier(comm);
755    MPI_Barrier(comm);
756   
757    // TESE OF INTERCOMM_CREATE
758    {
759      MPI_Barrier(comm);
760     
761      int rank, size;
762      MPI_Comm_rank(comm, &rank);
763      MPI_Comm_size(comm, &size);
764
765      int config = 1;
766      if(config=1)
767      {
768        assert(size == 16 && omp_get_num_threads()==4);
769      }
770     
771      int tab_color[16] = {2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1}; // used for config 1
772      int tab_key[16]   = {2, 1, 4, 1, 0, 4, 3, 3, 4, 3, 4, 4, 4, 0, 0, 2}; // used for config 1
773
774      int color = tab_color[rank];
775      int key = tab_key[rank];
776     
777 
778      MPI_Comm split_comm;
779      MPI_Comm_split(comm, color, key, &split_comm);
780
781   
782      int split_rank, split_size;
783      MPI_Comm_rank(split_comm, &split_rank);
784      MPI_Comm_size(split_comm, &split_size);
785
786
787     
788
789      MPI_Barrier(comm);
790      MPI_Barrier(comm);
791     
792      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n");
793     
794      MPI_Barrier(comm);
795      MPI_Barrier(comm);
796     
797     
798     
799     
800     
801      int local_leader = 0;
802      int remote_leader = color==2? 13: 4; // used for config 1
803
804      MPI_Comm peer_comm = comm;
805
806      MPI_Comm inter_comm;
807      MPI_Intercomm_create(split_comm, local_leader, peer_comm, remote_leader, 99, &inter_comm);
808
809      int inter_rank, inter_size, remote_size;
810      MPI_Comm_rank(inter_comm, &inter_rank);
811      MPI_Comm_size(inter_comm, &inter_size);
812      MPI_Comm_remote_size(inter_comm, &remote_size);
813     
814     
815      MPI_Barrier(comm);
816      MPI_Barrier(comm);
817
818      if(rank == 0) printf("            \t MPI_Intercomm_create \t OK\n");
819
820      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);
821
822     
823      MPI_Barrier(comm);
824      MPI_Barrier(comm);
825
826      if(color==2 && split_rank==1)
827      {
828        double sendbuf[9]={1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9};
829        MPI_Request send_request;
830        MPI_Status send_status;
831        MPI_Isend(sendbuf, 9, MPI_DOUBLE, 5, 10, inter_comm, &send_request);
832        MPI_Wait(&send_request, &send_status);
833      }
834
835      if(color==1 && split_rank==5)
836      {
837        double recvbuf[9];
838        MPI_Request recv_request;
839        MPI_Status recv_status;
840        MPI_Irecv(recvbuf, 9, MPI_DOUBLE, 1, 10, inter_comm, &recv_request);
841        MPI_Wait(&recv_request, &recv_status);
842        for(int i=0; i<9; i++)
843        {
844          printf("recvbuf[%d] = %lf\n", i, recvbuf[i]);
845        }
846      }
847
848      MPI_Barrier(comm);
849      MPI_Barrier(comm);
850
851      if(rank == 0) printf("            \t Test iP2P for intercomm \t OK\n");
852
853
854      MPI_Barrier(comm);
855      MPI_Barrier(comm);
856
857      MPI_Barrier(split_comm);
858      MPI_Comm_free(&split_comm);
859
860      MPI_Barrier(comm);
861      MPI_Barrier(comm);
862
863      MPI_Comm_free(&inter_comm);
864     
865
866      /*
867      MPI_Barrier(comm);
868      if(rank == 0) printf("\tMPI_Intercomm_create OK\n");
869      MPI_Barrier(comm);
870
871   
872
873      int high=color;
874      MPI_Comm intra_comm;
875      MPI_Intercomm_merge(inter_comm, high, &intra_comm);
876   
877      int intra_rank, intra_size;
878      MPI_Comm_rank(intra_comm, &intra_rank);
879      MPI_Comm_size(intra_comm, &intra_size);
880
881      MPI_Barrier(comm);
882      if(rank == 0) printf("\tMPI_Intercomm_merge OK\n");
883      MPI_Barrier(comm);
884   
885   
886
887      //check_test_gatherv(comm);
888     
889      MPI_Barrier(comm);
890      MPI_Comm_free(&inter_comm);
891      */
892    }
893 
894    MPI_Barrier(comm);
895    MPI_Comm_free(&comm);
896  }
897
898/*
899  int num_threads;
900  if(mpi_rank < mpi_size-2)
901  {
902    printf("Proc %d is client\n", mpi_rank);
903    num_threads = 2;//+mpi_rank;
904  }
905  else
906  {
907    printf("Proc %d is server\n", mpi_rank);
908    num_threads = 1;
909  }
910 
911  omp_set_num_threads(num_threads);
912
913  #pragma omp parallel default(shared) firstprivate(num_threads)
914  {
915    int num_ep = num_threads;
916    MPI_Info info;
917
918    //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);
919    MPI_Comm *ep_comm;
920    #pragma omp master
921    {
922      MPI_Comm *ep_comm;
923      MPI_Comm_create_endpoints(MPI_COMM_WORLD->mpi_comm, num_ep, info, ep_comm);
924      passage = ep_comm; 
925    }
926
927    #pragma omp barrier
928
929
930    MPI_Comm comm; // this should act as EP_COMM_WORLD
931    comm = passage[omp_get_thread_num()];
932   
933    int rank, size;
934    MPI_Comm_rank(comm, &rank);
935    MPI_Comm_size(comm, &size);
936   
937   
938
939    bool isClient = false;
940    bool isServer = false;
941
942    if(omp_get_num_threads()>1) isClient = true;
943    else isServer = true;
944
945    printf("mpi_rank = %d, ep_rank = %d, isClient = %d\n", mpi_rank, rank, isClient);
946
947    MPI_Win ep_win;
948    MPI_Aint buf_size=1;
949    int buf = rank;
950    int local_buf = rank;
951    int result_buf = -1;
952    MPI_Win_create(&buf, buf_size, sizeof(int), info, comm, &ep_win);
953    MPI_Barrier(comm);
954   
955    // MPI_Win_fence(MPI_MODE_NOPRECEDE, ep_win);
956
957    MPI_Barrier(comm);
958    sleep(0.2);
959    MPI_Barrier(comm);
960
961    MPI_Win_fence(0, ep_win);
962
963    if(rank == 0)
964    {
965      local_buf = 99;
966      MPI_Aint displs=0;
967      MPI_Put(&local_buf, 1, MPI_INT, size-1, displs, 1, MPI_INT, ep_win);
968    }
969
970    if(rank == size-2)
971    {
972      MPI_Aint displs(0);
973      MPI_Get(&local_buf, 1, MPI_INT, 2, displs, 1, MPI_INT, ep_win);
974    }
975
976    MPI_Win_fence(0, ep_win);
977
978    if(rank == 1)
979    {
980      MPI_Aint displs=0;
981      MPI_Accumulate(&local_buf, 1, MPI_INT, size-1, displs, 1, MPI_INT, MPI_REPLACE, ep_win);
982    }
983
984
985    MPI_Barrier(comm);
986
987    MPI_Win_fence(0, ep_win);
988
989    if(rank == 2)
990    {
991      MPI_Aint displs = 0;
992      MPI_Get_accumulate(&local_buf, 1, MPI_INT, &result_buf,
993                         1, MPI_INT, size-2, displs,
994                         1, MPI_INT, MPI_SUM, ep_win);
995    }
996   
997    MPI_Win_fence(0, ep_win);
998   
999    if(rank == 6)
1000    {
1001      MPI_Aint displs = 0;
1002      MPI_Fetch_and_op(&local_buf, &result_buf, MPI_INT, size-1, displs,
1003                       MPI_SUM, ep_win);
1004    }
1005
1006    MPI_Win_fence(0, ep_win);
1007
1008    if(rank == 7)
1009    {
1010      MPI_Aint displs = 0;
1011      MPI_Compare_and_swap(&local_buf, &buf, &result_buf, MPI_INT, size-1, displs, ep_win);
1012    }
1013
1014    MPI_Win_fence(0, ep_win);
1015
1016    //::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]));
1017
1018    MPI_Win ep_win_allocated;
1019    int* baseptr = new int[10];
1020    MPI_Aint base_size = 4;
1021
1022    MPI_Win_allocate (base_size, sizeof(int), info, comm, baseptr, &ep_win_allocated);
1023
1024    MPI_Win_fence(0, ep_win_allocated);
1025
1026    MPI_Win_free(&ep_win_allocated);
1027    delete[] baseptr;
1028
1029    MPI_Win_free(&ep_win);
1030    printf("rank = %d, buf = %d, local_buf = %d, result_buf = %d\n", rank, buf, local_buf, result_buf);
1031   
1032    MPI_Comm_free(&comm);
1033
1034  }
1035*/
1036  MPI_Finalize();
1037
1038}
Note: See TracBrowser for help on using the repository browser.