Changeset 1639


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

revert erroneous commit on trunk

Location:
XIOS/trunk
Files:
2 deleted
70 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}; 
  • XIOS/trunk/src/buffer_client.cpp

    r1638 r1639  
    1212  size_t CClientBuffer::maxRequestSize = 0; 
    1313 
    14   CClientBuffer::CClientBuffer(ep_lib::MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
     14  CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
    1515    : interComm(interComm) 
    1616    , serverRank(serverRank) 
     
    8383  bool CClientBuffer::checkBuffer(void) 
    8484  { 
    85     ep_lib::MPI_Status status; 
     85    MPI_Status status; 
    8686    int flag; 
    8787 
     
    8989    { 
    9090      traceOff(); 
    91       ep_lib::MPI_Test(&request, &flag, &status); 
     91      MPI_Test(&request, &flag, &status); 
    9292      traceOn(); 
    9393      if (flag == true) pending = false; 
     
    9898      if (count > 0) 
    9999      { 
    100         ep_lib::MPI_Issend(buffer[current], count, EP_CHAR, serverRank, 20, interComm, &request); 
     100        MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request); 
    101101        pending = true; 
    102102        if (current == 1) current = 0; 
  • XIOS/trunk/src/buffer_client.hpp

    r1638 r1639  
    1414      static size_t maxRequestSize; 
    1515 
    16       CClientBuffer(ep_lib::MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
     16      CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
    1717      ~CClientBuffer(); 
    1818 
     
    3939      bool pending; 
    4040 
    41       ep_lib::MPI_Request request; 
     41      MPI_Request request; 
    4242 
    4343      CBufferOut* retBuffer; 
    44       const ep_lib::MPI_Comm interComm; 
     44      const MPI_Comm interComm; 
    4545  }; 
    4646} 
  • XIOS/trunk/src/client.cpp

    r1638 r1639  
    99#include "oasis_cinterface.hpp" 
    1010#include "mpi.hpp" 
    11 //#include "mpi_wrapper.hpp" 
    1211#include "timer.hpp" 
    1312#include "buffer_client.hpp" 
     
    1716{ 
    1817 
    19     ep_lib::MPI_Comm CClient::intraComm ; 
    20     ep_lib::MPI_Comm CClient::interComm ; 
    21     std::list<ep_lib::MPI_Comm> CClient::contextInterComms; 
     18    MPI_Comm CClient::intraComm ; 
     19    MPI_Comm CClient::interComm ; 
     20    std::list<MPI_Comm> CClient::contextInterComms; 
    2221    int CClient::serverLeader ; 
    2322    bool CClient::is_MPI_Initialized ; 
     
    2524    StdOFStream CClient::m_infoStream; 
    2625    StdOFStream CClient::m_errorStream; 
    27     ep_lib::MPI_Comm& CClient::getInterComm(void)   { return (interComm); } 
     26    MPI_Comm& CClient::getInterComm(void)   { return (interComm); } 
    2827      
    2928///--------------------------------------------------------------- 
     
    3635 */ 
    3736 
    38     void CClient::initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) 
     37    void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
    3938    { 
    4039      int initialized ; 
    41       ep_lib::MPI_Initialized(&initialized) ; 
     40      MPI_Initialized(&initialized) ; 
    4241      if (initialized) is_MPI_Initialized=true ; 
    4342      else is_MPI_Initialized=false ; 
     
    4847      { 
    4948// localComm isn't given 
    50         if (localComm == EP_COMM_NULL) 
     49        if (localComm == MPI_COMM_NULL) 
    5150        { 
    5251          if (!is_MPI_Initialized) 
    5352          { 
    54             ep_lib::MPI_Init(NULL, NULL); 
     53            MPI_Init(NULL, NULL); 
    5554          } 
    5655          CTimer::get("XIOS").resume() ; 
     
    6463          int myColor ; 
    6564          int i,c ; 
    66           ep_lib::MPI_Comm newComm ; 
    67  
    68           ep_lib::MPI_Comm_size(CXios::globalComm,&size) ; 
    69  
    70           ep_lib::MPI_Comm_rank(CXios::globalComm,&rank_); 
     65          MPI_Comm newComm ; 
     66 
     67          MPI_Comm_size(CXios::globalComm,&size) ; 
     68          MPI_Comm_rank(CXios::globalComm,&rank_); 
    7169 
    7270          hashAll=new unsigned long[size] ; 
    7371 
    74           ep_lib::MPI_Allgather(&hashClient,1,EP_LONG,hashAll,1,EP_LONG,CXios::globalComm) ; 
     72          MPI_Allgather(&hashClient,1,MPI_LONG,hashAll,1,MPI_LONG,CXios::globalComm) ; 
    7573 
    7674          map<unsigned long, int> colors ; 
     
    9997 
    10098          myColor=colors[hashClient]; 
    101           ep_lib::MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ; 
     99          MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ; 
    102100 
    103101          if (CXios::usingServer) 
     
    106104            serverLeader=leaders[hashServer] ; 
    107105            int intraCommSize, intraCommRank ; 
    108             ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
    109             ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ; 
     106            MPI_Comm_size(intraComm,&intraCommSize) ; 
     107            MPI_Comm_rank(intraComm,&intraCommRank) ; 
    110108            info(50)<<"intercommCreate::client "<<rank_<<" intraCommSize : "<<intraCommSize 
    111109                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ; 
    112              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
     110             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
    113111             //rank_ = intraCommRank; 
    114112          } 
    115113          else 
    116114          { 
    117             ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
     115            MPI_Comm_dup(intraComm,&interComm) ; 
    118116          } 
    119117          delete [] hashAll ; 
     
    128126          else 
    129127          { 
    130             ep_lib::MPI_Comm_dup(localComm,&intraComm) ; 
    131             ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
     128            MPI_Comm_dup(localComm,&intraComm) ; 
     129            MPI_Comm_dup(intraComm,&interComm) ; 
    132130          } 
    133131        } 
     
    137135      { 
    138136        // localComm isn't given 
    139         if (localComm == EP_COMM_NULL) 
     137        if (localComm == MPI_COMM_NULL) 
    140138        { 
    141139          if (!is_MPI_Initialized) oasis_init(codeId) ; 
    142140          oasis_get_localcomm(localComm) ; 
    143141        } 
    144         ep_lib::MPI_Comm_dup(localComm,&intraComm) ; 
     142        MPI_Comm_dup(localComm,&intraComm) ; 
    145143 
    146144        CTimer::get("XIOS").resume() ; 
     
    149147        if (CXios::usingServer) 
    150148        { 
    151           ep_lib::MPI_Status status ; 
    152           ep_lib::MPI_Comm_rank(intraComm,&rank_) ; 
     149          MPI_Status status ; 
     150          MPI_Comm_rank(intraComm,&rank_) ; 
    153151 
    154152          oasis_get_intercomm(interComm,CXios::xiosCodeId) ; 
    155           if (rank_==0) ep_lib::MPI_Recv(&serverLeader,1, EP_INT, 0, 0, interComm, &status) ; 
    156           ep_lib::MPI_Bcast(&serverLeader,1,EP_INT,0,intraComm) ; 
    157         } 
    158         else ep_lib::MPI_Comm_dup(intraComm,&interComm) ; 
    159       } 
    160  
    161       ep_lib::MPI_Comm_dup(intraComm,&returnComm) ; 
     153          if (rank_==0) MPI_Recv(&serverLeader,1, MPI_INT, 0, 0, interComm, &status) ; 
     154          MPI_Bcast(&serverLeader,1,MPI_INT,0,intraComm) ; 
     155        } 
     156        else MPI_Comm_dup(intraComm,&interComm) ; 
     157      } 
     158 
     159      MPI_Comm_dup(intraComm,&returnComm) ; 
    162160    } 
    163161 
     
    170168 * Function is only called by client. 
    171169 */ 
    172     void CClient::registerContext(const string& id, ep_lib::MPI_Comm contextComm) 
     170    void CClient::registerContext(const string& id, MPI_Comm contextComm) 
    173171    { 
    174172      CContext::setCurrent(id) ; 
     
    180178      // Attached mode 
    181179      { 
    182         ep_lib::MPI_Comm contextInterComm ; 
    183         ep_lib::MPI_Comm_dup(contextComm,&contextInterComm) ; 
     180        MPI_Comm contextInterComm ; 
     181        MPI_Comm_dup(contextComm,&contextInterComm) ; 
    184182        CContext* contextServer = CContext::create(idServer); 
    185183 
     
    200198        size_t message_size ; 
    201199        int leaderRank ; 
    202         ep_lib::MPI_Comm contextInterComm ; 
    203  
    204         ep_lib::MPI_Comm_size(contextComm,&size) ; 
    205         ep_lib::MPI_Comm_rank(contextComm,&rank) ; 
    206         ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
     200        MPI_Comm contextInterComm ; 
     201 
     202        MPI_Comm_size(contextComm,&size) ; 
     203        MPI_Comm_rank(contextComm,&rank) ; 
     204        MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    207205        if (rank!=0) globalRank=0 ; 
    208206 
     
    216214        buffer<<msg ; 
    217215 
    218         ep_lib::MPI_Send((void*)buff,buffer.count(),EP_CHAR,serverLeader,1,CXios::globalComm) ; 
    219  
    220         ep_lib::MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
     216        MPI_Send((void*)buff,buffer.count(),MPI_CHAR,serverLeader,1,CXios::globalComm) ; 
     217 
     218        MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
    221219        info(10)<<"Register new Context : "<<id<<endl ; 
    222         ep_lib::MPI_Comm inter ; 
    223         ep_lib::MPI_Intercomm_merge(contextInterComm,0,&inter) ; 
    224         ep_lib::MPI_Barrier(inter) ; 
     220        MPI_Comm inter ; 
     221        MPI_Intercomm_merge(contextInterComm,0,&inter) ; 
     222        MPI_Barrier(inter) ; 
    225223 
    226224        context->initClient(contextComm,contextInterComm) ; 
    227225 
    228226        contextInterComms.push_back(contextInterComm); 
    229         ep_lib::MPI_Comm_free(&inter); 
     227        MPI_Comm_free(&inter); 
    230228        delete [] buff ; 
    231229 
     
    253251        int msg=0 ; 
    254252 
    255         ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
     253        MPI_Comm_rank(intraComm,&rank) ; 
    256254        if (rank==0)  
    257255        { 
    258           ep_lib::MPI_Send(&msg,1,EP_INT,0,5,interComm) ; // tags oasis_endded = 5 
     256          MPI_Send(&msg,1,MPI_INT,0,5,interComm) ; // tags oasis_endded = 5 
    259257        } 
    260258 
     
    268266      int msg=0 ; 
    269267 
    270       ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
     268      MPI_Comm_rank(intraComm,&rank) ; 
    271269  
    272270      if (!CXios::isServer) 
    273271      { 
    274         ep_lib::MPI_Comm_rank(intraComm,&rank) ; 
     272        MPI_Comm_rank(intraComm,&rank) ; 
    275273        if (rank==0) 
    276274        { 
    277           ep_lib::MPI_Send(&msg,1,EP_INT,0,0,interComm) ; 
    278         } 
    279       } 
    280  
    281       for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    282         ep_lib::MPI_Comm_free(&(*it)); 
    283       ep_lib::MPI_Comm_free(&interComm); 
    284       ep_lib::MPI_Comm_free(&intraComm); 
     275          MPI_Send(&msg,1,MPI_INT,0,0,interComm) ; 
     276        } 
     277      } 
     278 
     279      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
     280        MPI_Comm_free(&(*it)); 
     281      MPI_Comm_free(&interComm); 
     282      MPI_Comm_free(&intraComm); 
    285283 
    286284      CTimer::get("XIOS init/finalize").suspend() ; 
     
    290288      { 
    291289        if (CXios::usingOasis) oasis_finalize(); 
    292         else ep_lib::MPI_Finalize() ; 
     290        else MPI_Finalize() ; 
    293291      } 
    294292       
     
    327325      int size = 0; 
    328326      int rank; 
    329       ep_lib::MPI_Comm_size(CXios::globalComm, &size); 
     327      MPI_Comm_size(CXios::globalComm, &size); 
    330328      while (size) 
    331329      { 
     
    336334      if (CXios::usingOasis) 
    337335      { 
    338         ep_lib::MPI_Comm_rank(CXios::globalComm,&rank); 
     336        MPI_Comm_rank(CXios::globalComm,&rank); 
    339337        fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext; 
    340338      } 
  • XIOS/trunk/src/client.hpp

    r1638 r1639  
    1010    { 
    1111      public: 
    12         static void initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm); 
     12        static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm); 
    1313        static void finalize(void); 
    14         static void registerContext(const string& id, ep_lib::MPI_Comm contextComm); 
     14        static void registerContext(const string& id, MPI_Comm contextComm); 
    1515        static void callOasisEnddef(void) ; 
    1616 
    17         static ep_lib::MPI_Comm intraComm; 
    18         static ep_lib::MPI_Comm interComm; 
    19         static std::list<ep_lib::MPI_Comm> contextInterComms; 
     17        static MPI_Comm intraComm; 
     18        static MPI_Comm interComm; 
     19        static std::list<MPI_Comm> contextInterComms; 
    2020        static int serverLeader; 
    2121        static bool is_MPI_Initialized ; 
    2222 
    23         static ep_lib::MPI_Comm& getInterComm(); 
     23        static MPI_Comm& getInterComm(); 
    2424 
    2525        //! Get global rank without oasis and current rank in model intraComm in case of oasis 
  • XIOS/trunk/src/client_client_dht_template.hpp

    r1638 r1639  
    4040  public: 
    4141    CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoInitMap, 
    42                              const ep_lib::MPI_Comm& clientIntraComm); 
     42                             const MPI_Comm& clientIntraComm); 
    4343 
    4444    CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoInitMap, 
    45                              const ep_lib::MPI_Comm& clientIntraComm); 
     45                             const MPI_Comm& clientIntraComm); 
    4646 
    4747    void computeIndexInfoMapping(const CArray<size_t,1>& indices); 
     
    5555 
    5656  protected: 
    57     CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm); 
     57    CClientClientDHTTemplate(const MPI_Comm& clientIntraComm); 
    5858 
    5959  protected: 
     
    6262    // Redistribute index and info among clients 
    6363    void computeDistributedIndex(const Index2InfoTypeMap& indexInfoInitMap, 
    64                                  const ep_lib::MPI_Comm& intraCommLevel, 
     64                                 const MPI_Comm& intraCommLevel, 
    6565                                 int level); 
    6666 
    6767    void computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoInitMap, 
    68                                  const ep_lib::MPI_Comm& intraCommLevel, 
     68                                 const MPI_Comm& intraCommLevel, 
    6969                                 int level); 
    7070 
     
    7373 
    7474    void computeIndexInfoMappingLevel(const CArray<size_t,1>& indices, 
    75                                       const ep_lib::MPI_Comm& intraCommLevel, 
     75                                      const MPI_Comm& intraCommLevel, 
    7676                                      int level); 
    7777 
     
    8585    // Send information to clients 
    8686    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    87                            const ep_lib::MPI_Comm& clientIntraComm, 
    88                            std::vector<ep_lib::MPI_Request>& requestSendInfo); 
    89     void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    90                            const ep_lib::MPI_Comm& clientIntraComm, 
    91                            ep_lib::MPI_Request* requestSendInfo); 
     87                           const MPI_Comm& clientIntraComm, 
     88                           std::vector<MPI_Request>& requestSendInfo); 
    9289 
    9390    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    94                             const ep_lib::MPI_Comm& clientIntraComm, 
    95                             std::vector<ep_lib::MPI_Request>& requestRecvInfo); 
    96     void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    97                              const ep_lib::MPI_Comm& clientIntraComm, 
    98                              ep_lib::MPI_Request* requestRecvInfo); 
    99                                                          
     91                            const MPI_Comm& clientIntraComm, 
     92                            std::vector<MPI_Request>& requestRecvInfo); 
    10093 
    10194    // Send global index to clients 
    10295    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    103                             const ep_lib::MPI_Comm& clientIntraComm, 
    104                             std::vector<ep_lib::MPI_Request>& requestSendIndexGlobal); 
    105     void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    106                             const ep_lib::MPI_Comm& clientIntraComm, 
    107                             ep_lib::MPI_Request* requestSendIndexGlobal); 
     96                            const MPI_Comm& clientIntraComm, 
     97                            std::vector<MPI_Request>& requestSendIndexGlobal); 
    10898 
    10999    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    110                              const ep_lib::MPI_Comm& clientIntraComm, 
    111                              std::vector<ep_lib::MPI_Request>& requestRecvIndex); 
    112     void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    113                               const ep_lib::MPI_Comm& clientIntraComm, 
    114                               ep_lib::MPI_Request* requestRecvIndex); 
     100                             const MPI_Comm& clientIntraComm, 
     101                             std::vector<MPI_Request>& requestRecvIndex); 
    115102 
    116103    void sendRecvOnReturn(const std::vector<int>& sendNbRank, std::vector<int>& sendNbElements, 
  • XIOS/trunk/src/client_client_dht_template_impl.hpp

    r1638 r1639  
    1414{ 
    1515template<typename T, typename H> 
    16 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm) 
     16CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const MPI_Comm& clientIntraComm) 
    1717  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    1818{ 
    19   ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
     19  MPI_Comm_size(clientIntraComm, &nbClient_); 
    2020  this->computeMPICommLevel(); 
    2121  int nbLvl = this->getNbLevel(); 
     
    3434template<typename T, typename H> 
    3535CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoMap, 
    36                                                         const ep_lib::MPI_Comm& clientIntraComm) 
     36                                                        const MPI_Comm& clientIntraComm) 
    3737  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    3838{ 
    39   ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
     39  MPI_Comm_size(clientIntraComm, &nbClient_); 
    4040  this->computeMPICommLevel(); 
    4141  int nbLvl = this->getNbLevel(); 
     
    5959template<typename T, typename H> 
    6060CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoMap, 
    61                                                         const ep_lib::MPI_Comm& clientIntraComm) 
     61                                                        const MPI_Comm& clientIntraComm) 
    6262  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    6363{ 
    64   ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
     64  MPI_Comm_size(clientIntraComm, &nbClient_); 
    6565  this->computeMPICommLevel(); 
    6666  int nbLvl = this->getNbLevel(); 
     
    9595template<typename T, typename H> 
    9696void CClientClientDHTTemplate<T,H>::computeIndexInfoMappingLevel(const CArray<size_t,1>& indices, 
    97                                                                  const ep_lib::MPI_Comm& commLevel, 
     97                                                                 const MPI_Comm& commLevel, 
    9898                                                                 int level) 
    9999{ 
    100100  int clientRank; 
    101   ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
     101  MPI_Comm_rank(commLevel,&clientRank); 
    102102  int groupRankBegin = this->getGroupBegin()[level]; 
    103103  int nbClient = this->getNbInGroup()[level]; 
     
    169169    recvIndexBuff = new unsigned long[recvNbIndexCount]; 
    170170 
    171   int request_size = 0; 
    172   for (int idx = 0; idx < recvRankClient.size(); ++idx) 
    173   { 
    174     if (0 != recvNbIndexClientCount[idx]) 
    175       request_size ++; 
    176   } 
    177  
    178   request_size += client2ClientIndex.size(); 
    179  
    180   std::vector<ep_lib::MPI_Request> request(request_size); 
     171  std::vector<MPI_Request> request; 
    181172  std::vector<int>::iterator itbRecvIndex = recvRankClient.begin(), itRecvIndex, 
    182173                             iteRecvIndex = recvRankClient.end(), 
     
    185176  int currentIndex = 0; 
    186177  int nbRecvClient = recvRankClient.size(); 
    187   int request_position = 0; 
    188178  for (int idx = 0; idx < nbRecvClient; ++idx) 
    189179  { 
    190180    if (0 != recvNbIndexClientCount[idx]) 
    191       recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
     181      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    192182    currentIndex += recvNbIndexClientCount[idx]; 
    193183  } 
     
    196186                                                iteIndex = client2ClientIndex.end(); 
    197187  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    198     sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    199  
    200   std::vector<ep_lib::MPI_Status> status(request.size()); 
    201   ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
     188    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
     189 
     190  std::vector<MPI_Status> status(request.size()); 
     191  MPI_Waitall(request.size(), &request[0], &status[0]); 
    202192 
    203193  CArray<size_t,1>* tmpGlobalIndex; 
     
    252242  } 
    253243 
    254   int requestOnReturn_size=0; 
    255   for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
    256   { 
    257     if (0 != recvNbIndexOnReturn[idx]) 
    258     { 
    259       requestOnReturn_size += 2; 
    260     } 
    261   } 
    262  
    263   for (int idx = 0; idx < nbRecvClient; ++idx) 
    264   { 
    265     if (0 != sendNbIndexOnReturn[idx]) 
    266     { 
    267       requestOnReturn_size += 2; 
    268     } 
    269   } 
    270  
    271   int requestOnReturn_position=0; 
    272  
    273   std::vector<ep_lib::MPI_Request> requestOnReturn(requestOnReturn_size); 
     244  std::vector<MPI_Request> requestOnReturn; 
    274245  currentIndex = 0; 
    275246  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
     
    277248    if (0 != recvNbIndexOnReturn[idx]) 
    278249    { 
    279       recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
     250      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    280251      recvInfoFromClients(recvRankOnReturn[idx], 
    281252                          recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    282253                          recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    283                           commLevel, &requestOnReturn[requestOnReturn_position++]); 
     254                          commLevel, requestOnReturn); 
    284255    } 
    285256    currentIndex += recvNbIndexOnReturn[idx]; 
     
    315286 
    316287      sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
    317                          sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
     288                         sendNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    318289      sendInfoToClients(rank, client2ClientInfoOnReturn[rank], 
    319                         sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, &requestOnReturn[requestOnReturn_position++]); 
     290                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn); 
    320291    } 
    321292    currentIndex += recvNbIndexClientCount[idx]; 
    322293  } 
    323294 
    324   std::vector<ep_lib::MPI_Status> statusOnReturn(requestOnReturn.size()); 
    325   ep_lib::MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
     295  std::vector<MPI_Status> statusOnReturn(requestOnReturn.size()); 
     296  MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
    326297 
    327298  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    389360template<typename T, typename H> 
    390361void CClientClientDHTTemplate<T,H>::computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoMap, 
    391                                                             const ep_lib::MPI_Comm& commLevel, 
     362                                                            const MPI_Comm& commLevel, 
    392363                                                            int level) 
    393364{ 
    394365  int clientRank; 
    395   ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
     366  MPI_Comm_rank(commLevel,&clientRank); 
    396367  computeSendRecvRank(level, clientRank); 
    397368 
     
    468439  // it will send a message to the correct clients. 
    469440  // Contents of the message are index and its corresponding informatioin 
    470   int request_size = 0; 
    471    for (int idx = 0; idx < recvRankClient.size(); ++idx) 
    472    { 
    473      if (0 != recvNbIndexClientCount[idx]) 
    474      { 
    475        request_size += 2; 
    476      } 
    477    } 
    478   
    479    request_size += client2ClientIndex.size(); 
    480    request_size += client2ClientInfo.size(); 
    481   
    482    std::vector<ep_lib::MPI_Request> request(request_size); 
    483  
     441  std::vector<MPI_Request> request; 
    484442  int currentIndex = 0; 
    485443  int nbRecvClient = recvRankClient.size(); 
    486   int request_position=0; 
    487444  for (int idx = 0; idx < nbRecvClient; ++idx) 
    488445  { 
    489446    if (0 != recvNbIndexClientCount[idx]) 
    490447    { 
    491       recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
    492       //if(clientRank==0) printf("recv index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request)); 
     448      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    493449      recvInfoFromClients(recvRankClient[idx], 
    494                             recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    495                             recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    496                             commLevel, &request[request_position++]); 
    497       //if(clientRank==0) printf("recv info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request)); 
     450                          recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
     451                          recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
     452                          commLevel, request); 
    498453    } 
    499454    currentIndex += recvNbIndexClientCount[idx]; 
     
    503458                                                iteIndex = client2ClientIndex.end(); 
    504459  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    505   {  sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    506   }    //if(clientRank==0) printf("send index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));} 
     460    sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    507461  std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo, 
    508462                                                      iteInfo = client2ClientInfo.end(); 
    509463  for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo) 
    510    { sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]); 
    511    }//   if(clientRank==0) printf("send info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));} 
    512  
    513   std::vector<ep_lib::MPI_Status> status(request.size()); 
    514    
    515   ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
     464    sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request); 
     465 
     466  std::vector<MPI_Status> status(request.size()); 
     467  MPI_Waitall(request.size(), &request[0], &status[0]); 
    516468 
    517469  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    566518template<typename T, typename H> 
    567519void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    568                                                        const ep_lib::MPI_Comm& clientIntraComm, 
    569                                                        std::vector<ep_lib::MPI_Request>& requestSendIndex) 
    570 { 
    571   ep_lib::MPI_Request request; 
     520                                                       const MPI_Comm& clientIntraComm, 
     521                                                       std::vector<MPI_Request>& requestSendIndex) 
     522{ 
     523  MPI_Request request; 
    572524  requestSendIndex.push_back(request); 
    573   ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG, 
     525  MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG, 
    574526            clientDestRank, MPI_DHT_INDEX, clientIntraComm, &(requestSendIndex.back())); 
    575 } 
    576  
    577 /*! 
    578   Send message containing index to clients 
    579   \param [in] clientDestRank rank of destination client 
    580   \param [in] indices index to send 
    581   \param [in] indiceSize size of index array to send 
    582   \param [in] clientIntraComm communication group of client 
    583   \param [in] requestSendIndex sending request 
    584 */ 
    585 template<typename T, typename H> 
    586 void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
    587                                                        const ep_lib::MPI_Comm& clientIntraComm, 
    588                                                        ep_lib::MPI_Request* requestSendIndex) 
    589 { 
    590   ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG, 
    591             clientDestRank, MPI_DHT_INDEX, clientIntraComm, requestSendIndex); 
    592527} 
    593528 
     
    601536template<typename T, typename H> 
    602537void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    603                                                          const ep_lib::MPI_Comm& clientIntraComm, 
    604                                                          std::vector<ep_lib::MPI_Request>& requestRecvIndex) 
    605 { 
    606   ep_lib::MPI_Request request; 
     538                                                         const MPI_Comm& clientIntraComm, 
     539                                                         std::vector<MPI_Request>& requestRecvIndex) 
     540{ 
     541  MPI_Request request; 
    607542  requestRecvIndex.push_back(request); 
    608   ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG, 
     543  MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG, 
    609544            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, &(requestRecvIndex.back())); 
    610 } 
    611  
    612 /*! 
    613   Receive message containing index to clients 
    614   \param [in] clientDestRank rank of destination client 
    615   \param [in] indices index to send 
    616   \param [in] clientIntraComm communication group of client 
    617   \param [in] requestRecvIndex receiving request 
    618 */ 
    619 template<typename T, typename H> 
    620 void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    621                                                          const ep_lib::MPI_Comm& clientIntraComm, 
    622                                                          ep_lib::MPI_Request *requestRecvIndex) 
    623 { 
    624   ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG, 
    625             clientSrcRank, MPI_DHT_INDEX, clientIntraComm, requestRecvIndex); 
    626545} 
    627546 
     
    636555template<typename T, typename H> 
    637556void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    638                                                       const ep_lib::MPI_Comm& clientIntraComm, 
    639                                                       std::vector<ep_lib::MPI_Request>& requestSendInfo) 
    640 { 
    641   ep_lib::MPI_Request request; 
     557                                                      const MPI_Comm& clientIntraComm, 
     558                                                      std::vector<MPI_Request>& requestSendInfo) 
     559{ 
     560  MPI_Request request; 
    642561  requestSendInfo.push_back(request); 
    643562 
    644   ep_lib::MPI_Isend(info, infoSize, EP_CHAR, 
     563  MPI_Isend(info, infoSize, MPI_CHAR, 
    645564            clientDestRank, MPI_DHT_INFO, clientIntraComm, &(requestSendInfo.back())); 
    646 } 
    647  
    648 /*! 
    649   Send message containing information to clients 
    650   \param [in] clientDestRank rank of destination client 
    651   \param [in] info info array to send 
    652   \param [in] infoSize info array size to send 
    653   \param [in] clientIntraComm communication group of client 
    654   \param [in] requestSendInfo sending request 
    655 */ 
    656 template<typename T, typename H> 
    657 void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
    658                                                       const ep_lib::MPI_Comm& clientIntraComm, 
    659                                                       ep_lib::MPI_Request *requestSendInfo) 
    660 { 
    661   ep_lib::MPI_Isend(info, infoSize, EP_CHAR, 
    662             clientDestRank, MPI_DHT_INFO, clientIntraComm, requestSendInfo); 
    663565} 
    664566 
     
    673575template<typename T, typename H> 
    674576void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    675                                                         const ep_lib::MPI_Comm& clientIntraComm, 
    676                                                         std::vector<ep_lib::MPI_Request>& requestRecvInfo) 
    677 { 
    678   ep_lib::MPI_Request request; 
     577                                                        const MPI_Comm& clientIntraComm, 
     578                                                        std::vector<MPI_Request>& requestRecvInfo) 
     579{ 
     580  MPI_Request request; 
    679581  requestRecvInfo.push_back(request); 
    680582 
    681   ep_lib::MPI_Irecv(info, infoSize, EP_CHAR, 
     583  MPI_Irecv(info, infoSize, MPI_CHAR, 
    682584            clientSrcRank, MPI_DHT_INFO, clientIntraComm, &(requestRecvInfo.back())); 
    683 } 
    684  
    685 /*! 
    686   Receive message containing information from other clients 
    687   \param [in] clientDestRank rank of destination client 
    688   \param [in] info info array to receive 
    689   \param [in] infoSize info array size to receive 
    690   \param [in] clientIntraComm communication group of client 
    691   \param [in] requestRecvInfo list of receiving request 
    692 */ 
    693 template<typename T, typename H> 
    694 void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    695                                                         const ep_lib::MPI_Comm& clientIntraComm, 
    696                                                         ep_lib::MPI_Request* requestRecvInfo) 
    697 { 
    698   ep_lib::MPI_Irecv(info, infoSize, EP_CHAR, 
    699             clientSrcRank, MPI_DHT_INFO, clientIntraComm, requestRecvInfo); 
    700585} 
    701586 
     
    766651{ 
    767652  recvNbElements.resize(recvNbRank.size()); 
    768   std::vector<ep_lib::MPI_Request> request(sendNbRank.size()+recvNbRank.size()); 
    769   std::vector<ep_lib::MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size()); 
     653  std::vector<MPI_Request> request(sendNbRank.size()+recvNbRank.size()); 
     654  std::vector<MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size()); 
    770655 
    771656  int nRequest = 0; 
    772657  for (int idx = 0; idx < recvNbRank.size(); ++idx) 
    773658  { 
    774     ep_lib::MPI_Irecv(&recvNbElements[0]+idx, 1, EP_INT, 
     659    MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT, 
    775660              recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    776661    ++nRequest; 
     
    779664  for (int idx = 0; idx < sendNbRank.size(); ++idx) 
    780665  { 
    781     ep_lib::MPI_Isend(&sendNbElements[0]+idx, 1, EP_INT, 
     666    MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT, 
    782667              sendNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    783668    ++nRequest; 
    784669  } 
    785670 
    786   ep_lib::MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
     671  MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
    787672} 
    788673 
     
    811696  std::vector<int> recvBuff(recvBuffSize*2,0); 
    812697 
    813   std::vector<ep_lib::MPI_Request> request(sendBuffSize+recvBuffSize); 
    814   std::vector<ep_lib::MPI_Status> requestStatus(sendBuffSize+recvBuffSize); 
     698  std::vector<MPI_Request> request(sendBuffSize+recvBuffSize); 
     699  std::vector<MPI_Status> requestStatus(sendBuffSize+recvBuffSize); 
    815700 
    816701  int nRequest = 0; 
    817702  for (int idx = 0; idx < recvBuffSize; ++idx) 
    818703  { 
    819     ep_lib::MPI_Irecv(&recvBuff[0]+2*idx, 2, EP_INT, 
     704    MPI_Irecv(&recvBuff[0]+2*idx, 2, MPI_INT, 
    820705              recvRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    821706    ++nRequest; 
     
    831716  for (int idx = 0; idx < sendBuffSize; ++idx) 
    832717  { 
    833     ep_lib::MPI_Isend(&sendBuff[idx*2], 2, EP_INT, 
     718    MPI_Isend(&sendBuff[idx*2], 2, MPI_INT, 
    834719              sendRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    835720    ++nRequest; 
    836721  } 
    837722 
    838   ep_lib::MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
     723  MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
    839724  int nbRecvRank = 0, nbRecvElements = 0; 
    840725  recvNbRank.clear(); 
  • XIOS/trunk/src/client_server_mapping.cpp

    r1638 r1639  
    3030*/ 
    3131std::map<int,int> CClientServerMapping::computeConnectedClients(int nbServer, int nbClient, 
    32                                                                 ep_lib::MPI_Comm& clientIntraComm, 
     32                                                                MPI_Comm& clientIntraComm, 
    3333                                                                const std::vector<int>& connectedServerRank) 
    3434{ 
     
    6262 
    6363  // get connected server for everybody 
    64   ep_lib::MPI_Allgather(&nbConnectedServer,1,EP_INT,recvCount,1,EP_INT,clientIntraComm) ; 
     64  MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ; 
    6565 
    6666  displ[0]=0 ; 
     
    7070 
    7171 
    72   ep_lib::MPI_Allgatherv(sendBuff,nbConnectedServer,EP_INT,recvBuff,recvCount,displ,EP_INT,clientIntraComm) ; 
     72  MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ; 
    7373  for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ; 
    7474 
  • XIOS/trunk/src/client_server_mapping.hpp

    r1638 r1639  
    3737 
    3838    static std::map<int,int> computeConnectedClients(int nbServer, int nbClient, 
    39                                                      ep_lib::MPI_Comm& clientIntraComm, 
     39                                                     MPI_Comm& clientIntraComm, 
    4040                                                     const std::vector<int>& connectedServerRank); 
    4141 
  • XIOS/trunk/src/client_server_mapping_distributed.cpp

    r1638 r1639  
    2020 
    2121CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    22                                                                  const ep_lib::MPI_Comm& clientIntraComm, bool isDataDistributed) 
     22                                                                 const MPI_Comm& clientIntraComm, bool isDataDistributed) 
    2323  : CClientServerMapping(), ccDHT_(0) 
    2424{ 
  • XIOS/trunk/src/client_server_mapping_distributed.hpp

    r1638 r1639  
    3535    /** Default constructor */ 
    3636    CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    37                                     const ep_lib::MPI_Comm& clientIntraComm, 
     37                                    const MPI_Comm& clientIntraComm, 
    3838                                    bool isDataDistributed = true); 
    3939 
  • XIOS/trunk/src/context_client.cpp

    r1638 r1639  
    2121    \cxtSer [in] cxtSer Pointer to context of server side. (It is only used in case of attached mode). 
    2222    */ 
    23     CContextClient::CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_, CContext* cxtSer) 
     23    CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer) 
    2424     : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4) 
    2525    { 
     
    2727      intraComm = intraComm_; 
    2828      interComm = interComm_; 
    29       ep_lib::MPI_Comm_rank(intraComm, &clientRank); 
    30       ep_lib::MPI_Comm_size(intraComm, &clientSize); 
     29      MPI_Comm_rank(intraComm, &clientRank); 
     30      MPI_Comm_size(intraComm, &clientSize); 
    3131 
    3232      int flag; 
    33       ep_lib::MPI_Comm_test_inter(interComm, &flag); 
    34       if (flag) ep_lib::MPI_Comm_remote_size(interComm, &serverSize); 
    35       else  ep_lib::MPI_Comm_size(interComm, &serverSize); 
     33      MPI_Comm_test_inter(interComm, &flag); 
     34      if (flag) MPI_Comm_remote_size(interComm, &serverSize); 
     35      else  MPI_Comm_size(interComm, &serverSize); 
    3636 
    3737      computeLeader(clientRank, clientSize, serverSize, ranksServerLeader, ranksServerNotLeader); 
     
    102102        classId_in=event.getClassId() ; 
    103103//        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_UINT64_T, MPI_SUM, intraComm) ; // MPI_UINT64_T standardized by MPI 3 
    104         ep_lib::MPI_Allreduce(&timeLine,&timeLine_out, 1, EP_LONG_LONG_INT, EP_SUM, intraComm) ;  
    105         ep_lib::MPI_Allreduce(&typeId_in,&typeId, 1, EP_INT, EP_SUM, intraComm) ; 
    106         ep_lib::MPI_Allreduce(&classId_in,&classId, 1, EP_INT, EP_SUM, intraComm) ; 
     104        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_LONG_LONG_INT, MPI_SUM, intraComm) ;  
     105        MPI_Allreduce(&typeId_in,&typeId, 1, MPI_INT, MPI_SUM, intraComm) ; 
     106        MPI_Allreduce(&classId_in,&classId, 1, MPI_INT, MPI_SUM, intraComm) ; 
    107107        if (typeId/clientSize!=event.getTypeId() || classId/clientSize!=event.getClassId() || timeLine_out/clientSize!=timeLine) 
    108108        { 
     
    343343       if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio; 
    344344     } 
    345      #ifdef _usingMPI 
    346      ep_lib::MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm); 
    347      #elif _usingEP 
    348      ep_lib::MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm); 
    349      #endif 
     345     MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    350346 
    351347     if (minBufferSizeEventSizeRatio < 1.0) 
  • XIOS/trunk/src/context_client.hpp

    r1638 r1639  
    2727    public: 
    2828      // Contructor 
    29       CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* parentServer = 0); 
     29      CContextClient(CContext* parent, MPI_Comm intraComm, MPI_Comm interComm, CContext* parentServer = 0); 
    3030 
    3131      // Send event to server 
     
    7171      int serverSize; //!< Size of server group 
    7272 
    73       ep_lib::MPI_Comm interComm; //!< Communicator of server group 
     73      MPI_Comm interComm; //!< Communicator of server group 
    7474 
    75       ep_lib::MPI_Comm intraComm; //!< Communicator of client group 
     75      MPI_Comm intraComm; //!< Communicator of client group 
    7676 
    7777      map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers 
  • XIOS/trunk/src/context_server.cpp

    r1638 r1639  
    2323{ 
    2424 
    25   CContextServer::CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm_,ep_lib::MPI_Comm interComm_) 
     25  CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_) 
    2626  { 
    2727    context=parent; 
    2828    intraComm=intraComm_; 
    29     ep_lib::MPI_Comm_size(intraComm,&intraCommSize); 
    30     ep_lib::MPI_Comm_rank(intraComm,&intraCommRank); 
     29    MPI_Comm_size(intraComm,&intraCommSize); 
     30    MPI_Comm_rank(intraComm,&intraCommRank); 
    3131 
    3232    interComm=interComm_; 
    3333    int flag; 
    34     ep_lib::MPI_Comm_test_inter(interComm,&flag); 
    35     if (flag) ep_lib::MPI_Comm_remote_size(interComm,&commSize); 
    36     else  ep_lib::MPI_Comm_size(interComm,&commSize); 
     34    MPI_Comm_test_inter(interComm,&flag); 
     35    if (flag) MPI_Comm_remote_size(interComm,&commSize); 
     36    else  MPI_Comm_size(interComm,&commSize); 
    3737 
    3838    currentTimeLine=0; 
     
    7676    int count; 
    7777    char * addr; 
    78     ep_lib::MPI_Status status; 
     78    MPI_Status status; 
    7979    map<int,CServerBuffer*>::iterator it; 
    8080    bool okLoop; 
    8181 
    8282    traceOff(); 
    83     #ifdef _usingMPI 
    8483    MPI_Iprobe(MPI_ANY_SOURCE, 20,interComm,&flag,&status); 
    85     #elif _usingEP 
    86     ep_lib::MPI_Iprobe(-2, 20,interComm,&flag,&status); 
    87     #endif 
    8884    traceOn(); 
    8985 
    9086    if (flag==true) 
    9187    { 
    92       #ifdef _usingMPI 
    9388      rank=status.MPI_SOURCE ; 
    94       #elif _usingEP 
    95       rank=status.ep_src ; 
    96       #endif 
    9789      okLoop = true; 
    9890      if (pendingRequest.find(rank)==pendingRequest.end()) 
     
    10698 
    10799            traceOff(); 
    108             ep_lib::MPI_Iprobe(rank, 20,interComm,&flag,&status); 
     100            MPI_Iprobe(rank, 20,interComm,&flag,&status); 
    109101            traceOn(); 
    110102            if (flag==true) listenPendingRequest(status) ; 
     
    115107  } 
    116108 
    117   bool CContextServer::listenPendingRequest(ep_lib::MPI_Status& status) 
     109  bool CContextServer::listenPendingRequest(MPI_Status& status) 
    118110  { 
    119111    int count; 
    120112    char * addr; 
    121113    map<int,CServerBuffer*>::iterator it; 
    122     #ifdef _usingMPI 
    123114    int rank=status.MPI_SOURCE ; 
    124     #elif _usingEP 
    125     int rank=status.ep_src ; 
    126     #endif 
    127115 
    128116    it=buffers.find(rank); 
     
    130118    { 
    131119       StdSize buffSize = 0; 
    132        ep_lib::MPI_Recv(&buffSize, 1, EP_LONG, rank, 20, interComm, &status); 
     120       MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
    133121       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    134122       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
     
    137125    else 
    138126    { 
    139       ep_lib::MPI_Get_count(&status,EP_CHAR,&count); 
     127      MPI_Get_count(&status,MPI_CHAR,&count); 
    140128      if (it->second->isBufferFree(count)) 
    141129      { 
    142130         addr=(char*)it->second->getBuffer(count); 
    143          ep_lib::MPI_Irecv(addr,count,EP_CHAR,rank,20,interComm,&pendingRequest[rank]); 
     131         MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]); 
    144132         bufferRequest[rank]=addr; 
    145133         return true; 
     
    153141  void CContextServer::checkPendingRequest(void) 
    154142  { 
    155     map<int,ep_lib::MPI_Request>::iterator it; 
     143    map<int,MPI_Request>::iterator it; 
    156144    list<int> recvRequest; 
    157145    list<int>::iterator itRecv; 
     
    159147    int flag; 
    160148    int count; 
    161     ep_lib::MPI_Status status; 
     149    MPI_Status status; 
    162150 
    163151    for(it=pendingRequest.begin();it!=pendingRequest.end();it++) 
     
    165153      rank=it->first; 
    166154      traceOff(); 
    167       ep_lib::MPI_Test(& it->second, &flag, &status); 
     155      MPI_Test(& it->second, &flag, &status); 
    168156      traceOn(); 
    169157      if (flag==true) 
    170158      { 
    171159        recvRequest.push_back(rank); 
    172         ep_lib::MPI_Get_count(&status,EP_CHAR,&count); 
     160        MPI_Get_count(&status,MPI_CHAR,&count); 
    173161        processRequest(rank,bufferRequest[rank],count); 
    174162      } 
     
    230218         // The best way to properly solve this problem will be to use the event scheduler also in attached mode 
    231219         // for now just set up a MPI barrier 
    232          if (!CServer::eventScheduler && CXios::isServer) ep_lib::MPI_Barrier(intraComm) ; 
     220         if (!CServer::eventScheduler && CXios::isServer) MPI_Barrier(intraComm) ; 
    233221 
    234222         CTimer::get("Process events").resume(); 
  • XIOS/trunk/src/context_server.hpp

    r1638 r1639  
    1414    public: 
    1515 
    16     CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm,ep_lib::MPI_Comm interComm) ; 
     16    CContextServer(CContext* parent,MPI_Comm intraComm,MPI_Comm interComm) ; 
    1717    bool eventLoop(bool enableEventsProcessing = true); 
    1818    void listen(void) ; 
    19     bool listenPendingRequest(ep_lib::MPI_Status& status) ; 
     19    bool listenPendingRequest(MPI_Status& status) ; 
    2020    void checkPendingRequest(void) ; 
    2121    void processRequest(int rank, char* buff,int count) ; 
     
    2626    bool hasPendingEvent(void) ; 
    2727 
    28     ep_lib::MPI_Comm intraComm ; 
     28    MPI_Comm intraComm ; 
    2929    int intraCommSize ; 
    3030    int intraCommRank ; 
    3131 
    32     ep_lib::MPI_Comm interComm ; 
     32    MPI_Comm interComm ; 
    3333    int commSize ; 
    3434 
    3535    map<int,CServerBuffer*> buffers ; 
    36     map<int,ep_lib::MPI_Request> pendingRequest ; 
     36    map<int,MPI_Request> pendingRequest ; 
    3737    map<int,char*> bufferRequest ; 
    3838 
  • XIOS/trunk/src/cxios.cpp

    r1638 r1639  
    2626  bool CXios::isClient ; 
    2727  bool CXios::isServer ; 
    28   ep_lib::MPI_Comm CXios::globalComm ; 
     28  MPI_Comm CXios::globalComm ; 
    2929  bool CXios::usingOasis ; 
    3030  bool CXios::usingServer = false; 
     
    9090 
    9191    checkEventSync = getin<bool>("check_event_sync", checkEventSync); 
    92     #ifdef _usingMPI 
     92 
    9393    globalComm=MPI_COMM_WORLD ; 
    94     #elif _usingEP 
    95     ep_lib::MPI_Comm *ep_comm; 
    96     ep_lib::MPI_Info info; 
    97     ep_lib::MPI_Comm_create_endpoints(EP_COMM_WORLD->mpi_comm, 1, info, ep_comm); 
    98     ep_lib::passage = ep_comm; 
    99     globalComm=ep_lib::passage[0] ; 
    100     #endif 
    10194  } 
    10295 
     
    107100  \param [in/out] returnComm communicator corresponding to group of client with same codeId 
    108101  */ 
    109   void CXios::initClientSide(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) 
     102  void CXios::initClientSide(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
    110103  TRY 
    111104  { 
     105    initialize() ; 
     106 
    112107    isClient = true; 
    113     isServer = false; 
    114  
    115     initialize() ; 
    116  
    117108 
    118109    CClient::initialize(codeId,localComm,returnComm) ; 
    119110    if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ; 
    120  
    121111 
    122112    // If there are no server processes then we are in attached mode 
     
    177167  void CXios::initServerSide(void) 
    178168  { 
    179     isClient = false; 
    180     isServer = true; 
    181  
    182169    initServer(); 
    183170    isClient = false; 
    184171    isServer = true; 
     172 
    185173    // Initialize all aspects MPI 
    186174    CServer::initialize(); 
     
    235223        int firstPoolGlobalRank = secondaryServerGlobalRanks[0]; 
    236224        int rankGlobal; 
    237         ep_lib::MPI_Comm_rank(globalComm, &rankGlobal); 
     225        MPI_Comm_rank(globalComm, &rankGlobal); 
    238226 
    239227        // Merge registries defined on each pools 
     
    247235            globalRegistrySndServers.mergeRegistry(*globalRegistry) ; 
    248236            int registrySize = globalRegistrySndServers.size(); 
    249             ep_lib::MPI_Send(&registrySize,1,EP_LONG,firstPoolGlobalRank,15,CXios::globalComm) ; 
     237            MPI_Send(&registrySize,1,MPI_LONG,firstPoolGlobalRank,15,CXios::globalComm) ; 
    250238            CBufferOut buffer(registrySize) ; 
    251239            globalRegistrySndServers.toBuffer(buffer) ; 
    252             ep_lib::MPI_Send(buffer.start(),registrySize,EP_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ; 
     240            MPI_Send(buffer.start(),registrySize,MPI_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ; 
    253241          } 
    254242        } 
     
    257245        if (rankGlobal == firstPoolGlobalRank) 
    258246        { 
    259           ep_lib::MPI_Status status; 
     247          MPI_Status status; 
    260248          char* recvBuff; 
    261249 
     
    266254            int rank = secondaryServerGlobalRanks[i]; 
    267255            int registrySize = 0; 
    268             ep_lib::MPI_Recv(&registrySize, 1, EP_LONG, rank, 15, CXios::globalComm, &status); 
     256            MPI_Recv(&registrySize, 1, MPI_LONG, rank, 15, CXios::globalComm, &status); 
    269257            recvBuff = new char[registrySize]; 
    270             ep_lib::MPI_Recv(recvBuff, registrySize, EP_CHAR, rank, 15, CXios::globalComm, &status); 
     258            MPI_Recv(recvBuff, registrySize, MPI_CHAR, rank, 15, CXios::globalComm, &status); 
    271259            CBufferIn buffer(recvBuff, registrySize) ; 
    272260            CRegistry recvRegistry; 
  • XIOS/trunk/src/cxios.hpp

    r1638 r1639  
    1515    public: 
    1616     static void initialize(void) ; 
    17      static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ; 
     17     static void initClientSide(const string & codeId, MPI_Comm& localComm, MPI_Comm& returnComm) ; 
    1818     static void initServerSide(void) ; 
    1919     static void clientFinalize(void) ; 
     
    4040     static bool isServer ; //!< Check if xios is server 
    4141 
    42      static ep_lib::MPI_Comm globalComm ; //!< Global communicator 
     42     static MPI_Comm globalComm ; //!< Global communicator 
    4343 
    4444     static bool printLogs2Files; //!< Printing out logs into files 
  • XIOS/trunk/src/dht_auto_indexing.cpp

    r1638 r1639  
    2222 
    2323  CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue, 
    24                                      const ep_lib::MPI_Comm& clientIntraComm) 
     24                                     const MPI_Comm& clientIntraComm) 
    2525    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    2626  { 
     
    2828    nbIndexOnProc_ = hashValue.size(); 
    2929    size_t nbIndexAccum; 
    30     ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm); 
     30    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm); 
    3131 
    3232    // Broadcasting the total number of indexes 
    3333    int rank, size; 
    34     ep_lib::MPI_Comm_rank(clientIntraComm, &rank); 
    35     ep_lib::MPI_Comm_size(clientIntraComm, &size); 
     34    MPI_Comm_rank(clientIntraComm, &rank); 
     35    MPI_Comm_size(clientIntraComm, &size); 
    3636    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum; 
    37     ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm); 
     37    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm); 
    3838 
    3939    CArray<size_t,1>::const_iterator itbIdx = hashValue.begin(), itIdx, 
     
    5858  */ 
    5959  CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, 
    60                                      const ep_lib::MPI_Comm& clientIntraComm) 
     60                                     const MPI_Comm& clientIntraComm) 
    6161    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    6262  { 
     
    6464    nbIndexOnProc_ = hashInitMap.size(); 
    6565    size_t nbIndexAccum; 
    66     ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm); 
     66    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm); 
    6767 
    6868    int rank, size; 
    69     ep_lib::MPI_Comm_rank(clientIntraComm, &rank); 
    70     ep_lib::MPI_Comm_size(clientIntraComm, &size); 
     69    MPI_Comm_rank(clientIntraComm, &rank); 
     70    MPI_Comm_size(clientIntraComm, &size); 
    7171    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum; 
    72     ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm); 
     72    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm); 
    7373 
    7474    Index2VectorInfoTypeMap::iterator itbIdx = hashInitMap.begin(), itIdx, 
  • XIOS/trunk/src/dht_auto_indexing.hpp

    r1638 r1639  
    2525 
    2626    CDHTAutoIndexing(const CArray<size_t,1>& hashValue, 
    27                      const ep_lib::MPI_Comm& clientIntraComm); 
     27                     const MPI_Comm& clientIntraComm); 
    2828 
    2929    CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, 
    30                      const ep_lib::MPI_Comm& clientIntraComm); 
     30                     const MPI_Comm& clientIntraComm); 
    3131 
    3232    size_t getNbIndexesGlobal() const; 
  • XIOS/trunk/src/event_scheduler.cpp

    r1638 r1639  
    88  
    99  
    10   CEventScheduler::CEventScheduler(const ep_lib::MPI_Comm& comm)  
    11   { 
    12     ep_lib::MPI_Comm_dup(comm, &communicator) ; 
    13     ep_lib::MPI_Comm_size(communicator,&mpiSize) ; 
    14     ep_lib::MPI_Comm_rank(communicator,&mpiRank); 
     10  CEventScheduler::CEventScheduler(const MPI_Comm& comm)  
     11  { 
     12    MPI_Comm_dup(comm, &communicator) ; 
     13    MPI_Comm_size(communicator,&mpiSize) ; 
     14    MPI_Comm_rank(communicator,&mpiRank); 
    1515 
    1616 
     
    8888 
    8989    pendingSentParentRequest.push(sentRequest) ; 
    90     ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ; 
     90    MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ; 
    9191    traceOn() ; 
    9292  }  
     
    115115  { 
    116116    int completed ; 
    117     ep_lib::MPI_Status status ; 
     117    MPI_Status status ; 
    118118    int received ; 
    119119    SPendingRequest* recvRequest ; 
     
    135135    while(received) 
    136136    { 
    137       #ifdef _usingMPI 
    138137      MPI_Iprobe(MPI_ANY_SOURCE,1,communicator,&received, &status) ; 
    139       #elif _usingEP 
    140       ep_lib::MPI_Iprobe(-2,1,communicator,&received, &status) ; 
    141       #endif 
    142138      if (received) 
    143139      { 
    144140        recvRequest=new SPendingRequest ; 
    145         #ifdef _usingMPI 
    146141        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 1, communicator, &(recvRequest->request)) ; 
    147         #elif _usingEP 
    148         ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 1, communicator, &(recvRequest->request)) ; 
    149         #endif 
    150142        pendingRecvParentRequest.push(recvRequest) ; 
    151143      } 
     
    157149    { 
    158150      recvRequest=pendingRecvParentRequest.front() ; 
    159       ep_lib::MPI_Test( &(recvRequest->request), &completed, &status) ; 
     151      MPI_Test( &(recvRequest->request), &completed, &status) ; 
    160152      if (completed)  
    161153      { 
     
    177169// function call only by parent mpi process 
    178170 
    179     ep_lib::MPI_Status status ;  
     171    MPI_Status status ;  
    180172    int received ; 
    181173    received=true ; 
     
    185177    while(received) 
    186178    { 
    187       #ifdef _usingMPI 
    188179      MPI_Iprobe(MPI_ANY_SOURCE,0,communicator,&received, &status) ; 
    189       #elif _usingEP 
    190       ep_lib::MPI_Iprobe(-2,0,communicator,&received, &status) ; 
    191       #endif 
    192180      if (received) 
    193181      { 
    194182        recvRequest=new SPendingRequest ; 
    195         #ifdef _usingMPI 
    196183        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 0, communicator, &recvRequest->request) ; 
    197         #elif _usingEP 
    198         ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 0, communicator, &recvRequest->request) ; 
    199         #endif 
    200184        pendingRecvChildRequest.push_back(recvRequest) ; 
    201185      } 
     
    206190    for(list<SPendingRequest*>::iterator it=pendingRecvChildRequest.begin(); it!=pendingRecvChildRequest.end() ; ) 
    207191    { 
    208       ep_lib::MPI_Test(&((*it)->request),&received,&status) ; 
     192      MPI_Test(&((*it)->request),&received,&status) ; 
    209193      if (received) 
    210194      { 
     
    244228    for(list<SPendingRequest*>::iterator it=pendingSentChildRequest.begin(); it!=pendingSentChildRequest.end() ; ) 
    245229    { 
    246       ep_lib::MPI_Test(&(*it)->request,&received,&status) ; 
     230      MPI_Test(&(*it)->request,&received,&status) ; 
    247231      if (received) 
    248232      { 
     
    267251      sentRequest->buffer[1]=contextHashId ; 
    268252      sentRequest->buffer[2]=lev+1 ; 
    269       ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ; 
     253      MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ; 
    270254      pendingSentChildRequest.push_back(sentRequest) ; 
    271255    } 
  • XIOS/trunk/src/event_scheduler.hpp

    r1638 r1639  
    2626        *  @param[in] comm : MPI communicator du duplicate for internal use 
    2727        */ 
    28        CEventScheduler(const ep_lib::MPI_Comm& comm) ; 
     28       CEventScheduler(const MPI_Comm& comm) ; 
    2929 
    3030 
     
    151151       { 
    152152         size_t buffer[3] ;      /*!< communication buffer : timeLine, hashId, level */ 
    153          ep_lib::MPI_Request request ;   /*!< pending MPI request */  
     153         MPI_Request request ;   /*!< pending MPI request */  
    154154       } ; 
    155155        
    156        ep_lib::MPI_Comm communicator ;  /*!< Internal MPI communicator */  
     156       MPI_Comm communicator ;  /*!< Internal MPI communicator */  
    157157       int mpiRank ;            /*!< Rank in the communicator */ 
    158158       int mpiSize ;            /*!< Size of the communicator */ 
  • XIOS/trunk/src/filter/spatial_transform_filter.cpp

    r1638 r1639  
    224224 
    225225      idxSendBuff = 0; 
    226       std::vector<ep_lib::MPI_Request> sendRecvRequest; 
     226      std::vector<MPI_Request> sendRecvRequest; 
    227227      for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff) 
    228228      { 
     
    234234          sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx)); 
    235235        } 
    236         sendRecvRequest.push_back(ep_lib::MPI_Request()); 
    237         ep_lib::MPI_Isend(sendBuff[idxSendBuff], countSize, EP_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back()); 
     236        sendRecvRequest.push_back(MPI_Request()); 
     237        MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back()); 
    238238      } 
    239239 
     
    252252        int srcRank = itRecv->first; 
    253253        int countSize = itRecv->second.size(); 
    254         sendRecvRequest.push_back(ep_lib::MPI_Request()); 
    255         ep_lib::MPI_Irecv(recvBuff + currentBuff, countSize, EP_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back()); 
     254        sendRecvRequest.push_back(MPI_Request()); 
     255        MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back()); 
    256256        currentBuff += countSize; 
    257257      } 
    258       std::vector<ep_lib::MPI_Status> status(sendRecvRequest.size()); 
    259       ep_lib::MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]); 
     258      std::vector<MPI_Status> status(sendRecvRequest.size()); 
     259      MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]); 
    260260 
    261261      dataCurrentDest.resize(*itNbListRecv); 
  • XIOS/trunk/src/interface/c/icdata.cpp

    r1638 r1639  
    6060   { 
    6161      std::string str; 
    62       ep_lib::MPI_Comm local_comm; 
    63       ep_lib::MPI_Comm return_comm; 
     62      MPI_Comm local_comm; 
     63      MPI_Comm return_comm; 
    6464 
    6565      if (!cstr2string(client_id, len_client_id, str)) return; 
    6666 
    6767      int initialized; 
    68       ep_lib::MPI_Initialized(&initialized); 
    69       #ifdef _usingMPI 
     68      MPI_Initialized(&initialized); 
    7069      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm); 
    7170      else local_comm=MPI_COMM_NULL; 
    72       #elif _usingEP 
    73       if (initialized) local_comm=EP_Comm_f2c(f_local_comm); 
    74       else local_comm=EP_COMM_NULL; 
    75       #endif 
    7671      CXios::initClientSide(str, local_comm, return_comm); 
    77       #ifdef _usingMPI 
    7872      *f_return_comm=MPI_Comm_c2f(return_comm); 
    79       #elif _usingEP 
    80       *f_return_comm=*static_cast<MPI_Fint* >(EP_Comm_c2f(return_comm)); 
    81       #endif 
    8273      CTimer::get("XIOS init").suspend(); 
    8374      CTimer::get("XIOS").suspend(); 
     
    8980   { 
    9081     std::string str; 
    91      ep_lib::MPI_Comm comm; 
     82     MPI_Comm comm; 
    9283 
    9384     if (!cstr2string(context_id, len_context_id, str)) return; 
    9485     CTimer::get("XIOS").resume(); 
    9586     CTimer::get("XIOS init context").resume(); 
    96      #ifdef _usingMPI 
    9787     comm=MPI_Comm_f2c(*f_comm); 
    98      #elif _usingEP 
    99      comm=EP_Comm_f2c(f_comm); 
    100      #endif 
    10188     CClient::registerContext(str, comm); 
    10289     CTimer::get("XIOS init context").suspend(); 
  • XIOS/trunk/src/interface/c/oasis_cinterface.cpp

    r1638 r1639  
    2121  } 
    2222 
    23   void oasis_get_localcomm(ep_lib::MPI_Comm& comm) 
     23  void oasis_get_localcomm(MPI_Comm& comm) 
    2424  { 
    25     ep_lib::MPI_Fint f_comm ; 
     25    MPI_Fint f_comm ; 
    2626     
    2727    fxios_oasis_get_localcomm(&f_comm) ; 
    28     //comm=MPI_Comm_f2c(f_comm) ; 
     28    comm=MPI_Comm_f2c(f_comm) ; 
    2929  } 
    3030  
    31   void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
     31  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) 
    3232  { 
    33     ep_lib::MPI_Fint f_comm ; 
     33    MPI_Fint f_comm ; 
    3434     
    3535    fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ; 
    36     //comm_client_server=MPI_Comm_f2c(f_comm) ; 
     36    comm_client_server=MPI_Comm_f2c(f_comm) ; 
    3737  } 
    3838  
    39   void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
     39  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) 
    4040  { 
    41     ep_lib::MPI_Fint f_comm ; 
     41    MPI_Fint f_comm ; 
    4242     
    4343    fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ; 
    44     //comm_client_server=MPI_Comm_f2c(f_comm) ; 
     44    comm_client_server=MPI_Comm_f2c(f_comm) ; 
    4545  } 
    4646} 
  • XIOS/trunk/src/interface/c/oasis_cinterface.hpp

    r1638 r1639  
    1010  void fxios_oasis_enddef(void) ; 
    1111  void fxios_oasis_finalize(void) ; 
    12   void fxios_oasis_get_localcomm(ep_lib::MPI_Fint* f_comm) ; 
    13   void fxios_oasis_get_intracomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    14   void fxios_oasis_get_intercomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     12  void fxios_oasis_get_localcomm(MPI_Fint* f_comm) ; 
     13  void fxios_oasis_get_intracomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     14  void fxios_oasis_get_intercomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    1515} 
    1616  
     
    2020  void oasis_enddef(void) ; 
    2121  void oasis_finalize(void) ; 
    22   void oasis_get_localcomm(ep_lib::MPI_Comm& comm) ; 
    23   void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
    24   void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
     22  void oasis_get_localcomm(MPI_Comm& comm) ; 
     23  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
     24  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
    2525} 
    2626#endif 
  • XIOS/trunk/src/io/inetcdf4.cpp

    r1638 r1639  
    77namespace xios 
    88{ 
    9   CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, 
     9  CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, 
    1010                       bool readMetaDataPar /*= false*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1111  { 
     
    1414    { 
    1515      int commSize = 0; 
    16       ep_lib::MPI_Comm_size(*comm, &commSize); 
     16      MPI_Comm_size(*comm, &commSize); 
    1717      if (commSize <= 1) 
    1818        comm = NULL; 
     
    2323    // even if Parallel NetCDF ends up being used. 
    2424    if (mpi) 
    25       CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, EP_INFO_NULL, this->ncidp); 
     25      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, MPI_INFO_NULL, this->ncidp); 
    2626    else 
    2727      CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp); 
  • XIOS/trunk/src/io/inetcdf4.hpp

    r1638 r1639  
    2222    public: 
    2323      /// Constructors /// 
    24       CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
     24      CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true, 
    2525                bool readMetaDataPar = false, const StdString& timeCounterName = "time_counter"); 
    2626 
  • XIOS/trunk/src/io/nc4_data_input.cpp

    r1638 r1639  
    1010namespace xios 
    1111{ 
    12   CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, 
     12  CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, 
    1313                               bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1414    : SuperClass() 
  • XIOS/trunk/src/io/nc4_data_input.hpp

    r1638 r1639  
    2323 
    2424    /// Constructors /// 
    25     CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     25    CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true, 
    2626                  bool readMetaDataPar = false, bool ugridConvention = false, const StdString& timeCounterName = "time_counter"); 
    2727    CNc4DataInput(const CNc4DataInput& dataInput);       // Not implemented. 
     
    7070  private: 
    7171    /// Private attributes /// 
    72     ep_lib::MPI_Comm comm_file; 
     72    MPI_Comm comm_file; 
    7373    const StdString filename; 
    7474    bool isCollective; 
  • XIOS/trunk/src/io/nc4_data_output.cpp

    r1638 r1639  
    2828      CNc4DataOutput::CNc4DataOutput 
    2929         (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention, 
    30           ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
     30          MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
    3131            : SuperClass() 
    3232            , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName) 
  • XIOS/trunk/src/io/nc4_data_output.hpp

    r1638 r1639  
    2727               (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, 
    2828                bool useCFConvention, 
    29                 ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     29                MPI_Comm comm_file, bool multifile, bool isCollective = true, 
    3030                const StdString& timeCounterName = "time_counter"); 
    3131 
     
    117117 
    118118            /// Propriétés privées /// 
    119             ep_lib::MPI_Comm comm_file; 
     119            MPI_Comm comm_file; 
    120120            const StdString filename; 
    121121            std::map<Time, StdSize> timeToRecordCache; 
  • XIOS/trunk/src/io/netCdfInterface.cpp

    r1638 r1639  
    1010#include "netCdfInterface.hpp" 
    1111#include "netCdfException.hpp" 
    12 #include "ep_mpi.hpp" 
     12 
    1313namespace xios 
    1414{ 
     
    4747\return Status code 
    4848*/ 
    49 int CNetCdfInterface::createPar(const StdString& fileName, int cMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
    50 { 
    51   #ifdef _usingMPI 
     49int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId) 
     50{ 
    5251  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId); 
    53   #elif _usingEP 
    54   int status = xios::nc_create_par(fileName.c_str(), cMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
    55   #endif 
    5652  if (NC_NOERR != status) 
    5753  { 
     
    104100\return Status code 
    105101*/ 
    106 int CNetCdfInterface::openPar(const StdString& fileName, int oMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
    107 { 
    108   #ifdef _usingMPI 
     102int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId) 
     103{ 
    109104  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); 
    110   #elif _usingEP 
    111   int status = xios::nc_open_par(fileName.c_str(), oMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
    112   #endif 
    113105  if (NC_NOERR != status) 
    114106  { 
  • XIOS/trunk/src/io/netCdfInterface.hpp

    r1638 r1639  
    3232 
    3333    //! Create a netcdf file on a parallel file system 
    34     static int createPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId); 
     34    static int createPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId); 
    3535 
    3636    //! Open a netcdf file 
     
    3838 
    3939    //! Open a netcdf file 
    40     static int openPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId); 
     40    static int openPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId); 
    4141 
    4242    //! Close a netcdf file 
  • XIOS/trunk/src/io/onetcdf4.cpp

    r1638 r1639  
    1515      CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat, 
    1616                                                        bool useCFConvention, 
    17                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     17                           const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    1818        : path() 
    1919        , wmpi(false) 
     
    3333 
    3434      void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,  
    35                                  const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     35                                 const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    3636      { 
    3737         this->useClassicFormat = useClassicFormat; 
     
    4444         { 
    4545            int commSize = 0; 
    46             ep_lib::MPI_Comm_size(*comm, &commSize); 
     46            MPI_Comm_size(*comm, &commSize); 
    4747            if (commSize <= 1) 
    4848               comm = NULL; 
     
    5858            CTimer::get("Files : create").resume(); 
    5959            if (wmpi) 
    60                CNetCdfInterface::createPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp); 
     60               CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp); 
    6161            else 
    6262               CNetCdfInterface::create(filename, mode, this->ncidp); 
     
    7070            CTimer::get("Files : open").resume(); 
    7171            if (wmpi) 
    72                CNetCdfInterface::openPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp); 
     72               CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp); 
    7373            else 
    7474               CNetCdfInterface::open(filename, mode, this->ncidp); 
  • XIOS/trunk/src/io/onetcdf4.hpp

    r1638 r1639  
    2828            CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false, 
    2929                          bool useCFConvention = true, 
    30                       const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
     30                      const MPI_Comm* comm = NULL, bool multifile = true, 
    3131                      const StdString& timeCounterName = "time_counter"); 
    3232 
     
    3737            /// Initialisation /// 
    3838            void initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
    39                             const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
     39                            const MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
    4040            void close(void); 
    4141            void sync(void); 
  • XIOS/trunk/src/mpi.hpp

    r1638 r1639  
    1111#define OMPI_SKIP_MPICXX 
    1212 
    13 #ifdef _usingEP 
    14 #include "ep_lib.hpp" 
    15 #include "ep_declaration.hpp" 
    16 #endif 
    17  
    1813#include <mpi.h> 
    1914 
    20 #ifdef _usingMPI 
    21  
    22 #define ep_lib   
    23  
    24 #define EP_INT MPI_INT 
    25 #define EP_FLOAT MPI_FLOAT 
    26 #define EP_DOUBLE MPI_DOUBLE 
    27 #define EP_CHAR MPI_CHAR 
    28 #define EP_LONG MPI_LONG 
    29 #define EP_LONG_LONG_INT MPI_LONG_LONG_INT 
    30 #define EP_UNSIGNED_LONG  MPI_UNSIGNED_LONG 
    31 #define EP_UNSIGNED_CHAR  MPI_UNSIGNED_CHAR 
    32  
    33  
    34 #define EP_COMM_WORLD MPI_COMM_WORLD 
    35 #define EP_COMM_NULL MPI_COMM_NULL 
    36 #define EP_INFO_NULL MPI_INFO_NULL 
    37  
    38 #define EP_MAX MPI_MAX 
    39 #define EP_MIN MPI_MIN 
    40 #define EP_SUM MPI_SUM 
    41 #define EP_LOR MPI_LOR 
    42  
    4315#endif 
    44  
    45 #endif 
  • XIOS/trunk/src/node/axis.cpp

    r1638 r1639  
    130130     \return the number of indexes written by each server 
    131131   */ 
    132    int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     132   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom) 
    133133   TRY 
    134134   { 
    135135     int writtenSize; 
    136      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     136     MPI_Comm_size(writtenCom, &writtenSize); 
    137137     return numberWrittenIndexes_[writtenSize]; 
    138138   } 
     
    143143     \return the total number of indexes written by the servers 
    144144   */ 
    145    int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     145   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
    146146   TRY 
    147147   { 
    148148     int writtenSize; 
    149      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     149     MPI_Comm_size(writtenCom, &writtenSize); 
    150150     return totalNumberWrittenIndexes_[writtenSize]; 
    151151   } 
     
    156156     \return the offset of indexes written by each server 
    157157   */ 
    158    int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     158   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
    159159   TRY 
    160160   { 
    161161     int writtenSize; 
    162      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     162     MPI_Comm_size(writtenCom, &writtenSize); 
    163163     return offsetWrittenIndexes_[writtenSize]; 
    164164   } 
    165165   CATCH_DUMP_ATTR 
    166166 
    167    CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
     167   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
    168168   TRY 
    169169   { 
    170170     int writtenSize; 
    171      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     171     MPI_Comm_size(writtenCom, &writtenSize); 
    172172     return compressedIndexToWriteOnServer[writtenSize]; 
    173173   } 
     
    768768  CATCH_DUMP_ATTR 
    769769 
    770   void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
     770  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
    771771  TRY 
    772772  { 
    773773    int writtenCommSize; 
    774     ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
     774    MPI_Comm_size(writtenComm, &writtenCommSize); 
    775775    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    776776      return; 
     
    850850      { 
    851851              
    852         ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
    853         ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
     852        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     853        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    854854        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    855855      } 
  • XIOS/trunk/src/node/axis.hpp

    r1638 r1639  
    6868         const std::set<StdString> & getRelFiles(void) const; 
    6969 
    70          int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    71          int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    72          int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    73          CArray<int, 1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom); 
     70         int getNumberWrittenIndexes(MPI_Comm writtenCom); 
     71         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
     72         int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
     73         CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
    7474 
    7575         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
     
    113113 
    114114         void computeWrittenIndex(); 
    115          void computeWrittenCompressedIndex(ep_lib::MPI_Comm); 
     115         void computeWrittenCompressedIndex(MPI_Comm); 
    116116         bool hasTransformation(); 
    117117         void solveInheritanceTransformation(); 
  • XIOS/trunk/src/node/context.cpp

    r1638 r1639  
    265265 
    266266   //! Initialize client side 
    267    void CContext::initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer /*= 0*/) 
     267   void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/) 
    268268   TRY 
    269269   { 
    270270 
    271271     hasClient = true; 
    272      ep_lib::MPI_Comm intraCommServer, interCommServer; 
     272     MPI_Comm intraCommServer, interCommServer; 
    273273      
    274274 
     
    284284       else 
    285285       { 
    286          ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
     286         MPI_Comm_dup(intraComm, &intraCommServer); 
    287287         comms.push_back(intraCommServer); 
    288          ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
     288         MPI_Comm_dup(interComm, &interCommServer); 
    289289         comms.push_back(interCommServer); 
    290290       } 
     
    309309     { 
    310310       clientPrimServer.push_back(new CContextClient(this, intraComm, interComm)); 
    311        ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
     311       MPI_Comm_dup(intraComm, &intraCommServer); 
    312312       comms.push_back(intraCommServer); 
    313        ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
     313       MPI_Comm_dup(interComm, &interCommServer); 
    314314       comms.push_back(interCommServer); 
    315315       serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer)); 
     
    383383   CATCH_DUMP_ATTR 
    384384 
    385    void CContext::initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient /*= 0*/) 
     385   void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/) 
    386386   TRY 
    387387   { 
     
    402402     registryOut->setPath(contextRegistryId) ; 
    403403 
    404      ep_lib::MPI_Comm intraCommClient, interCommClient; 
     404     MPI_Comm intraCommClient, interCommClient; 
    405405     if (cxtClient) // Attached mode 
    406406     { 
     
    410410     else 
    411411     { 
    412        ep_lib::MPI_Comm_dup(intraComm, &intraCommClient); 
     412       MPI_Comm_dup(intraComm, &intraCommClient); 
    413413       comms.push_back(intraCommClient); 
    414        ep_lib::MPI_Comm_dup(interComm, &interCommClient); 
     414       MPI_Comm_dup(interComm, &interCommClient); 
    415415       comms.push_back(interCommClient); 
    416416     } 
     
    502502 
    503503         //! Free internally allocated communicators 
    504          for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    505            ep_lib::MPI_Comm_free(&(*it)); 
     504         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     505           MPI_Comm_free(&(*it)); 
    506506         comms.clear(); 
    507507 
     
    544544 
    545545         //! Free internally allocated communicators 
    546          for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    547            ep_lib::MPI_Comm_free(&(*it)); 
     546         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     547           MPI_Comm_free(&(*it)); 
    548548         comms.clear(); 
    549549 
     
    560560   TRY 
    561561   { 
    562      for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    563        ep_lib::MPI_Comm_free(&(*it)); 
     562     for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     563       MPI_Comm_free(&(*it)); 
    564564     comms.clear(); 
    565565   } 
  • XIOS/trunk/src/node/context.hpp

    r1638 r1639  
    8888      public : 
    8989         // Initialize server or client 
    90          void initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer = 0); 
    91          void initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient = 0); 
     90         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0); 
     91         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0); 
    9292         bool isInitialized(void); 
    9393 
     
    263263         StdString idServer_; 
    264264         CGarbageCollector garbageCollector; 
    265          std::list<ep_lib::MPI_Comm> comms; //!< Communicators allocated internally 
     265         std::list<MPI_Comm> comms; //!< Communicators allocated internally 
    266266 
    267267      public: // Some function maybe removed in the near future 
  • XIOS/trunk/src/node/domain.cpp

    r1638 r1639  
    9999     \return the number of indexes written by each server 
    100100   */ 
    101    int CDomain::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     101   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
    102102   TRY 
    103103   { 
    104104     int writtenSize; 
    105      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     105     MPI_Comm_size(writtenCom, &writtenSize); 
    106106     return numberWrittenIndexes_[writtenSize]; 
    107107   } 
     
    112112     \return the total number of indexes written by the servers 
    113113   */ 
    114    int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     114   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
    115115   TRY 
    116116   { 
    117117     int writtenSize; 
    118      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     118     MPI_Comm_size(writtenCom, &writtenSize); 
    119119     return totalNumberWrittenIndexes_[writtenSize]; 
    120120   } 
     
    125125     \return the offset of indexes written by each server 
    126126   */ 
    127    int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     127   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
    128128   TRY 
    129129   { 
    130130     int writtenSize; 
    131      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     131     MPI_Comm_size(writtenCom, &writtenSize); 
    132132     return offsetWrittenIndexes_[writtenSize]; 
    133133   } 
    134134   CATCH_DUMP_ATTR 
    135135 
    136    CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
     136   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
    137137   TRY 
    138138   { 
    139139     int writtenSize; 
    140      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     140     MPI_Comm_size(writtenCom, &writtenSize); 
    141141     return compressedIndexToWriteOnServer[writtenSize]; 
    142142   } 
     
    690690     int v ; 
    691691     v=ibegin ; 
    692      ep_lib::MPI_Allgather(&v,1,EP_INT,ibegin_g,1,EP_INT,client->intraComm) ; 
     692     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
    693693     v=jbegin ; 
    694      ep_lib::MPI_Allgather(&v,1,EP_INT,jbegin_g,1,EP_INT,client->intraComm) ; 
     694     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
    695695     v=ni ; 
    696      ep_lib::MPI_Allgather(&v,1,EP_INT,ni_g,1,EP_INT,client->intraComm) ; 
     696     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
    697697     v=nj ; 
    698      ep_lib::MPI_Allgather(&v,1,EP_INT,nj_g,1,EP_INT,client->intraComm) ; 
    699  
    700      ep_lib::MPI_Allgatherv(lon.dataFirst(),ni,EP_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,EP_DOUBLE,client->intraComm) ; 
    701      ep_lib::MPI_Allgatherv(lat.dataFirst(),nj,EP_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,EP_DOUBLE,client->intraComm) ; 
     698     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
     699 
     700     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
     701     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
    702702 
    703703      delete[] ibegin_g ; 
     
    19321932          displs[0] = 0; 
    19331933          int localCount = connectedServerRank_[nbServer].size() ; 
    1934           ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ; 
     1934          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
    19351935          for (int i = 0; i < clientSize-1; ++i) 
    19361936          { 
     
    19381938          } 
    19391939          std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]); 
    1940           ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm); 
     1940          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    19411941 
    19421942          if ((allConnectedServers.size() != nbServer) && (rank == 0)) 
     
    20032003   CATCH_DUMP_ATTR 
    20042004 
    2005   void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
     2005  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
    20062006  TRY 
    20072007  { 
    20082008    int writtenCommSize; 
    2009     ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
     2009    MPI_Comm_size(writtenComm, &writtenCommSize); 
    20102010    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    20112011      return; 
     
    20642064      { 
    20652065              
    2066         ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
    2067         ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm); 
     2066        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2067        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    20682068        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    20692069      } 
  • XIOS/trunk/src/node/domain.hpp

    r1638 r1639  
    9494         bool isWrittenCompressed(const StdString& filename) const; 
    9595          
    96          int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    97          int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    98          int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom); 
    99          CArray<int,1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom); 
     96         int getNumberWrittenIndexes(MPI_Comm writtenCom); 
     97         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
     98         int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
     99         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
    100100 
    101101         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false); 
     
    116116          
    117117         void computeWrittenIndex(); 
    118          void computeWrittenCompressedIndex(ep_lib::MPI_Comm); 
     118         void computeWrittenCompressedIndex(MPI_Comm); 
    119119 
    120120         void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
  • XIOS/trunk/src/node/field.cpp

    r1638 r1639  
    531531    if (!nstepMaxRead) 
    532532    { 
    533        #ifdef _usingMPI 
    534533       MPI_Allreduce(MPI_IN_PLACE, &nstepMax, 1, MPI_INT, MPI_MAX, context->server->intraComm); 
    535        #elif _usingEP 
    536        ep_lib::MPI_Allreduce(&nstepMax, &nstepMax, 1, EP_INT, EP_MAX, context->server->intraComm); 
    537        #endif 
    538534       nstepMaxRead = true; 
    539535    } 
  • XIOS/trunk/src/node/file.cpp

    r1638 r1639  
    2525   CFile::CFile(void) 
    2626      : CObjectTemplate<CFile>(), CFileAttributes() 
    27       , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL) 
     27      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
    2828      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false) 
    2929   { 
     
    3434   CFile::CFile(const StdString & id) 
    3535      : CObjectTemplate<CFile>(id), CFileAttributes() 
    36       , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL) 
     36      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
    3737      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false) 
    3838    { 
     
    307307 
    308308      int color = allZoneEmpty ? 0 : 1; 
    309       ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
    310       if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm); 
     309      MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
     310      if (allZoneEmpty) MPI_Comm_free(&fileComm); 
    311311    } 
    312312    CATCH_DUMP_ATTR 
     
    554554         { 
    555555            int commSize, commRank; 
    556             ep_lib::MPI_Comm_size(fileComm, &commSize); 
    557             ep_lib::MPI_Comm_rank(fileComm, &commRank); 
     556            MPI_Comm_size(fileComm, &commSize); 
     557            MPI_Comm_rank(fileComm, &commRank); 
    558558 
    559559            if (server->intraCommSize > 1) 
     
    634634    CContext* context = CContext::getCurrent(); 
    635635    CContextServer* server = context->server; 
    636     ep_lib::MPI_Comm readComm = this->fileComm; 
     636    MPI_Comm readComm = this->fileComm; 
    637637 
    638638    if (!allZoneEmpty) 
     
    677677      { 
    678678        int commSize, commRank; 
    679         ep_lib::MPI_Comm_size(readComm, &commSize); 
    680         ep_lib::MPI_Comm_rank(readComm, &commRank); 
     679        MPI_Comm_size(readComm, &commSize); 
     680        MPI_Comm_rank(readComm, &commRank); 
    681681 
    682682        if (server->intraCommSize > 1) 
     
    722722        isOpen = false; 
    723723       } 
    724       if (fileComm != EP_COMM_NULL) ep_lib::MPI_Comm_free(&fileComm); 
     724      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
    725725   } 
    726726   CATCH_DUMP_ATTR 
  • XIOS/trunk/src/node/file.hpp

    r1638 r1639  
    175175         int nbAxis, nbDomains; 
    176176         bool isOpen;          
    177          ep_lib::MPI_Comm fileComm; 
     177         MPI_Comm fileComm; 
    178178 
    179179      private: 
  • XIOS/trunk/src/node/grid.cpp

    r1638 r1639  
    661661        { 
    662662          CContextServer* server = CContext::getCurrent()->server;       
    663           ep_lib::MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm); 
    664           ep_lib::MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm); 
     663          MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     664          MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    665665          offsetWrittenIndexes_ -= numberWrittenIndexes_; 
    666666        } 
     
    856856         displs[0] = 0; 
    857857         int localCount = connectedServerRank_[receiverSize].size() ; 
    858          ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ; 
     858         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
    859859         for (int i = 0; i < client->clientSize-1; ++i) 
    860860         { 
     
    862862         } 
    863863         std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]); 
    864          ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm); 
     864         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    865865 
    866866         if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0)) 
  • XIOS/trunk/src/node/mesh.cpp

    r1638 r1639  
    414414 * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type. 
    415415 */ 
    416   void CMesh::createMeshEpsilon(const ep_lib::MPI_Comm& comm, 
     416  void CMesh::createMeshEpsilon(const MPI_Comm& comm, 
    417417                                const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
    418418                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
     
    421421    int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
    422422    int mpiRank, mpiSize; 
    423     ep_lib::MPI_Comm_rank(comm, &mpiRank); 
    424     ep_lib::MPI_Comm_size(comm, &mpiSize); 
     423    MPI_Comm_rank(comm, &mpiRank); 
     424    MPI_Comm_size(comm, &mpiSize); 
    425425    double prec = 1e-11;  // used in calculations of edge_lon/lat 
    426426 
     
    460460      unsigned long nbEdgesOnProc = nbEdges_; 
    461461      unsigned long nbEdgesAccum; 
    462       ep_lib::MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     462      MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    463463      nbEdgesAccum -= nbEdges_; 
    464464 
     
    590590         unsigned long nodeCount = nodeIdx2Idx.size(); 
    591591         unsigned long nodeStart, nbNodes; 
    592          ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     592         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    593593         int nNodes = nodeStart; 
    594          ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
     594         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
    595595         nbNodesGlo = nNodes; 
    596596 
     
    683683      unsigned long nbFacesOnProc = nbFaces_; 
    684684      unsigned long nbFacesAccum; 
    685       ep_lib::MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     685      MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    686686      nbFacesAccum -= nbFaces_; 
    687687 
     
    807807 
    808808        unsigned long edgeStart, nbEdges; 
    809         ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     809        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    810810        int nEdges = edgeStart; 
    811         ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
     811        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
    812812        nbEdgesGlo = nEdges; 
    813813 
     
    10281028        unsigned long edgeCount = edgeIdx2Idx.size(); 
    10291029        unsigned long edgeStart, nbEdges; 
    1030         ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     1030        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    10311031        int nEdges = edgeStart; 
    1032         ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
     1032        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
    10331033        nbEdgesGlo = nEdges; 
    10341034 
     
    12981298        unsigned long nodeCount = nodeIdx2Idx.size(); 
    12991299        unsigned long nodeStart, nbNodes; 
    1300         ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     1300        MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    13011301        int nNodes = nodeStart; 
    1302         ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
     1302        MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
    13031303        nbNodesGlo = nNodes; 
    13041304 
     
    14181418        unsigned long edgeCount = edgeIdx2Idx.size(); 
    14191419        unsigned long edgeStart, nbEdges; 
    1420         ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm); 
     1420        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm); 
    14211421        int nEdges = edgeStart; 
    1422         ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm); 
     1422        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm); 
    14231423        nbEdgesGlo = nEdges; 
    14241424 
     
    16141614   */ 
    16151615 
    1616   void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1616  void CMesh::getGloNghbFacesNodeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    16171617                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    16181618                               CArray<int, 2>& nghbFaces) 
     
    16231623 
    16241624    int mpiRank, mpiSize; 
    1625     ep_lib::MPI_Comm_rank(comm, &mpiRank); 
    1626     ep_lib::MPI_Comm_size(comm, &mpiSize); 
     1625    MPI_Comm_rank(comm, &mpiRank); 
     1626    MPI_Comm_size(comm, &mpiSize); 
    16271627 
    16281628    // (1) Generating unique node indexes 
     
    17701770   */ 
    17711771 
    1772   void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1772  void CMesh::getGloNghbFacesEdgeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    17731773                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    17741774                               CArray<int, 2>& nghbFaces) 
     
    17791779 
    17801780    int mpiRank, mpiSize; 
    1781     ep_lib::MPI_Comm_rank(comm, &mpiRank); 
    1782     ep_lib::MPI_Comm_size(comm, &mpiSize); 
     1781    MPI_Comm_rank(comm, &mpiRank); 
     1782    MPI_Comm_size(comm, &mpiSize); 
    17831783 
    17841784    // (1) Generating unique node indexes 
     
    19511951   */ 
    19521952 
    1953   void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm, 
     1953  void CMesh::getGlobalNghbFaces(const int nghbType, const MPI_Comm& comm, 
    19541954                                 const CArray<int, 1>& face_idx, 
    19551955                                 const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
  • XIOS/trunk/src/node/mesh.hpp

    r1638 r1639  
    6060                      const CArray<double, 2>&, const CArray<double, 2>& ); 
    6161                         
    62       void createMeshEpsilon(const ep_lib::MPI_Comm&, 
     62      void createMeshEpsilon(const MPI_Comm&, 
    6363                             const CArray<double, 1>&, const CArray<double, 1>&, 
    6464                             const CArray<double, 2>&, const CArray<double, 2>& ); 
    6565 
    66       void getGlobalNghbFaces(const int, const ep_lib::MPI_Comm&, const CArray<int, 1>&, 
     66      void getGlobalNghbFaces(const int, const MPI_Comm&, const CArray<int, 1>&, 
    6767                              const CArray<double, 2>&, const CArray<double, 2>&, 
    6868                              CArray<int, 2>&); 
     
    8787      CClientClientDHTSizet* pNodeGlobalIndex;                    // pointer to a map <nodeHash, nodeIdxGlo> 
    8888      CClientClientDHTSizet* pEdgeGlobalIndex;                    // pointer to a map <edgeHash, edgeIdxGlo> 
    89       void getGloNghbFacesNodeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
    90       void getGloNghbFacesEdgeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
     89      void getGloNghbFacesNodeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
     90      void getGloNghbFacesEdgeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&); 
    9191      void getLocNghbFacesNodeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&); 
    9292      void getLocNghbFacesEdgeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&); 
  • XIOS/trunk/src/policy.cpp

    r1638 r1639  
    4949//} 
    5050 
    51 DivideAdaptiveComm::DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm) 
     51DivideAdaptiveComm::DivideAdaptiveComm(const MPI_Comm& mpiComm) 
    5252  : internalComm_(mpiComm), level_(0), groupBegin_(), nbInGroup_(), computed_(false) 
    5353{ 
     
    6161 
    6262  int mpiSize, mpiRank; 
    63   ep_lib::MPI_Comm_size(internalComm_,&mpiSize); 
    64   ep_lib::MPI_Comm_rank(internalComm_,&mpiRank); 
     63  MPI_Comm_size(internalComm_,&mpiSize); 
     64  MPI_Comm_rank(internalComm_,&mpiRank); 
    6565 
    6666  int maxChild=1; 
  • XIOS/trunk/src/policy.hpp

    r1638 r1639  
    3131{ 
    3232protected: 
    33   DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm); 
     33  DivideAdaptiveComm(const MPI_Comm& mpiComm); 
    3434 
    3535  void computeMPICommLevel(); 
     
    4141 
    4242protected: 
    43   const ep_lib::MPI_Comm& internalComm_; 
     43  const MPI_Comm& internalComm_; 
    4444  std::vector<std::vector<int> > groupParentsBegin_; 
    4545  std::vector<std::vector<int> > nbInGroupParents_; 
  • XIOS/trunk/src/registry.cpp

    r1638 r1639  
    191191  { 
    192192    int rank ; 
    193     ep_lib::MPI_Comm_rank(communicator,&rank); 
     193    MPI_Comm_rank(communicator,&rank); 
    194194    if (rank==0) 
    195195    { 
     
    197197      this->toBuffer(buffer) ; 
    198198      int size=buffer.count() ; 
    199       ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ; 
    200       ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ; 
     199      MPI_Bcast(&size,1,MPI_INT,0,communicator) ; 
     200      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ; 
    201201    } 
    202202    else 
    203203    { 
    204204      int size ; 
    205       ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ; 
     205      MPI_Bcast(&size,1,MPI_INT,0,communicator) ; 
    206206      CBufferIn buffer(size) ; 
    207       ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ; 
     207      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ; 
    208208      this->fromBuffer(buffer) ; 
    209209    } 
     
    214214  } 
    215215 
    216   void CRegistry::gatherRegistry(const ep_lib::MPI_Comm& comm) 
     216  void CRegistry::gatherRegistry(const MPI_Comm& comm) 
    217217  { 
    218218    int rank,mpiSize ; 
    219     ep_lib::MPI_Comm_rank(comm,&rank); 
    220     ep_lib::MPI_Comm_size(comm,&mpiSize); 
     219    MPI_Comm_rank(comm,&rank); 
     220    MPI_Comm_size(comm,&mpiSize); 
    221221 
    222222    int* sizes=new int[mpiSize] ; 
     
    224224    this->toBuffer(localBuffer) ; 
    225225    int localSize=localBuffer.count() ; 
    226     ep_lib::MPI_Gather(&localSize,1,EP_INT,sizes,1,EP_INT,0,comm) ; 
     226    MPI_Gather(&localSize,1,MPI_INT,sizes,1,MPI_INT,0,comm) ; 
    227227 
    228228    char* globalBuffer ; 
     
    240240 
    241241      globalBuffer=new char[globalBufferSize] ; 
    242       ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ; 
     242      MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ; 
    243243      for(int i=1;i<mpiSize;++i) 
    244244      { 
     
    251251      delete[] globalBuffer ; 
    252252    } 
    253     else  ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;    
     253    else  MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;    
    254254    delete[] sizes ; 
    255255     
     
    261261  } 
    262262 
    263   void CRegistry::hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) 
     263  void CRegistry::hierarchicalGatherRegistry(const MPI_Comm& comm) 
    264264  { 
    265265    int mpiRank,mpiSize ; 
    266     ep_lib::MPI_Comm_rank(comm,&mpiRank); 
    267     ep_lib::MPI_Comm_size(comm,&mpiSize);     
     266    MPI_Comm_rank(comm,&mpiRank); 
     267    MPI_Comm_size(comm,&mpiSize);     
    268268 
    269269    if (mpiSize>2) 
     
    272272      if (mpiRank<mpiSize/2+mpiSize%2) color=0 ; 
    273273      else color=1 ; 
    274       ep_lib::MPI_Comm commUp ; 
    275       ep_lib::MPI_Comm_split(comm,color,mpiRank,&commUp) , 
     274      MPI_Comm commUp ; 
     275      MPI_Comm_split(comm,color,mpiRank,&commUp) , 
    276276      hierarchicalGatherRegistry(commUp) ; 
    277       ep_lib::MPI_Comm_free(&commUp) ; 
     277      MPI_Comm_free(&commUp) ; 
    278278    } 
    279279 
    280280    if (mpiSize>1) 
    281281    { 
    282       ep_lib::MPI_Comm commDown ; 
     282      MPI_Comm commDown ; 
    283283      int color ; 
    284284       
    285285      if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ; 
    286286      else color=1 ; 
    287       ep_lib::MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
     287      MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
    288288      if (color==0) gatherRegistry(commDown) ; 
    289       ep_lib::MPI_Comm_free(&commDown) ;     
     289      MPI_Comm_free(&commDown) ;     
    290290    } 
    291291  } 
  • XIOS/trunk/src/registry.hpp

    r1638 r1639  
    2323 
    2424/** Constructor, the communicator is used for bcast or gather operation between MPI processes */ 
    25       CRegistry(const ep_lib::MPI_Comm& comm=EP_COMM_WORLD) : communicator(comm) {} 
     25      CRegistry(const MPI_Comm& comm=MPI_COMM_WORLD) : communicator(comm) {} 
    2626 
    2727/** Copy constructor */ 
     
    106106 
    107107/** use internally for recursivity */ 
    108       void gatherRegistry(const ep_lib::MPI_Comm& comm) ; 
     108      void gatherRegistry(const MPI_Comm& comm) ; 
    109109 
    110110/** use internally for recursivity */ 
    111       void hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) ; 
     111      void hierarchicalGatherRegistry(const MPI_Comm& comm) ; 
    112112 
    113113 
     
    120120 
    121121/** MPI communicator used for broadcast and gather operation */ 
    122       ep_lib::MPI_Comm communicator ; 
     122      MPI_Comm communicator ; 
    123123  } ; 
    124124 
  • XIOS/trunk/src/server.cpp

    r1638 r1639  
    1818namespace xios 
    1919{ 
    20     ep_lib::MPI_Comm CServer::intraComm ; 
    21     std::list<ep_lib::MPI_Comm> CServer::interCommLeft ; 
    22     std::list<ep_lib::MPI_Comm> CServer::interCommRight ; 
    23     std::list<ep_lib::MPI_Comm> CServer::contextInterComms; 
    24     std::list<ep_lib::MPI_Comm> CServer::contextIntraComms; 
     20    MPI_Comm CServer::intraComm ; 
     21    std::list<MPI_Comm> CServer::interCommLeft ; 
     22    std::list<MPI_Comm> CServer::interCommRight ; 
     23    std::list<MPI_Comm> CServer::contextInterComms; 
     24    std::list<MPI_Comm> CServer::contextIntraComms; 
    2525    int CServer::serverLevel = 0 ; 
    2626    int CServer::nbContexts = 0; 
     
    4848    { 
    4949      int initialized ; 
    50       ep_lib::MPI_Initialized(&initialized) ; 
     50      MPI_Initialized(&initialized) ; 
    5151      if (initialized) is_MPI_Initialized=true ; 
    5252      else is_MPI_Initialized=false ; 
     
    5959        if (!is_MPI_Initialized) 
    6060        { 
    61           ep_lib::MPI_Init(NULL, NULL); 
     61          MPI_Init(NULL, NULL); 
    6262        } 
    6363        CTimer::get("XIOS").resume() ; 
     
    7272        int myColor ; 
    7373        int i,c ; 
    74         ep_lib::MPI_Comm newComm; 
    75  
    76         ep_lib::MPI_Comm_size(CXios::globalComm, &size) ; 
    77         ep_lib::MPI_Comm_rank(CXios::globalComm, &rank_); 
     74        MPI_Comm newComm; 
     75 
     76        MPI_Comm_size(CXios::globalComm, &size) ; 
     77        MPI_Comm_rank(CXios::globalComm, &rank_); 
    7878 
    7979        hashAll=new unsigned long[size] ; 
    80         ep_lib::MPI_Allgather(&hashServer, 1, EP_LONG, hashAll, 1, EP_LONG, CXios::globalComm) ; 
     80        MPI_Allgather(&hashServer, 1, MPI_LONG, hashAll, 1, MPI_LONG, CXios::globalComm) ; 
    8181 
    8282        map<unsigned long, int> colors ; 
     
    174174        // (2) Create intraComm 
    175175        if (serverLevel != 2) myColor=colors[hashServer]; 
    176         ep_lib::MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
     176        MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
    177177 
    178178        // (3) Create interComm 
     
    186186              clientLeader=it->second ; 
    187187              int intraCommSize, intraCommRank ; 
    188               ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
    189               ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ; 
     188              MPI_Comm_size(intraComm,&intraCommSize) ; 
     189              MPI_Comm_rank(intraComm,&intraCommRank) ; 
    190190              info(50)<<"intercommCreate::server (classical mode) "<<rank_<<" intraCommSize : "<<intraCommSize 
    191191                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    192192 
    193               ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     193              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
    194194              interCommLeft.push_back(newComm) ; 
    195195            } 
     
    207207              clientLeader=it->second ; 
    208208              int intraCommSize, intraCommRank ; 
    209               ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
    210               ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
     209              MPI_Comm_size(intraComm, &intraCommSize) ; 
     210              MPI_Comm_rank(intraComm, &intraCommRank) ; 
    211211              info(50)<<"intercommCreate::server (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    212212                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    213               ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     213              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
    214214              interCommLeft.push_back(newComm) ; 
    215215            } 
     
    219219          { 
    220220            int intraCommSize, intraCommRank ; 
    221             ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
    222             ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
     221            MPI_Comm_size(intraComm, &intraCommSize) ; 
     222            MPI_Comm_rank(intraComm, &intraCommRank) ; 
    223223            info(50)<<"intercommCreate::client (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    224224                <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< sndServerGlobalRanks[i]<<endl ; 
    225             ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ; 
     225            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ; 
    226226            interCommRight.push_back(newComm) ; 
    227227          } 
     
    232232          clientLeader = leaders[hashString(CXios::xiosCodeId)]; 
    233233          int intraCommSize, intraCommRank ; 
    234           ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
    235           ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
     234          MPI_Comm_size(intraComm, &intraCommSize) ; 
     235          MPI_Comm_rank(intraComm, &intraCommRank) ; 
    236236          info(50)<<"intercommCreate::server (server level 2) "<<rank_<<" intraCommSize : "<<intraCommSize 
    237237                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    238238 
    239           ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
     239          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
    240240          interCommLeft.push_back(newComm) ; 
    241241        } 
     
    253253 
    254254        CTimer::get("XIOS").resume() ; 
    255         ep_lib::MPI_Comm localComm; 
     255        MPI_Comm localComm; 
    256256        oasis_get_localcomm(localComm); 
    257         ep_lib::MPI_Comm_rank(localComm,&rank_) ; 
     257        MPI_Comm_rank(localComm,&rank_) ; 
    258258 
    259259//      (1) Create server intraComm 
    260260        if (!CXios::usingServer2) 
    261261        { 
    262           ep_lib::MPI_Comm_dup(localComm, &intraComm); 
     262          MPI_Comm_dup(localComm, &intraComm); 
    263263        } 
    264264        else 
    265265        { 
    266266          int globalRank; 
    267           ep_lib::MPI_Comm_size(localComm,&size) ; 
    268           ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
     267          MPI_Comm_size(localComm,&size) ; 
     268          MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    269269          srvGlobalRanks = new int[size] ; 
    270           ep_lib::MPI_Allgather(&globalRank, 1, EP_INT, srvGlobalRanks, 1, EP_INT, localComm) ; 
     270          MPI_Allgather(&globalRank, 1, MPI_INT, srvGlobalRanks, 1, MPI_INT, localComm) ; 
    271271 
    272272          int reqNbProc = size*CXios::ratioServer2/100.; 
     
    276276                << "It is impossible to dedicate the requested number of processes = "<<reqNbProc 
    277277                <<" to secondary server. XIOS will run in the classical server mode."<<endl; 
    278             ep_lib::MPI_Comm_dup(localComm, &intraComm); 
     278            MPI_Comm_dup(localComm, &intraComm); 
    279279          } 
    280280          else 
     
    339339            } 
    340340            if (serverLevel != 2) myColor=0; 
    341             ep_lib::MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
     341            MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
    342342          } 
    343343        } 
     
    348348        vector<string>::iterator it ; 
    349349 
    350         ep_lib::MPI_Comm newComm ; 
     350        MPI_Comm newComm ; 
    351351        int globalRank ; 
    352         ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank); 
     352        MPI_Comm_rank(CXios::globalComm,&globalRank); 
    353353 
    354354//      (2) Create interComms with models 
     
    359359          { 
    360360            interCommLeft.push_back(newComm) ; 
    361             if (rank_==0) ep_lib::MPI_Send(&globalRank,1,EP_INT,0,0,newComm) ; 
     361            if (rank_==0) MPI_Send(&globalRank,1,MPI_INT,0,0,newComm) ; 
    362362          } 
    363363        } 
     
    365365//      (3) Create interComms between primary and secondary servers 
    366366        int intraCommSize, intraCommRank ; 
    367         ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
    368         ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
     367        MPI_Comm_size(intraComm,&intraCommSize) ; 
     368        MPI_Comm_rank(intraComm, &intraCommRank) ; 
    369369 
    370370        if (serverLevel == 1) 
     
    375375            info(50)<<"intercommCreate::client (server level 1) "<<globalRank<<" intraCommSize : "<<intraCommSize 
    376376                <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvSndLeader<<endl ; 
    377             ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ; 
     377            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ; 
    378378            interCommRight.push_back(newComm) ; 
    379379          } 
     
    383383          info(50)<<"intercommCreate::server (server level 2)"<<globalRank<<" intraCommSize : "<<intraCommSize 
    384384                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvGlobalRanks[0] <<endl ; 
    385           ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
     385          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
    386386          interCommLeft.push_back(newComm) ; 
    387387        } 
     
    393393 
    394394 
    395       ep_lib::MPI_Comm_rank(intraComm, &rank) ; 
     395      MPI_Comm_rank(intraComm, &rank) ; 
    396396      if (rank==0) isRoot=true; 
    397397      else isRoot=false; 
     
    406406      delete eventScheduler ; 
    407407 
    408       for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    409         ep_lib::MPI_Comm_free(&(*it)); 
    410  
    411       for (std::list<ep_lib::MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++) 
    412         ep_lib::MPI_Comm_free(&(*it)); 
     408      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
     409        MPI_Comm_free(&(*it)); 
     410 
     411      for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++) 
     412        MPI_Comm_free(&(*it)); 
    413413 
    414414//      for (std::list<MPI_Comm>::iterator it = interComm.begin(); it != interComm.end(); it++) 
     
    418418//          MPI_Comm_free(&(*it)); 
    419419 
    420         for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    421           ep_lib::MPI_Comm_free(&(*it)); 
    422  
    423       ep_lib::MPI_Comm_free(&intraComm); 
     420        for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
     421          MPI_Comm_free(&(*it)); 
     422 
     423      MPI_Comm_free(&intraComm); 
    424424 
    425425      if (!is_MPI_Initialized) 
    426426      { 
    427427        if (CXios::usingOasis) oasis_finalize(); 
    428         else ep_lib::MPI_Finalize() ; 
     428        else MPI_Finalize() ; 
    429429      } 
    430430      report(0)<<"Performance report : Time spent for XIOS : "<<CTimer::get("XIOS server").getCumulatedTime()<<endl  ; 
     
    465465     void CServer::listenFinalize(void) 
    466466     { 
    467         list<ep_lib::MPI_Comm>::iterator it, itr; 
     467        list<MPI_Comm>::iterator it, itr; 
    468468        int msg ; 
    469469        int flag ; 
     
    471471        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    472472        { 
    473            ep_lib::MPI_Status status ; 
     473           MPI_Status status ; 
    474474           traceOff() ; 
    475            ep_lib::MPI_Iprobe(0,0,*it,&flag,&status) ; 
     475           MPI_Iprobe(0,0,*it,&flag,&status) ; 
    476476           traceOn() ; 
    477477           if (flag==true) 
    478478           { 
    479               ep_lib::MPI_Recv(&msg,1,EP_INT,0,0,*it,&status) ; 
     479              MPI_Recv(&msg,1,MPI_INT,0,0,*it,&status) ; 
    480480              info(20)<<" CServer : Receive client finalize"<<endl ; 
    481481              // Sending server finalize message to secondary servers (if any) 
    482482              for(itr=interCommRight.begin();itr!=interCommRight.end();itr++) 
    483483              { 
    484                 ep_lib::MPI_Send(&msg,1,EP_INT,0,0,*itr) ; 
     484                MPI_Send(&msg,1,MPI_INT,0,0,*itr) ; 
    485485              } 
    486               ep_lib::MPI_Comm_free(&(*it)); 
     486              MPI_Comm_free(&(*it)); 
    487487              interCommLeft.erase(it) ; 
    488488              break ; 
     
    493493         { 
    494494           int i,size ; 
    495            ep_lib::MPI_Comm_size(intraComm,&size) ; 
    496            ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size-1] ; 
    497            ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size-1] ; 
    498  
    499            for(int i=1;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,4,intraComm,&requests[i-1]) ; 
    500            ep_lib::MPI_Waitall(size-1,requests,status) ; 
     495           MPI_Comm_size(intraComm,&size) ; 
     496           MPI_Request* requests= new MPI_Request[size-1] ; 
     497           MPI_Status* status= new MPI_Status[size-1] ; 
     498 
     499           for(int i=1;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,4,intraComm,&requests[i-1]) ; 
     500           MPI_Waitall(size-1,requests,status) ; 
    501501 
    502502           finished=true ; 
     
    510510     { 
    511511        int flag ; 
    512         ep_lib::MPI_Status status ; 
     512        MPI_Status status ; 
    513513        int msg ; 
    514514 
    515515        traceOff() ; 
    516         ep_lib::MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
     516        MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
    517517        traceOn() ; 
    518518        if (flag==true) 
    519519        { 
    520            ep_lib::MPI_Recv(&msg,1,EP_INT,0,4,intraComm,&status) ; 
     520           MPI_Recv(&msg,1,MPI_INT,0,4,intraComm,&status) ; 
    521521           finished=true ; 
    522522        } 
     
    534534     { 
    535535        int flag ; 
    536         ep_lib::MPI_Status status ; 
    537         list<ep_lib::MPI_Comm>::iterator it; 
     536        MPI_Status status ; 
     537        list<MPI_Comm>::iterator it; 
    538538        int msg ; 
    539539        static int nbCompound=0 ; 
    540540        int size ; 
    541541        static bool sent=false ; 
    542         static ep_lib::MPI_Request* allRequests ; 
    543         static ep_lib::MPI_Status* allStatus ; 
     542        static MPI_Request* allRequests ; 
     543        static MPI_Status* allStatus ; 
    544544 
    545545 
    546546        if (sent) 
    547547        { 
    548           ep_lib::MPI_Comm_size(intraComm,&size) ; 
    549           ep_lib::MPI_Testall(size,allRequests, &flag, allStatus) ; 
     548          MPI_Comm_size(intraComm,&size) ; 
     549          MPI_Testall(size,allRequests, &flag, allStatus) ; 
    550550          if (flag==true) 
    551551          { 
     
    559559        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    560560        { 
    561            ep_lib::MPI_Status status ; 
     561           MPI_Status status ; 
    562562           traceOff() ; 
    563            ep_lib::MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
     563           MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
    564564           traceOn() ; 
    565565           if (flag==true) 
    566566           { 
    567               ep_lib::MPI_Recv(&msg,1,EP_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
     567              MPI_Recv(&msg,1,MPI_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
    568568              nbCompound++ ; 
    569569              if (nbCompound==interCommLeft.size()) 
    570570              { 
    571                 for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
     571                for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    572572                { 
    573                    ep_lib::MPI_Send(&msg,1,EP_INT,0,5,*it) ; // tags oasis_endded = 5 
     573                   MPI_Send(&msg,1,MPI_INT,0,5,*it) ; // tags oasis_endded = 5 
    574574                } 
    575                 ep_lib::MPI_Comm_size(intraComm,&size) ; 
    576                 allRequests= new ep_lib::MPI_Request[size] ; 
    577                 allStatus= new ep_lib::MPI_Status[size] ; 
    578                 for(int i=0;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5 
     575                MPI_Comm_size(intraComm,&size) ; 
     576                allRequests= new MPI_Request[size] ; 
     577                allStatus= new MPI_Status[size] ; 
     578                for(int i=0;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5 
    579579                sent=true ; 
    580580              } 
     
    590590     { 
    591591       int flag ; 
    592        ep_lib::MPI_Status status ; 
     592       MPI_Status status ; 
    593593       const int root=0 ; 
    594594       int msg ; 
     
    607607          
    608608       traceOff() ; 
    609        ep_lib::MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
     609       MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
    610610       traceOn() ; 
    611611       if (flag==true) 
    612612       { 
    613          ep_lib::MPI_Recv(&msg,1,EP_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
     613         MPI_Recv(&msg,1,MPI_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
    614614         boost::hash<string> hashString; 
    615615         size_t hashId = hashString("oasis_enddef"); 
     
    626626     { 
    627627 
    628        ep_lib::MPI_Status status ; 
     628       MPI_Status status ; 
    629629       int flag ; 
    630630       static char* buffer ; 
    631        static ep_lib::MPI_Request request ; 
     631       static MPI_Request request ; 
    632632       static bool recept=false ; 
    633633       int rank ; 
     
    637637       { 
    638638         traceOff() ; 
    639          #ifdef _usingMPI 
    640          ep_lib::MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
    641          #elif _usingEP 
    642          ep_lib::MPI_Iprobe(-2,1,CXios::globalComm, &flag, &status) ; 
    643          #endif 
     639         MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
    644640         traceOn() ; 
    645641         if (flag==true) 
    646642         { 
    647            #ifdef _usingMPI 
    648643           rank=status.MPI_SOURCE ; 
    649            #elif _usingEP 
    650            rank=status.ep_src ; 
    651            #endif 
    652            ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
     644           MPI_Get_count(&status,MPI_CHAR,&count) ; 
    653645           buffer=new char[count] ; 
    654            ep_lib::MPI_Irecv((void*)buffer,count,EP_CHAR,rank,1,CXios::globalComm,&request) ; 
     646           MPI_Irecv((void*)buffer,count,MPI_CHAR,rank,1,CXios::globalComm,&request) ; 
    655647           recept=true ; 
    656648         } 
     
    659651       { 
    660652         traceOff() ; 
    661          ep_lib::MPI_Test(&request,&flag,&status) ; 
     653         MPI_Test(&request,&flag,&status) ; 
    662654         traceOn() ; 
    663655         if (flag==true) 
    664656         { 
    665            #ifdef _usingMPI 
    666657           rank=status.MPI_SOURCE ; 
    667            #elif _usingEP 
    668            rank=status.ep_src ; 
    669            #endif 
    670            ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
     658           MPI_Get_count(&status,MPI_CHAR,&count) ; 
    671659           recvContextMessage((void*)buffer,count) ; 
    672660           delete [] buffer ; 
     
    701689       { 
    702690         int size ; 
    703          ep_lib::MPI_Comm_size(intraComm,&size) ; 
     691         MPI_Comm_size(intraComm,&size) ; 
    704692//         MPI_Request* requests= new MPI_Request[size-1] ; 
    705693//         MPI_Status* status= new MPI_Status[size-1] ; 
    706          ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size] ; 
    707          ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size] ; 
     694         MPI_Request* requests= new MPI_Request[size] ; 
     695         MPI_Status* status= new MPI_Status[size] ; 
    708696 
    709697         CMessage msg ; 
     
    717705         for(int i=0; i<size; i++) 
    718706         { 
    719            ep_lib::MPI_Isend(sendBuff,sendBuffer.count(),EP_CHAR,i,2,intraComm,&requests[i]) ; 
     707           MPI_Isend(sendBuff,sendBuffer.count(),MPI_CHAR,i,2,intraComm,&requests[i]) ; 
    720708         } 
    721709 
     
    729717     void CServer::listenRootContext(void) 
    730718     { 
    731        ep_lib::MPI_Status status ; 
     719       MPI_Status status ; 
    732720       int flag ; 
    733721       static std::vector<void*> buffers; 
    734        static std::vector<ep_lib::MPI_Request> requests ; 
     722       static std::vector<MPI_Request> requests ; 
    735723       static std::vector<int> counts ; 
    736724       static std::vector<bool> isEventRegistered ; 
    737725       static std::vector<bool> isEventQueued ; 
    738        ep_lib::MPI_Request request; 
     726       MPI_Request request; 
    739727 
    740728       int rank ; 
     
    745733       // (1) Receive context id from the root, save it into a buffer 
    746734       traceOff() ; 
    747        ep_lib::MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
     735       MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
    748736       traceOn() ; 
    749737       if (flag==true) 
    750738       { 
    751739         counts.push_back(0); 
    752          ep_lib::MPI_Get_count(&status,EP_CHAR,&(counts.back())) ; 
     740         MPI_Get_count(&status,MPI_CHAR,&(counts.back())) ; 
    753741         buffers.push_back(new char[counts.back()]) ; 
    754742         requests.push_back(request); 
    755          ep_lib::MPI_Irecv((void*)(buffers.back()),counts.back(),EP_CHAR,root,2,intraComm,&(requests.back())) ; 
     743         MPI_Irecv((void*)(buffers.back()),counts.back(),MPI_CHAR,root,2,intraComm,&(requests.back())) ; 
    756744         isEventRegistered.push_back(false); 
    757745         isEventQueued.push_back(false); 
     
    762750       { 
    763751         // (2) If context id is received, register an event 
    764          ep_lib::MPI_Test(&requests[ctxNb],&flag,&status) ; 
     752         MPI_Test(&requests[ctxNb],&flag,&status) ; 
    765753         if (flag==true && !isEventRegistered[ctxNb]) 
    766754         { 
     
    799787       // (1) create interComm (with a client) 
    800788       // (2) initialize client and server (contextClient and contextServer) 
    801        ep_lib::MPI_Comm inter; 
     789       MPI_Comm inter; 
    802790       if (serverLevel < 2) 
    803791       { 
    804          ep_lib::MPI_Comm contextInterComm; 
    805          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm); 
    806          ep_lib::MPI_Intercomm_merge(contextInterComm,1,&inter); 
    807          ep_lib::MPI_Barrier(inter); 
    808          ep_lib::MPI_Comm_free(&inter); 
     792         MPI_Comm contextInterComm; 
     793         MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm); 
     794         MPI_Intercomm_merge(contextInterComm,1,&inter); 
     795         MPI_Barrier(inter); 
     796         MPI_Comm_free(&inter); 
    809797         context->initServer(intraComm,contextInterComm); 
    810798         contextInterComms.push_back(contextInterComm); 
     
    819807       else if (serverLevel == 2) 
    820808       { 
    821          ep_lib::MPI_Comm_dup(interCommLeft.front(), &inter); 
     809         MPI_Comm_dup(interCommLeft.front(), &inter); 
    822810         contextInterComms.push_back(inter); 
    823811         context->initServer(intraComm, contextInterComms.back()); 
     
    830818       { 
    831819         int i = 0, size; 
    832          ep_lib::MPI_Comm_size(intraComm, &size) ; 
    833          for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i) 
     820         MPI_Comm_size(intraComm, &size) ; 
     821         for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i) 
    834822         { 
    835823           StdString str = contextId +"_server_" + boost::lexical_cast<string>(i); 
     
    841829           CBufferOut buffer(buff,messageSize) ; 
    842830           buffer<<msg ; 
    843            ep_lib::MPI_Send(buff, buffer.count(), EP_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
    844            ep_lib::MPI_Comm_dup(*it, &inter); 
     831           MPI_Send(buff, buffer.count(), MPI_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
     832           MPI_Comm_dup(*it, &inter); 
    845833           contextInterComms.push_back(inter); 
    846            ep_lib::MPI_Comm_dup(intraComm, &inter); 
     834           MPI_Comm_dup(intraComm, &inter); 
    847835           contextIntraComms.push_back(inter); 
    848836           context->initClient(contextIntraComms.back(), contextInterComms.back()) ; 
     
    874862     { 
    875863       int rank; 
    876        ep_lib::MPI_Comm_rank(intraComm,&rank); 
     864       MPI_Comm_rank(intraComm,&rank); 
    877865       return rank; 
    878866     } 
     
    897885      int size = 0; 
    898886      int id; 
    899       ep_lib::MPI_Comm_size(CXios::globalComm, &size); 
     887      MPI_Comm_size(CXios::globalComm, &size); 
    900888      while (size) 
    901889      { 
  • XIOS/trunk/src/server.hpp

    r1638 r1639  
    2626        static void registerContext(void* buff,int count, int leaderRank=0); 
    2727 
    28         static ep_lib::MPI_Comm intraComm; 
    29         static std::list<ep_lib::MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server) 
    30         static std::list<ep_lib::MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool) 
    31         static std::list<ep_lib::MPI_Comm> contextInterComms;  // list of context intercomms 
    32         static std::list<ep_lib::MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers) 
     28        static MPI_Comm intraComm; 
     29        static std::list<MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server) 
     30        static std::list<MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool) 
     31        static std::list<MPI_Comm> contextInterComms;  // list of context intercomms 
     32        static std::list<MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers) 
    3333        static CEventScheduler* eventScheduler; 
    3434 
  • XIOS/trunk/src/timer.cpp

    r1638 r1639  
    11#include "timer.hpp" 
    2 //#include "mpi_std.hpp" 
    32#include "mpi.hpp" 
    43#include <string> 
     
    76#include <sstream> 
    87#include "tracer.hpp" 
    9 //extern ::MPI_Comm MPI_COMM_WORLD; 
    108 
    119namespace xios 
     
    2018  double CTimer::getTime(void) 
    2119  { 
    22     MPI_COMM_WORLD; 
    2320    return MPI_Wtime(); 
    2421  } 
  • XIOS/trunk/src/tracer.cpp

    r1638 r1639  
    11#include "tracer.hpp" 
    22#ifdef VTRACE 
    3 //#include <vt_user.h> 
    4 #include <VT.h> 
     3#include <vt_user.h> 
    54#endif 
    65#include <string> 
     
    1312  { 
    1413#ifdef VTRACE 
    15     //VT_ON() ; 
    16     VT_traceon() ; 
     14    VT_ON() ; 
    1715#endif 
    1816  } 
     
    2119  { 
    2220#ifdef VTRACE 
    23     //VT_OFF() ; 
    24     VT_traceoff() ; 
     21    VT_OFF() ; 
    2522#endif 
    2623  } 
     
    2926  { 
    3027#ifdef VTRACE 
    31     //VT_USER_START(name.c_str()) ; 
     28    VT_USER_START(name.c_str()) ; 
    3229#endif 
    3330  } 
     
    3633  { 
    3734#ifdef VTRACE 
    38     //VT_USER_END(name.c_str()) ; 
     35    VT_USER_END(name.c_str()) ; 
    3936#endif 
    4037  } 
  • XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

    r1638 r1639  
    272272 
    273273    int* recvCount=new int[nbClient]; 
    274     ep_lib::MPI_Allgather(&numValue,1,EP_INT,recvCount,1,EP_INT,client->intraComm); 
     274    MPI_Allgather(&numValue,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm); 
    275275 
    276276    int* displ=new int[nbClient]; 
     
    279279 
    280280    // Each client have enough global info of axis 
    281     ep_lib::MPI_Allgatherv(sendIndexBuff,numValue,EP_INT,recvIndexBuff,recvCount,displ,EP_INT,client->intraComm); 
    282     ep_lib::MPI_Allgatherv(sendValueBuff,numValue,EP_DOUBLE,&(recvBuff[0]),recvCount,displ,EP_DOUBLE,client->intraComm); 
     281    MPI_Allgatherv(sendIndexBuff,numValue,MPI_INT,recvIndexBuff,recvCount,displ,MPI_INT,client->intraComm); 
     282    MPI_Allgatherv(sendValueBuff,numValue,MPI_DOUBLE,&(recvBuff[0]),recvCount,displ,MPI_DOUBLE,client->intraComm); 
    283283 
    284284    for (int idx = 0; idx < srcSize; ++idx) 
  • XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

    r1638 r1639  
    161161    sendRankSizeMap[itIndex->first] = sendSize; 
    162162  } 
    163   ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm); 
     163  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm); 
    164164 
    165165  displ[0]=0 ; 
     
    168168  int* recvRankBuff=new int[recvSize]; 
    169169  int* recvSizeBuff=new int[recvSize]; 
    170   ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm); 
    171   ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm); 
     170  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm); 
     171  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm); 
    172172  for (int i = 0; i < nbClient; ++i) 
    173173  { 
     
    181181 
    182182  // Sending global index of grid source to corresponding process as well as the corresponding mask 
    183   std::vector<ep_lib::MPI_Request> requests; 
    184   std::vector<ep_lib::MPI_Status> status; 
     183  std::vector<MPI_Request> requests; 
     184  std::vector<MPI_Status> status; 
    185185  std::unordered_map<int, unsigned long* > recvGlobalIndexSrc; 
    186186  std::unordered_map<int, double* > sendValueToDest; 
     
    192192    sendValueToDest[recvRank] = new double [recvSize]; 
    193193 
    194     requests.push_back(ep_lib::MPI_Request()); 
    195     ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back()); 
     194    requests.push_back(MPI_Request()); 
     195    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back()); 
    196196  } 
    197197 
     
    214214 
    215215    // Send global index source and mask 
    216     requests.push_back(ep_lib::MPI_Request()); 
    217     ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back()); 
     216    requests.push_back(MPI_Request()); 
     217    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back()); 
    218218  } 
    219219 
    220220  status.resize(requests.size()); 
    221   ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]); 
    222  
    223  
    224   std::vector<ep_lib::MPI_Request>().swap(requests); 
    225   std::vector<ep_lib::MPI_Status>().swap(status); 
     221  MPI_Waitall(requests.size(), &requests[0], &status[0]); 
     222 
     223 
     224  std::vector<MPI_Request>().swap(requests); 
     225  std::vector<MPI_Status>().swap(status); 
    226226 
    227227  // Okie, on destination side, we will wait for information of masked index of source 
     
    231231    int recvSize = itSend->second; 
    232232 
    233     requests.push_back(ep_lib::MPI_Request()); 
    234     ep_lib::MPI_Irecv(recvValueFromSrc[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back()); 
     233    requests.push_back(MPI_Request()); 
     234    MPI_Irecv(recvValueFromSrc[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back()); 
    235235  } 
    236236 
     
    249249    } 
    250250    // Okie, now inform the destination which source index are masked 
    251     requests.push_back(ep_lib::MPI_Request()); 
    252     ep_lib::MPI_Isend(sendValueToDest[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back()); 
     251    requests.push_back(MPI_Request()); 
     252    MPI_Isend(sendValueToDest[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back()); 
    253253  } 
    254254  status.resize(requests.size()); 
    255   ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]); 
     255  MPI_Waitall(requests.size(), &requests[0], &status[0]); 
    256256 
    257257 
  • XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp

    r1638 r1639  
    7070        StdSize hashValue = hashFunc.hashVec(globalAxisIndex); 
    7171        std::vector<StdSize> recvBuff(client->clientSize); 
    72         ep_lib::MPI_Gather(&hashValue, 1, EP_UNSIGNED_LONG, 
    73                    &recvBuff[0], 1, EP_UNSIGNED_LONG, 
     72        MPI_Gather(&hashValue, 1, MPI_UNSIGNED_LONG, 
     73                   &recvBuff[0], 1, MPI_UNSIGNED_LONG, 
    7474                   0, 
    7575                   client->intraComm); 
     
    8787        } 
    8888 
    89         ep_lib::MPI_Bcast(&nbLocalAxis[0], nbAxis, EP_INT, 
     89        MPI_Bcast(&nbLocalAxis[0], nbAxis, MPI_INT, 
    9090                  0, client->intraComm); 
    9191      } 
  • XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp

    r1638 r1639  
    434434  CContextClient* client=context->client; 
    435435 
    436   ep_lib::MPI_Comm poleComme(EP_COMM_NULL); 
    437   #ifdef _usingMPI 
     436  MPI_Comm poleComme(MPI_COMM_NULL); 
    438437  MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme); 
    439   #elif _usingEP 
    440   ep_lib::MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? 0 : 1, 0, &poleComme); 
    441   #endif 
    442   if (EP_COMM_NULL != poleComme) 
     438  if (MPI_COMM_NULL != poleComme) 
    443439  { 
    444440    int nbClientPole; 
    445     ep_lib::MPI_Comm_size(poleComme, &nbClientPole); 
     441    MPI_Comm_size(poleComme, &nbClientPole); 
    446442 
    447443    std::map<int,std::vector<std::pair<int,double> > >::iterator itePole = interMapValuePole.end(), itPole, 
     
    454450    std::vector<int> recvCount(nbClientPole,0); 
    455451    std::vector<int> displ(nbClientPole,0); 
    456     ep_lib::MPI_Allgather(&nbWeight,1,EP_INT,&recvCount[0],1,EP_INT,poleComme) ; 
     452    MPI_Allgather(&nbWeight,1,MPI_INT,&recvCount[0],1,MPI_INT,poleComme) ; 
    457453 
    458454    displ[0]=0; 
     
    477473 
    478474    // Gather all index and weight for pole 
    479     ep_lib::MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,EP_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],EP_INT,poleComme); 
    480     ep_lib::MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,EP_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],EP_DOUBLE,poleComme); 
     475    MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,MPI_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],MPI_INT,poleComme); 
     476    MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,MPI_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],MPI_DOUBLE,poleComme); 
    481477 
    482478    std::map<int,double> recvTemp; 
     
    635631 
    636632 
    637   ep_lib::MPI_Allreduce(sendBuff, recvBuff, nbClient, EP_INT, EP_SUM, client->intraComm); 
     633  MPI_Allreduce(sendBuff, recvBuff, nbClient, MPI_INT, MPI_SUM, client->intraComm); 
    638634 
    639635  int* sendIndexDestBuff = new int [sendBuffSize]; 
     
    641637  double* sendWeightBuff = new double [sendBuffSize]; 
    642638 
    643   std::vector<ep_lib::MPI_Request> sendRequest; 
     639  std::vector<MPI_Request> sendRequest; 
    644640 
    645641  int sendOffSet = 0, l = 0; 
     
    662658    } 
    663659 
    664     sendRequest.push_back(ep_lib::MPI_Request()); 
    665     ep_lib::MPI_Isend(sendIndexDestBuff + sendOffSet, 
     660    sendRequest.push_back(MPI_Request()); 
     661    MPI_Isend(sendIndexDestBuff + sendOffSet, 
    666662             k, 
    667              EP_INT, 
     663             MPI_INT, 
    668664             itMap->first, 
    669665             MPI_DOMAIN_INTERPOLATION_DEST_INDEX, 
    670666             client->intraComm, 
    671667             &sendRequest.back()); 
    672     sendRequest.push_back(ep_lib::MPI_Request()); 
    673     ep_lib::MPI_Isend(sendIndexSrcBuff + sendOffSet, 
     668    sendRequest.push_back(MPI_Request()); 
     669    MPI_Isend(sendIndexSrcBuff + sendOffSet, 
    674670             k, 
    675              EP_INT, 
     671             MPI_INT, 
    676672             itMap->first, 
    677673             MPI_DOMAIN_INTERPOLATION_SRC_INDEX, 
    678674             client->intraComm, 
    679675             &sendRequest.back()); 
    680     sendRequest.push_back(ep_lib::MPI_Request()); 
    681     ep_lib::MPI_Isend(sendWeightBuff + sendOffSet, 
     676    sendRequest.push_back(MPI_Request()); 
     677    MPI_Isend(sendWeightBuff + sendOffSet, 
    682678             k, 
    683              EP_DOUBLE, 
     679             MPI_DOUBLE, 
    684680             itMap->first, 
    685681             MPI_DOMAIN_INTERPOLATION_WEIGHT, 
     
    697693  while (receivedSize < recvBuffSize) 
    698694  { 
    699     ep_lib::MPI_Status recvStatus; 
    700     #ifdef _usingMPI 
     695    MPI_Status recvStatus; 
    701696    MPI_Recv((recvIndexDestBuff + receivedSize), 
    702697             recvBuffSize, 
    703              EP_INT, 
     698             MPI_INT, 
    704699             MPI_ANY_SOURCE, 
    705700             MPI_DOMAIN_INTERPOLATION_DEST_INDEX, 
    706701             client->intraComm, 
    707702             &recvStatus); 
    708     #elif _usingEP 
    709     ep_lib::MPI_Recv((recvIndexDestBuff + receivedSize), 
     703 
     704    int countBuff = 0; 
     705    MPI_Get_count(&recvStatus, MPI_INT, &countBuff); 
     706    clientSrcRank = recvStatus.MPI_SOURCE; 
     707 
     708    MPI_Recv((recvIndexSrcBuff + receivedSize), 
    710709             recvBuffSize, 
    711              EP_INT, 
    712              -2, 
    713              MPI_DOMAIN_INTERPOLATION_DEST_INDEX, 
    714              client->intraComm, 
    715              &recvStatus); 
    716     #endif 
    717  
    718     int countBuff = 0; 
    719     ep_lib::MPI_Get_count(&recvStatus, EP_INT, &countBuff); 
    720     #ifdef _usingMPI 
    721     clientSrcRank = recvStatus.MPI_SOURCE; 
    722     #elif _usingEP 
    723     clientSrcRank = recvStatus.ep_src; 
    724     #endif 
    725  
    726     ep_lib::MPI_Recv((recvIndexSrcBuff + receivedSize), 
    727              recvBuffSize, 
    728              EP_INT, 
     710             MPI_INT, 
    729711             clientSrcRank, 
    730712             MPI_DOMAIN_INTERPOLATION_SRC_INDEX, 
     
    732714             &recvStatus); 
    733715 
    734     ep_lib::MPI_Recv((recvWeightBuff + receivedSize), 
     716    MPI_Recv((recvWeightBuff + receivedSize), 
    735717             recvBuffSize, 
    736              EP_DOUBLE, 
     718             MPI_DOUBLE, 
    737719             clientSrcRank, 
    738720             MPI_DOMAIN_INTERPOLATION_WEIGHT, 
     
    748730  } 
    749731 
    750   std::vector<ep_lib::MPI_Status> requestStatus(sendRequest.size()); 
    751   #ifdef _usingMPI 
     732  std::vector<MPI_Status> requestStatus(sendRequest.size()); 
    752733  MPI_Waitall(sendRequest.size(), &sendRequest[0], MPI_STATUS_IGNORE); 
    753   #elif _usingEP 
    754   std::vector<ep_lib::MPI_Status> waitstat(sendRequest.size()); 
    755   ep_lib::MPI_Waitall(sendRequest.size(), &sendRequest[0], &waitstat[0]); 
    756   #endif 
    757734 
    758735  delete [] sendIndexDestBuff; 
     
    768745  
    769746/*! Redefined some functions of CONetCDF4 to make use of them */ 
    770 CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const ep_lib::MPI_Comm comm) 
     747CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const MPI_Comm comm) 
    771748  : CNc4DataOutput(NULL, filename, false, false, true, comm, false, true) {} 
    772749int CDomainAlgorithmInterpolate::WriteNetCdf::addDimensionWrite(const StdString& name,  
     
    858835  } 
    859836 
    860   ep_lib::MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, EP_LONG, EP_SUM, client->intraComm); 
    861   ep_lib::MPI_Scan(&localNbWeight, &startIndex, 1, EP_LONG, EP_SUM, client->intraComm); 
     837  MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, MPI_LONG, MPI_SUM, client->intraComm); 
     838  MPI_Scan(&localNbWeight, &startIndex, 1, MPI_LONG, MPI_SUM, client->intraComm); 
    862839   
    863840  if (0 == globalNbWeight) 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r1638 r1639  
    136136      { 
    137137        distributed=domainListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]->isDistributed() ; 
    138         ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ; 
     138        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ; 
    139139     
    140140      } 
     
    142142      { 
    143143        distributed=axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]->isDistributed() ; 
    144         ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ; 
     144        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ; 
    145145      } 
    146146      else //it's a scalar 
     
    238238  int sendValue = (computeGlobalIndexOnProc) ? 1 : 0; 
    239239  int recvValue = 0; 
    240   ep_lib::MPI_Allreduce(&sendValue, &recvValue, 1, EP_INT, EP_SUM, client->intraComm); 
     240  MPI_Allreduce(&sendValue, &recvValue, 1, MPI_INT, MPI_SUM, client->intraComm); 
    241241  computeGlobalIndexOnProc = (0 < recvValue); 
    242242 
  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r1638 r1639  
    514514    sendRankSizeMap[itIndex->first] = sendSize; 
    515515  } 
    516   ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm); 
     516  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm); 
    517517 
    518518  displ[0]=0 ; 
     
    521521  int* recvRankBuff=new int[recvSize]; 
    522522  int* recvSizeBuff=new int[recvSize]; 
    523   ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm); 
    524   ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm); 
     523  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm); 
     524  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm); 
    525525  for (int i = 0; i < nbClient; ++i) 
    526526  { 
     
    534534 
    535535  // Sending global index of grid source to corresponding process as well as the corresponding mask 
    536   std::vector<ep_lib::MPI_Request> requests(recvRankSizeMap.size()*2 + globaIndexWeightFromSrcToDst.size()*2); 
    537   std::vector<ep_lib::MPI_Status> status; 
     536  std::vector<MPI_Request> requests; 
     537  std::vector<MPI_Status> status; 
    538538  std::unordered_map<int, unsigned char* > recvMaskDst; 
    539539  std::unordered_map<int, unsigned long* > recvGlobalIndexSrc; 
    540   int requests_position = 0; 
    541540  for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv) 
    542541  { 
     
    546545    recvGlobalIndexSrc[recvRank] = new unsigned long [recvSize]; 
    547546 
    548     ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests[requests_position++]); 
    549     ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests[requests_position++]); 
    550  
    551     //requests.push_back(ep_lib::MPI_Request()); 
    552     //ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back()); 
    553     //requests.push_back(ep_lib::MPI_Request()); 
    554     //ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back()); 
     547    requests.push_back(MPI_Request()); 
     548    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back()); 
     549    requests.push_back(MPI_Request()); 
     550    MPI_Irecv(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back()); 
    555551  } 
    556552 
     
    587583 
    588584    // Send global index source and mask 
    589     ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests[requests_position++]); 
    590     ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests[requests_position++]); 
    591     //requests.push_back(ep_lib::MPI_Request()); 
    592     //ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back()); 
    593     //requests.push_back(ep_lib::MPI_Request()); 
    594     //ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back()); 
     585    requests.push_back(MPI_Request()); 
     586    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back()); 
     587    requests.push_back(MPI_Request()); 
     588    MPI_Isend(sendMaskDst[sendRank], sendSize, MPI_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back()); 
    595589  } 
    596590 
    597591  status.resize(requests.size()); 
    598   ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]); 
     592  MPI_Waitall(requests.size(), &requests[0], &status[0]); 
    599593 
    600594  // Okie, now use the mask to identify which index source we need to send, then also signal the destination which masked index we will return 
    601   requests.resize(sendRankSizeMap.size() + recvRankSizeMap.size()); 
    602   requests_position = 0; 
    603   std::vector<ep_lib::MPI_Status>().swap(status); 
     595  std::vector<MPI_Request>().swap(requests); 
     596  std::vector<MPI_Status>().swap(status); 
    604597  // Okie, on destination side, we will wait for information of masked index of source 
    605598  for (std::map<int,int>::const_iterator itSend = sendRankSizeMap.begin(); itSend != sendRankSizeMap.end(); ++itSend) 
     
    608601    int recvSize = itSend->second; 
    609602 
    610     ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]); 
    611     //requests.push_back(ep_lib::MPI_Request()); 
    612     //ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back()); 
     603    requests.push_back(MPI_Request()); 
     604    MPI_Irecv(sendMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back()); 
    613605  } 
    614606 
     
    646638 
    647639    // Okie, now inform the destination which source index are masked 
    648     ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]); 
    649     //requests.push_back(ep_lib::MPI_Request()); 
    650     //ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back()); 
     640    requests.push_back(MPI_Request()); 
     641    MPI_Isend(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back()); 
    651642  } 
    652643  status.resize(requests.size()); 
    653   ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]); 
     644  MPI_Waitall(requests.size(), &requests[0], &status[0]); 
    654645 
    655646  // Cool, now we can fill in local index of grid destination (counted for masked index) 
Note: See TracChangeset for help on using the changeset viewer.