Changeset 1639 for XIOS/trunk/src/client.cpp

Timestamp:

01/22/19 16:43:32 (5 years ago)

Author:

yushan

Message:

revert erroneous commit on trunk

File:

• XIOS/trunk/src/client.cpp (modified) (20 diffs)

XIOS/trunk/src/client.cpp

@@ -9 +9 @@
 #include "oasis_cinterface.hpp"
 #include "mpi.hpp"
-//#include "mpi_wrapper.hpp"
 #include "timer.hpp"
 #include "buffer_client.hpp"
@@ -17 +16 @@
 {
 
-    ep_lib::MPI_Comm CClient::intraComm ;
-    ep_lib::MPI_Comm CClient::interComm ;
-    std::list<ep_lib::MPI_Comm> CClient::contextInterComms;
+    MPI_Comm CClient::intraComm ;
+    MPI_Comm CClient::interComm ;
+    std::list<MPI_Comm> CClient::contextInterComms;
     int CClient::serverLeader ;
     bool CClient::is_MPI_Initialized ;
@@ -25 +24 @@
     StdOFStream CClient::m_infoStream;
     StdOFStream CClient::m_errorStream;
-    ep_lib::MPI_Comm& CClient::getInterComm(void)   { return (interComm); }
+    MPI_Comm& CClient::getInterComm(void)   { return (interComm); }
      
 ///---------------------------------------------------------------
@@ -36 +35 @@
  */
 
-    void CClient::initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm)
+    void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm)
     {
       int initialized ;
-      ep_lib::MPI_Initialized(&initialized) ;
+      MPI_Initialized(&initialized) ;
       if (initialized) is_MPI_Initialized=true ;
       else is_MPI_Initialized=false ;
@@ -48 +47 @@
       {
 // localComm isn't given
-        if (localComm == EP_COMM_NULL)
+        if (localComm == MPI_COMM_NULL)
         {
           if (!is_MPI_Initialized)
           {
-            ep_lib::MPI_Init(NULL, NULL);
+            MPI_Init(NULL, NULL);
           }
           CTimer::get("XIOS").resume() ;
@@ -64 +63 @@
           int myColor ;
           int i,c ;
-          ep_lib::MPI_Comm newComm ;
-
-          ep_lib::MPI_Comm_size(CXios::globalComm,&size) ;
-
-          ep_lib::MPI_Comm_rank(CXios::globalComm,&rank_);
+          MPI_Comm newComm ;
+
+          MPI_Comm_size(CXios::globalComm,&size) ;
+          MPI_Comm_rank(CXios::globalComm,&rank_);
 
           hashAll=new unsigned long[size] ;
 
-          ep_lib::MPI_Allgather(&hashClient,1,EP_LONG,hashAll,1,EP_LONG,CXios::globalComm) ;
+          MPI_Allgather(&hashClient,1,MPI_LONG,hashAll,1,MPI_LONG,CXios::globalComm) ;
 
           map<unsigned long, int> colors ;
@@ -99 +97 @@
 
           myColor=colors[hashClient];
-          ep_lib::MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ;
+          MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ;
 
           if (CXios::usingServer)
@@ -106 +104 @@
             serverLeader=leaders[hashServer] ;
             int intraCommSize, intraCommRank ;
-            ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ;
-            ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ;
+            MPI_Comm_size(intraComm,&intraCommSize) ;
+            MPI_Comm_rank(intraComm,&intraCommRank) ;
             info(50)<<"intercommCreate::client "<<rank_<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ;
-             ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ;
+             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ;
              //rank_ = intraCommRank;
           }
           else
           {
-            ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
+            MPI_Comm_dup(intraComm,&interComm) ;
           }
           delete [] hashAll ;
@@ -128 +126 @@
           else
           {
-            ep_lib::MPI_Comm_dup(localComm,&intraComm) ;
-            ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
+            MPI_Comm_dup(localComm,&intraComm) ;
+            MPI_Comm_dup(intraComm,&interComm) ;
           }
         }
@@ -137 +135 @@
       {
         // localComm isn't given
-        if (localComm == EP_COMM_NULL)
+        if (localComm == MPI_COMM_NULL)
         {
           if (!is_MPI_Initialized) oasis_init(codeId) ;
           oasis_get_localcomm(localComm) ;
         }
-        ep_lib::MPI_Comm_dup(localComm,&intraComm) ;
+        MPI_Comm_dup(localComm,&intraComm) ;
 
         CTimer::get("XIOS").resume() ;
@@ -149 +147 @@
         if (CXios::usingServer)
         {
-          ep_lib::MPI_Status status ;
-          ep_lib::MPI_Comm_rank(intraComm,&rank_) ;
+          MPI_Status status ;
+          MPI_Comm_rank(intraComm,&rank_) ;
 
           oasis_get_intercomm(interComm,CXios::xiosCodeId) ;
-          if (rank_==0) ep_lib::MPI_Recv(&serverLeader,1, EP_INT, 0, 0, interComm, &status) ;
-          ep_lib::MPI_Bcast(&serverLeader,1,EP_INT,0,intraComm) ;
-        }
-        else ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
-      }
-
-      ep_lib::MPI_Comm_dup(intraComm,&returnComm) ;
+          if (rank_==0) MPI_Recv(&serverLeader,1, MPI_INT, 0, 0, interComm, &status) ;
+          MPI_Bcast(&serverLeader,1,MPI_INT,0,intraComm) ;
+        }
+        else MPI_Comm_dup(intraComm,&interComm) ;
+      }
+
+      MPI_Comm_dup(intraComm,&returnComm) ;
     }
 
@@ -170 +168 @@
  * Function is only called by client.
  */
-    void CClient::registerContext(const string& id, ep_lib::MPI_Comm contextComm)
+    void CClient::registerContext(const string& id, MPI_Comm contextComm)
     {
       CContext::setCurrent(id) ;
@@ -180 +178 @@
       // Attached mode
       {
-        ep_lib::MPI_Comm contextInterComm ;
-        ep_lib::MPI_Comm_dup(contextComm,&contextInterComm) ;
+        MPI_Comm contextInterComm ;
+        MPI_Comm_dup(contextComm,&contextInterComm) ;
         CContext* contextServer = CContext::create(idServer);
 
@@ -200 +198 @@
         size_t message_size ;
         int leaderRank ;
-        ep_lib::MPI_Comm contextInterComm ;
-
-        ep_lib::MPI_Comm_size(contextComm,&size) ;
-        ep_lib::MPI_Comm_rank(contextComm,&rank) ;
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ;
+        MPI_Comm contextInterComm ;
+
+        MPI_Comm_size(contextComm,&size) ;
+        MPI_Comm_rank(contextComm,&rank) ;
+        MPI_Comm_rank(CXios::globalComm,&globalRank) ;
         if (rank!=0) globalRank=0 ;
 
@@ -216 +214 @@
         buffer<<msg ;
 
-        ep_lib::MPI_Send((void*)buff,buffer.count(),EP_CHAR,serverLeader,1,CXios::globalComm) ;
-
-        ep_lib::MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ;
+        MPI_Send((void*)buff,buffer.count(),MPI_CHAR,serverLeader,1,CXios::globalComm) ;
+
+        MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ;
         info(10)<<"Register new Context : "<<id<<endl ;
-        ep_lib::MPI_Comm inter ;
-        ep_lib::MPI_Intercomm_merge(contextInterComm,0,&inter) ;
-        ep_lib::MPI_Barrier(inter) ;
+        MPI_Comm inter ;
+        MPI_Intercomm_merge(contextInterComm,0,&inter) ;
+        MPI_Barrier(inter) ;
 
         context->initClient(contextComm,contextInterComm) ;
 
         contextInterComms.push_back(contextInterComm);
-        ep_lib::MPI_Comm_free(&inter);
+        MPI_Comm_free(&inter);
         delete [] buff ;
 
@@ -253 +251 @@
         int msg=0 ;
 
-        ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+        MPI_Comm_rank(intraComm,&rank) ;
         if (rank==0) 
         {
-          ep_lib::MPI_Send(&msg,1,EP_INT,0,5,interComm) ; // tags oasis_endded = 5
+          MPI_Send(&msg,1,MPI_INT,0,5,interComm) ; // tags oasis_endded = 5
         }
 
@@ -268 +266 @@
       int msg=0 ;
 
-      ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+      MPI_Comm_rank(intraComm,&rank) ;
  
       if (!CXios::isServer)
       {
-        ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+        MPI_Comm_rank(intraComm,&rank) ;
         if (rank==0)
         {
-          ep_lib::MPI_Send(&msg,1,EP_INT,0,0,interComm) ;
-        }
-      }
-
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
-      ep_lib::MPI_Comm_free(&interComm);
-      ep_lib::MPI_Comm_free(&intraComm);
+          MPI_Send(&msg,1,MPI_INT,0,0,interComm) ;
+        }
+      }
+
+      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
+        MPI_Comm_free(&(*it));
+      MPI_Comm_free(&interComm);
+      MPI_Comm_free(&intraComm);
 
       CTimer::get("XIOS init/finalize").suspend() ;
@@ -290 +288 @@
       {
         if (CXios::usingOasis) oasis_finalize();
-        else ep_lib::MPI_Finalize() ;
+        else MPI_Finalize() ;
       }
       
@@ -327 +325 @@
       int size = 0;
       int rank;
-      ep_lib::MPI_Comm_size(CXios::globalComm, &size);
+      MPI_Comm_size(CXios::globalComm, &size);
       while (size)
       {
@@ -336 +334 @@
       if (CXios::usingOasis)
       {
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&rank);
+        MPI_Comm_rank(CXios::globalComm,&rank);
         fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext;
       }