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

dev on ADA

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/server.cpp

    r1587 r1638  
    1818namespace xios 
    1919{ 
    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; 
     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; 
    2525    int CServer::serverLevel = 0 ; 
    2626    int CServer::nbContexts = 0; 
    … …  
    4848    { 
    4949      int initialized ; 
    50       MPI_Initialized(&initialized) ; 
     50      ep_lib::MPI_Initialized(&initialized) ; 
    5151      if (initialized) is_MPI_Initialized=true ; 
    5252      else is_MPI_Initialized=false ; 
    … …  
    5959        if (!is_MPI_Initialized) 
    6060        { 
    61           MPI_Init(NULL, NULL); 
     61          ep_lib::MPI_Init(NULL, NULL); 
    6262        } 
    6363        CTimer::get("XIOS").resume() ; 
    … …  
    7272        int myColor ; 
    7373        int i,c ; 
    74         MPI_Comm newComm; 
    75  
    76         MPI_Comm_size(CXios::globalComm, &size) ; 
    77         MPI_Comm_rank(CXios::globalComm, &rank_); 
     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_); 
    7878 
    7979        hashAll=new unsigned long[size] ; 
    80         MPI_Allgather(&hashServer, 1, MPI_LONG, hashAll, 1, MPI_LONG, CXios::globalComm) ; 
     80        ep_lib::MPI_Allgather(&hashServer, 1, EP_LONG, hashAll, 1, EP_LONG, CXios::globalComm) ; 
    8181 
    8282        map<unsigned long, int> colors ; 
    … …  
    174174        // (2) Create intraComm 
    175175        if (serverLevel != 2) myColor=colors[hashServer]; 
    176         MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
     176        ep_lib::MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ; 
    177177 
    178178        // (3) Create interComm 
    … …  
    186186              clientLeader=it->second ; 
    187187              int intraCommSize, intraCommRank ; 
    188               MPI_Comm_size(intraComm,&intraCommSize) ; 
    189               MPI_Comm_rank(intraComm,&intraCommRank) ; 
     188              ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
     189              ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ; 
    190190              info(50)<<"intercommCreate::server (classical mode) "<<rank_<<" intraCommSize : "<<intraCommSize 
    191191                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    192192 
    193               MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     193              ep_lib::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               MPI_Comm_size(intraComm, &intraCommSize) ; 
    210               MPI_Comm_rank(intraComm, &intraCommRank) ; 
     209              ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     210              ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    211211              info(50)<<"intercommCreate::server (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    212212                       <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    213               MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
     213              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ; 
    214214              interCommLeft.push_back(newComm) ; 
    215215            } 
    … …  
    219219          { 
    220220            int intraCommSize, intraCommRank ; 
    221             MPI_Comm_size(intraComm, &intraCommSize) ; 
    222             MPI_Comm_rank(intraComm, &intraCommRank) ; 
     221            ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     222            ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    223223            info(50)<<"intercommCreate::client (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize 
    224224                <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< sndServerGlobalRanks[i]<<endl ; 
    225             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ; 
     225            ep_lib::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           MPI_Comm_size(intraComm, &intraCommSize) ; 
    235           MPI_Comm_rank(intraComm, &intraCommRank) ; 
     234          ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ; 
     235          ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ; 
    236236          info(50)<<"intercommCreate::server (server level 2) "<<rank_<<" intraCommSize : "<<intraCommSize 
    237237                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ; 
    238238 
    239           MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
     239          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ; 
    240240          interCommLeft.push_back(newComm) ; 
    241241        } 
    … …  
    253253 
    254254        CTimer::get("XIOS").resume() ; 
    255         MPI_Comm localComm; 
     255        ep_lib::MPI_Comm localComm; 
    256256        oasis_get_localcomm(localComm); 
    257         MPI_Comm_rank(localComm,&rank_) ; 
     257        ep_lib::MPI_Comm_rank(localComm,&rank_) ; 
    258258 
    259259//      (1) Create server intraComm 
    260260        if (!CXios::usingServer2) 
    261261        { 
    262           MPI_Comm_dup(localComm, &intraComm); 
     262          ep_lib::MPI_Comm_dup(localComm, &intraComm); 
    263263        } 
    264264        else 
    265265        { 
    266266          int globalRank; 
    267           MPI_Comm_size(localComm,&size) ; 
    268           MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
     267          ep_lib::MPI_Comm_size(localComm,&size) ; 
     268          ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    269269          srvGlobalRanks = new int[size] ; 
    270           MPI_Allgather(&globalRank, 1, MPI_INT, srvGlobalRanks, 1, MPI_INT, localComm) ; 
     270          ep_lib::MPI_Allgather(&globalRank, 1, EP_INT, srvGlobalRanks, 1, EP_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             MPI_Comm_dup(localComm, &intraComm); 
     278            ep_lib::MPI_Comm_dup(localComm, &intraComm); 
    279279          } 
    280280          else 
    … …  
    339339            } 
    340340            if (serverLevel != 2) myColor=0; 
    341             MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
     341            ep_lib::MPI_Comm_split(localComm, myColor, rank_, &intraComm) ; 
    342342          } 
    343343        } 
    … …  
    348348        vector<string>::iterator it ; 
    349349 
    350         MPI_Comm newComm ; 
     350        ep_lib::MPI_Comm newComm ; 
    351351        int globalRank ; 
    352         MPI_Comm_rank(CXios::globalComm,&globalRank); 
     352        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank); 
    353353 
    354354//      (2) Create interComms with models 
    … …  
    359359          { 
    360360            interCommLeft.push_back(newComm) ; 
    361             if (rank_==0) MPI_Send(&globalRank,1,MPI_INT,0,0,newComm) ; 
     361            if (rank_==0) ep_lib::MPI_Send(&globalRank,1,EP_INT,0,0,newComm) ; 
    362362          } 
    363363        } 
    … …  
    365365//      (3) Create interComms between primary and secondary servers 
    366366        int intraCommSize, intraCommRank ; 
    367         MPI_Comm_size(intraComm,&intraCommSize) ; 
    368         MPI_Comm_rank(intraComm, &intraCommRank) ; 
     367        ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ; 
     368        ep_lib::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             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ; 
     377            ep_lib::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           MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
     385          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ; 
    386386          interCommLeft.push_back(newComm) ; 
    387387        } 
    … …  
    393393 
    394394 
    395       MPI_Comm_rank(intraComm, &rank) ; 
     395      ep_lib::MPI_Comm_rank(intraComm, &rank) ; 
    396396      if (rank==0) isRoot=true; 
    397397      else isRoot=false; 
    … …  
    406406      delete eventScheduler ; 
    407407 
    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)); 
     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)); 
    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<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    421           MPI_Comm_free(&(*it)); 
    422  
    423       MPI_Comm_free(&intraComm); 
     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); 
    424424 
    425425      if (!is_MPI_Initialized) 
    426426      { 
    427427        if (CXios::usingOasis) oasis_finalize(); 
    428         else MPI_Finalize() ; 
     428        else ep_lib::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<MPI_Comm>::iterator it, itr; 
     467        list<ep_lib::MPI_Comm>::iterator it, itr; 
    468468        int msg ; 
    469469        int flag ; 
    … …  
    471471        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    472472        { 
    473            MPI_Status status ; 
     473           ep_lib::MPI_Status status ; 
    474474           traceOff() ; 
    475            MPI_Iprobe(0,0,*it,&flag,&status) ; 
     475           ep_lib::MPI_Iprobe(0,0,*it,&flag,&status) ; 
    476476           traceOn() ; 
    477477           if (flag==true) 
    478478           { 
    479               MPI_Recv(&msg,1,MPI_INT,0,0,*it,&status) ; 
     479              ep_lib::MPI_Recv(&msg,1,EP_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                 MPI_Send(&msg,1,MPI_INT,0,0,*itr) ; 
     484                ep_lib::MPI_Send(&msg,1,EP_INT,0,0,*itr) ; 
    485485              } 
    486               MPI_Comm_free(&(*it)); 
     486              ep_lib::MPI_Comm_free(&(*it)); 
    487487              interCommLeft.erase(it) ; 
    488488              break ; 
    … …  
    493493         { 
    494494           int i,size ; 
    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) ; 
     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) ; 
    501501 
    502502           finished=true ; 
    … …  
    510510     { 
    511511        int flag ; 
    512         MPI_Status status ; 
     512        ep_lib::MPI_Status status ; 
    513513        int msg ; 
    514514 
    515515        traceOff() ; 
    516         MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
     516        ep_lib::MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
    517517        traceOn() ; 
    518518        if (flag==true) 
    519519        { 
    520            MPI_Recv(&msg,1,MPI_INT,0,4,intraComm,&status) ; 
     520           ep_lib::MPI_Recv(&msg,1,EP_INT,0,4,intraComm,&status) ; 
    521521           finished=true ; 
    522522        } 
    … …  
    534534     { 
    535535        int flag ; 
    536         MPI_Status status ; 
    537         list<MPI_Comm>::iterator it; 
     536        ep_lib::MPI_Status status ; 
     537        list<ep_lib::MPI_Comm>::iterator it; 
    538538        int msg ; 
    539539        static int nbCompound=0 ; 
    540540        int size ; 
    541541        static bool sent=false ; 
    542         static MPI_Request* allRequests ; 
    543         static MPI_Status* allStatus ; 
     542        static ep_lib::MPI_Request* allRequests ; 
     543        static ep_lib::MPI_Status* allStatus ; 
    544544 
    545545 
    546546        if (sent) 
    547547        { 
    548           MPI_Comm_size(intraComm,&size) ; 
    549           MPI_Testall(size,allRequests, &flag, allStatus) ; 
     548          ep_lib::MPI_Comm_size(intraComm,&size) ; 
     549          ep_lib::MPI_Testall(size,allRequests, &flag, allStatus) ; 
    550550          if (flag==true) 
    551551          { 
    … …  
    559559        for(it=interCommLeft.begin();it!=interCommLeft.end();it++) 
    560560        { 
    561            MPI_Status status ; 
     561           ep_lib::MPI_Status status ; 
    562562           traceOff() ; 
    563            MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
     563           ep_lib::MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5 
    564564           traceOn() ; 
    565565           if (flag==true) 
    566566           { 
    567               MPI_Recv(&msg,1,MPI_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
     567              ep_lib::MPI_Recv(&msg,1,EP_INT,0,5,*it,&status) ; // tags oasis_endded = 5 
    568568              nbCompound++ ; 
    569569              if (nbCompound==interCommLeft.size()) 
    570570              { 
    571                 for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
     571                for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    572572                { 
    573                    MPI_Send(&msg,1,MPI_INT,0,5,*it) ; // tags oasis_endded = 5 
     573                   ep_lib::MPI_Send(&msg,1,EP_INT,0,5,*it) ; // tags oasis_endded = 5 
    574574                } 
    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 
     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 
    579579                sent=true ; 
    580580              } 
    … …  
    590590     { 
    591591       int flag ; 
    592        MPI_Status status ; 
     592       ep_lib::MPI_Status status ; 
    593593       const int root=0 ; 
    594594       int msg ; 
    … …  
    607607          
    608608       traceOff() ; 
    609        MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
     609       ep_lib::MPI_Iprobe(root,5,intraComm, &flag, &status) ; 
    610610       traceOn() ; 
    611611       if (flag==true) 
    612612       { 
    613          MPI_Recv(&msg,1,MPI_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
     613         ep_lib::MPI_Recv(&msg,1,EP_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5 
    614614         boost::hash<string> hashString; 
    615615         size_t hashId = hashString("oasis_enddef"); 
    … …  
    626626     { 
    627627 
    628        MPI_Status status ; 
     628       ep_lib::MPI_Status status ; 
    629629       int flag ; 
    630630       static char* buffer ; 
    631        static MPI_Request request ; 
     631       static ep_lib::MPI_Request request ; 
    632632       static bool recept=false ; 
    633633       int rank ; 
    … …  
    637637       { 
    638638         traceOff() ; 
    639          MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
     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 
    640644         traceOn() ; 
    641645         if (flag==true) 
    642646         { 
     647           #ifdef _usingMPI 
    643648           rank=status.MPI_SOURCE ; 
    644            MPI_Get_count(&status,MPI_CHAR,&count) ; 
     649           #elif _usingEP 
     650           rank=status.ep_src ; 
     651           #endif 
     652           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
    645653           buffer=new char[count] ; 
    646            MPI_Irecv((void*)buffer,count,MPI_CHAR,rank,1,CXios::globalComm,&request) ; 
     654           ep_lib::MPI_Irecv((void*)buffer,count,EP_CHAR,rank,1,CXios::globalComm,&request) ; 
    647655           recept=true ; 
    648656         } 
    … …  
    651659       { 
    652660         traceOff() ; 
    653          MPI_Test(&request,&flag,&status) ; 
     661         ep_lib::MPI_Test(&request,&flag,&status) ; 
    654662         traceOn() ; 
    655663         if (flag==true) 
    656664         { 
     665           #ifdef _usingMPI 
    657666           rank=status.MPI_SOURCE ; 
    658            MPI_Get_count(&status,MPI_CHAR,&count) ; 
     667           #elif _usingEP 
     668           rank=status.ep_src ; 
     669           #endif 
     670           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ; 
    659671           recvContextMessage((void*)buffer,count) ; 
    660672           delete [] buffer ; 
    … …  
    689701       { 
    690702         int size ; 
    691          MPI_Comm_size(intraComm,&size) ; 
     703         ep_lib::MPI_Comm_size(intraComm,&size) ; 
    692704//         MPI_Request* requests= new MPI_Request[size-1] ; 
    693705//         MPI_Status* status= new MPI_Status[size-1] ; 
    694          MPI_Request* requests= new MPI_Request[size] ; 
    695          MPI_Status* status= new MPI_Status[size] ; 
     706         ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size] ; 
     707         ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size] ; 
    696708 
    697709         CMessage msg ; 
    … …  
    705717         for(int i=0; i<size; i++) 
    706718         { 
    707            MPI_Isend(sendBuff,sendBuffer.count(),MPI_CHAR,i,2,intraComm,&requests[i]) ; 
     719           ep_lib::MPI_Isend(sendBuff,sendBuffer.count(),EP_CHAR,i,2,intraComm,&requests[i]) ; 
    708720         } 
    709721 
    … …  
    717729     void CServer::listenRootContext(void) 
    718730     { 
    719        MPI_Status status ; 
     731       ep_lib::MPI_Status status ; 
    720732       int flag ; 
    721733       static std::vector<void*> buffers; 
    722        static std::vector<MPI_Request> requests ; 
     734       static std::vector<ep_lib::MPI_Request> requests ; 
    723735       static std::vector<int> counts ; 
    724736       static std::vector<bool> isEventRegistered ; 
    725737       static std::vector<bool> isEventQueued ; 
    726        MPI_Request request; 
     738       ep_lib::MPI_Request request; 
    727739 
    728740       int rank ; 
    … …  
    733745       // (1) Receive context id from the root, save it into a buffer 
    734746       traceOff() ; 
    735        MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
     747       ep_lib::MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
    736748       traceOn() ; 
    737749       if (flag==true) 
    738750       { 
    739751         counts.push_back(0); 
    740          MPI_Get_count(&status,MPI_CHAR,&(counts.back())) ; 
     752         ep_lib::MPI_Get_count(&status,EP_CHAR,&(counts.back())) ; 
    741753         buffers.push_back(new char[counts.back()]) ; 
    742754         requests.push_back(request); 
    743          MPI_Irecv((void*)(buffers.back()),counts.back(),MPI_CHAR,root,2,intraComm,&(requests.back())) ; 
     755         ep_lib::MPI_Irecv((void*)(buffers.back()),counts.back(),EP_CHAR,root,2,intraComm,&(requests.back())) ; 
    744756         isEventRegistered.push_back(false); 
    745757         isEventQueued.push_back(false); 
    … …  
    750762       { 
    751763         // (2) If context id is received, register an event 
    752          MPI_Test(&requests[ctxNb],&flag,&status) ; 
     764         ep_lib::MPI_Test(&requests[ctxNb],&flag,&status) ; 
    753765         if (flag==true && !isEventRegistered[ctxNb]) 
    754766         { 
    … …  
    787799       // (1) create interComm (with a client) 
    788800       // (2) initialize client and server (contextClient and contextServer) 
    789        MPI_Comm inter; 
     801       ep_lib::MPI_Comm inter; 
    790802       if (serverLevel < 2) 
    791803       { 
    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); 
     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); 
    797809         context->initServer(intraComm,contextInterComm); 
    798810         contextInterComms.push_back(contextInterComm); 
    … …  
    807819       else if (serverLevel == 2) 
    808820       { 
    809          MPI_Comm_dup(interCommLeft.front(), &inter); 
     821         ep_lib::MPI_Comm_dup(interCommLeft.front(), &inter); 
    810822         contextInterComms.push_back(inter); 
    811823         context->initServer(intraComm, contextInterComms.back()); 
    … …  
    818830       { 
    819831         int i = 0, size; 
    820          MPI_Comm_size(intraComm, &size) ; 
    821          for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i) 
     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) 
    822834         { 
    823835           StdString str = contextId +"_server_" + boost::lexical_cast<string>(i); 
    … …  
    829841           CBufferOut buffer(buff,messageSize) ; 
    830842           buffer<<msg ; 
    831            MPI_Send(buff, buffer.count(), MPI_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
    832            MPI_Comm_dup(*it, &inter); 
     843           ep_lib::MPI_Send(buff, buffer.count(), EP_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ; 
     844           ep_lib::MPI_Comm_dup(*it, &inter); 
    833845           contextInterComms.push_back(inter); 
    834            MPI_Comm_dup(intraComm, &inter); 
     846           ep_lib::MPI_Comm_dup(intraComm, &inter); 
    835847           contextIntraComms.push_back(inter); 
    836848           context->initClient(contextIntraComms.back(), contextInterComms.back()) ; 
    … …  
    862874     { 
    863875       int rank; 
    864        MPI_Comm_rank(intraComm,&rank); 
     876       ep_lib::MPI_Comm_rank(intraComm,&rank); 
    865877       return rank; 
    866878     } 
    … …  
    885897      int size = 0; 
    886898      int id; 
    887       MPI_Comm_size(CXios::globalComm, &size); 
     899      ep_lib::MPI_Comm_size(CXios::globalComm, &size); 
    888900      while (size) 
    889901      { 
Note: See TracChangeset for help on using the changeset viewer.