Changeset 1638 for XIOS/trunk/src/node

Timestamp:

01/22/19 16:15:03 (6 years ago)

Author:

yushan

Message:

dev on ADA

Location:

XIOS/trunk/src/node

Files:

• axis.cpp (modified) (5 diffs)
• axis.hpp (modified) (2 diffs)
• context.cpp (modified) (9 diffs)
• context.hpp (modified) (2 diffs)
• domain.cpp (modified) (8 diffs)
• domain.hpp (modified) (2 diffs)
• field.cpp (modified) (1 diff)
• file.cpp (modified) (7 diffs)
• file.hpp (modified) (1 diff)
• grid.cpp (modified) (3 diffs)
• mesh.cpp (modified) (14 diffs)
• mesh.hpp (modified) (2 diffs)

XIOS/trunk/src/node/axis.cpp

@@ -130 +130 @@
      \return the number of indexes written by each server
    */
-   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom)
+   int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return numberWrittenIndexes_[writtenSize];
    }
@@ -143 +143 @@
      \return the total number of indexes written by the servers
    */
-   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
+   int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return totalNumberWrittenIndexes_[writtenSize];
    }
@@ -156 +156 @@
      \return the offset of indexes written by each server
    */
-   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom)
+   int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return offsetWrittenIndexes_[writtenSize];
    }
    CATCH_DUMP_ATTR
 
-   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
+   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return compressedIndexToWriteOnServer[writtenSize];
    }
@@ -768 +768 @@
   CATCH_DUMP_ATTR
 
-  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
+  void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
   TRY
   {
     int writtenCommSize;
-    MPI_Comm_size(writtenComm, &writtenCommSize);
+    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
     if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
       return;
@@ -850 +850 @@
       {
              
-        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
-        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
+        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
         offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
       }

XIOS/trunk/src/node/axis.hpp

@@ -68 +68 @@
          const std::set<StdString> & getRelFiles(void) const;
 
-         int getNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
-         CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
+         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         CArray<int, 1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom);
 
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
@@ -113 +113 @@
 
          void computeWrittenIndex();
-         void computeWrittenCompressedIndex(MPI_Comm);
+         void computeWrittenCompressedIndex(ep_lib::MPI_Comm);
          bool hasTransformation();
          void solveInheritanceTransformation();

XIOS/trunk/src/node/context.cpp

@@ -265 +265 @@
 
    //! Initialize client side
-   void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/)
+   void CContext::initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer /*= 0*/)
    TRY
    {
 
      hasClient = true;
-     MPI_Comm intraCommServer, interCommServer;
+     ep_lib::MPI_Comm intraCommServer, interCommServer;
      
 
@@ -284 +284 @@
        else
        {
-         MPI_Comm_dup(intraComm, &intraCommServer);
+         ep_lib::MPI_Comm_dup(intraComm, &intraCommServer);
          comms.push_back(intraCommServer);
-         MPI_Comm_dup(interComm, &interCommServer);
+         ep_lib::MPI_Comm_dup(interComm, &interCommServer);
          comms.push_back(interCommServer);
        }
@@ -309 +309 @@
      {
        clientPrimServer.push_back(new CContextClient(this, intraComm, interComm));
-       MPI_Comm_dup(intraComm, &intraCommServer);
+       ep_lib::MPI_Comm_dup(intraComm, &intraCommServer);
        comms.push_back(intraCommServer);
-       MPI_Comm_dup(interComm, &interCommServer);
+       ep_lib::MPI_Comm_dup(interComm, &interCommServer);
        comms.push_back(interCommServer);
        serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer));
@@ -383 +383 @@
    CATCH_DUMP_ATTR
 
-   void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/)
+   void CContext::initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient /*= 0*/)
    TRY
    {
@@ -402 +402 @@
      registryOut->setPath(contextRegistryId) ;
 
-     MPI_Comm intraCommClient, interCommClient;
+     ep_lib::MPI_Comm intraCommClient, interCommClient;
      if (cxtClient) // Attached mode
      {
@@ -410 +410 @@
      else
      {
-       MPI_Comm_dup(intraComm, &intraCommClient);
+       ep_lib::MPI_Comm_dup(intraComm, &intraCommClient);
        comms.push_back(intraCommClient);
-       MPI_Comm_dup(interComm, &interCommClient);
+       ep_lib::MPI_Comm_dup(interComm, &interCommClient);
        comms.push_back(interCommClient);
      }
@@ -502 +502 @@
 
          //! Free internally allocated communicators
-         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-           MPI_Comm_free(&(*it));
+         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           ep_lib::MPI_Comm_free(&(*it));
          comms.clear();
 
@@ -544 +544 @@
 
          //! Free internally allocated communicators
-         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-           MPI_Comm_free(&(*it));
+         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           ep_lib::MPI_Comm_free(&(*it));
          comms.clear();
 
@@ -560 +560 @@
    TRY
    {
-     for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-       MPI_Comm_free(&(*it));
+     for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+       ep_lib::MPI_Comm_free(&(*it));
      comms.clear();
    }

XIOS/trunk/src/node/context.hpp

@@ -88 +88 @@
       public :
          // Initialize server or client
-         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
-         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
+         void initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer = 0);
+         void initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient = 0);
          bool isInitialized(void);
 
@@ -263 +263 @@
          StdString idServer_;
          CGarbageCollector garbageCollector;
-         std::list<MPI_Comm> comms; //!< Communicators allocated internally
+         std::list<ep_lib::MPI_Comm> comms; //!< Communicators allocated internally
 
       public: // Some function maybe removed in the near future

XIOS/trunk/src/node/domain.cpp

@@ -99 +99 @@
      \return the number of indexes written by each server
    */
-   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom)
+   int CDomain::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return numberWrittenIndexes_[writtenSize];
    }
@@ -112 +112 @@
      \return the total number of indexes written by the servers
    */
-   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
+   int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return totalNumberWrittenIndexes_[writtenSize];
    }
@@ -125 +125 @@
      \return the offset of indexes written by each server
    */
-   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom)
+   int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return offsetWrittenIndexes_[writtenSize];
    }
    CATCH_DUMP_ATTR
 
-   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
+   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     MPI_Comm_size(writtenCom, &writtenSize);
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
      return compressedIndexToWriteOnServer[writtenSize];
    }
@@ -690 +690 @@
      int v ;
      v=ibegin ;
-     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ;
+     ep_lib::MPI_Allgather(&v,1,EP_INT,ibegin_g,1,EP_INT,client->intraComm) ;
      v=jbegin ;
-     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ;
+     ep_lib::MPI_Allgather(&v,1,EP_INT,jbegin_g,1,EP_INT,client->intraComm) ;
      v=ni ;
-     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ;
+     ep_lib::MPI_Allgather(&v,1,EP_INT,ni_g,1,EP_INT,client->intraComm) ;
      v=nj ;
-     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ;
-
-     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ;
-     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ;
+     ep_lib::MPI_Allgather(&v,1,EP_INT,nj_g,1,EP_INT,client->intraComm) ;
+
+     ep_lib::MPI_Allgatherv(lon.dataFirst(),ni,EP_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,EP_DOUBLE,client->intraComm) ;
+     ep_lib::MPI_Allgatherv(lat.dataFirst(),nj,EP_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,EP_DOUBLE,client->intraComm) ;
 
       delete[] ibegin_g ;
@@ -1932 +1932 @@
           displs[0] = 0;
           int localCount = connectedServerRank_[nbServer].size() ;
-          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
+          ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
           for (int i = 0; i < clientSize-1; ++i)
           {
@@ -1938 +1938 @@
           }
           std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]);
-          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
+          ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
 
           if ((allConnectedServers.size() != nbServer) && (rank == 0))
@@ -2003 +2003 @@
    CATCH_DUMP_ATTR
 
-  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
+  void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
   TRY
   {
     int writtenCommSize;
-    MPI_Comm_size(writtenComm, &writtenCommSize);
+    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
     if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
       return;
@@ -2064 +2064 @@
       {
              
-        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
-        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
+        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
         offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
       }

XIOS/trunk/src/node/domain.hpp

@@ -94 +94 @@
          bool isWrittenCompressed(const StdString& filename) const;
          
-         int getNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
-         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
+         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom);
+         CArray<int,1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom);
 
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
@@ -116 +116 @@
          
          void computeWrittenIndex();
-         void computeWrittenCompressedIndex(MPI_Comm);
+         void computeWrittenCompressedIndex(ep_lib::MPI_Comm);
 
          void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat,

XIOS/trunk/src/node/field.cpp

@@ -531 +531 @@
     if (!nstepMaxRead)
     {
+       #ifdef _usingMPI
        MPI_Allreduce(MPI_IN_PLACE, &nstepMax, 1, MPI_INT, MPI_MAX, context->server->intraComm);
+       #elif _usingEP
+       ep_lib::MPI_Allreduce(&nstepMax, &nstepMax, 1, EP_INT, EP_MAX, context->server->intraComm);
+       #endif
        nstepMaxRead = true;
     }

XIOS/trunk/src/node/file.cpp

@@ -25 +25 @@
    CFile::CFile(void)
       : CObjectTemplate<CFile>(), CFileAttributes()
-      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL)
       , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
    {
@@ -34 +34 @@
    CFile::CFile(const StdString & id)
       : CObjectTemplate<CFile>(id), CFileAttributes()
-      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL)
       , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
     {
@@ -307 +307 @@
 
       int color = allZoneEmpty ? 0 : 1;
-      MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
-      if (allZoneEmpty) MPI_Comm_free(&fileComm);
+      ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
+      if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm);
     }
     CATCH_DUMP_ATTR
@@ -554 +554 @@
          {
             int commSize, commRank;
-            MPI_Comm_size(fileComm, &commSize);
-            MPI_Comm_rank(fileComm, &commRank);
+            ep_lib::MPI_Comm_size(fileComm, &commSize);
+            ep_lib::MPI_Comm_rank(fileComm, &commRank);
 
             if (server->intraCommSize > 1)
@@ -634 +634 @@
     CContext* context = CContext::getCurrent();
     CContextServer* server = context->server;
-    MPI_Comm readComm = this->fileComm;
+    ep_lib::MPI_Comm readComm = this->fileComm;
 
     if (!allZoneEmpty)
@@ -677 +677 @@
       {
         int commSize, commRank;
-        MPI_Comm_size(readComm, &commSize);
-        MPI_Comm_rank(readComm, &commRank);
+        ep_lib::MPI_Comm_size(readComm, &commSize);
+        ep_lib::MPI_Comm_rank(readComm, &commRank);
 
         if (server->intraCommSize > 1)
@@ -722 +722 @@
         isOpen = false;
        }
-      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm);
+      if (fileComm != EP_COMM_NULL) ep_lib::MPI_Comm_free(&fileComm);
    }
    CATCH_DUMP_ATTR

XIOS/trunk/src/node/file.hpp

@@ -175 +175 @@
          int nbAxis, nbDomains;
          bool isOpen;         
-         MPI_Comm fileComm;
+         ep_lib::MPI_Comm fileComm;
 
       private:

XIOS/trunk/src/node/grid.cpp

@@ -661 +661 @@
         {
           CContextServer* server = CContext::getCurrent()->server;      
-          MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
-          MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+          ep_lib::MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
+          ep_lib::MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
           offsetWrittenIndexes_ -= numberWrittenIndexes_;
         }
@@ -856 +856 @@
          displs[0] = 0;
          int localCount = connectedServerRank_[receiverSize].size() ;
-         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
+         ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
          for (int i = 0; i < client->clientSize-1; ++i)
          {
@@ -862 +862 @@
          }
          std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]);
-         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
+         ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
 
          if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0))

XIOS/trunk/src/node/mesh.cpp

@@ -414 +414 @@
  * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type.
  */
-  void CMesh::createMeshEpsilon(const MPI_Comm& comm,
+  void CMesh::createMeshEpsilon(const ep_lib::MPI_Comm& comm,
                                 const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue,
                                 const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat)
@@ -421 +421 @@
     int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows();
     int mpiRank, mpiSize;
-    MPI_Comm_rank(comm, &mpiRank);
-    MPI_Comm_size(comm, &mpiSize);
+    ep_lib::MPI_Comm_rank(comm, &mpiRank);
+    ep_lib::MPI_Comm_size(comm, &mpiSize);
     double prec = 1e-11;  // used in calculations of edge_lon/lat
 
@@ -460 +460 @@
       unsigned long nbEdgesOnProc = nbEdges_;
       unsigned long nbEdgesAccum;
-      MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+      ep_lib::MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
       nbEdgesAccum -= nbEdges_;
 
@@ -590 +590 @@
          unsigned long nodeCount = nodeIdx2Idx.size();
          unsigned long nodeStart, nbNodes;
-         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+         ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
          int nNodes = nodeStart;
-         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+         ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
          nbNodesGlo = nNodes;
 
@@ -683 +683 @@
       unsigned long nbFacesOnProc = nbFaces_;
       unsigned long nbFacesAccum;
-      MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+      ep_lib::MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
       nbFacesAccum -= nbFaces_;
 
@@ -807 +807 @@
 
         unsigned long edgeStart, nbEdges;
-        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
         int nEdges = edgeStart;
-        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1028 +1028 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
         int nEdges = edgeStart;
-        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1298 +1298 @@
         unsigned long nodeCount = nodeIdx2Idx.size();
         unsigned long nodeStart, nbNodes;
-        MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
         int nNodes = nodeStart;
-        MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
         nbNodesGlo = nNodes;
 
@@ -1418 +1418 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
         int nEdges = edgeStart;
-        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1614 +1614 @@
    */
 
-  void CMesh::getGloNghbFacesNodeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,
                                CArray<int, 2>& nghbFaces)
@@ -1623 +1623 @@
 
     int mpiRank, mpiSize;
-    MPI_Comm_rank(comm, &mpiRank);
-    MPI_Comm_size(comm, &mpiSize);
+    ep_lib::MPI_Comm_rank(comm, &mpiRank);
+    ep_lib::MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1770 +1770 @@
    */
 
-  void CMesh::getGloNghbFacesEdgeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,
                                CArray<int, 2>& nghbFaces)
@@ -1779 +1779 @@
 
     int mpiRank, mpiSize;
-    MPI_Comm_rank(comm, &mpiRank);
-    MPI_Comm_size(comm, &mpiSize);
+    ep_lib::MPI_Comm_rank(comm, &mpiRank);
+    ep_lib::MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1951 +1951 @@
    */
 
-  void CMesh::getGlobalNghbFaces(const int nghbType, const MPI_Comm& comm,
+  void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm,
                                  const CArray<int, 1>& face_idx,
                                  const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,

XIOS/trunk/src/node/mesh.hpp

@@ -60 +60 @@
                       const CArray<double, 2>&, const CArray<double, 2>& );
                         
-      void createMeshEpsilon(const MPI_Comm&,
+      void createMeshEpsilon(const ep_lib::MPI_Comm&,
                              const CArray<double, 1>&, const CArray<double, 1>&,
                              const CArray<double, 2>&, const CArray<double, 2>& );
 
-      void getGlobalNghbFaces(const int, const MPI_Comm&, const CArray<int, 1>&,
+      void getGlobalNghbFaces(const int, const ep_lib::MPI_Comm&, const CArray<int, 1>&,
                               const CArray<double, 2>&, const CArray<double, 2>&,
                               CArray<int, 2>&);
@@ -87 +87 @@
       CClientClientDHTSizet* pNodeGlobalIndex;                    // pointer to a map <nodeHash, nodeIdxGlo>
       CClientClientDHTSizet* pEdgeGlobalIndex;                    // pointer to a map <edgeHash, edgeIdxGlo>
-      void getGloNghbFacesNodeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
-      void getGloNghbFacesEdgeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
+      void getGloNghbFacesNodeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
+      void getGloNghbFacesEdgeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
       void getLocNghbFacesNodeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&);
       void getLocNghbFacesEdgeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&);