Ignore:
Timestamp:
06/07/18 19:39:07 (3 years ago)
Author:
yushan
Message:

save dev : intercomm_create via intracomm. To do : modif related intercomm communication routines, barrier, free, rank, size...

File:
1 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/branch_openmp/extern/ep_dev/main.cpp

    r1522 r1525  
    717717      MPI_Barrier(comm); 
    718718       
    719       if(rank == 0) printf("            \t tMPI_Comm_split \t OK\n"); 
     719      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n"); 
    720720       
    721721      MPI_Barrier(comm); 
     
    746746      MPI_Barrier(split_comm2); 
    747747      MPI_Comm_free(&split_comm2); 
     748 
    748749       
    749750       
     
    825826      MPI_Barrier(comm); 
    826827      MPI_Barrier(comm); 
     828 
    827829 
    828830      if(color==2 && split_rank==0) 
     
    878880 
    879881 
    880       //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); 
     882      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); 
    881883 
    882884      MPI_Comm inter_comm_dup_merged; 
     
    892894      //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); 
    893895       
    894       // TEST OF TESTALL 
    895        
    896         int merged_size, merged_rank; 
    897         MPI_Comm_rank(inter_comm_dup_merged, &merged_rank); 
    898         MPI_Comm_size(inter_comm_dup_merged, &merged_size); 
    899          
    900         int left = merged_rank>0? merged_rank-1 : merged_size-1; 
    901         int right = (merged_rank+1) % merged_size; 
    902          
    903         //printf("rank = %d, left = %d, right = %d\n", merged_rank, left, right); 
    904          
    905         int N=10000; 
    906         int *left_buf = new int[N]; 
    907         int *right_buf = new int[N]; 
    908                  
    909         for(int i=0; i<N; i++) 
    910         { 
    911           right_buf[i] = merged_rank*100000+i; 
    912         } 
    913          
    914         MPI_Request request[2]; 
    915         MPI_Status status[2]; 
    916          
    917         MPI_Irecv(left_buf, N, MPI_INT, left, 0, inter_comm_dup_merged, &request[0]); 
    918         MPI_Isend(right_buf, N, MPI_INT, right, 0, inter_comm_dup_merged, &request[1]); 
    919          
    920          
    921         int flag; 
    922         MPI_Testall(2, request, &flag, status); 
    923        
    924         printf("rank = %d, flag = %d\n", merged_rank, flag); 
    925          
    926         while(!flag) MPI_Testall(2, request, &flag, status); 
    927         //if(!flag)  MPI_Waitall(2, request, status); 
    928          
    929         int recv_count; 
    930         MPI_Get_count(&status[0], MPI_INT, &recv_count); 
    931          
    932         MPI_Barrier(inter_comm_dup_merged); 
    933          
    934         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]); 
    935                          
    936         delete[] left_buf; 
    937         delete[] right_buf; 
    938        
    939        
     896       
     897      MPI_Barrier(inter_comm_dup_merged); 
    940898 
    941899      // TEST OF GATHER 
    942900      { 
     901         
     902 
    943903        int gather_root = 99; 
    944904   
     
    976936      } 
    977937 
     938      MPI_Barrier(inter_comm_dup_merged); 
     939 
    978940      // TEST OF ALLREDUCE 
    979941      { 
     
    1009971      } 
    1010972 
     973      MPI_Barrier(inter_comm_dup_merged); 
     974 
    1011975      // TEST OF EXSCAN 
    1012       /*{ 
     976      { 
    1013977  
    1014978        std::vector<int>sendbuf(2, inter_comm_dup_merged_rank); 
     
    1029993          exscan_test = 0;  
    1030994        } 
    1031  
    1032         //printf(" ID=%d : sendbuf = (%d, %d), recvbuf = (%d, %d), exscan_test = %d \n", inter_comm_dup_merged_rank, sendbuf[0], sendbuf[1], recvbuf[0], recvbuf[1], exscan_test);  
    1033995         
    1034996        int exscan_result; 
     
    1037999        if(inter_comm_dup_merged_rank == 0 && exscan_result)  printf("            \t test MPI_Exscan for merged comm \t OK\n"); 
    10381000        if(inter_comm_dup_merged_rank == 0 && !exscan_result) printf("            \t test MPI_Exscan for merged comm \t FAILED %d\n", exscan_result); 
    1039       }*/ 
     1001      } 
     1002 
     1003      MPI_Barrier(inter_comm_dup_merged); 
    10401004 
    10411005      // TEST OF SCATTERV 
     
    10671031        MPI_Scatterv(sendbuf.data(), sendcounts.data(), displs.data(), MPI_INT, recvbuf.data(), 2, MPI_INT, scatterv_root, inter_comm_dup_merged); 
    10681032 
    1069         //printf("ID = %d : %d %d\n", inter_comm_dup_merged_rank, recvbuf[0], recvbuf[1]); 
    1070  
    10711033        int scatterv_test = 1; 
    10721034 
     
    10851047      } 
    10861048 
    1087  
    1088  
     1049      MPI_Barrier(inter_comm_dup_merged); 
     1050 
     1051      // TEST OF TESTALL 
     1052      { 
     1053        int merged_size, merged_rank; 
     1054        MPI_Comm_rank(inter_comm_dup_merged, &merged_rank); 
     1055        MPI_Comm_size(inter_comm_dup_merged, &merged_size); 
     1056         
     1057        int left = merged_rank>0? merged_rank-1 : merged_size-1; 
     1058        int right = (merged_rank+1) % merged_size; 
     1059                 
     1060        int N=10000; 
     1061        int *left_buf = new int[N]; 
     1062        int *right_buf = new int[N]; 
     1063                 
     1064        for(int i=0; i<N; i++) 
     1065        { 
     1066          right_buf[i] = merged_rank*100000+i; 
     1067        } 
     1068         
     1069        MPI_Request request[2]; 
     1070        MPI_Status status[2]; 
     1071         
     1072        MPI_Irecv(left_buf, N, MPI_INT, left, 0, inter_comm_dup_merged, &request[0]); 
     1073        MPI_Isend(right_buf, N, MPI_INT, right, 0, inter_comm_dup_merged, &request[1]); 
     1074         
     1075         
     1076        int flag; 
     1077        MPI_Testall(2, request, &flag, status); 
     1078       
     1079        printf("rank = %d, flag = %d\n", merged_rank, flag); 
     1080         
     1081        while(!flag) MPI_Testall(2, request, &flag, status); 
     1082         
     1083        int recv_count; 
     1084        MPI_Get_count(&status[0], MPI_INT, &recv_count); 
     1085         
     1086        MPI_Barrier(inter_comm_dup_merged); 
     1087         
     1088        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]); 
     1089                         
     1090        delete[] left_buf; 
     1091        delete[] right_buf; 
     1092      } 
     1093       
     1094      MPI_Barrier(inter_comm_dup_merged); 
     1095 
     1096      // TEST WAITALL 
     1097      { 
     1098        int merged_rank; 
     1099        int merged_size; 
     1100 
     1101        MPI_Comm_rank(inter_comm_dup_merged, &merged_rank); 
     1102        MPI_Comm_size(inter_comm_dup_merged, &merged_size); 
     1103 
     1104        int left = merged_rank>0? merged_rank-1 : merged_size-1; 
     1105        int right = (merged_rank+1)%merged_size; 
     1106 
     1107        printf("merged_rank = %d, left = %d, right = %d\n", merged_rank, left, right); 
     1108 
     1109        int NN=10000; 
     1110 
     1111        double *left_buf = new double[NN]; 
     1112        double *right_buf = new double[NN]; 
     1113 
     1114        for(int i=0; i<NN; i++) 
     1115        { 
     1116          right_buf[i] = merged_rank*1000000 + i; 
     1117        } 
     1118 
     1119        MPI_Request request[2]; 
     1120        MPI_Status  status[2]; 
     1121 
     1122        MPI_Irecv(left_buf,  NN, MPI_DOUBLE, left,  0, inter_comm_dup_merged, &request[0]); 
     1123        MPI_Isend(right_buf, NN, MPI_DOUBLE, right, 0, inter_comm_dup_merged, &request[1]); 
     1124         
     1125 
     1126        MPI_Waitall(2, request, status); 
     1127 
     1128        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]); 
     1129 
     1130 
     1131        delete left_buf; 
     1132        delete right_buf; 
     1133      } 
    10891134 
    10901135      MPI_Barrier(comm); 
     
    11081153      MPI_Comm_free(&inter_comm); 
    11091154       
    1110  
    1111       /* 
    1112       MPI_Barrier(comm); 
    1113       if(rank == 0) printf("\tMPI_Intercomm_create OK\n"); 
    1114       MPI_Barrier(comm); 
    1115  
    1116      
    1117  
    1118       int high=color; 
    1119       MPI_Comm intra_comm; 
    1120       MPI_Intercomm_merge(inter_comm, high, &intra_comm); 
    1121      
    1122       int intra_rank, intra_size; 
    1123       MPI_Comm_rank(intra_comm, &intra_rank); 
    1124       MPI_Comm_size(intra_comm, &intra_size); 
    1125  
    1126       MPI_Barrier(comm); 
    1127       if(rank == 0) printf("\tMPI_Intercomm_merge OK\n"); 
    1128       MPI_Barrier(comm); 
    1129      
    1130      
    1131  
    1132       //check_test_gatherv(comm); 
    1133        
    1134       MPI_Barrier(comm); 
    1135       MPI_Comm_free(&inter_comm); 
    1136       */ 
     1155    } 
     1156 
     1157    // TESE OF INTERCOMM_CREATE 
     1158    { 
     1159      MPI_Barrier(comm); 
     1160       
     1161      int rank, size; 
     1162      MPI_Comm_rank(comm, &rank); 
     1163      MPI_Comm_size(comm, &size); 
     1164 
     1165      int config = 1; 
     1166      if(config=1) 
     1167      { 
     1168        assert(size == 16 && omp_get_num_threads()==4); 
     1169      } 
     1170       
     1171      int tab_color[16] = {2, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1}; // used for config 1 
     1172      int tab_key[16]   = {2, 1, 4, 1, 0, 4, 3, 3, 4, 3, 4, 4, 4, 0, 0, 2}; // used for config 1 
     1173 
     1174      int color = tab_color[rank]; 
     1175      int key = tab_key[rank]; 
     1176       
     1177   
     1178      MPI_Comm split_comm; 
     1179      MPI_Comm_split(comm, color, key, &split_comm); 
     1180 
     1181     
     1182      int split_rank, split_size; 
     1183      MPI_Comm_rank(split_comm, &split_rank); 
     1184      MPI_Comm_size(split_comm, &split_size); 
     1185 
     1186 
     1187       
     1188 
     1189      MPI_Barrier(comm); 
     1190      MPI_Barrier(comm); 
     1191       
     1192      if(rank == 0) printf("            \t MPI_Comm_split \t OK\n"); 
     1193       
     1194      MPI_Barrier(comm); 
     1195      MPI_Barrier(comm); 
     1196       
     1197             
     1198      int local_leader = 5; 
     1199      int remote_leader = color==2? 5: 2; // used for config 1 
     1200 
     1201      MPI_Comm peer_comm = comm; 
     1202 
     1203      MPI_Comm inter_comm; 
     1204      MPI_Intercomm_create2(split_comm, local_leader, peer_comm, remote_leader, 99, &inter_comm); 
     1205 
     1206      int inter_rank; 
     1207      int inter_size; 
     1208      MPI_Comm_rank(inter_comm, &inter_rank); 
     1209      MPI_Comm_size(inter_comm, &inter_size); 
     1210 
     1211      printf("split_rank = %d, inter_rank = %d / %d\n", split_rank, inter_rank, inter_size); 
     1212 
     1213      MPI_Barrier(split_comm); 
     1214      MPI_Comm_free(&split_comm); 
     1215 
     1216      MPI_Barrier2(inter_comm); 
     1217      MPI_Comm_free2(&inter_comm); 
     1218       
    11371219    } 
    11381220   
Note: See TracChangeset for help on using the changeset viewer.