Ignore:
Timestamp:
05/15/19 17:19:08 (5 years ago)
Author:
yushan
Message:

MARK: branch merged with trunk @1660. Test (test_complete, test_remap) on ADA with IntelMPI and _usingEP/_usingMPI as switch.

Location:
XIOS/dev/dev_trunk_omp/src/node
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_trunk_omp/src/node/axis.cpp

    r1646 r1661  
    149149     \return the number of indexes written by each server 
    150150   */ 
    151    int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     151   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom) 
    152152   TRY 
    153153   { 
    154154     int writtenSize; 
    155      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     155     MPI_Comm_size(writtenCom, &writtenSize); 
    156156     return numberWrittenIndexes_[writtenSize]; 
    157157   } 
    … …  
    162162     \return the total number of indexes written by the servers 
    163163   */ 
    164    int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     164   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
    165165   TRY 
    166166   { 
    167167     int writtenSize; 
    168      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     168     MPI_Comm_size(writtenCom, &writtenSize); 
    169169     return totalNumberWrittenIndexes_[writtenSize]; 
    170170   } 
    … …  
    175175     \return the offset of indexes written by each server 
    176176   */ 
    177    int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     177   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
    178178   TRY 
    179179   { 
    180180     int writtenSize; 
    181      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     181     MPI_Comm_size(writtenCom, &writtenSize); 
    182182     return offsetWrittenIndexes_[writtenSize]; 
    183183   } 
    184184   CATCH_DUMP_ATTR 
    185185 
    186    CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
     186   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
    187187   TRY 
    188188   { 
    189189     int writtenSize; 
    190      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     190     MPI_Comm_size(writtenCom, &writtenSize); 
    191191     return compressedIndexToWriteOnServer[writtenSize]; 
    192192   } 
    … …  
    787787  CATCH_DUMP_ATTR 
    788788 
    789   void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
     789  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
    790790  TRY 
    791791  { 
    792792    int writtenCommSize; 
    793     ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
     793    MPI_Comm_size(writtenComm, &writtenCommSize); 
    794794    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    795795      return; 
    … …  
    869869      { 
    870870              
    871         ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    872         ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     871        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     872        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    873873        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    874874      } 

  • XIOS/dev/dev_trunk_omp/src/node/axis.hpp

    r1646 r1661  
    182182         static std::map<StdString, ETranformationType> *transformationMapList_ptr; 
    183183         #pragma omp threadprivate(transformationMapList_ptr) 
    184          //static bool dummyTransformationMapList_; 
    185184 
    186185         DECLARE_REF_FUNC(Axis,axis) 

  • XIOS/dev/dev_trunk_omp/src/node/context.cpp

    r1646 r1661  
    287287       else 
    288288       { 
    289          ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
     289         MPI_Comm_dup(intraComm, &intraCommServer); 
    290290         comms.push_back(intraCommServer); 
    291          ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
     291         MPI_Comm_dup(interComm, &interCommServer); 
    292292         comms.push_back(interCommServer); 
    293293       } 
    … …  
    312312     { 
    313313       clientPrimServer.push_back(new CContextClient(this, intraComm, interComm)); 
    314        ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
     314       MPI_Comm_dup(intraComm, &intraCommServer); 
    315315       comms.push_back(intraCommServer); 
    316        ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
     316       MPI_Comm_dup(interComm, &interCommServer); 
    317317       comms.push_back(interCommServer); 
    318318       serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer)); 
    … …  
    413413     else 
    414414     { 
    415        ep_lib::MPI_Comm_dup(intraComm, &intraCommClient); 
     415       MPI_Comm_dup(intraComm, &intraCommClient); 
    416416       comms.push_back(intraCommClient); 
    417        ep_lib::MPI_Comm_dup(interComm, &interCommClient); 
     417       MPI_Comm_dup(interComm, &interCommClient); 
    418418       comms.push_back(interCommClient); 
    419419     } 
    … …  
    506506         //! Free internally allocated communicators 
    507507         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    508            ep_lib::MPI_Comm_free(&(*it)); 
     508           MPI_Comm_free(&(*it)); 
    509509         comms.clear(); 
    510510 
    … …  
    554554         //! Free internally allocated communicators 
    555555         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    556            ep_lib::MPI_Comm_free(&(*it)); 
     556           MPI_Comm_free(&(*it)); 
    557557         comms.clear(); 
    558558 
    … …  
    573573   { 
    574574     for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    575        ep_lib::MPI_Comm_free(&(*it)); 
     575       MPI_Comm_free(&(*it)); 
    576576     comms.clear(); 
    577577   } 

  • XIOS/dev/dev_trunk_omp/src/node/context.hpp

    r1646 r1661  
    145145         void distributeFileOverMemoryBandwith() ; 
    146146          
    147  
    148147         // Send context close definition 
    149148         void sendCloseDefinition(void); 

  • XIOS/dev/dev_trunk_omp/src/node/domain.cpp

    r1646 r1661  
    116116     \return the number of indexes written by each server 
    117117   */ 
    118    int CDomain::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     118   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
    119119   TRY 
    120120   { 
    121121     int writtenSize; 
    122      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     122     MPI_Comm_size(writtenCom, &writtenSize); 
    123123     return numberWrittenIndexes_[writtenSize]; 
    124124   } 
    … …  
    129129     \return the total number of indexes written by the servers 
    130130   */ 
    131    int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     131   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
    132132   TRY 
    133133   { 
    134134     int writtenSize; 
    135      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     135     MPI_Comm_size(writtenCom, &writtenSize); 
    136136     return totalNumberWrittenIndexes_[writtenSize]; 
    137137   } 
    … …  
    142142     \return the offset of indexes written by each server 
    143143   */ 
    144    int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom) 
     144   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
    145145   TRY 
    146146   { 
    147147     int writtenSize; 
    148      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     148     MPI_Comm_size(writtenCom, &writtenSize); 
    149149     return offsetWrittenIndexes_[writtenSize]; 
    150150   } 
    151151   CATCH_DUMP_ATTR 
    152152 
    153    CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom) 
     153   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
    154154   TRY 
    155155   { 
    156156     int writtenSize; 
    157      ep_lib::MPI_Comm_size(writtenCom, &writtenSize); 
     157     MPI_Comm_size(writtenCom, &writtenSize); 
    158158     return compressedIndexToWriteOnServer[writtenSize]; 
    159159   } 
    … …  
    707707     int v ; 
    708708     v=ibegin ; 
    709      ep_lib::MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
     709     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
    710710     v=jbegin ; 
    711      ep_lib::MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
     711     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
    712712     v=ni ; 
    713      ep_lib::MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
     713     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
    714714     v=nj ; 
    715      ep_lib::MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
    716  
    717      ep_lib::MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
    718      ep_lib::MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
     715     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
     716 
     717     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
     718     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
    719719 
    720720      delete[] ibegin_g ; 
    … …  
    19491949          displs[0] = 0; 
    19501950          int localCount = connectedServerRank_[nbServer].size() ; 
    1951           ep_lib::MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
     1951          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
    19521952          for (int i = 0; i < clientSize-1; ++i) 
    19531953          { 
    … …  
    19551955          } 
    19561956          std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]); 
    1957  
    1958           ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    1959  
     1957          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    19601958 
    19611959          if ((allConnectedServers.size() != nbServer) && (rank == 0)) 
    … …  
    20222020   CATCH_DUMP_ATTR 
    20232021 
    2024   void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm) 
     2022  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
    20252023  TRY 
    20262024  { 
    20272025    int writtenCommSize; 
    2028     ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize); 
     2026    MPI_Comm_size(writtenComm, &writtenCommSize); 
    20292027    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
    20302028      return; 
    … …  
    20832081      { 
    20842082              
    2085         ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    2086         ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2083        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2084        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
    20872085        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    20882086      } 

  • XIOS/dev/dev_trunk_omp/src/node/file.cpp

    r1646 r1661  
    307307 
    308308      int color = allZoneEmpty ? 0 : 1; 
    309       ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
    310       if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm); 
     309      MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
     310      if (allZoneEmpty) MPI_Comm_free(&fileComm); 
    311311    } 
    312312    CATCH_DUMP_ATTR 
    … …  
    557557         { 
    558558            int commSize, commRank; 
    559             ep_lib::MPI_Comm_size(fileComm, &commSize); 
    560             ep_lib::MPI_Comm_rank(fileComm, &commRank); 
     559            MPI_Comm_size(fileComm, &commSize); 
     560            MPI_Comm_rank(fileComm, &commRank); 
    561561 
    562562            if (server->intraCommSize > 1) 
    … …  
    683683      { 
    684684        int commSize, commRank; 
    685         ep_lib::MPI_Comm_size(readComm, &commSize); 
    686         ep_lib::MPI_Comm_rank(readComm, &commRank); 
     685        MPI_Comm_size(readComm, &commSize); 
     686        MPI_Comm_rank(readComm, &commRank); 
    687687 
    688688        if (server->intraCommSize > 1) 
    … …  
    728728        isOpen = false; 
    729729       } 
    730       //if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     730     #ifdef _usingMPI  
     731     if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     732     #endif 
    731733   } 
    732734   CATCH_DUMP_ATTR 

  • XIOS/dev/dev_trunk_omp/src/node/grid.cpp

    r1646 r1661  
    697697     CContext* context = CContext::getCurrent(); 
    698698 
    699      CContextClient* client = context->client;  // Here it's not important which contextClient to recuperate 
     699     CContextClient* client = context->client; 
    700700     int rank = client->clientRank; 
    701701 
    … …  
    856856         displs[0] = 0; 
    857857         int localCount = connectedServerRank_[receiverSize].size() ; 
    858          ep_lib::MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
    859           
     858         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ; 
    860859         for (int i = 0; i < client->clientSize-1; ++i) 
    861860         { 
    … …  
    863862         } 
    864863         std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]); 
    865  
    866          ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    867  
     864         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm); 
    868865 
    869866         if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0)) 
Note: See TracChangeset for help on using the changeset viewer.