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

revert erroneous commit on trunk

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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      { 
Note: See TracChangeset for help on using the changeset viewer.