Changeset 2589


Ignore:
Timestamp:
10/06/23 11:32:05 (7 months ago)
Author:
jderouillat
Message:

Specify the usage of the xios namespace to overload the MPI funtions

Location:
XIOS3/trunk/src
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • XIOS3/trunk/src/client.cpp

    r2580 r2589  
    105105          delete[] hashAll ; 
    106106 
    107           MPI_Comm_split(globalComm, color, commRank, &clientComm) ; 
     107          xios::MPI_Comm_split(globalComm, color, commRank, &clientComm) ; 
    108108          CXios::getMpiGarbageCollector().registerCommunicator(clientComm) ; 
    109109        } 
    … …  
    115115      else // localComm is given 
    116116      { 
    117         MPI_Comm_dup(localComm,&clientComm) ; 
     117        xios::MPI_Comm_dup(localComm,&clientComm) ; 
    118118        CXios::getMpiGarbageCollector().registerCommunicator(clientComm) ; 
    119         MPI_Comm_dup(localComm,&intraComm_) ; 
     119        xios::MPI_Comm_dup(localComm,&intraComm_) ; 
    120120        CXios::getMpiGarbageCollector().registerCommunicator(intraComm_) ; 
    121121 
    … …  
    145145         MPI_Comm splitComm,interComm ; 
    146146         MPI_Comm_rank(globalComm,&commGlobalRank) ; 
    147          MPI_Comm_split(globalComm, 0, commGlobalRank, &splitComm) ; 
     147         xios::MPI_Comm_split(globalComm, 0, commGlobalRank, &splitComm) ; 
    148148         int splitCommSize, globalCommSize ; 
    149149         
    … …  
    152152         if (splitCommSize==globalCommSize) // no server 
    153153         { 
    154            MPI_Comm_dup(globalComm,&xiosGlobalComm) ; 
     154           xios::MPI_Comm_dup(globalComm,&xiosGlobalComm) ; 
    155155           CXios::setXiosComm(xiosGlobalComm) ; 
    156156         } 
    … …  
    163163           MPI_Allreduce(&clientLeader,&clientRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
    164164           MPI_Allreduce(&serverLeader,&serverRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
    165            MPI_Intercomm_create(splitComm, 0, globalComm, serverRemoteLeader,1341,&interComm) ; 
    166            MPI_Intercomm_merge(interComm,true,&xiosGlobalComm) ; 
     165           xios::MPI_Intercomm_create(splitComm, 0, globalComm, serverRemoteLeader,1341,&interComm) ; 
     166           xios::MPI_Intercomm_merge(interComm,true,&xiosGlobalComm) ; 
    167167           CXios::setXiosComm(xiosGlobalComm) ; 
    168168         } 
    … …  
    177177      int commRank ; 
    178178      MPI_Comm_rank(CXios::getXiosComm(), &commRank) ; 
    179       MPI_Comm_split(CXios::getXiosComm(),false,commRank, &clientsComm_) ; 
     179      xios::MPI_Comm_split(CXios::getXiosComm(),false,commRank, &clientsComm_) ; 
    180180      CXios::getMpiGarbageCollector().registerCommunicator(clientsComm_) ; 
    181181       
    … …  
    271271      { 
    272272        MPI_Comm intraComm ; 
    273         MPI_Comm_dup(clientComm,&intraComm) ; 
     273        xios::MPI_Comm_dup(clientComm,&intraComm) ; 
    274274        MPI_Comm interComm ; 
    275275         
    … …  
    280280        for(int i=pos ; i<clientsCodeId.size(); i++) 
    281281        {   
    282           MPI_Intercomm_create(intraComm, 0, globalComm, serverRank, 3141, &interComm); 
     282          xios::MPI_Intercomm_create(intraComm, 0, globalComm, serverRank, 3141, &interComm); 
    283283          CXios::getMpiGarbageCollector().registerCommunicator(interComm) ; 
    284           MPI_Comm_free(&intraComm) ; 
    285           MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
     284          xios::MPI_Comm_free(&intraComm) ; 
     285          xios::MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
    286286          high=false ; 
    287287          if (i==pos) { 
    … …  
    313313        int client ; 
    314314        MPI_Comm intraComm ; 
    315         MPI_Comm_dup(clientComm,&intraComm) ; 
     315        xios::MPI_Comm_dup(clientComm,&intraComm) ; 
    316316        MPI_Comm interComm ; 
    317317         
    … …  
    324324          if (codeId==clientsCodeId[0])   // first model play the server rule 
    325325          {           
    326             MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm); 
    327             MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
     326            xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm); 
     327            xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
    328328          } 
    329329          else 
    330330          {           
    331             MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[0], 3141, &interComm); 
    332             MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
     331            xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[0], 3141, &interComm); 
     332            xios::MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
    333333            high=false ; 
    334334          } 
    … …  
    381381          {   
    382382            MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
    383             MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
     383            xios::MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
    384384          } 
    385385          xiosGlobalComm=intraComm ; 
    … …  
    401401            {   
    402402              MPI_Comm_accept(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
    403               MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
     403              xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
    404404            } 
    405405          } 
    … …  
    423423              {   
    424424                MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
    425                 MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
     425                xios::MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
    426426              } 
    427427              xiosGlobalComm=intraComm ; 
    … …  
    523523      CXios::getMpiGarbageCollector().release() ; // release unfree MPI ressources 
    524524      MPI_Comm xiosComm=CXios::getXiosComm() ; 
    525       MPI_Comm_free(&xiosComm) ; 
     525      xios::MPI_Comm_free(&xiosComm) ; 
    526526      CCommTrack::dumpComm() ; 
    527527      if (!is_MPI_Initialized) 

  • XIOS3/trunk/src/distribution/grid_remote_connector.cpp

    r2507 r2589  
    609609    if (commRank==0) color=1 ; 
    610610    MPI_Comm newComm ; 
    611     MPI_Comm_split(localComm_, color, commRank, &newComm) ; 
     611    xios::MPI_Comm_split(localComm_, color, commRank, &newComm) ; 
    612612    if (color==1) 
    613613    { 
    … …  
    620620      MPI_Bcast(indGlo.data(),dataSize,MPI_SIZE_T,0,newComm) ; 
    621621    } 
    622     MPI_Comm_free(&newComm) ; 
     622    xios::MPI_Comm_free(&newComm) ; 
    623623 
    624624    // construct element_[i] from indGlo 

  • XIOS3/trunk/src/event_scheduler.cpp

    r2570 r2589  
    2727  void CEventScheduler::initialize(const MPI_Comm& comm)  
    2828  { 
    29     MPI_Comm_dup(comm, &communicator_) ; 
     29    xios::MPI_Comm_dup(comm, &communicator_) ; 
    3030    CXios::getMpiGarbageCollector().registerCommunicator(communicator_) ; 
    3131    MPI_Comm_size(communicator_,&mpiSize_) ; 
    … …  
    123123    if (child->isRoot()) color=1 ; 
    124124    else color=0 ; 
    125     MPI_Comm_split(communicator_, color, mpiRank_, &newComm) ; 
     125    xios::MPI_Comm_split(communicator_, color, mpiRank_, &newComm) ; 
    126126    CXios::getMpiGarbageCollector().registerCommunicator(newComm) ; 
    127127 

  • XIOS3/trunk/src/manager/daemons_manager.cpp

    r2547 r2589  
    1717    MPI_Comm_rank(xiosComm,&commRank) ; 
    1818    MPI_Comm splitComm ; 
    19     MPI_Comm_split(xiosComm,isXiosServer,commRank,&splitComm) ; 
     19    xios::MPI_Comm_split(xiosComm,isXiosServer,commRank,&splitComm) ; 
    2020     
    2121    CXios::launchRegistryManager(isXiosServer) ; 
    … …  
    2828    if (isXiosServer) CServer::launchServersRessource(splitComm) ; 
    2929    MPI_Barrier(xiosComm) ; 
    30     MPI_Comm_free(&splitComm) ; 
     30    xios::MPI_Comm_free(&splitComm) ; 
    3131  } 
    3232 

  • XIOS3/trunk/src/manager/pool_ressource.cpp

    r2580 r2589  
    1515  { 
    1616    int commRank, commSize ; 
    17     MPI_Comm_dup(poolComm, &poolComm_) ; 
     17    xios::MPI_Comm_dup(poolComm, &poolComm_) ; 
    1818    CXios::getMpiGarbageCollector().registerCommunicator(poolComm_) ; 
    1919    winNotify_ = new CWindowManager(poolComm_, maxBufferSize_,"CPoolRessource::winNotify_") ; 
    … …  
    336336    else color=1 ;  
    337337    MPI_Comm_rank(poolComm_,&commRank) ; 
    338     MPI_Comm_split(poolComm_, color, commRank, &freeComm) ;  // workaround 
     338    xios::MPI_Comm_split(poolComm_, color, commRank, &freeComm) ;  // workaround 
    339339     
    340340    if (services_.empty())  
    341341    { 
    342342      MPI_Comm_rank(freeComm,&commRank) ; 
    343       MPI_Comm_split(freeComm, in, commRank, &serviceComm) ; 
     343      xios::MPI_Comm_split(freeComm, in, commRank, &serviceComm) ; 
    344344 
    345345      // temporary for event scheduler, we must using hierarchical split of free ressources communicator. 
    … …  
    364364        else  partitionId = serviceCommRank / (serviceCommSize/nbPartitions + 1) ; 
    365365 
    366         MPI_Comm_split(serviceComm, partitionId, commRank, &newServiceComm) ; 
     366        xios::MPI_Comm_split(serviceComm, partitionId, commRank, &newServiceComm) ; 
    367367 
    368368        MPI_Comm_size(newServiceComm,&serviceCommSize) ; 
    … …  
    378378        services_[std::make_tuple(serviceId,partitionId)] = new CService(newServiceComm, childScheduler, Id_, serviceId, partitionId, type, nbPartitions) ; 
    379379        
    380         MPI_Comm_free(&newServiceComm) ; 
     380        xios::MPI_Comm_free(&newServiceComm) ; 
    381381      } 
    382382      else 
    … …  
    388388        isFirstSplit_=false ; 
    389389      } 
    390       MPI_Comm_free(&serviceComm) ; 
    391     } 
    392     MPI_Comm_free(&freeComm) ; 
     390      xios::MPI_Comm_free(&serviceComm) ; 
     391    } 
     392    xios::MPI_Comm_free(&freeComm) ; 
    393393  } 
    394394   
    … …  
    404404        const MPI_Comm& serviceComm = service.second->getCommunicator() ; 
    405405        MPI_Comm newServiceComm ; 
    406         MPI_Comm_dup(serviceComm, &newServiceComm) ; 
     406        xios::MPI_Comm_dup(serviceComm, &newServiceComm) ; 
    407407        CXios::getMpiGarbageCollector().registerCommunicator(newServiceComm) ; 
    408408        int nbPartitions = service.second->getNbPartitions() ; 

  • XIOS3/trunk/src/manager/server_context.cpp

    r2588 r2589  
    2323   int localRank, globalRank, commSize ; 
    2424 
    25     MPI_Comm_dup(contextComm, &contextComm_) ; 
     25    xios::MPI_Comm_dup(contextComm, &contextComm_) ; 
    2626    CXios::getMpiGarbageCollector().registerCommunicator(contextComm_) ; 
    2727    xiosComm_=CXios::getXiosComm() ; 
    … …  
    104104    { 
    105105      MPI_Comm newInterCommClient, newInterCommServer ; 
    106       MPI_Comm_dup(contextComm_,&newInterCommClient) ; 
    107       MPI_Comm_dup(contextComm_,&newInterCommServer) ; 
     106      xios::MPI_Comm_dup(contextComm_,&newInterCommClient) ; 
     107      xios::MPI_Comm_dup(contextComm_,&newInterCommServer) ; 
    108108      overlapedComm_[name_]=tuple<bool, MPI_Comm, MPI_Comm>(false, newInterCommClient, newInterCommServer) ; 
    109109      MPI_Barrier(contextComm_) ; 
    … …  
    129129      if (nOverlap==0) 
    130130      {  
    131         MPI_Intercomm_create(intraComm, 0, xiosComm_, contextLeader, 3141, &interCommClient) ; 
     131        xios::MPI_Intercomm_create(intraComm, 0, xiosComm_, contextLeader, 3141, &interCommClient) ; 
    132132        CXios::getMpiGarbageCollector().registerCommunicator(interCommClient) ; 
    133         MPI_Comm_dup(interCommClient, &interCommServer) ; 
     133        xios::MPI_Comm_dup(interCommClient, &interCommServer) ; 
    134134        CXios::getMpiGarbageCollector().registerCommunicator(interCommServer) ; 
    135         MPI_Comm_free(&newInterCommClient) ; 
    136         MPI_Comm_free(&newInterCommServer) ; 
     135        xios::MPI_Comm_free(&newInterCommClient) ; 
     136        xios::MPI_Comm_free(&newInterCommServer) ; 
    137137      } 
    138138      else 
    … …  
    320320    {  
    321321      info(10)<<"CServerContext::createIntercomm : No overlap ==> context in server mode"<<endl ; 
    322       MPI_Intercomm_create(contextComm_, 0, xiosComm_, remoteLeader, 3141, &interCommServer) ; 
     322      xios::MPI_Intercomm_create(contextComm_, 0, xiosComm_, remoteLeader, 3141, &interCommServer) ; 
    323323      CXios::getMpiGarbageCollector().registerCommunicator(interCommServer) ; 
    324       MPI_Comm_dup(interCommServer,&interCommClient) ; 
     324      xios::MPI_Comm_dup(interCommServer,&interCommClient) ; 
    325325      CXios::getMpiGarbageCollector().registerCommunicator(interCommClient) ; 
    326326      context_ -> createClientInterComm(interCommClient,interCommServer) ; 
    … …  
    339339    //delete winNotify_ ; 
    340340    //winNotify_=nullptr ; 
    341     //MPI_Comm_free(&contextComm_) ; 
     341    //xios::MPI_Comm_free(&contextComm_) ; 
    342342    // don't forget intercomm -> later 
    343343  } 

  • XIOS3/trunk/src/manager/servers_ressource.cpp

    r2580 r2589  
    2222  { 
    2323 
    24     MPI_Comm_dup(serverComm, &serverComm_) ; 
     24    xios::MPI_Comm_dup(serverComm, &serverComm_) ; 
    2525    CXios::getMpiGarbageCollector().registerCommunicator(serverComm_) ;  
    2626    MPI_Comm xiosComm=CXios::getXiosComm() ; 
    … …  
    4242    } 
    4343 
    44     MPI_Comm_dup(serverComm_, &freeRessourcesComm_) ;  
     44    xios::MPI_Comm_dup(serverComm_, &freeRessourcesComm_) ;  
    4545    CXios::getMpiGarbageCollector().registerCommunicator(freeRessourcesComm_) ; 
    4646    eventScheduler_ = make_shared<CEventScheduler>(freeRessourcesComm_) ; 
    … …  
    225225    MPI_Comm poolComm ; 
    226226    MPI_Comm_rank(freeRessourcesComm_,&commRank) ; 
    227     MPI_Comm_split(freeRessourcesComm_, isPartOf, commRank, &poolComm) ; 
     227    xios::MPI_Comm_split(freeRessourcesComm_, isPartOf, commRank, &poolComm) ; 
    228228     
    229229    shared_ptr<CEventScheduler> parentScheduler, childScheduler ; 
    … …  
    236236    {   
    237237      poolRessource_ = new CPoolRessource(poolComm, childScheduler, poolId, true) ; 
    238       MPI_Comm_free(&poolComm) ; 
     238      xios::MPI_Comm_free(&poolComm) ; 
    239239    } 
    240240    else  
    241241    { 
    242242      freeRessourceEventScheduler_ = childScheduler ; 
    243       MPI_Comm_free(&freeRessourcesComm_) ; 
     243      xios::MPI_Comm_free(&freeRessourcesComm_) ; 
    244244      freeRessourcesComm_=poolComm ; 
    245245    } 

  • XIOS3/trunk/src/manager/services.cpp

    r2580 r2589  
    2121    int localRank, globalRank, commSize ; 
    2222 
    23     MPI_Comm_dup(serviceComm, &serviceComm_) ; 
     23    xios::MPI_Comm_dup(serviceComm, &serviceComm_) ; 
    2424    CXios::getMpiGarbageCollector().registerCommunicator(serviceComm_) ; 
    2525    MPI_Comm globalComm_=CXios::getXiosComm() ; 

  • XIOS3/trunk/src/mpi_garbage_collector.hpp

    r2580 r2589  
    2828      { 
    2929        for( auto& it : stack_)  
    30           if (it.type==SType::COMM) MPI_Comm_free(&it.comm); 
     30          if (it.type==SType::COMM) xios::MPI_Comm_free(&it.comm); 
    3131          else if (it.type==SType::WIN) MPI_Win_free(&it.win); 
    3232        stack_.clear(); 

  • XIOS3/trunk/src/node/context.cpp

    r2588 r2589  
    541541  { 
    542542    MPI_Comm intraCommClient ; 
    543     MPI_Comm_dup(intraComm_, &intraCommClient); 
     543    xios::MPI_Comm_dup(intraComm_, &intraCommClient); 
    544544    comms.push_back(intraCommClient); 
    545545 
    … …  
    598598 
    599599      intraCommClient=intraComm_ ; 
    600       MPI_Comm_dup(intraComm_, &intraCommServer) ; 
     600      xios::MPI_Comm_dup(intraComm_, &intraCommServer) ; 
    601601      CXios::getMpiGarbageCollector().registerCommunicator(intraCommServer) ; 
    602602 
    … …  
    806806         MPI_Comm intraCommClient, intraCommServer ; 
    807807 
    808          MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
    809  
    810         MPI_Comm_dup(intraComm_, &intraCommClient) ; 
    811         MPI_Comm_dup(intraComm_, &intraCommServer) ; 
    812         MPI_Comm_dup(interComm, &interCommClient) ; 
    813         MPI_Comm_dup(interComm, &interCommServer) ; 
     808         xios::MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
     809 
     810        xios::MPI_Comm_dup(intraComm_, &intraCommClient) ; 
     811        xios::MPI_Comm_dup(intraComm_, &intraCommServer) ; 
     812        xios::MPI_Comm_dup(interComm, &interCommClient) ; 
     813        xios::MPI_Comm_dup(interComm, &interCommServer) ; 
    814814        CContextClient* client = CContextClient::getNew(this, intraCommClient, interCommClient); 
    815815        CContextServer* server = CContextServer::getNew(this, intraCommServer, interCommServer); 
    816816        client->setAssociatedServer(server) ; 
    817817        server->setAssociatedClient(client) ; 
    818         MPI_Comm_free(&interComm) ; 
     818        xios::MPI_Comm_free(&interComm) ; 
    819819        couplerOutClient_[fullContextId] = client ; 
    820820        couplerOutServer_[fullContextId] = server ; 
    … …  
    829829       MPI_Comm intraCommClient, intraCommServer ; 
    830830 
    831        MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
    832  
    833        MPI_Comm_dup(intraComm_, &intraCommClient) ; 
    834        MPI_Comm_dup(intraComm_, &intraCommServer) ; 
    835        MPI_Comm_dup(interComm, &interCommServer) ; 
    836        MPI_Comm_dup(interComm, &interCommClient) ; 
     831       xios::MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ; 
     832 
     833       xios::MPI_Comm_dup(intraComm_, &intraCommClient) ; 
     834       xios::MPI_Comm_dup(intraComm_, &intraCommServer) ; 
     835       xios::MPI_Comm_dup(interComm, &interCommServer) ; 
     836       xios::MPI_Comm_dup(interComm, &interCommClient) ; 
    837837       CContextServer* server = CContextServer::getNew(this, intraCommServer, interCommServer); 
    838838       CContextClient* client = CContextClient::getNew(this, intraCommClient, interCommClient); 
    839839       client->setAssociatedServer(server) ; 
    840840       server->setAssociatedClient(client) ; 
    841        MPI_Comm_free(&interComm) ; 
     841       xios::MPI_Comm_free(&interComm) ; 
    842842 
    843843       couplerInClient_[fullContextId] = client ; 
    … …  
    10011001   { 
    10021002     for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    1003        MPI_Comm_free(&(*it)); 
     1003       xios::MPI_Comm_free(&(*it)); 
    10041004     comms.clear(); 
    10051005   } 

  • XIOS3/trunk/src/node/file.cpp

    r2507 r2589  
    272272      { 
    273273        // NetCDF runs now write of null data 
    274         MPI_Comm_dup(context->intraComm_, &fileComm) ; 
     274        xios::MPI_Comm_dup(context->intraComm_, &fileComm) ; 
    275275      } 
    276276 
    … …  
    287287      //createSubComFile(); 
    288288      allZoneEmpty = false;  
    289       MPI_Comm_dup(context->intraComm_, &fileComm) ; 
     289      xios::MPI_Comm_dup(context->intraComm_, &fileComm) ; 
    290290      checkRead = true; 
    291291    } 
    … …  
    312312 
    313313      int color = allZoneEmpty ? 0 : 1; 
    314       MPI_Comm_split(context->intraComm_, color, context->intraCommRank_, &fileComm); 
    315       if (allZoneEmpty) MPI_Comm_free(&fileComm); 
     314      xios::MPI_Comm_split(context->intraComm_, color, context->intraCommRank_, &fileComm); 
     315      if (allZoneEmpty) xios::MPI_Comm_free(&fileComm); 
    316316    } 
    317317    CATCH_DUMP_ATTR 
    … …  
    725725        isOpen = false; 
    726726       } 
    727       if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     727      if (fileComm != MPI_COMM_NULL) xios::MPI_Comm_free(&fileComm); 
    728728   } 
    729729   CATCH_DUMP_ATTR 

  • XIOS3/trunk/src/policy.cpp

    r1639 r2589  
    4444//   int color = clientRank % 2; 
    4545//   commLevel_.push_back(MPI_Comm()); 
    46 //   MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back())); 
     46//   xios::MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back())); 
    4747//   divideMPICommLevel(commLevel_.back(), level); 
    4848//  } 
    … …  
    160160//   int color = clientRank % 2; 
    161161//   commLevel_.push_back(MPI_Comm()); 
    162 //   MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back())); 
     162//   xios::MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back())); 
    163163//   divideMPICommLevel(commLevel_.back(), level); 
    164164//  } 

  • XIOS3/trunk/src/registry.cpp

    r2586 r2589  
    265265    if (rank==0) color=1 ; 
    266266    MPI_Comm newComm ; 
    267     MPI_Comm_split(communicator,color,rank,&newComm) ; 
     267    xios::MPI_Comm_split(communicator,color,rank,&newComm) ; 
    268268    if (color==1) hierarchicalGatherRegistry(newComm) ; 
    269     MPI_Comm_free(&newComm) ;     
     269    xios::MPI_Comm_free(&newComm) ;     
    270270  } 
    271271 
    … …  
    282282      else color=1 ; 
    283283      MPI_Comm commUp ; 
    284       MPI_Comm_split(comm,color,mpiRank,&commUp) , 
     284      xios::MPI_Comm_split(comm,color,mpiRank,&commUp) , 
    285285      hierarchicalGatherRegistry(commUp) ; 
    286       MPI_Comm_free(&commUp) ; 
     286      xios::MPI_Comm_free(&commUp) ; 
    287287    } 
    288288 
    … …  
    294294      if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ; 
    295295      else color=1 ; 
    296       MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
     296      xios::MPI_Comm_split(comm,color,mpiRank,&commDown) ; 
    297297      if (color==0) gatherRegistry(commDown) ; 
    298       MPI_Comm_free(&commDown) ;     
     298      xios::MPI_Comm_free(&commDown) ;     
    299299    } 
    300300  } 

  • XIOS3/trunk/src/server.cpp

    r2580 r2589  
    101101        delete[] hashAll ; 
    102102 
    103         MPI_Comm_split(globalComm, color, commRank, &serverComm) ; 
     103        xios::MPI_Comm_split(globalComm, color, commRank, &serverComm) ; 
    104104        CXios::getMpiGarbageCollector().registerCommunicator(serverComm) ; 
    105105 
    … …  
    119119        driver_->getComponentCommunicator( serverComm ); 
    120120      } 
    121       MPI_Comm_dup(serverComm, &intraComm_); 
     121      xios::MPI_Comm_dup(serverComm, &intraComm_); 
    122122      CXios::getMpiGarbageCollector().registerCommunicator(intraComm_) ; 
    123123       
    … …  
    142142        MPI_Comm splitComm,interComm ; 
    143143        MPI_Comm_rank(globalComm,&commGlobalRank) ; 
    144         MPI_Comm_split(globalComm, 1, commGlobalRank, &splitComm) ; 
     144        xios::MPI_Comm_split(globalComm, 1, commGlobalRank, &splitComm) ; 
    145145        MPI_Comm_rank(splitComm,&commRank) ; 
    146146        if (commRank==0) serverLeader=commGlobalRank ; 
    … …  
    149149        MPI_Allreduce(&clientLeader,&clientRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
    150150        MPI_Allreduce(&serverLeader,&serverRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
    151         MPI_Intercomm_create(splitComm, 0, globalComm, clientRemoteLeader,1341,&interComm) ; 
    152         MPI_Intercomm_merge(interComm,false,&xiosGlobalComm) ; 
     151        xios::MPI_Intercomm_create(splitComm, 0, globalComm, clientRemoteLeader,1341,&interComm) ; 
     152        xios::MPI_Intercomm_merge(interComm,false,&xiosGlobalComm) ; 
    153153        CXios::setXiosComm(xiosGlobalComm) ; 
    154154      } 
    … …  
    167167      int commRank ; 
    168168      MPI_Comm_rank(CXios::getXiosComm(), &commRank) ; 
    169       MPI_Comm_split(CXios::getXiosComm(),true,commRank,&serversComm_) ; 
     169      xios::MPI_Comm_split(CXios::getXiosComm(),true,commRank,&serversComm_) ; 
    170170      CXios::getMpiGarbageCollector().registerCommunicator(serversComm_) ; 
    171171       
    … …  
    442442 
    443443      MPI_Comm intraComm ; 
    444       MPI_Comm_dup(serverComm,&intraComm) ; 
     444      xios::MPI_Comm_dup(serverComm,&intraComm) ; 
    445445      MPI_Comm interComm ; 
    446446      for(int i=0 ; i<clientsRank.size(); i++) 
    447447      {   
    448         MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm); 
     448        xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm); 
    449449        CXios::getMpiGarbageCollector().registerCommunicator(interComm) ; 
    450450        interCommLeft.push_back(interComm) ; 
    451         MPI_Comm_free(&intraComm) ; 
    452         MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
     451        xios::MPI_Comm_free(&intraComm) ; 
     452        xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
    453453      } 
    454454      xiosGlobalComm=intraComm ;   
    … …  
    485485        {   
    486486          MPI_Comm_accept(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
    487           MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
     487          xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
    488488        } 
    489489*/       
    … …  
    590590 
    591591      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    592         MPI_Comm_free(&(*it)); 
     592        xios::MPI_Comm_free(&(*it)); 
    593593 
    594594      for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++) 
    595         MPI_Comm_free(&(*it)); 
     595        xios::MPI_Comm_free(&(*it)); 
    596596 
    597597        for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++) 
    598           MPI_Comm_free(&(*it)); 
    599  
    600 //      MPI_Comm_free(&intraComm); 
     598          xios::MPI_Comm_free(&(*it)); 
     599 
     600//      xios::MPI_Comm_free(&intraComm); 
    601601      CXios::finalizeDaemonsManager(); 
    602602      finalizeServersRessource(); 
    … …  
    606606      CXios::getMpiGarbageCollector().release() ; // release unfree MPI ressources 
    607607      MPI_Comm xiosComm=CXios::getXiosComm() ; 
    608       MPI_Comm_free(&xiosComm) ; 
     608      xios::MPI_Comm_free(&xiosComm) ; 
    609609      CMemChecker::logMem( "CServer::finalize", true ); 
    610610       

  • XIOS3/trunk/src/transformation/domain_algorithm/domain_algorithm_interpolate.cpp

    r2313 r2589  
    447447   
    448448  MPI_Comm poleComme(MPI_COMM_NULL); 
    449   MPI_Comm_split(context->intraComm_, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme); 
     449  xios::MPI_Comm_split(context->intraComm_, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme); 
    450450  if (MPI_COMM_NULL != poleComme) 
    451451  { 

  • XIOS3/trunk/src/transport/legacy_context_client.cpp

    r2547 r2589  
    3131    { 
    3232      pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test) 
    33       MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
    34       MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
     33      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
     34      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
    3535      eventScheduler_ = parent->getEventScheduler() ;   
    3636      timeLine = 1; 
    … …  
    219219          MPI_Comm interComm ; 
    220220          int tag = 0 ; 
    221           MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ; 
    222           MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ; 
    223           MPI_Comm_free(&interComm) ; 
     221          xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ; 
     222          xios::MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ; 
     223          xios::MPI_Comm_free(&interComm) ; 
    224224                 
    225225          buffer->attachWindows(winComm_[rank]) ; 
    … …  
    242242            MPI_Comm interComm ; 
    243243            int tag = 0 ; 
    244             MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ; 
    245             MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ; 
    246             MPI_Comm_free(&interComm) ; 
     244            xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ; 
     245            xios::MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ; 
     246            xios::MPI_Comm_free(&interComm) ; 
    247247               
    248248            buffer->attachWindows(winComm_[rank]) ; 

  • XIOS3/trunk/src/transport/legacy_context_server.cpp

    r2558 r2589  
    3636  { 
    3737  
    38     MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
     38    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
    3939  
    4040 
    … …  
    4343    finished=false; 
    4444 
    45     MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
    46     MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
     45    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
     46    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
    4747     
    4848    itLastTimeLine=lastTimeLine.begin() ; 
    … …  
    122122      MPI_Comm interComm ; 
    123123      int tag = 0 ; 
    124       MPI_Intercomm_create(commSelf_, 0, interCommMerged_, rank, tag , &interComm) ; 
    125       MPI_Intercomm_merge(interComm, true, &winComm_[rank]) ; 
    126       MPI_Comm_free(&interComm) ; 
     124      xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, rank, tag , &interComm) ; 
     125      xios::MPI_Intercomm_merge(interComm, true, &winComm_[rank]) ; 
     126      xios::MPI_Comm_free(&interComm) ; 
    127127      windows_[rank].resize(2) ; 
    128128      //MPI_Win_create_dynamic(MPI_INFO_NULL, winComm_[rank], &windows_[rank][0]); 

  • XIOS3/trunk/src/transport/one_sided_client_buffer.cpp

    r2587 r2589  
    2222    CTimer::get("create Windows").resume() ; 
    2323    MPI_Comm interComm ; 
    24     MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ; 
    25     MPI_Intercomm_merge(interComm, false, &winComm_) ; 
     24    xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ; 
     25    xios::MPI_Intercomm_merge(interComm, false, &winComm_) ; 
    2626    int rank ; 
    2727    MPI_Comm_rank(winComm_,&rank) ; 
    2828    info(logProtocol)<<"Windows rank="<<rank<<endl ; 
    2929    CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ; 
    30     MPI_Comm_free(&interComm) ; 
     30    xios::MPI_Comm_free(&interComm) ; 
    3131     
    3232    maxWindows_=MAX_WINDOWS ;     

  • XIOS3/trunk/src/transport/one_sided_context_client.cpp

    r2585 r2589  
    3131      pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test) 
    3232 
    33       MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
    34        
    35       MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
     33      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
     34       
     35      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
    3636      eventScheduler_ = parent->getEventScheduler() ;   
    3737      timeLine = 1; 

  • XIOS3/trunk/src/transport/one_sided_context_server.cpp

    r2566 r2589  
    3636  { 
    3737    
    38     MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
     38    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
    3939  
    4040    currentTimeLine=1; 
    … …  
    4242    finished=false; 
    4343 
    44     MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
    45     MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
     44    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
     45    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
    4646     
    4747    itLastTimeLine=lastTimeLine.begin() ; 
    … …  
    237237    //    MPI_Win_free(&windows_[rank][0]); 
    238238    //    MPI_Win_free(&windows_[rank][1]); 
    239     //    MPI_Comm_free(&winComm_[rank]) ; 
     239    //    xios::MPI_Comm_free(&winComm_[rank]) ; 
    240240    //  } 
    241241  } 

  • XIOS3/trunk/src/transport/one_sided_server_buffer.cpp

    r2565 r2589  
    2525    CTimer::get("create Windows").resume() ; 
    2626    MPI_Comm interComm ; 
    27     MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ; 
    28     MPI_Intercomm_merge(interComm, true, &winComm_) ; 
     27    xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ; 
     28    xios::MPI_Intercomm_merge(interComm, true, &winComm_) ; 
    2929    CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ; 
    30     MPI_Comm_free(&interComm) ; 
     30    xios::MPI_Comm_free(&interComm) ; 
    3131     
    3232    maxWindows_=MAX_WINDOWS ; 

  • XIOS3/trunk/src/transport/p2p_client_buffer.cpp

    r2587 r2589  
    2424    CTimer::get("create Windows").resume() ; 
    2525    //MPI_Comm interComm ; 
    26     //MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ; 
    27     //MPI_Intercomm_merge(interComm, false, &winComm_) ; 
     26    //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ; 
     27    //xios::MPI_Intercomm_merge(interComm, false, &winComm_) ; 
    2828    //int rank ; 
    2929    //MPI_Comm_rank(winComm_,&rank) ; 
    3030    //info(logProtocol)<<"Windows rank="<<rank<<endl ; 
    3131    //CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ; 
    32     //MPI_Comm_free(&interComm) ; 
     32    //xios::MPI_Comm_free(&interComm) ; 
    3333     
    3434    maxWindows_=MAX_WINDOWS ;     

  • XIOS3/trunk/src/transport/p2p_context_client.cpp

    r2585 r2589  
    3131      pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test) 
    3232 
    33       MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
     33      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ; 
    3434      CXios::getMpiGarbageCollector().registerCommunicator(interCommMerged_) ; 
    3535       
    36       MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
     36      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows 
    3737      CXios::getMpiGarbageCollector().registerCommunicator(commSelf_) ; 
    3838      eventScheduler_ = parent->getEventScheduler() ;   

  • XIOS3/trunk/src/transport/p2p_context_server.cpp

    r2580 r2589  
    3636  { 
    3737    
    38     MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
     38    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ; 
    3939    CXios::getMpiGarbageCollector().registerCommunicator(processEventBarrier_) ; 
    4040     
    … …  
    4343    finished=false; 
    4444 
    45     MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
     45    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ; 
    4646    CXios::getMpiGarbageCollector().registerCommunicator(interCommMerged_) ; 
    47     MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
     47    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows 
    4848    CXios::getMpiGarbageCollector().registerCommunicator(commSelf_) ; 
    4949     
    … …  
    244244    //    MPI_Win_free(&windows_[rank][0]); 
    245245    //    MPI_Win_free(&windows_[rank][1]); 
    246     //    MPI_Comm_free(&winComm_[rank]) ; 
     246    //    xios::MPI_Comm_free(&winComm_[rank]) ; 
    247247    //  } 
    248248  } 

  • XIOS3/trunk/src/transport/p2p_server_buffer.cpp

    r2564 r2589  
    2525    CTimer::get("create Windows").resume() ; 
    2626    //MPI_Comm interComm ; 
    27     //MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ; 
    28     //MPI_Intercomm_merge(interComm, true, &winComm_) ; 
     27    //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ; 
     28    //xios::MPI_Intercomm_merge(interComm, true, &winComm_) ; 
    2929    //CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ; 
    30     //MPI_Comm_free(&interComm) ; 
     30    //xios::MPI_Comm_free(&interComm) ; 
    3131     
    3232    //maxWindows_=MAX_WINDOWS ; 
Note: See TracChangeset for help on using the changeset viewer.