Changeset 1638 for XIOS/trunk/extern


Ignore:
Timestamp:
01/22/19 16:15:03 (5 years ago)
Author:
yushan
Message:

dev on ADA

Location:
XIOS/trunk/extern/remap/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/extern/remap/src/libmapper.cpp

    r1614 r1638  
    4343  double* src_area=NULL ; 
    4444  double* dst_area=NULL ; 
    45   mapper = new Mapper(MPI_COMM_WORLD); 
     45  mapper = new Mapper(EP_COMM_WORLD); 
    4646  mapper->setVerbosity(PROGRESS) ; 
    4747  mapper->setSourceMesh(src_bounds_lon, src_bounds_lat, src_area, n_vert_per_cell_src, n_cell_src, src_pole ) ; 

  • XIOS/trunk/extern/remap/src/mapper.cpp

    r1614 r1638  
    3232 
    3333  int mpiRank, mpiSize; 
    34   MPI_Comm_rank(communicator, &mpiRank); 
    35   MPI_Comm_size(communicator, &mpiSize); 
     34  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     35  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    3636 
    3737  sourceElements.reserve(nbCells); 
    … …  
    4343    long int offset ; 
    4444    long int nb=nbCells ; 
    45     MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ; 
     45    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
    4646    offset=offset-nb ; 
    4747    for(int i=0;i<nbCells;i++) sourceGlobalId[i]=offset+i ; 
    … …  
    7070 
    7171  int mpiRank, mpiSize; 
    72   MPI_Comm_rank(communicator, &mpiRank); 
    73   MPI_Comm_size(communicator, &mpiSize); 
     72  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     73  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    7474 
    7575  targetElements.reserve(nbCells); 
    … …  
    8181    long int offset ; 
    8282    long int nb=nbCells ; 
    83     MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ; 
     83    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
    8484    offset=offset-nb ; 
    8585    for(int i=0;i<nbCells;i++) targetGlobalId[i]=offset+i ; 
    … …  
    117117  vector<double> timings; 
    118118  int mpiSize, mpiRank; 
    119   MPI_Comm_size(communicator, &mpiSize); 
    120   MPI_Comm_rank(communicator, &mpiRank); 
     119  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     120  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    121121 
    122122  this->buildSSTree(sourceMesh, targetMesh); 
    … …  
    173173{ 
    174174  int mpiSize, mpiRank; 
    175   MPI_Comm_size(communicator, &mpiSize); 
    176   MPI_Comm_rank(communicator, &mpiRank); 
     175  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     176  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    177177 
    178178  /* create list of intersections (super mesh elements) for each rank */ 
    … …  
    235235  /* communicate sizes of source elements to be sent (index lists and later values and gradients) */ 
    236236  int *nbRecvElement = new int[mpiSize]; 
    237   MPI_Alltoall(nbSendElement, 1, MPI_INT, nbRecvElement, 1, MPI_INT, communicator); 
     237  ep_lib::MPI_Alltoall(nbSendElement, 1, EP_INT, nbRecvElement, 1, EP_INT, communicator); 
    238238 
    239239  /* communicate indices of source elements on other ranks whoes value and gradient we need (since intersection) */ 
    … …  
    246246  Coord **sendGrad = new Coord*[mpiSize]; 
    247247  GloId **sendNeighIds = new GloId*[mpiSize]; 
    248   MPI_Request *sendRequest = new MPI_Request[5*mpiSize]; 
    249   MPI_Request *recvRequest = new MPI_Request[5*mpiSize]; 
     248  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[5*mpiSize]; 
     249  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[5*mpiSize]; 
    250250  for (int rank = 0; rank < mpiSize; rank++) 
    251251  { 
    252252    if (nbSendElement[rank] > 0) 
    253253    { 
    254       MPI_Issend(sendElement[rank], nbSendElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     254      ep_lib::MPI_Issend(sendElement[rank], nbSendElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    255255      nbSendRequest++; 
    256256    } 
    … …  
    271271        sendNeighIds[rank] = new GloId[nbRecvElement[rank]]; 
    272272      } 
    273       MPI_Irecv(recvElement[rank], nbRecvElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     273      ep_lib::MPI_Irecv(recvElement[rank], nbRecvElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    274274      nbRecvRequest++; 
    275275    } 
    276276  } 
    277   MPI_Status *status = new MPI_Status[5*mpiSize]; 
     277  ep_lib::MPI_Status *status = new ep_lib::MPI_Status[5*mpiSize]; 
    278278   
    279   MPI_Waitall(nbSendRequest, sendRequest, status); 
    280         MPI_Waitall(nbRecvRequest, recvRequest, status); 
     279  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     280        ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    281281 
    282282  /* for all indices that have been received from requesting ranks: pack values and gradients, then send */ 
    … …  
    310310          sendNeighIds[rank][j] = sstree.localElements[recvElement[rank][j]].src_id; 
    311311      } 
    312       MPI_Issend(sendValue[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     312      ep_lib::MPI_Issend(sendValue[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    313313      nbSendRequest++; 
    314       MPI_Issend(sendArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     314      ep_lib::MPI_Issend(sendArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    315315      nbSendRequest++; 
    316       MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     316      ep_lib::MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    317317      nbSendRequest++; 
    318318      if (order == 2) 
    319319      { 
    320         MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     320        ep_lib::MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    321321        nbSendRequest++; 
    322         MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     322        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    323323//ym  --> attention taille GloId 
    324324        nbSendRequest++; 
    … …  
    326326      else 
    327327      { 
    328         MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     328        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    329329//ym  --> attention taille GloId 
    330330        nbSendRequest++; 
    … …  
    333333    if (nbSendElement[rank] > 0) 
    334334    { 
    335       MPI_Irecv(recvValue[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     335      ep_lib::MPI_Irecv(recvValue[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    336336      nbRecvRequest++; 
    337       MPI_Irecv(recvArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     337      ep_lib::MPI_Irecv(recvArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    338338      nbRecvRequest++; 
    339       MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     339      ep_lib::MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    340340      nbRecvRequest++; 
    341341      if (order == 2) 
    342342      { 
    343         MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
    344             MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     343        ep_lib::MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
     344            EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    345345        nbRecvRequest++; 
    346         MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     346        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    347347//ym  --> attention taille GloId 
    348348        nbRecvRequest++; 
    … …  
    350350      else 
    351351      { 
    352         MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     352        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    353353//ym  --> attention taille GloId 
    354354        nbRecvRequest++; 
    … …  
    357357  } 
    358358         
    359         MPI_Waitall(nbSendRequest, sendRequest, status); 
    360   MPI_Waitall(nbRecvRequest, recvRequest, status); 
     359        ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     360  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    361361   
    362362 
    … …  
    487487{ 
    488488  int mpiSize, mpiRank; 
    489   MPI_Comm_size(communicator, &mpiSize); 
    490   MPI_Comm_rank(communicator, &mpiRank); 
     489  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     490  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    491491 
    492492  vector<Node> *routingList = new vector<Node>[mpiSize]; 
    … …  
    522522  } 
    523523 
    524   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    525   MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     524  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     525  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    526526 
    527527  char **sendBuffer = new char*[mpiSize]; 
    … …  
    549549  int nbSendRequest = 0; 
    550550  int nbRecvRequest = 0; 
    551   MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
    552   MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
    553   MPI_Status  *status      = new MPI_Status[mpiSize]; 
     551  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize]; 
     552  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize]; 
     553  ep_lib::MPI_Status  *status      = new ep_lib::MPI_Status[mpiSize]; 
    554554 
    555555  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    557557    if (nbSendNode[rank] > 0) 
    558558    { 
    559       MPI_Issend(sendBuffer[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     559      ep_lib::MPI_Issend(sendBuffer[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    560560      nbSendRequest++; 
    561561    } 
    562562    if (nbRecvNode[rank] > 0) 
    563563    { 
    564       MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     564      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    565565      nbRecvRequest++; 
    566566    } 
    567567  } 
    568568 
    569   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    570   MPI_Waitall(nbSendRequest, sendRequest, status); 
     569  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     570  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    571571 
    572572  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    615615 
    616616 
    617   MPI_Barrier(communicator); 
    618   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    619   MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     617  ep_lib::MPI_Barrier(communicator); 
     618  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     619  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    620620 
    621621  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    629629    if (nbSendNode[rank] > 0) 
    630630    { 
    631       MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     631      ep_lib::MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    632632      nbSendRequest++; 
    633633    } 
    634634    if (nbRecvNode[rank] > 0) 
    635635    { 
    636       MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     636      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    637637      nbRecvRequest++; 
    638638    } 
    639639  } 
    640640 
    641   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    642   MPI_Waitall(nbSendRequest, sendRequest, status); 
     641  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     642  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    643643 
    644644  int nbNeighbourNodes = 0; 
    … …  
    725725{ 
    726726  int mpiSize, mpiRank; 
    727   MPI_Comm_size(communicator, &mpiSize); 
    728   MPI_Comm_rank(communicator, &mpiRank); 
    729  
    730   MPI_Barrier(communicator); 
     727  ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     728  ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     729 
     730  ep_lib::MPI_Barrier(communicator); 
    731731 
    732732  vector<Node> *routingList = new vector<Node>[mpiSize]; 
    … …  
    753753    cout << endl; 
    754754  } 
    755   MPI_Barrier(communicator); 
     755  ep_lib::MPI_Barrier(communicator); 
    756756 
    757757  int *nbSendNode = new int[mpiSize]; 
    … …  
    771771  } 
    772772 
    773   MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
    774   MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     773  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator); 
     774  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    775775 
    776776  int total = 0; 
    … …  
    805805  int nbSendRequest = 0; 
    806806  int nbRecvRequest = 0; 
    807   MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
    808   MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
    809   MPI_Status   *status = new MPI_Status[mpiSize]; 
     807  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize]; 
     808  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize]; 
     809  ep_lib::MPI_Status   *status = new ep_lib::MPI_Status[mpiSize]; 
    810810 
    811811  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    813813    if (nbSendNode[rank] > 0) 
    814814    { 
    815       MPI_Issend(sendBuffer[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     815      ep_lib::MPI_Issend(sendBuffer[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    816816      nbSendRequest++; 
    817817    } 
    818818    if (nbRecvNode[rank] > 0) 
    819819    { 
    820       MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     820      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    821821      nbRecvRequest++; 
    822822    } 
    823823  } 
    824824 
    825   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    826   MPI_Waitall(nbSendRequest, sendRequest, status); 
     825  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     826  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    827827  char **sendBuffer2 = new char*[mpiSize]; 
    828828  char **recvBuffer2 = new char*[mpiSize]; 
    … …  
    883883 
    884884  if (verbose >= 2) cout << "Rank " << mpiRank << "  Compute (internal) intersection " << cputime() - tic << " s" << endl; 
    885   MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
     885  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
    886886 
    887887  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    896896    if (sentMessageSize[rank] > 0) 
    897897    { 
    898       MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     898      ep_lib::MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    899899      nbSendRequest++; 
    900900    } 
    901901    if (recvMessageSize[rank] > 0) 
    902902    { 
    903       MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     903      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    904904      nbRecvRequest++; 
    905905    } 
    906906  } 
    907907 
    908   MPI_Waitall(nbRecvRequest, recvRequest, status); 
    909   MPI_Waitall(nbSendRequest, sendRequest, status); 
     908  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     909  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    910910 
    911911  delete [] sendRequest; 

  • XIOS/trunk/extern/remap/src/mapper.hpp

    r1614 r1638  
    1818{ 
    1919public: 
    20        Mapper(MPI_Comm comm=MPI_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {} 
     20       Mapper(ep_lib::MPI_Comm comm=EP_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {} 
    2121       ~Mapper(); 
    2222       void setVerbosity(verbosity v) {verbose=v ;} 
    … …  
    6767 
    6868       CParallelTree sstree; 
    69        MPI_Comm communicator ; 
     69       ep_lib::MPI_Comm communicator ; 
    7070       std::vector<Elt>  sourceElements ; 
    7171       std::vector<Node> sourceMesh ; 

  • XIOS/trunk/extern/remap/src/mpi_cascade.cpp

    r688 r1638  
    44namespace sphereRemap { 
    55 
    6 CMPICascade::CMPICascade(int nodes_per_level, MPI_Comm comm) 
     6CMPICascade::CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm) 
    77{ 
    88        int remaining_levels; 
    9         MPI_Comm intraComm; 
     9        ep_lib::MPI_Comm intraComm; 
    1010        int l = 0; // current level 
    1111        do { 
    … …  
    1515                level[l].p_grp_size = level[l].size/level[l].group_size; 
    1616         
    17                 MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm); 
    18                 MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm)); 
     17                ep_lib::MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm); 
     18                ep_lib::MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm)); 
    1919                comm = intraComm; 
    2020                l++; 

  • XIOS/trunk/extern/remap/src/mpi_cascade.hpp

    r694 r1638  
    1212{ 
    1313public: 
    14         CCascadeLevel(MPI_Comm comm) : comm(comm) 
     14        CCascadeLevel(ep_lib::MPI_Comm comm) : comm(comm) 
    1515        { 
    16                 MPI_Comm_size(comm, &size); 
    17                 MPI_Comm_rank(comm, &rank); 
     16                ep_lib::MPI_Comm_size(comm, &size); 
     17                ep_lib::MPI_Comm_rank(comm, &rank); 
    1818        } 
    1919        int colour() const { return rank % group_size; }; 
    … …  
    2424        int p_key() const { return colour() + rank/(p_grp_size*group_size)*group_size; } 
    2525 
    26         MPI_Comm comm, pg_comm; 
     26        ep_lib::MPI_Comm comm, pg_comm; 
    2727        int rank; 
    2828        int size; 
    … …  
    3535public: 
    3636        //  
    37         CMPICascade(int nodes_per_level, MPI_Comm comm); 
     37        CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm); 
    3838 
    3939        int num_levels; 

  • XIOS/trunk/extern/remap/src/mpi_routing.cpp

    r694 r1638  
    1010const int verbose = 0; 
    1111 
    12 CMPIRouting::CMPIRouting(MPI_Comm comm) : communicator(comm) 
    13 { 
    14         MPI_Comm_rank(comm, &mpiRank); 
    15         MPI_Comm_size(comm, &mpiSize); 
     12CMPIRouting::CMPIRouting(ep_lib::MPI_Comm comm) : communicator(comm) 
     13{ 
     14        ep_lib::MPI_Comm_rank(comm, &mpiRank); 
     15        ep_lib::MPI_Comm_size(comm, &mpiSize); 
    1616} 
    1717 
    … …  
    1919    but message lengths are *known* to receiver */ 
    2020template <typename T> 
    21 void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator) 
    22 { 
    23         vector<MPI_Request> request(ranks.size() * 2); 
    24         vector<MPI_Status>  status(ranks.size() * 2); 
     21void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator) 
     22{ 
     23        vector<ep_lib::MPI_Request> request(ranks.size() * 2); 
     24        vector<ep_lib::MPI_Status>  status(ranks.size() * 2); 
    2525 
    2626        // communicate data 
    … …  
    2828        for (int i = 0; i < ranks.size(); i++) 
    2929                if (recv[i].size()) 
    30                         MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
     30                        ep_lib::MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
    3131        for (int i = 0; i < ranks.size(); i++) 
    3232                if (send[i].size()) 
    33                         MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
    34         MPI_Waitall(nbRequest, &request[0], &status[0]); 
     33                        ep_lib::MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
     34        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]); 
    3535} 
    3636 
    … …  
    3838    but message lengths are *unknown* to receiver */ 
    3939template <typename T> 
    40 void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator) 
    41 { 
    42         vector<MPI_Request> request(ranks.size() * 2); 
    43         vector<MPI_Status>  status(ranks.size() * 2); 
     40void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator) 
     41{ 
     42        vector<ep_lib::MPI_Request> request(ranks.size() * 2); 
     43        vector<ep_lib::MPI_Status>  status(ranks.size() * 2); 
    4444 
    4545        // communicate sizes 
    … …  
    5050                sendSizes[i] = send[i].size(); 
    5151        for (int i = 0; i < ranks.size(); i++) 
    52                 MPI_Irecv(&recvSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     52                ep_lib::MPI_Irecv(&recvSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
    5353        for (int i = 0; i < ranks.size(); i++) 
    54                 MPI_Isend(&sendSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
    55         MPI_Waitall(nbRequest, &request[0], &status[0]); 
     54                ep_lib::MPI_Isend(&sendSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     55        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]); 
    5656 
    5757        // allocate 
    … …  
    118118        CTimer::get("CMPIRouting::init(reduce_scatter)").reset(); 
    119119        CTimer::get("CMPIRouting::init(reduce_scatter)").resume(); 
    120         MPI_Reduce_scatter(toSend, &nbSource, recvCount, MPI_INT, MPI_SUM, communicator); 
     120        ep_lib::MPI_Reduce_scatter(toSend, &nbSource, recvCount, EP_INT, EP_SUM, communicator); 
    121121        CTimer::get("CMPIRouting::init(reduce_scatter)").suspend(); 
    122122        CTimer::get("CMPIRouting::init(reduce_scatter)").print(); 
    123123 
    124         MPI_Alloc_mem(nbTarget *sizeof(int), MPI_INFO_NULL, &targetRank); 
    125         MPI_Alloc_mem(nbSource *sizeof(int), MPI_INFO_NULL, &sourceRank); 
     124        ep_lib::MPI_Alloc_mem(nbTarget *sizeof(int), EP_INFO_NULL, &targetRank); 
     125        ep_lib::MPI_Alloc_mem(nbSource *sizeof(int), EP_INFO_NULL, &sourceRank); 
    126126 
    127127        targetRankToIndex = new int[mpiSize]; 
    … …  
    137137        } 
    138138 
    139         MPI_Barrier(communicator); 
     139        ep_lib::MPI_Barrier(communicator); 
    140140        CTimer::get("CMPIRouting::init(get_source)").reset(); 
    141141        CTimer::get("CMPIRouting::init(get_source)").resume(); 
    142142 
    143         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    144         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     143        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     144        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    145145 
    146146        int indexRequest = 0; 
    … …  
    150150        for (int i = 0; i < nbSource; i++) 
    151151        { 
    152                 MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
    153                 indexRequest++; 
     152                #ifdef _usingMPI 
     153                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
     154                #elif _usingEP 
     155                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]); 
     156                #endif 
     157                indexRequest++; 
    154158        } 
    155159        MPI_Barrier(communicator); 
    156160        for (int i = 0; i < nbTarget; i++) 
    157161        { 
    158                 MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     162                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    159163                indexRequest++; 
    160164        } 
    … …  
    170174        for (int i = 0; i < nbSource; i++) 
    171175        { 
    172                 MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
    173                 indexRequest++; 
    174         } 
    175  
    176         for (int i = 0; i < nbTarget; i++) 
    177         { 
    178                 MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     176                #ifdef _usingMPI 
     177                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
     178                #elif _usingEP 
     179                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]); 
     180                #endif 
     181                indexRequest++; 
     182        } 
     183 
     184        for (int i = 0; i < nbTarget; i++) 
     185        { 
     186                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    179187                indexRequest++; 
    180188        } 
    … …  
    201209        for (int i = 0; i < nbSource; i++) 
    202210        { 
    203                 MPI_Irecv(&nbSourceElement[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     211                ep_lib::MPI_Irecv(&nbSourceElement[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    204212                indexRequest++; 
    205213        } 
    … …  
    208216        { 
    209217                totalTargetElement += nbTargetElement[i]; 
    210                 MPI_Isend(&nbTargetElement[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     218                ep_lib::MPI_Isend(&nbTargetElement[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    211219                indexRequest++; 
    212220        } 
    … …  
    276284 
    277285 
    278         MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
    279         MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
     286        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget]; 
     287        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget]; 
    280288        int indexRequest=0; 
    281289 
    282         MPI_Barrier(communicator); 
     290        ep_lib::MPI_Barrier(communicator); 
    283291        CTimer::get("CMPIRouting::transferToTarget").reset(); 
    284292        CTimer::get("CMPIRouting::transferToTarget").resume(); 
    … …  
    286294        for(int i=0; i<nbSource; i++) 
    287295        { 
    288                 MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     296                ep_lib::MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    289297                indexRequest++; 
    290298        } 
    … …  
    292300        for(int i=0;i<nbTarget; i++) 
    293301        { 
    294                 MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    295                 indexRequest++; 
    296         } 
    297  
    298         MPI_Waitall(indexRequest,request,status); 
     302                ep_lib::MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     303                indexRequest++; 
     304        } 
     305 
     306        ep_lib::MPI_Waitall(indexRequest,request,status); 
    299307 
    300308        CTimer::get("CMPIRouting::transferToTarget").suspend(); 
    301309        CTimer::get("CMPIRouting::transferToTarget").print(); 
    302         MPI_Barrier(communicator); 
     310        ep_lib::MPI_Barrier(communicator); 
    303311 
    304312        // unpack the data 
    … …  
    340348        } 
    341349 
    342         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    343         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     350        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     351        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    344352        int indexRequest = 0; 
    345353 
    346         MPI_Barrier(communicator); 
     354        ep_lib::MPI_Barrier(communicator); 
    347355        CTimer::get("CMPIRouting::transferToTarget(messageSize)").reset(); 
    348356        CTimer::get("CMPIRouting::transferToTarget(messageSize)").resume(); 
    … …  
    350358        for(int i=0; i<nbSource; i++) 
    351359        { 
    352                 MPI_Irecv(&sourceMessageSize[i],1,MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     360                ep_lib::MPI_Irecv(&sourceMessageSize[i],1,EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    353361                indexRequest++; 
    354362        } 
    … …  
    356364        for(int i=0; i<nbTarget; i++) 
    357365        { 
    358                 MPI_Isend(&targetMessageSize[i],1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    359                 indexRequest++; 
    360         } 
    361  
    362         MPI_Waitall(indexRequest,request,status); 
    363  
    364         MPI_Barrier(communicator); 
     366                ep_lib::MPI_Isend(&targetMessageSize[i],1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     367                indexRequest++; 
     368        } 
     369 
     370        ep_lib::MPI_Waitall(indexRequest,request,status); 
     371 
     372        ep_lib::MPI_Barrier(communicator); 
    365373        CTimer::get("CMPIRouting::transferToTarget(messageSize)").suspend(); 
    366374        CTimer::get("CMPIRouting::transferToTarget(messageSize)").print(); 
    … …  
    395403        for(int i=0; i<nbSource; i++) 
    396404        { 
    397                 MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     405                ep_lib::MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    398406                indexRequest++; 
    399407        } 
    … …  
    401409        for(int i=0;i<nbTarget; i++) 
    402410        { 
    403                 MPI_Isend(targetBuffer[i],targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     411                ep_lib::MPI_Isend(targetBuffer[i],targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    404412                indexRequest++; 
    405413        } 
    … …  
    460468        } 
    461469 
    462         MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
    463         MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
     470        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget]; 
     471        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget]; 
    464472        int indexRequest=0; 
    465473 
    466474        for(int i=0; i<nbSource; i++) 
    467475        { 
    468                 MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     476                ep_lib::MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    469477                indexRequest++; 
    470478        } 
    … …  
    472480        for(int i=0;i<nbTarget; i++) 
    473481        { 
    474                 MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    475                 indexRequest++; 
    476         } 
    477  
    478         MPI_Waitall(indexRequest,request,status); 
     482                ep_lib::MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     483                indexRequest++; 
     484        } 
     485 
     486        ep_lib::MPI_Waitall(indexRequest,request,status); 
    479487 
    480488        // unpack the data 
    … …  
    516524        } 
    517525 
    518         MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
    519         MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
     526        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget]; 
     527        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget]; 
    520528        int indexRequest = 0; 
    521529        for (int i = 0; i < nbSource; i++) 
    522530        { 
    523                 MPI_Isend(&sourceMessageSize[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    524                 indexRequest++; 
    525         } 
    526         for (int i = 0; i < nbTarget; i++) 
    527         { 
    528                 MPI_Irecv(&targetMessageSize[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    529                 indexRequest++; 
    530         } 
    531         MPI_Waitall(indexRequest, request, status); 
     531                ep_lib::MPI_Isend(&sourceMessageSize[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     532                indexRequest++; 
     533        } 
     534        for (int i = 0; i < nbTarget; i++) 
     535        { 
     536                ep_lib::MPI_Irecv(&targetMessageSize[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     537                indexRequest++; 
     538        } 
     539        ep_lib::MPI_Waitall(indexRequest, request, status); 
    532540 
    533541        for (int i = 0; i < nbTarget; i++) 
    … …  
    557565        for (int i = 0; i < nbSource; i++) 
    558566        { 
    559                 MPI_Isend(sourceBuffer[i], sourceMessageSize[i], MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    560                 indexRequest++; 
    561         } 
    562         for (int i = 0; i < nbTarget; i++) 
    563         { 
    564                 MPI_Irecv(targetBuffer[i], targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    565                 indexRequest++; 
    566         } 
    567         MPI_Waitall(indexRequest, request, status); 
     567                ep_lib::MPI_Isend(sourceBuffer[i], sourceMessageSize[i], EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     568                indexRequest++; 
     569        } 
     570        for (int i = 0; i < nbTarget; i++) 
     571        { 
     572                ep_lib::MPI_Irecv(targetBuffer[i], targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     573                indexRequest++; 
     574        } 
     575        ep_lib::MPI_Waitall(indexRequest, request, status); 
    568576 
    569577        // unpack the data 
    … …  
    605613 
    606614template void alltoalls_unknown(const std::vector<std::vector<NES> >& send, std::vector<std::vector<NES> >& recv, 
    607                                 const std::vector<int>& ranks, MPI_Comm communicator); 
     615                                const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    608616 
    609617template void alltoalls_known(const std::vector<std::vector<int> >& send, std::vector<std::vector<int> >& recv, 
    610                               const std::vector<int>& ranks, MPI_Comm communicator); 
    611  
    612 } 
     618                              const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
     619 
     620} 

  • XIOS/trunk/extern/remap/src/mpi_routing.hpp

    r694 r1638  
    1111{ 
    1212 
    13         MPI_Comm communicator; 
     13        ep_lib::MPI_Comm communicator; 
    1414        int mpiRank; 
    1515        int mpiSize; 
    … …  
    2929 
    3030public: 
    31         CMPIRouting(MPI_Comm comm); 
     31        CMPIRouting(ep_lib::MPI_Comm comm); 
    3232        ~CMPIRouting(); 
    3333        template<typename T> void init(const std::vector<T>& route, CMPICascade *cascade = NULL); 
    … …  
    4444template <typename T> 
    4545void alltoalls_known(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv, 
    46                      const std::vector<int>& ranks, MPI_Comm communicator); 
     46                     const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    4747 
    4848template <typename T> 
    4949void alltoalls_unknown(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv, 
    50                        const std::vector<int>& ranks, MPI_Comm communicator); 
     50                       const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    5151} 
    5252#endif 

  • XIOS/trunk/extern/remap/src/parallel_tree.cpp

    r923 r1638  
    115115 
    116116//CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MIN_NODE_SZ*MIN_NODE_SZ, comm) 
    117 CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm) 
     117CParallelTree::CParallelTree(ep_lib::MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm) 
    118118{ 
    119119        treeCascade.reserve(cascade.num_levels); 
    … …  
    151151 
    152152        int nrecv; // global number of samples  THIS WILL BE THE NUMBER OF LEAFS IN THE SAMPLE TREE 
    153         MPI_Allreduce(&n, &nrecv, 1, MPI_INT, MPI_SUM, comm.comm); // => size of sample tree does not depend on keepNodes! 
     153        ep_lib::MPI_Allreduce(&n, &nrecv, 1, EP_INT, EP_SUM, comm.comm); // => size of sample tree does not depend on keepNodes! 
    154154        double ratio = blocSize / (1.0 * nrecv); 
    155155        int nsend = ratio * n + 1; // nsend = n_local_samples / n_global_samples * blocksize + 1 = blocksize/comm.size 
    … …  
    157157 
    158158        int *counts = new int[comm.size]; 
    159         MPI_Allgather(&nsend, 1, MPI_INT, counts, 1, MPI_INT, comm.comm); 
     159        ep_lib::MPI_Allgather(&nsend, 1, EP_INT, counts, 1, EP_INT, comm.comm); 
    160160 
    161161        nrecv = 0; 
    … …  
    183183        /* each process needs the sample elements from all processes */ 
    184184        double *recvBuffer = new double[nrecv*4]; 
    185         MPI_Allgatherv(sendBuffer, 4 * nsend, MPI_DOUBLE, recvBuffer, counts, displs, MPI_DOUBLE, comm.comm); 
     185        ep_lib::MPI_Allgatherv(sendBuffer, 4 * nsend, EP_DOUBLE, recvBuffer, counts, displs, EP_DOUBLE, comm.comm); 
    186186        delete[] sendBuffer; 
    187187        delete[] counts; 
    … …  
    241241         << "   node size : "<<node.size()<<"   bloc size : "<<blocSize<<"  total number of leaf : "<<tree.leafs.size()<<endl ; 
    242242/* 
    243         MPI_Allreduce(&ok, &allok, 1, MPI_INT, MPI_PROD, communicator); 
     243        MPI_Allreduce(&ok, &allok, 1, EP_INT, MPI_PROD, communicator); 
    244244        if (!allok) { 
    245245                MPI_Finalize(); 
    … …  
    247247        } 
    248248*/ 
    249     MPI_Abort(MPI_COMM_WORLD,-1) ; 
     249    ep_lib::MPI_Abort(EP_COMM_WORLD,-1) ; 
    250250  } 
    251251/* 
    … …  
    265265{ 
    266266        CMPIRouting MPIRoute(communicator); 
    267         MPI_Barrier(communicator); 
     267        ep_lib::MPI_Barrier(communicator); 
    268268        CTimer::get("buildLocalTree(initRoute)").resume(); 
    269269        MPIRoute.init(route); 
    … …  
    290290 
    291291        int mpiRank; 
    292         MPI_Comm_rank(communicator, &mpiRank); 
     292        ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    293293        localTree.leafs.reserve(nbLocalElements); 
    294294        for (int i = 0; i < nbLocalElements; i++) 
    … …  
    316316  nb1=node.size() ; nb2=node2.size() ; 
    317317  nb=nb1+nb2 ; 
    318   MPI_Allreduce(&nb, &nbTot, 1, MPI_LONG, MPI_SUM, communicator) ; 
     318  ep_lib::MPI_Allreduce(&nb, &nbTot, 1, EP_LONG, EP_SUM, communicator) ; 
    319319  int commSize ; 
    320   MPI_Comm_size(communicator,&commSize) ; 
     320  ep_lib::MPI_Comm_size(communicator,&commSize) ; 
    321321   
    322322        // make multiple of two 
    … …  
    501501        // gather circles on this level of the cascade 
    502502        int pg_size; 
    503         MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
     503        ep_lib::MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
    504504        vector<Coord> allRootCentres(pg_size); 
    505505        vector<double> allRootRadia(pg_size); 
    506         MPI_Allgather(&rootCentre, 3, MPI_DOUBLE, &allRootCentres[0], 3, MPI_DOUBLE, cascade.level[level].pg_comm); 
    507         MPI_Allgather(&rootRadius, 1, MPI_DOUBLE, &allRootRadia[0],   1, MPI_DOUBLE, cascade.level[level].pg_comm); 
     506        ep_lib::MPI_Allgather(&rootCentre, 3, EP_DOUBLE, &allRootCentres[0], 3, EP_DOUBLE, cascade.level[level].pg_comm); 
     507        ep_lib::MPI_Allgather(&rootRadius, 1, EP_DOUBLE, &allRootRadia[0],   1, EP_DOUBLE, cascade.level[level].pg_comm); 
    508508 
    509509        // now allRootsRadia and allRootCentres must be inserted into second levels of us and propagated to root 

  • XIOS/trunk/extern/remap/src/parallel_tree.hpp

    r694 r1638  
    1212{ 
    1313public: 
    14         CParallelTree(MPI_Comm comm); 
     14        CParallelTree(ep_lib::MPI_Comm comm); 
    1515        ~CParallelTree(); 
    1616 
    … …  
    3434        vector<CSampleTree> treeCascade; // first for sample tree, then for routing tree 
    3535        CMPICascade cascade; 
    36   MPI_Comm communicator ; 
     36  ep_lib::MPI_Comm communicator ; 
    3737 
    3838}; 
Note: See TracChangeset for help on using the changeset viewer.