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

revert erroneous commit on trunk

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

Legend:

Unmodified
Added
Removed

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

    r1638 r1639  
    4343  double* src_area=NULL ; 
    4444  double* dst_area=NULL ; 
    45   mapper = new Mapper(EP_COMM_WORLD); 
     45  mapper = new Mapper(MPI_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

    r1638 r1639  
    3232 
    3333  int mpiRank, mpiSize; 
    34   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    35   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     34  MPI_Comm_rank(communicator, &mpiRank); 
     35  MPI_Comm_size(communicator, &mpiSize); 
    3636 
    3737  sourceElements.reserve(nbCells); 
    … …  
    4343    long int offset ; 
    4444    long int nb=nbCells ; 
    45     ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
     45    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ; 
    4646    offset=offset-nb ; 
    4747    for(int i=0;i<nbCells;i++) sourceGlobalId[i]=offset+i ; 
    … …  
    7070 
    7171  int mpiRank, mpiSize; 
    72   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    73   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
     72  MPI_Comm_rank(communicator, &mpiRank); 
     73  MPI_Comm_size(communicator, &mpiSize); 
    7474 
    7575  targetElements.reserve(nbCells); 
    … …  
    8181    long int offset ; 
    8282    long int nb=nbCells ; 
    83     ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ; 
     83    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_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   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    120   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     119  MPI_Comm_size(communicator, &mpiSize); 
     120  MPI_Comm_rank(communicator, &mpiRank); 
    121121 
    122122  this->buildSSTree(sourceMesh, targetMesh); 
    … …  
    173173{ 
    174174  int mpiSize, mpiRank; 
    175   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    176   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     175  MPI_Comm_size(communicator, &mpiSize); 
     176  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   ep_lib::MPI_Alltoall(nbSendElement, 1, EP_INT, nbRecvElement, 1, EP_INT, communicator); 
     237  MPI_Alltoall(nbSendElement, 1, MPI_INT, nbRecvElement, 1, MPI_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   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]; 
     248  MPI_Request *sendRequest = new MPI_Request[5*mpiSize]; 
     249  MPI_Request *recvRequest = new MPI_Request[5*mpiSize]; 
    250250  for (int rank = 0; rank < mpiSize; rank++) 
    251251  { 
    252252    if (nbSendElement[rank] > 0) 
    253253    { 
    254       ep_lib::MPI_Issend(sendElement[rank], nbSendElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     254      MPI_Issend(sendElement[rank], nbSendElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    255255      nbSendRequest++; 
    256256    } 
    … …  
    271271        sendNeighIds[rank] = new GloId[nbRecvElement[rank]]; 
    272272      } 
    273       ep_lib::MPI_Irecv(recvElement[rank], nbRecvElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     273      MPI_Irecv(recvElement[rank], nbRecvElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    274274      nbRecvRequest++; 
    275275    } 
    276276  } 
    277   ep_lib::MPI_Status *status = new ep_lib::MPI_Status[5*mpiSize]; 
     277  MPI_Status *status = new MPI_Status[5*mpiSize]; 
    278278   
    279   ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    280         ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     279  MPI_Waitall(nbSendRequest, sendRequest, status); 
     280        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       ep_lib::MPI_Issend(sendValue[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     312      MPI_Issend(sendValue[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    313313      nbSendRequest++; 
    314       ep_lib::MPI_Issend(sendArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     314      MPI_Issend(sendArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    315315      nbSendRequest++; 
    316       ep_lib::MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     316      MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    317317      nbSendRequest++; 
    318318      if (order == 2) 
    319319      { 
    320         ep_lib::MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     320        MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    321321        nbSendRequest++; 
    322         ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     322        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    323323//ym  --> attention taille GloId 
    324324        nbSendRequest++; 
    … …  
    326326      else 
    327327      { 
    328         ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     328        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    329329//ym  --> attention taille GloId 
    330330        nbSendRequest++; 
    … …  
    333333    if (nbSendElement[rank] > 0) 
    334334    { 
    335       ep_lib::MPI_Irecv(recvValue[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     335      MPI_Irecv(recvValue[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    336336      nbRecvRequest++; 
    337       ep_lib::MPI_Irecv(recvArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     337      MPI_Irecv(recvArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    338338      nbRecvRequest++; 
    339       ep_lib::MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     339      MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    340340      nbRecvRequest++; 
    341341      if (order == 2) 
    342342      { 
    343         ep_lib::MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
    344             EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     343        MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1), 
     344            MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    345345        nbRecvRequest++; 
    346         ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     346        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    347347//ym  --> attention taille GloId 
    348348        nbRecvRequest++; 
    … …  
    350350      else 
    351351      { 
    352         ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     352        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    353353//ym  --> attention taille GloId 
    354354        nbRecvRequest++; 
    … …  
    357357  } 
    358358         
    359         ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
    360   ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
     359        MPI_Waitall(nbSendRequest, sendRequest, status); 
     360  MPI_Waitall(nbRecvRequest, recvRequest, status); 
    361361   
    362362 
    … …  
    487487{ 
    488488  int mpiSize, mpiRank; 
    489   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    490   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     489  MPI_Comm_size(communicator, &mpiSize); 
     490  MPI_Comm_rank(communicator, &mpiRank); 
    491491 
    492492  vector<Node> *routingList = new vector<Node>[mpiSize]; 
    … …  
    522522  } 
    523523 
    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); 
     524  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
     525  MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
    526526 
    527527  char **sendBuffer = new char*[mpiSize]; 
    … …  
    549549  int nbSendRequest = 0; 
    550550  int nbRecvRequest = 0; 
    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]; 
     551  MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
     552  MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
     553  MPI_Status  *status      = new MPI_Status[mpiSize]; 
    554554 
    555555  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    557557    if (nbSendNode[rank] > 0) 
    558558    { 
    559       ep_lib::MPI_Issend(sendBuffer[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     559      MPI_Issend(sendBuffer[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    560560      nbSendRequest++; 
    561561    } 
    562562    if (nbRecvNode[rank] > 0) 
    563563    { 
    564       ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     564      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    565565      nbRecvRequest++; 
    566566    } 
    567567  } 
    568568 
    569   ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    570   ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     569  MPI_Waitall(nbRecvRequest, recvRequest, status); 
     570  MPI_Waitall(nbSendRequest, sendRequest, status); 
    571571 
    572572  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    615615 
    616616 
    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); 
     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); 
    620620 
    621621  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    629629    if (nbSendNode[rank] > 0) 
    630630    { 
    631       ep_lib::MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     631      MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    632632      nbSendRequest++; 
    633633    } 
    634634    if (nbRecvNode[rank] > 0) 
    635635    { 
    636       ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     636      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    637637      nbRecvRequest++; 
    638638    } 
    639639  } 
    640640 
    641   ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    642   ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     641  MPI_Waitall(nbRecvRequest, recvRequest, status); 
     642  MPI_Waitall(nbSendRequest, sendRequest, status); 
    643643 
    644644  int nbNeighbourNodes = 0; 
    … …  
    725725{ 
    726726  int mpiSize, mpiRank; 
    727   ep_lib::MPI_Comm_size(communicator, &mpiSize); 
    728   ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
    729  
    730   ep_lib::MPI_Barrier(communicator); 
     727  MPI_Comm_size(communicator, &mpiSize); 
     728  MPI_Comm_rank(communicator, &mpiRank); 
     729 
     730  MPI_Barrier(communicator); 
    731731 
    732732  vector<Node> *routingList = new vector<Node>[mpiSize]; 
    … …  
    753753    cout << endl; 
    754754  } 
    755   ep_lib::MPI_Barrier(communicator); 
     755  MPI_Barrier(communicator); 
    756756 
    757757  int *nbSendNode = new int[mpiSize]; 
    … …  
    771771  } 
    772772 
    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); 
     773  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator); 
     774  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
    775775 
    776776  int total = 0; 
    … …  
    805805  int nbSendRequest = 0; 
    806806  int nbRecvRequest = 0; 
    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]; 
     807  MPI_Request *sendRequest = new MPI_Request[mpiSize]; 
     808  MPI_Request *recvRequest = new MPI_Request[mpiSize]; 
     809  MPI_Status   *status = new MPI_Status[mpiSize]; 
    810810 
    811811  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    813813    if (nbSendNode[rank] > 0) 
    814814    { 
    815       ep_lib::MPI_Issend(sendBuffer[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     815      MPI_Issend(sendBuffer[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    816816      nbSendRequest++; 
    817817    } 
    818818    if (nbRecvNode[rank] > 0) 
    819819    { 
    820       ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     820      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    821821      nbRecvRequest++; 
    822822    } 
    823823  } 
    824824 
    825   ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    826   ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     825  MPI_Waitall(nbRecvRequest, recvRequest, status); 
     826  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   ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator); 
     885  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator); 
    886886 
    887887  for (int rank = 0; rank < mpiSize; rank++) 
    … …  
    896896    if (sentMessageSize[rank] > 0) 
    897897    { 
    898       ep_lib::MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
     898      MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]); 
    899899      nbSendRequest++; 
    900900    } 
    901901    if (recvMessageSize[rank] > 0) 
    902902    { 
    903       ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
     903      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]); 
    904904      nbRecvRequest++; 
    905905    } 
    906906  } 
    907907 
    908   ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status); 
    909   ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status); 
     908  MPI_Waitall(nbRecvRequest, recvRequest, status); 
     909  MPI_Waitall(nbSendRequest, sendRequest, status); 
    910910 
    911911  delete [] sendRequest; 

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

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

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

    r1638 r1639  
    44namespace sphereRemap { 
    55 
    6 CMPICascade::CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm) 
     6CMPICascade::CMPICascade(int nodes_per_level, MPI_Comm comm) 
    77{ 
    88        int remaining_levels; 
    9         ep_lib::MPI_Comm intraComm; 
     9        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                 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)); 
     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)); 
    1919                comm = intraComm; 
    2020                l++; 

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

    r1638 r1639  
    1212{ 
    1313public: 
    14         CCascadeLevel(ep_lib::MPI_Comm comm) : comm(comm) 
     14        CCascadeLevel(MPI_Comm comm) : comm(comm) 
    1515        { 
    16                 ep_lib::MPI_Comm_size(comm, &size); 
    17                 ep_lib::MPI_Comm_rank(comm, &rank); 
     16                MPI_Comm_size(comm, &size); 
     17                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         ep_lib::MPI_Comm comm, pg_comm; 
     26        MPI_Comm comm, pg_comm; 
    2727        int rank; 
    2828        int size; 
    … …  
    3535public: 
    3636        //  
    37         CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm); 
     37        CMPICascade(int nodes_per_level, MPI_Comm comm); 
    3838 
    3939        int num_levels; 

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

    r1638 r1639  
    1010const int verbose = 0; 
    1111 
    12 CMPIRouting::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); 
     12CMPIRouting::CMPIRouting(MPI_Comm comm) : communicator(comm) 
     13{ 
     14        MPI_Comm_rank(comm, &mpiRank); 
     15        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, 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); 
     21void 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); 
    2525 
    2626        // communicate data 
    … …  
    2828        for (int i = 0; i < ranks.size(); i++) 
    2929                if (recv[i].size()) 
    30                         ep_lib::MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
     30                        MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]); 
    3131        for (int i = 0; i < ranks.size(); i++) 
    3232                if (send[i].size()) 
    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]); 
     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]); 
    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, 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); 
     40void 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); 
    4444 
    4545        // communicate sizes 
    … …  
    5050                sendSizes[i] = send[i].size(); 
    5151        for (int i = 0; i < ranks.size(); i++) 
    52                 ep_lib::MPI_Irecv(&recvSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     52                MPI_Irecv(&recvSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
    5353        for (int i = 0; i < ranks.size(); i++) 
    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]); 
     54                MPI_Isend(&sendSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]); 
     55        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         ep_lib::MPI_Reduce_scatter(toSend, &nbSource, recvCount, EP_INT, EP_SUM, communicator); 
     120        MPI_Reduce_scatter(toSend, &nbSource, recvCount, MPI_INT, MPI_SUM, communicator); 
    121121        CTimer::get("CMPIRouting::init(reduce_scatter)").suspend(); 
    122122        CTimer::get("CMPIRouting::init(reduce_scatter)").print(); 
    123123 
    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); 
     124        MPI_Alloc_mem(nbTarget *sizeof(int), MPI_INFO_NULL, &targetRank); 
     125        MPI_Alloc_mem(nbSource *sizeof(int), MPI_INFO_NULL, &sourceRank); 
    126126 
    127127        targetRankToIndex = new int[mpiSize]; 
    … …  
    137137        } 
    138138 
    139         ep_lib::MPI_Barrier(communicator); 
     139        MPI_Barrier(communicator); 
    140140        CTimer::get("CMPIRouting::init(get_source)").reset(); 
    141141        CTimer::get("CMPIRouting::init(get_source)").resume(); 
    142142 
    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]; 
     143        MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
     144        MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
    145145 
    146146        int indexRequest = 0; 
    … …  
    150150        for (int i = 0; i < nbSource; i++) 
    151151        { 
    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++; 
    158         } 
    159         MPI_Barrier(communicator); 
    160         for (int i = 0; i < nbTarget; i++) 
    161         { 
    162                 ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     152                MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]); 
     153                indexRequest++; 
     154        } 
     155        MPI_Barrier(communicator); 
     156        for (int i = 0; i < nbTarget; i++) 
     157        { 
     158                MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    163159                indexRequest++; 
    164160        } 
    … …  
    174170        for (int i = 0; i < nbSource; i++) 
    175171        { 
    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]); 
     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]); 
    187179                indexRequest++; 
    188180        } 
    … …  
    209201        for (int i = 0; i < nbSource; i++) 
    210202        { 
    211                 ep_lib::MPI_Irecv(&nbSourceElement[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     203                MPI_Irecv(&nbSourceElement[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    212204                indexRequest++; 
    213205        } 
    … …  
    216208        { 
    217209                totalTargetElement += nbTargetElement[i]; 
    218                 ep_lib::MPI_Isend(&nbTargetElement[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
     210                MPI_Isend(&nbTargetElement[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]); 
    219211                indexRequest++; 
    220212        } 
    … …  
    284276 
    285277 
    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]; 
     278        MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
     279        MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
    288280        int indexRequest=0; 
    289281 
    290         ep_lib::MPI_Barrier(communicator); 
     282        MPI_Barrier(communicator); 
    291283        CTimer::get("CMPIRouting::transferToTarget").reset(); 
    292284        CTimer::get("CMPIRouting::transferToTarget").resume(); 
    … …  
    294286        for(int i=0; i<nbSource; i++) 
    295287        { 
    296                 ep_lib::MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     288                MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    297289                indexRequest++; 
    298290        } 
    … …  
    300292        for(int i=0;i<nbTarget; i++) 
    301293        { 
    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); 
     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); 
    307299 
    308300        CTimer::get("CMPIRouting::transferToTarget").suspend(); 
    309301        CTimer::get("CMPIRouting::transferToTarget").print(); 
    310         ep_lib::MPI_Barrier(communicator); 
     302        MPI_Barrier(communicator); 
    311303 
    312304        // unpack the data 
    … …  
    348340        } 
    349341 
    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]; 
     342        MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
     343        MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
    352344        int indexRequest = 0; 
    353345 
    354         ep_lib::MPI_Barrier(communicator); 
     346        MPI_Barrier(communicator); 
    355347        CTimer::get("CMPIRouting::transferToTarget(messageSize)").reset(); 
    356348        CTimer::get("CMPIRouting::transferToTarget(messageSize)").resume(); 
    … …  
    358350        for(int i=0; i<nbSource; i++) 
    359351        { 
    360                 ep_lib::MPI_Irecv(&sourceMessageSize[i],1,EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
     352                MPI_Irecv(&sourceMessageSize[i],1,MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]); 
    361353                indexRequest++; 
    362354        } 
    … …  
    364356        for(int i=0; i<nbTarget; i++) 
    365357        { 
    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); 
     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); 
    373365        CTimer::get("CMPIRouting::transferToTarget(messageSize)").suspend(); 
    374366        CTimer::get("CMPIRouting::transferToTarget(messageSize)").print(); 
    … …  
    403395        for(int i=0; i<nbSource; i++) 
    404396        { 
    405                 ep_lib::MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     397                MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    406398                indexRequest++; 
    407399        } 
    … …  
    409401        for(int i=0;i<nbTarget; i++) 
    410402        { 
    411                 ep_lib::MPI_Isend(targetBuffer[i],targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
     403                MPI_Isend(targetBuffer[i],targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]); 
    412404                indexRequest++; 
    413405        } 
    … …  
    468460        } 
    469461 
    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]; 
     462        MPI_Request* request=new MPI_Request[nbSource+nbTarget]; 
     463        MPI_Status*  status=new MPI_Status[nbSource+nbTarget]; 
    472464        int indexRequest=0; 
    473465 
    474466        for(int i=0; i<nbSource; i++) 
    475467        { 
    476                 ep_lib::MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
     468                MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]); 
    477469                indexRequest++; 
    478470        } 
    … …  
    480472        for(int i=0;i<nbTarget; i++) 
    481473        { 
    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); 
     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); 
    487479 
    488480        // unpack the data 
    … …  
    524516        } 
    525517 
    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]; 
     518        MPI_Request *request = new MPI_Request[nbSource + nbTarget]; 
     519        MPI_Status  *status = new MPI_Status[nbSource + nbTarget]; 
    528520        int indexRequest = 0; 
    529521        for (int i = 0; i < nbSource; i++) 
    530522        { 
    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); 
     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); 
    540532 
    541533        for (int i = 0; i < nbTarget; i++) 
    … …  
    565557        for (int i = 0; i < nbSource; i++) 
    566558        { 
    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); 
     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); 
    576568 
    577569        // unpack the data 
    … …  
    613605 
    614606template void alltoalls_unknown(const std::vector<std::vector<NES> >& send, std::vector<std::vector<NES> >& recv, 
    615                                 const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
     607                                const std::vector<int>& ranks, MPI_Comm communicator); 
    616608 
    617609template void alltoalls_known(const std::vector<std::vector<int> >& send, std::vector<std::vector<int> >& recv, 
    618                               const std::vector<int>& ranks, ep_lib::MPI_Comm communicator); 
    619  
    620 } 
     610                              const std::vector<int>& ranks, MPI_Comm communicator); 
     611 
     612} 

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

    r1638 r1639  
    1111{ 
    1212 
    13         ep_lib::MPI_Comm communicator; 
     13        MPI_Comm communicator; 
    1414        int mpiRank; 
    1515        int mpiSize; 
    … …  
    2929 
    3030public: 
    31         CMPIRouting(ep_lib::MPI_Comm comm); 
     31        CMPIRouting(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, ep_lib::MPI_Comm communicator); 
     46                     const std::vector<int>& ranks, 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, ep_lib::MPI_Comm communicator); 
     50                       const std::vector<int>& ranks, MPI_Comm communicator); 
    5151} 
    5252#endif 

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

    r1638 r1639  
    115115 
    116116//CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MIN_NODE_SZ*MIN_NODE_SZ, comm) 
    117 CParallelTree::CParallelTree(ep_lib::MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm) 
     117CParallelTree::CParallelTree(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         ep_lib::MPI_Allreduce(&n, &nrecv, 1, EP_INT, EP_SUM, comm.comm); // => size of sample tree does not depend on keepNodes! 
     153        MPI_Allreduce(&n, &nrecv, 1, MPI_INT, MPI_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         ep_lib::MPI_Allgather(&nsend, 1, EP_INT, counts, 1, EP_INT, comm.comm); 
     159        MPI_Allgather(&nsend, 1, MPI_INT, counts, 1, MPI_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         ep_lib::MPI_Allgatherv(sendBuffer, 4 * nsend, EP_DOUBLE, recvBuffer, counts, displs, EP_DOUBLE, comm.comm); 
     185        MPI_Allgatherv(sendBuffer, 4 * nsend, MPI_DOUBLE, recvBuffer, counts, displs, MPI_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, EP_INT, MPI_PROD, communicator); 
     243        MPI_Allreduce(&ok, &allok, 1, MPI_INT, MPI_PROD, communicator); 
    244244        if (!allok) { 
    245245                MPI_Finalize(); 
    … …  
    247247        } 
    248248*/ 
    249     ep_lib::MPI_Abort(EP_COMM_WORLD,-1) ; 
     249    MPI_Abort(MPI_COMM_WORLD,-1) ; 
    250250  } 
    251251/* 
    … …  
    265265{ 
    266266        CMPIRouting MPIRoute(communicator); 
    267         ep_lib::MPI_Barrier(communicator); 
     267        MPI_Barrier(communicator); 
    268268        CTimer::get("buildLocalTree(initRoute)").resume(); 
    269269        MPIRoute.init(route); 
    … …  
    290290 
    291291        int mpiRank; 
    292         ep_lib::MPI_Comm_rank(communicator, &mpiRank); 
     292        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   ep_lib::MPI_Allreduce(&nb, &nbTot, 1, EP_LONG, EP_SUM, communicator) ; 
     318  MPI_Allreduce(&nb, &nbTot, 1, MPI_LONG, MPI_SUM, communicator) ; 
    319319  int commSize ; 
    320   ep_lib::MPI_Comm_size(communicator,&commSize) ; 
     320  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         ep_lib::MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
     503        MPI_Comm_size(cascade.level[level].pg_comm, &pg_size); 
    504504        vector<Coord> allRootCentres(pg_size); 
    505505        vector<double> allRootRadia(pg_size); 
    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); 
     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); 
    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

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