Changeset 1147


Ignore:
Timestamp:
05/29/17 16:15:38 (4 years ago)
Author:
yushan
Message:

bug fixed in MPI_Gather(v)

Location:
XIOS/dev/branch_yushan_merged/extern
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/branch_yushan_merged/extern/remap/src/mapper.cpp

    r1146 r1147  
    2121void cptOffsetsFromLengths(const int *lengths, int *offsets, int sz) 
    2222{ 
    23         offsets[0] = 0; 
    24         for (int i = 1; i < sz; i++) 
    25                 offsets[i] = offsets[i-1] + lengths[i-1]; 
     23  offsets[0] = 0; 
     24  for (int i = 1; i < sz; i++) 
     25    offsets[i] = offsets[i-1] + lengths[i-1]; 
    2626} 
    2727 
     
    3131  srcGrid.pole = Coord(pole[0], pole[1], pole[2]); 
    3232 
    33         int mpiRank, mpiSize; 
    34         MPI_Comm_rank(communicator, &mpiRank); 
    35         MPI_Comm_size(communicator, &mpiSize); 
    36  
    37         sourceElements.reserve(nbCells); 
    38         sourceMesh.reserve(nbCells); 
     33  int mpiRank, mpiSize; 
     34  MPI_Comm_rank(communicator, &mpiRank); 
     35  MPI_Comm_size(communicator, &mpiSize); 
     36 
     37  sourceElements.reserve(nbCells); 
     38  sourceMesh.reserve(nbCells); 
    3939  sourceGlobalId.resize(nbCells) ; 
    4040 
     
    4949  else sourceGlobalId.assign(globalId,globalId+nbCells); 
    5050 
    51         for (int i = 0; i < nbCells; i++) 
    52         { 
    53                 int offs = i*nVertex; 
    54                 Elt elt(boundsLon + offs, boundsLat + offs, nVertex); 
    55                 elt.src_id.rank = mpiRank; 
    56                 elt.src_id.ind = i; 
     51  for (int i = 0; i < nbCells; i++) 
     52  { 
     53    int offs = i*nVertex; 
     54    Elt elt(boundsLon + offs, boundsLat + offs, nVertex); 
     55    elt.src_id.rank = mpiRank; 
     56    elt.src_id.ind = i; 
    5757    elt.src_id.globalId = sourceGlobalId[i]; 
    58                 sourceElements.push_back(elt); 
    59                 sourceMesh.push_back(Node(elt.x, cptRadius(elt), &sourceElements.back())); 
    60                 cptEltGeom(sourceElements[i], Coord(pole[0], pole[1], pole[2])); 
    61         } 
     58    sourceElements.push_back(elt); 
     59    sourceMesh.push_back(Node(elt.x, cptRadius(elt), &sourceElements.back())); 
     60    cptEltGeom(sourceElements[i], Coord(pole[0], pole[1], pole[2])); 
     61  } 
    6262 
    6363} 
     
    485485    mpiRoute.init(routes); 
    486486    int nRecv = mpiRoute.getTotalSourceElement(); 
    487     // cout << mpiRank << " NRECV " << nRecv << "(" << routes.size() << ")"<< endl; 
    488487 
    489488    int *nbSendNode = new int[mpiSize]; 
     
    879878        { 
    880879            MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     880            printf("proc %d send %d elements to proc %d\n", mpiRank, sentMessageSize[rank], rank); 
    881881            nbSendRequest++; 
    882882        } 
     
    884884        { 
    885885            MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     886            printf("proc %d recv %d elements from proc %d\n", mpiRank, recvMessageSize[rank], rank); 
    886887            nbRecvRequest++; 
    887888        } 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_alltoall.cpp

    r1146 r1147  
    1616    int ep_size; 
    1717    MPI_Comm_size(comm, &ep_size); 
     18     
    1819 
    1920    for(int i=0; i<ep_size; i++) 
    2021    { 
    21       MPI_Gather(sendbuf+i*sendcount*typesize, sendcount, sendtype, recvbuf, recvcount, recvtype, i, comm); 
     22      ep_lib::MPI_Gather(sendbuf+i*sendcount*typesize, sendcount, sendtype, recvbuf, recvcount, recvtype, i, comm); 
    2223    } 
     24     
    2325 
    2426    return 0; 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_gather.cpp

    r1134 r1147  
    352352 
    353353    void *local_gather_recvbuf; 
     354    void *master_recvbuf; 
     355    if(ep_rank_loc == 0 && mpi_rank == root_mpi_rank && root_ep_loc != 0) master_recvbuf = new void*[sizeof(recvbuf)]; 
    354356 
    355357    if(ep_rank_loc==0) 
     
    381383      } 
    382384 
    383  
    384       ::MPI_Gatherv(local_gather_recvbuf, count*num_ep, static_cast< ::MPI_Datatype>(datatype), recvbuf, gatherv_recvcnt, 
     385      if(root_ep_loc != 0) // gather to root_master 
     386      { 
     387        ::MPI_Gatherv(local_gather_recvbuf, count*num_ep, static_cast< ::MPI_Datatype>(datatype), master_recvbuf, gatherv_recvcnt, 
    385388                    gatherv_displs, static_cast< ::MPI_Datatype>(datatype), root_mpi_rank, static_cast< ::MPI_Comm>(comm.mpi_comm)); 
     389      } 
     390      else 
     391      { 
     392        ::MPI_Gatherv(local_gather_recvbuf, count*num_ep, static_cast< ::MPI_Datatype>(datatype), recvbuf, gatherv_recvcnt, 
     393                    gatherv_displs, static_cast< ::MPI_Datatype>(datatype), root_mpi_rank, static_cast< ::MPI_Comm>(comm.mpi_comm)); 
     394      } 
    386395 
    387396      delete[] gatherv_recvcnt; 
     
    392401    if(root_ep_loc != 0 && mpi_rank == root_mpi_rank) // root is not master, master send to root and root receive from master 
    393402    { 
    394       innode_memcpy(0, recvbuf, root_ep_loc, recvbuf, count*ep_size, datatype, comm); 
     403      innode_memcpy(0, master_recvbuf, root_ep_loc, recvbuf, count*ep_size, datatype, comm); 
     404      if(ep_rank_loc == 0 ) delete[] master_recvbuf; 
    395405    } 
    396406 
     
    399409    if(ep_rank_loc==0) 
    400410    { 
     411 
    401412      if(datatype == MPI_INT) 
    402413      { 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_gatherv.cpp

    r1145 r1147  
    386386    void *local_gather_recvbuf; 
    387387    int buffer_size; 
     388    void *master_recvbuf; 
     389 
     390    if(ep_rank_loc == 0 && mpi_rank == root_mpi_rank && root_ep_loc != 0) master_recvbuf = new void*[sizeof(recvbuf)]; 
    388391 
    389392    if(ep_rank_loc==0) 
     
    411414      ::MPI_Gather(&buff_start,  1, MPI_INT_STD, mpi_displs,  1, MPI_INT_STD, root_mpi_rank, static_cast< ::MPI_Comm>(comm.mpi_comm)); 
    412415 
    413  
    414       ::MPI_Gatherv(local_gather_recvbuf + datasize*buff_start, mpi_sendcnt, static_cast< ::MPI_Datatype>(datatype), recvbuf, mpi_recvcnt, 
     416      if(root_ep_loc == 0) 
     417      ::MPI_Gatherv(local_gather_recvbuf + datasize*buff_start, mpi_sendcnt, static_cast< ::MPI_Datatype>(datatype), recvbuf, mpi_recvcnt, 
    415418                       mpi_displs, static_cast< ::MPI_Datatype>(datatype), root_mpi_rank, static_cast< ::MPI_Comm>(comm.mpi_comm)); 
     419      } 
     420      else  // gatherv to master_recvbuf 
     421      {  ::MPI_Gatherv(local_gather_recvbuf + datasize*buff_start, mpi_sendcnt, static_cast< ::MPI_Datatype>(datatype), master_recvbuf, mpi_recvcnt, 
     422                       mpi_displs, static_cast< ::MPI_Datatype>(datatype), root_mpi_rank, static_cast< ::MPI_Comm>(comm.mpi_comm)); 
     423      } 
    416424 
    417425      delete[] mpi_recvcnt; 
     
    425433    if(root_ep_loc != 0 && mpi_rank == root_mpi_rank) // root is not master, master send to root and root receive from master 
    426434    { 
    427       innode_memcpy(0, recvbuf+datasize*global_min_displs, root_ep_loc, recvbuf+datasize*global_min_displs, global_recvcnt, datatype, comm); 
     435      innode_memcpy(0, master_recvbuf+datasize*global_min_displs, root_ep_loc, recvbuf+datasize*global_min_displs, global_recvcnt, datatype, comm); 
     436      if(ep_rank_loc == 0) delete[] master_recvbuf; 
    428437    } 
    429438 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_recv.cpp

    r1134 r1147  
    1414 
    1515 
    16 namespace ep_lib { 
     16namespace ep_lib  
     17{ 
    1718 
    18         int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status *status) 
    19         { 
     19  int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status *status) 
     20  { 
    2021    int dest_rank; 
    2122    MPI_Comm_rank(comm, &dest_rank); 
     
    4142 
    4243    return 0; 
    43         } 
     44  } 
    4445 
    4546 
    4647 
    4748 
    48         int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request *request) 
    49         { 
     49  int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request *request) 
     50  { 
    5051 
    51                 Debug("MPI_Irecv with EP"); 
     52    Debug("MPI_Irecv with EP"); 
    5253    int dest_rank; 
    5354    MPI_Comm_rank(comm, &dest_rank); 
    5455 
    55                 if(!comm.is_ep) 
    56                 { 
    57                   ::MPI_Request mpi_request; 
    58                   ::MPI_Comm mpi_comm = static_cast< ::MPI_Comm > (comm.mpi_comm); 
    59                   ::MPI_Irecv(buf, count, static_cast< ::MPI_Datatype> (datatype), src<0? MPI_ANY_SOURCE : src, tag<0? MPI_ANY_TAG: tag, mpi_comm, &mpi_request); 
     56    if(!comm.is_ep) 
     57    { 
     58      ::MPI_Request mpi_request; 
     59      ::MPI_Comm mpi_comm = static_cast< ::MPI_Comm > (comm.mpi_comm); 
     60      ::MPI_Irecv(buf, count, static_cast< ::MPI_Datatype> (datatype), src<0? MPI_ANY_SOURCE : src, tag<0? MPI_ANY_TAG: tag, mpi_comm, &mpi_request); 
    6061 
    61                   request->mpi_request = mpi_request; 
     62      request->mpi_request = mpi_request; 
    6263      request->ep_src = src; 
    6364      request->ep_datatype = datatype; 
    6465      request->ep_tag = tag; 
    65                 } 
     66    } 
    6667 
    67                 Message_Check(comm); 
     68    Message_Check(comm); 
    6869                 
    6970 
    70                 request->mpi_request = MPI_REQUEST_NULL_STD; 
    71                 request->buf = buf; 
     71    request->mpi_request = MPI_REQUEST_NULL_STD; 
     72    request->buf = buf; 
    7273    request->comm = comm; 
    73                 request->type = 2; 
     74    request->type = 2; 
    7475 
    75                 request->ep_src = src; 
     76    request->ep_src = src; 
    7677    request->ep_tag = tag; 
    7778    request->ep_datatype = datatype; 
    7879 
    79  
    80      
    81                 /* With Improbe*/ 
    82                 Message_Check(comm); 
     80    /* With Improbe*/ 
     81    Message_Check(comm); 
    8382 
    8483    int flag = false; 
     
    9493 
    9594    return 0; 
    96         } 
     95  } 
    9796 
    98         int MPI_Imrecv(void *buf, int count, MPI_Datatype datatype, MPI_Message *message, MPI_Request *request) 
    99         { 
    100                 Debug("MPI_Imrecv"); 
     97  int MPI_Imrecv(void *buf, int count, MPI_Datatype datatype, MPI_Message *message, MPI_Request *request) 
     98  { 
     99    Debug("MPI_Imrecv"); 
    101100 
    102                 request->type = 3; 
     101    request->type = 3; 
    103102 
    104103    ::MPI_Request mpi_request; 
    105104    ::MPI_Message mpi_message = static_cast< ::MPI_Message >(message->mpi_message); 
    106105                 
    107                 ::MPI_Imrecv(buf, count, static_cast< ::MPI_Datatype>(datatype), &mpi_message, &mpi_request); 
     106    ::MPI_Imrecv(buf, count, static_cast< ::MPI_Datatype>(datatype), &mpi_message, &mpi_request); 
    108107 
    109108    request->mpi_request = mpi_request; 
     
    114113 
    115114    return 0; 
    116         } 
     115  } 
    117116 
    118117 
    119118  int MPI_Mrecv(void *buf, int count, MPI_Datatype datatype, MPI_Message *message, MPI_Status *status) 
    120         { 
     119  { 
    121120    Debug("EP Mrecv called\n"); 
    122121 
    123122    ::MPI_Status mpi_status; 
    124123    ::MPI_Message mpi_message = static_cast< ::MPI_Message >(message->mpi_message); 
    125                  
    126                 ::MPI_Mrecv(buf, count, static_cast< ::MPI_Datatype>(datatype), &mpi_message, &mpi_status); 
     124     
     125    ::MPI_Mrecv(buf, count, static_cast< ::MPI_Datatype>(datatype), &mpi_message, &mpi_status); 
    127126 
    128127    status->mpi_status = new ::MPI_Status(mpi_status); 
     
    134133 
    135134    return 0; 
    136         } 
     135  } 
     136 
     137} 
    137138 
    138139 
    139    
    140  
    141 } 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_send.cpp

    r1134 r1147  
    158158    request->type = 1;          // used in wait 
    159159    request->comm = comm; 
     160    request->buf = NULL; 
    160161     
    161162 
  • XIOS/dev/branch_yushan_merged/extern/src_ep_dev/ep_wait.cpp

    r1146 r1147  
    1414 
    1515 
    16 namespace ep_lib {       
     16namespace ep_lib  
     17{        
    1718 
    18     int MPI_Wait(MPI_Request *request, MPI_Status *status) 
     19  int MPI_Wait(MPI_Request *request, MPI_Status *status) 
     20  { 
     21 
     22    if(request->type == 1) 
    1923    { 
     24      ::MPI_Request mpi_request = static_cast< ::MPI_Request >(request->mpi_request); 
     25      ::MPI_Status mpi_status; 
     26      ::MPI_Wait(&mpi_request, &mpi_status); 
    2027 
    21         if(request->type == 1) 
    22         { 
    23             ::MPI_Request mpi_request = static_cast< ::MPI_Request >(request->mpi_request); 
    24             ::MPI_Status mpi_status; 
    25             ::MPI_Wait(&mpi_request, &mpi_status); 
     28      status->mpi_status = &mpi_status; 
     29      status->ep_src = request->ep_src; 
     30      status->ep_tag = request->ep_tag; 
     31      status->ep_datatype = request->ep_datatype; 
    2632 
     33      return 0; 
     34    } 
    2735 
     36    if(request->type == 2) 
     37    { 
     38      int flag = false; 
     39      MPI_Message message; 
    2840 
    29             status->mpi_status = &mpi_status; 
    30             status->ep_src = request->ep_src; 
    31             status->ep_tag = request->ep_tag; 
    32             status->ep_datatype = request->ep_datatype; 
     41      while(!flag) 
     42      { 
     43        Message_Check(request->comm); 
     44        #pragma omp flush 
     45        MPI_Improbe(request->ep_src, request->ep_tag, request->comm, &flag, &message, status); 
     46      } 
    3347 
    34             return 0; 
    35         } 
     48      int count; 
     49      MPI_Get_count(status, request->ep_datatype, &count); 
     50      MPI_Mrecv(request->buf, count, request->ep_datatype, &message, status); 
     51      status->ep_datatype = request->ep_datatype; 
    3652 
    37         if(request->type == 2) 
    38         { 
    39             int flag = false; 
    40             MPI_Message message; 
     53      //check_sum_recv(request->buf, count, request->ep_datatype, request->ep_src, request->ep_tag, request->comm, 2); 
    4154 
    42             while(!flag) 
    43             { 
    44                 Message_Check(request->comm); 
    45 #pragma omp flush 
    46                 MPI_Improbe(request->ep_src, request->ep_tag, request->comm, &flag, &message, status); 
    47             } 
     55      return 0; 
     56    } 
    4857 
    49             int count; 
    50             MPI_Get_count(status, request->ep_datatype, &count); 
    51             MPI_Mrecv(request->buf, count, request->ep_datatype, &message, status); 
    52             status->ep_datatype = request->ep_datatype; 
     58    if(request->type == 3) 
     59    { 
     60      ::MPI_Request mpi_request = static_cast< ::MPI_Request >(request->mpi_request); 
     61      ::MPI_Status mpi_status; 
     62      ::MPI_Wait(&mpi_request, &mpi_status); 
    5363 
    54             //check_sum_recv(request->buf, count, request->ep_datatype, request->ep_src, request->ep_tag, request->comm, 2); 
     64      status->mpi_status = new ::MPI_Status(mpi_status); 
     65      status->ep_src = request->ep_src; 
     66      status->ep_tag = request->ep_tag; 
     67      status->ep_datatype = request->ep_datatype; 
    5568 
    56             return 0; 
    57         } 
     69      //check_sum_recv(request->buf, count, request->ep_datatype, request->ep_src, request->ep_tag, request->comm, 2); 
     70    } 
    5871 
    59         if(request->type == 3) 
    60         { 
    61             ::MPI_Request mpi_request = static_cast< ::MPI_Request >(request->mpi_request); 
    62             ::MPI_Status mpi_status; 
    63             ::MPI_Wait(&mpi_request, &mpi_status); 
     72    return MPI_SUCCESS; 
    6473 
    65             status->mpi_status = new ::MPI_Status(mpi_status); 
    66             status->ep_src = request->ep_src; 
    67             status->ep_tag = request->ep_tag; 
    68             status->ep_datatype = request->ep_datatype; 
    69  
    70             //int count; 
    71             //MPI_Get_count(status, request->ep_datatype, &count); 
    72             //check_sum_recv(request->buf, count, request->ep_datatype, request->ep_src, request->ep_tag, request->comm, 2); 
    73         } 
    74         return MPI_SUCCESS; 
    75     } 
     74  }   /*end of mpi_wait*/ 
    7675 
    7776 
     
    8079 
    8180 
    82     int MPI_Waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses) 
     81  int MPI_Waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses) 
     82  { 
     83    int dest_rank; 
     84    MPI_Comm_rank(MPI_COMM_WORLD, &dest_rank); 
     85 
     86    int finished = 0; 
     87    int finished_index[count]; 
     88 
     89    for(int i=0; i<count; i++) 
    8390    { 
    84         int dest_rank; 
    85         MPI_Comm_rank(MPI_COMM_WORLD, &dest_rank); 
    86  
    87         int finished = 0; 
    88         int finished_index[count]; 
    89  
    90         for(int i=0; i<count; i++) 
    91         { 
    92             finished_index[i] = false; 
    93         } 
    94  
    95         while(finished < count) 
    96         { 
    97             for(int i=0; i<count; i++) 
    98             { 
    99                 //MPI_Test(&array_of_requests[i], &finished_index[i], &array_of_statuses[i]); 
    100                 if(finished_index[i] == false) // this request has not been tested. 
    101                 { 
    102                     if(array_of_requests[i].type != 2) // isend or imrecv 
    103                     {       
    104                         MPI_Wait(&array_of_requests[i], &array_of_statuses[i]); 
    105                         finished++; 
    106                         finished_index[i] = true; 
    107                     } 
    108                     else // irecv 
    109                     { 
    110                         int flag = false; 
    111                         MPI_Message message; 
    112  
    113                         MPI_Improbe(array_of_requests[i].ep_src, array_of_requests[i].ep_tag, array_of_requests[i].comm, &flag, &message, &array_of_statuses[i]); 
    114  
    115                         if(flag) 
    116                         { 
    117                             //printf("dest_rank = %d, Waiting one message with src = %d, tag = %d, buf = %p\n", dest_rank, array_of_requests[i].ep_src, array_of_requests[i].ep_tag, array_of_requests[i].buf); 
    118                             int recv_count; 
    119                             MPI_Get_count(&array_of_statuses[i], array_of_requests[i].ep_datatype, &recv_count); 
    120                             MPI_Mrecv(array_of_requests[i].buf, recv_count, array_of_requests[i].ep_datatype, &message, &array_of_statuses[i]); 
    121                             //check_sum_recv(array_of_requests[i].buf, recv_count, array_of_requests[i].ep_datatype, array_of_requests[i].ep_src, array_of_requests[i].ep_tag, array_of_requests[i].comm, 2); 
    122  
    123                             finished++; 
    124                             finished_index[i] = true; 
    125                         } 
    126                     } 
    127                 } 
    128             }     
    129         } 
    130         return MPI_SUCCESS; 
     91      finished_index[i] = false; 
    13192    } 
    13293 
     94    while(finished < count) 
     95    { 
     96      for(int i=0; i<count; i++) 
     97      { 
     98        if(finished_index[i] == false) // this request has not been tested. 
     99        { 
     100          if(array_of_requests[i].type != 2) // isend or imrecv 
     101          {       
     102            MPI_Wait(&array_of_requests[i], &array_of_statuses[i]); 
     103            finished++; 
     104            finished_index[i] = true; 
     105          } 
     106          else // irecv 
     107          { 
     108            int flag = false; 
     109            MPI_Message message; 
    133110 
     111            MPI_Improbe(array_of_requests[i].ep_src, array_of_requests[i].ep_tag, array_of_requests[i].comm, &flag, &message, &array_of_statuses[i]); 
    134112 
     113            if(flag) 
     114            { 
     115              int recv_count; 
     116              MPI_Get_count(&array_of_statuses[i], array_of_requests[i].ep_datatype, &recv_count); 
     117              MPI_Mrecv(array_of_requests[i].buf, recv_count, array_of_requests[i].ep_datatype, &message, &array_of_statuses[i]); 
     118              //check_sum_recv(array_of_requests[i].buf, recv_count, array_of_requests[i].ep_datatype, array_of_requests[i].ep_src, array_of_requests[i].ep_tag, array_of_requests[i].comm, 2); 
     119 
     120              finished++; 
     121              finished_index[i] = true; 
     122            } 
     123          } 
     124        } 
     125      }     
     126    } 
     127    return MPI_SUCCESS; 
     128  }  /* end of mpi_waitall*/ 
    135129 
    136130 
Note: See TracChangeset for help on using the changeset viewer.