Changeset 1639

Timestamp:

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

Author:

yushan

Message:

revert erroneous commit on trunk

Location:

XIOS/trunk

Files:

• extern/remap/src/libmapper.cpp (modified) (1 diff)
• extern/remap/src/mapper.cpp (modified) (27 diffs)
• extern/remap/src/mapper.hpp (modified) (2 diffs)
• extern/remap/src/mpi_cascade.cpp (modified) (2 diffs)
• extern/remap/src/mpi_cascade.hpp (modified) (3 diffs)
• extern/remap/src/mpi_routing.cpp (modified) (24 diffs)
• extern/remap/src/mpi_routing.hpp (modified) (3 diffs)
• extern/remap/src/parallel_tree.cpp (modified) (10 diffs)
• extern/remap/src/parallel_tree.hpp (modified) (2 diffs)
• src/buffer_client.cpp (modified) (4 diffs)
• src/buffer_client.hpp (modified) (2 diffs)
• src/client.cpp (modified) (20 diffs)
• src/client.hpp (modified) (1 diff)
• src/client_client_dht_template.hpp (modified) (5 diffs)
• src/client_client_dht_template_impl.hpp (modified) (21 diffs)
• src/client_server_mapping.cpp (modified) (3 diffs)
• src/client_server_mapping.hpp (modified) (1 diff)
• src/client_server_mapping_distributed.cpp (modified) (1 diff)
• src/client_server_mapping_distributed.hpp (modified) (1 diff)
• src/context_client.cpp (modified) (4 diffs)
• src/context_client.hpp (modified) (2 diffs)
• src/context_server.cpp (modified) (10 diffs)
• src/context_server.hpp (modified) (2 diffs)
• src/cxios.cpp (modified) (8 diffs)
• src/cxios.hpp (modified) (2 diffs)
• src/dht_auto_indexing.cpp (modified) (4 diffs)
• src/dht_auto_indexing.hpp (modified) (1 diff)
• src/event_scheduler.cpp (modified) (10 diffs)
• src/event_scheduler.hpp (modified) (2 diffs)
• src/filter/spatial_transform_filter.cpp (modified) (3 diffs)
• src/interface/c/icdata.cpp (modified) (2 diffs)
• src/interface/c/oasis_cinterface.cpp (modified) (1 diff)
• src/interface/c/oasis_cinterface.hpp (modified) (2 diffs)
• src/io/inetcdf4.cpp (modified) (3 diffs)
• src/io/inetcdf4.hpp (modified) (1 diff)
• src/io/nc4_data_input.cpp (modified) (1 diff)
• src/io/nc4_data_input.hpp (modified) (2 diffs)
• src/io/nc4_data_output.cpp (modified) (1 diff)
• src/io/nc4_data_output.hpp (modified) (2 diffs)
• src/io/netCdfInterface.cpp (modified) (3 diffs)
• src/io/netCdfInterface.hpp (modified) (2 diffs)
• src/io/onetcdf4.cpp (modified) (5 diffs)
• src/io/onetcdf4.hpp (modified) (2 diffs)
• src/mpi.hpp (modified) (1 diff)
• src/mpi_std.hpp (deleted)
• src/node/axis.cpp (modified) (5 diffs)
• src/node/axis.hpp (modified) (2 diffs)
• src/node/context.cpp (modified) (9 diffs)
• src/node/context.hpp (modified) (2 diffs)
• src/node/domain.cpp (modified) (8 diffs)
• src/node/domain.hpp (modified) (2 diffs)
• src/node/field.cpp (modified) (1 diff)
• src/node/file.cpp (modified) (7 diffs)
• src/node/file.hpp (modified) (1 diff)
• src/node/grid.cpp (modified) (3 diffs)
• src/node/mesh.cpp (modified) (14 diffs)
• src/node/mesh.hpp (modified) (2 diffs)
• src/policy.cpp (modified) (2 diffs)
• src/policy.hpp (modified) (2 diffs)
• src/registry.cpp (modified) (8 diffs)
• src/registry.hpp (modified) (3 diffs)
• src/server.cpp (modified) (42 diffs)
• src/server.hpp (modified) (1 diff)
• src/test/test_omp.f90 (deleted)
• src/timer.cpp (modified) (3 diffs)
• src/tracer.cpp (modified) (5 diffs)
• src/transformation/axis_algorithm_interpolate.cpp (modified) (2 diffs)
• src/transformation/axis_algorithm_inverse.cpp (modified) (7 diffs)
• src/transformation/domain_algorithm_generate_rectilinear.cpp (modified) (2 diffs)
• src/transformation/domain_algorithm_interpolate.cpp (modified) (11 diffs)
• src/transformation/generic_algorithm_transformation.cpp (modified) (3 diffs)
• src/transformation/grid_transformation.cpp (modified) (7 diffs)

XIOS/trunk/extern/remap/src/libmapper.cpp

@@ -43 +43 @@
   double* src_area=NULL ;
   double* dst_area=NULL ;
-  mapper = new Mapper(EP_COMM_WORLD);
+  mapper = new Mapper(MPI_COMM_WORLD);
   mapper->setVerbosity(PROGRESS) ;
   mapper->setSourceMesh(src_bounds_lon, src_bounds_lat, src_area, n_vert_per_cell_src, n_cell_src, src_pole ) ;

XIOS/trunk/extern/remap/src/mapper.cpp

@@ -32 +32 @@
 
   int mpiRank, mpiSize;
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
 
   sourceElements.reserve(nbCells);
@@ -43 +43 @@
     long int offset ;
     long int nb=nbCells ;
-    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ;
+    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ;
     offset=offset-nb ;
     for(int i=0;i<nbCells;i++) sourceGlobalId[i]=offset+i ;
@@ -70 +70 @@
 
   int mpiRank, mpiSize;
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
 
   targetElements.reserve(nbCells);
@@ -81 +81 @@
     long int offset ;
     long int nb=nbCells ;
-    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ;
+    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ;
     offset=offset-nb ;
     for(int i=0;i<nbCells;i++) targetGlobalId[i]=offset+i ;
@@ -117 +117 @@
   vector<double> timings;
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   this->buildSSTree(sourceMesh, targetMesh);
@@ -173 +173 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   /* create list of intersections (super mesh elements) for each rank */
@@ -235 +235 @@
   /* communicate sizes of source elements to be sent (index lists and later values and gradients) */
   int *nbRecvElement = new int[mpiSize];
-  ep_lib::MPI_Alltoall(nbSendElement, 1, EP_INT, nbRecvElement, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendElement, 1, MPI_INT, nbRecvElement, 1, MPI_INT, communicator);
 
   /* communicate indices of source elements on other ranks whoes value and gradient we need (since intersection) */
@@ -246 +246 @@
   Coord **sendGrad = new Coord*[mpiSize];
   GloId **sendNeighIds = new GloId*[mpiSize];
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[5*mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[5*mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[5*mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[5*mpiSize];
   for (int rank = 0; rank < mpiSize; rank++)
   {
     if (nbSendElement[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendElement[rank], nbSendElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendElement[rank], nbSendElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
@@ -271 +271 @@
         sendNeighIds[rank] = new GloId[nbRecvElement[rank]];
       }
-      ep_lib::MPI_Irecv(recvElement[rank], nbRecvElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvElement[rank], nbRecvElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
-  ep_lib::MPI_Status *status = new ep_lib::MPI_Status[5*mpiSize];
+  MPI_Status *status = new MPI_Status[5*mpiSize];
   
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
-        ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
+        MPI_Waitall(nbRecvRequest, recvRequest, status);
 
   /* for all indices that have been received from requesting ranks: pack values and gradients, then send */
@@ -310 +310 @@
           sendNeighIds[rank][j] = sstree.localElements[recvElement[rank][j]].src_id;
       }
-      ep_lib::MPI_Issend(sendValue[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendValue[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
-      ep_lib::MPI_Issend(sendArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
-      ep_lib::MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
       if (order == 2)
       {
-        ep_lib::MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
         nbSendRequest++;
-        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
 //ym  --> attention taille GloId
         nbSendRequest++;
@@ -326 +326 @@
       else
       {
-        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
 //ym  --> attention taille GloId
         nbSendRequest++;
@@ -333 +333 @@
     if (nbSendElement[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvValue[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvValue[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
-      ep_lib::MPI_Irecv(recvArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
-      ep_lib::MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
       if (order == 2)
       {
-        ep_lib::MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1),
-            EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1),
+            MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
         nbRecvRequest++;
-        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
 //ym  --> attention taille GloId
         nbRecvRequest++;
@@ -350 +350 @@
       else
       {
-        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
 //ym  --> attention taille GloId
         nbRecvRequest++;
@@ -357 +357 @@
   }
         
-        ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
+        MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
   
 
@@ -487 +487 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   vector<Node> *routingList = new vector<Node>[mpiSize];
@@ -522 +522 @@
   }
 
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   char **sendBuffer = new char*[mpiSize];
@@ -549 +549 @@
   int nbSendRequest = 0;
   int nbRecvRequest = 0;
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Status  *status      = new ep_lib::MPI_Status[mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[mpiSize];
+  MPI_Status  *status      = new MPI_Status[mpiSize];
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -557 +557 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -615 +615 @@
 
 
-  ep_lib::MPI_Barrier(communicator);
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Barrier(communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -629 +629 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   int nbNeighbourNodes = 0;
@@ -725 +725 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-
-  ep_lib::MPI_Barrier(communicator);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+
+  MPI_Barrier(communicator);
 
   vector<Node> *routingList = new vector<Node>[mpiSize];
@@ -753 +753 @@
     cout << endl;
   }
-  ep_lib::MPI_Barrier(communicator);
+  MPI_Barrier(communicator);
 
   int *nbSendNode = new int[mpiSize];
@@ -771 +771 @@
   }
 
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   int total = 0;
@@ -805 +805 @@
   int nbSendRequest = 0;
   int nbRecvRequest = 0;
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Status   *status = new ep_lib::MPI_Status[mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[mpiSize];
+  MPI_Status   *status = new MPI_Status[mpiSize];
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -813 +813 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
   char **sendBuffer2 = new char*[mpiSize];
   char **recvBuffer2 = new char*[mpiSize];
@@ -883 +883 @@
 
   if (verbose >= 2) cout << "Rank " << mpiRank << "  Compute (internal) intersection " << cputime() - tic << " s" << endl;
-  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -896 +896 @@
     if (sentMessageSize[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (recvMessageSize[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   delete [] sendRequest;

XIOS/trunk/extern/remap/src/mapper.hpp

@@ -18 +18 @@
 {
 public:
-       Mapper(ep_lib::MPI_Comm comm=EP_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {}
+       Mapper(MPI_Comm comm=MPI_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {}
        ~Mapper();
        void setVerbosity(verbosity v) {verbose=v ;}
@@ -67 +67 @@
 
        CParallelTree sstree;
-       ep_lib::MPI_Comm communicator ;
+       MPI_Comm communicator ;
        std::vector<Elt>  sourceElements ;
        std::vector<Node> sourceMesh ;

XIOS/trunk/extern/remap/src/mpi_cascade.cpp

@@ -4 +4 @@
 namespace sphereRemap {
 
-CMPICascade::CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm)
+CMPICascade::CMPICascade(int nodes_per_level, MPI_Comm comm)
 {
         int remaining_levels;
-        ep_lib::MPI_Comm intraComm;
+        MPI_Comm intraComm;
         int l = 0; // current level
         do {
@@ -15 +15 @@
                 level[l].p_grp_size = level[l].size/level[l].group_size;
         
-                ep_lib::MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm);
-                ep_lib::MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm));
+                MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm);
+                MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm));
                 comm = intraComm;
                 l++;

XIOS/trunk/extern/remap/src/mpi_cascade.hpp

@@ -12 +12 @@
 {
 public:
-        CCascadeLevel(ep_lib::MPI_Comm comm) : comm(comm)
+        CCascadeLevel(MPI_Comm comm) : comm(comm)
         {
-                ep_lib::MPI_Comm_size(comm, &size);
-                ep_lib::MPI_Comm_rank(comm, &rank);
+                MPI_Comm_size(comm, &size);
+                MPI_Comm_rank(comm, &rank);
         }
         int colour() const { return rank % group_size; };
@@ -24 +24 @@
         int p_key() const { return colour() + rank/(p_grp_size*group_size)*group_size; }
 
-        ep_lib::MPI_Comm comm, pg_comm;
+        MPI_Comm comm, pg_comm;
         int rank;
         int size;
@@ -35 +35 @@
 public:
         // 
-        CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm);
+        CMPICascade(int nodes_per_level, MPI_Comm comm);
 
         int num_levels;

XIOS/trunk/extern/remap/src/mpi_routing.cpp

@@ -10 +10 @@
 const int verbose = 0;
 
-CMPIRouting::CMPIRouting(ep_lib::MPI_Comm comm) : communicator(comm)
-{
-        ep_lib::MPI_Comm_rank(comm, &mpiRank);
-        ep_lib::MPI_Comm_size(comm, &mpiSize);
+CMPIRouting::CMPIRouting(MPI_Comm comm) : communicator(comm)
+{
+        MPI_Comm_rank(comm, &mpiRank);
+        MPI_Comm_size(comm, &mpiSize);
 }
 
@@ -19 +19 @@
     but message lengths are *known* to receiver */
 template <typename T>
-void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator)
-{
-        vector<ep_lib::MPI_Request> request(ranks.size() * 2);
-        vector<ep_lib::MPI_Status>  status(ranks.size() * 2);
+void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator)
+{
+        vector<MPI_Request> request(ranks.size() * 2);
+        vector<MPI_Status>  status(ranks.size() * 2);
 
         // communicate data
@@ -28 +28 @@
         for (int i = 0; i < ranks.size(); i++)
                 if (recv[i].size())
-                        ep_lib::MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
+                        MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
         for (int i = 0; i < ranks.size(); i++)
                 if (send[i].size())
-                        ep_lib::MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
-        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]);
+                        MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
+        MPI_Waitall(nbRequest, &request[0], &status[0]);
 }
 
@@ -38 +38 @@
     but message lengths are *unknown* to receiver */
 template <typename T>
-void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator)
-{
-        vector<ep_lib::MPI_Request> request(ranks.size() * 2);
-        vector<ep_lib::MPI_Status>  status(ranks.size() * 2);
+void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator)
+{
+        vector<MPI_Request> request(ranks.size() * 2);
+        vector<MPI_Status>  status(ranks.size() * 2);
 
         // communicate sizes
@@ -50 +50 @@
                 sendSizes[i] = send[i].size();
         for (int i = 0; i < ranks.size(); i++)
-                ep_lib::MPI_Irecv(&recvSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]);
+                MPI_Irecv(&recvSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]);
         for (int i = 0; i < ranks.size(); i++)
-                ep_lib::MPI_Isend(&sendSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]);
-        ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]);
+                MPI_Isend(&sendSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]);
+        MPI_Waitall(nbRequest, &request[0], &status[0]);
 
         // allocate
@@ -118 +118 @@
         CTimer::get("CMPIRouting::init(reduce_scatter)").reset();
         CTimer::get("CMPIRouting::init(reduce_scatter)").resume();
-        ep_lib::MPI_Reduce_scatter(toSend, &nbSource, recvCount, EP_INT, EP_SUM, communicator);
+        MPI_Reduce_scatter(toSend, &nbSource, recvCount, MPI_INT, MPI_SUM, communicator);
         CTimer::get("CMPIRouting::init(reduce_scatter)").suspend();
         CTimer::get("CMPIRouting::init(reduce_scatter)").print();
 
-        ep_lib::MPI_Alloc_mem(nbTarget *sizeof(int), EP_INFO_NULL, &targetRank);
-        ep_lib::MPI_Alloc_mem(nbSource *sizeof(int), EP_INFO_NULL, &sourceRank);
+        MPI_Alloc_mem(nbTarget *sizeof(int), MPI_INFO_NULL, &targetRank);
+        MPI_Alloc_mem(nbSource *sizeof(int), MPI_INFO_NULL, &sourceRank);
 
         targetRankToIndex = new int[mpiSize];
@@ -137 +137 @@
         }
 
-        ep_lib::MPI_Barrier(communicator);
+        MPI_Barrier(communicator);
         CTimer::get("CMPIRouting::init(get_source)").reset();
         CTimer::get("CMPIRouting::init(get_source)").resume();
 
-        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+        MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+        MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
 
         int indexRequest = 0;
@@ -150 +150 @@
         for (int i = 0; i < nbSource; i++)
         {
-                #ifdef _usingMPI
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
-                #elif _usingEP
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]);
-                #endif
-                indexRequest++;
-        }
-        MPI_Barrier(communicator);
-        for (int i = 0; i < nbTarget; i++)
-        {
-                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+        MPI_Barrier(communicator);
+        for (int i = 0; i < nbTarget; i++)
+        {
+                MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -174 +170 @@
         for (int i = 0; i < nbSource; i++)
         {
-                #ifdef _usingMPI
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
-                #elif _usingEP
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]);
-                #endif
-                indexRequest++;
-        }
-
-        for (int i = 0; i < nbTarget; i++)
-        {
-                ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+
+        for (int i = 0; i < nbTarget; i++)
+        {
+                MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -209 +201 @@
         for (int i = 0; i < nbSource; i++)
         {
-                ep_lib::MPI_Irecv(&nbSourceElement[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(&nbSourceElement[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -216 +208 @@
         {
                 totalTargetElement += nbTargetElement[i];
-                ep_lib::MPI_Isend(&nbTargetElement[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Isend(&nbTargetElement[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -284 +276 @@
 
 
-        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget];
-        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget];
+        MPI_Request* request=new MPI_Request[nbSource+nbTarget];
+        MPI_Status*  status=new MPI_Status[nbSource+nbTarget];
         int indexRequest=0;
 
-        ep_lib::MPI_Barrier(communicator);
+        MPI_Barrier(communicator);
         CTimer::get("CMPIRouting::transferToTarget").reset();
         CTimer::get("CMPIRouting::transferToTarget").resume();
@@ -294 +286 @@
         for(int i=0; i<nbSource; i++)
         {
-                ep_lib::MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -300 +292 @@
         for(int i=0;i<nbTarget; i++)
         {
-                ep_lib::MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-
-        ep_lib::MPI_Waitall(indexRequest,request,status);
+                MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+
+        MPI_Waitall(indexRequest,request,status);
 
         CTimer::get("CMPIRouting::transferToTarget").suspend();
         CTimer::get("CMPIRouting::transferToTarget").print();
-        ep_lib::MPI_Barrier(communicator);
+        MPI_Barrier(communicator);
 
         // unpack the data
@@ -348 +340 @@
         }
 
-        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+        MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+        MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
         int indexRequest = 0;
 
-        ep_lib::MPI_Barrier(communicator);
+        MPI_Barrier(communicator);
         CTimer::get("CMPIRouting::transferToTarget(messageSize)").reset();
         CTimer::get("CMPIRouting::transferToTarget(messageSize)").resume();
@@ -358 +350 @@
         for(int i=0; i<nbSource; i++)
         {
-                ep_lib::MPI_Irecv(&sourceMessageSize[i],1,EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(&sourceMessageSize[i],1,MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -364 +356 @@
         for(int i=0; i<nbTarget; i++)
         {
-                ep_lib::MPI_Isend(&targetMessageSize[i],1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-
-        ep_lib::MPI_Waitall(indexRequest,request,status);
-
-        ep_lib::MPI_Barrier(communicator);
+                MPI_Isend(&targetMessageSize[i],1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+
+        MPI_Waitall(indexRequest,request,status);
+
+        MPI_Barrier(communicator);
         CTimer::get("CMPIRouting::transferToTarget(messageSize)").suspend();
         CTimer::get("CMPIRouting::transferToTarget(messageSize)").print();
@@ -403 +395 @@
         for(int i=0; i<nbSource; i++)
         {
-                ep_lib::MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -409 +401 @@
         for(int i=0;i<nbTarget; i++)
         {
-                ep_lib::MPI_Isend(targetBuffer[i],targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Isend(targetBuffer[i],targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -468 +460 @@
         }
 
-        ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget];
-        ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget];
+        MPI_Request* request=new MPI_Request[nbSource+nbTarget];
+        MPI_Status*  status=new MPI_Status[nbSource+nbTarget];
         int indexRequest=0;
 
         for(int i=0; i<nbSource; i++)
         {
-                ep_lib::MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+                MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
                 indexRequest++;
         }
@@ -480 +472 @@
         for(int i=0;i<nbTarget; i++)
         {
-                ep_lib::MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-
-        ep_lib::MPI_Waitall(indexRequest,request,status);
+                MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+
+        MPI_Waitall(indexRequest,request,status);
 
         // unpack the data
@@ -524 +516 @@
         }
 
-        ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-        ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+        MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+        MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
         int indexRequest = 0;
         for (int i = 0; i < nbSource; i++)
         {
-                ep_lib::MPI_Isend(&sourceMessageSize[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-        for (int i = 0; i < nbTarget; i++)
-        {
-                ep_lib::MPI_Irecv(&targetMessageSize[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-        ep_lib::MPI_Waitall(indexRequest, request, status);
+                MPI_Isend(&sourceMessageSize[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+        for (int i = 0; i < nbTarget; i++)
+        {
+                MPI_Irecv(&targetMessageSize[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+        MPI_Waitall(indexRequest, request, status);
 
         for (int i = 0; i < nbTarget; i++)
@@ -565 +557 @@
         for (int i = 0; i < nbSource; i++)
         {
-                ep_lib::MPI_Isend(sourceBuffer[i], sourceMessageSize[i], EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-        for (int i = 0; i < nbTarget; i++)
-        {
-                ep_lib::MPI_Irecv(targetBuffer[i], targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-                indexRequest++;
-        }
-        ep_lib::MPI_Waitall(indexRequest, request, status);
+                MPI_Isend(sourceBuffer[i], sourceMessageSize[i], MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+        for (int i = 0; i < nbTarget; i++)
+        {
+                MPI_Irecv(targetBuffer[i], targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+                indexRequest++;
+        }
+        MPI_Waitall(indexRequest, request, status);
 
         // unpack the data
@@ -613 +605 @@
 
 template void alltoalls_unknown(const std::vector<std::vector<NES> >& send, std::vector<std::vector<NES> >& recv,
-                                const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                                const std::vector<int>& ranks, MPI_Comm communicator);
 
 template void alltoalls_known(const std::vector<std::vector<int> >& send, std::vector<std::vector<int> >& recv,
-                              const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
-
-}
+                              const std::vector<int>& ranks, MPI_Comm communicator);
+
+}

XIOS/trunk/extern/remap/src/mpi_routing.hpp

@@ -11 +11 @@
 {
 
-        ep_lib::MPI_Comm communicator;
+        MPI_Comm communicator;
         int mpiRank;
         int mpiSize;
@@ -29 +29 @@
 
 public:
-        CMPIRouting(ep_lib::MPI_Comm comm);
+        CMPIRouting(MPI_Comm comm);
         ~CMPIRouting();
         template<typename T> void init(const std::vector<T>& route, CMPICascade *cascade = NULL);
@@ -44 +44 @@
 template <typename T>
 void alltoalls_known(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv,
-                     const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                     const std::vector<int>& ranks, MPI_Comm communicator);
 
 template <typename T>
 void alltoalls_unknown(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv,
-                       const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                       const std::vector<int>& ranks, MPI_Comm communicator);
 }
 #endif

XIOS/trunk/extern/remap/src/parallel_tree.cpp

@@ -115 +115 @@
 
 //CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MIN_NODE_SZ*MIN_NODE_SZ, comm)
-CParallelTree::CParallelTree(ep_lib::MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm)
+CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm)
 {
         treeCascade.reserve(cascade.num_levels);
@@ -151 +151 @@
 
         int nrecv; // global number of samples  THIS WILL BE THE NUMBER OF LEAFS IN THE SAMPLE TREE
-        ep_lib::MPI_Allreduce(&n, &nrecv, 1, EP_INT, EP_SUM, comm.comm); // => size of sample tree does not depend on keepNodes!
+        MPI_Allreduce(&n, &nrecv, 1, MPI_INT, MPI_SUM, comm.comm); // => size of sample tree does not depend on keepNodes!
         double ratio = blocSize / (1.0 * nrecv);
         int nsend = ratio * n + 1; // nsend = n_local_samples / n_global_samples * blocksize + 1 = blocksize/comm.size
@@ -157 +157 @@
 
         int *counts = new int[comm.size];
-        ep_lib::MPI_Allgather(&nsend, 1, EP_INT, counts, 1, EP_INT, comm.comm);
+        MPI_Allgather(&nsend, 1, MPI_INT, counts, 1, MPI_INT, comm.comm);
 
         nrecv = 0;
@@ -183 +183 @@
         /* each process needs the sample elements from all processes */
         double *recvBuffer = new double[nrecv*4];
-        ep_lib::MPI_Allgatherv(sendBuffer, 4 * nsend, EP_DOUBLE, recvBuffer, counts, displs, EP_DOUBLE, comm.comm);
+        MPI_Allgatherv(sendBuffer, 4 * nsend, MPI_DOUBLE, recvBuffer, counts, displs, MPI_DOUBLE, comm.comm);
         delete[] sendBuffer;
         delete[] counts;
@@ -241 +241 @@
          << "   node size : "<<node.size()<<"   bloc size : "<<blocSize<<"  total number of leaf : "<<tree.leafs.size()<<endl ;
 /*
-        MPI_Allreduce(&ok, &allok, 1, EP_INT, MPI_PROD, communicator);
+        MPI_Allreduce(&ok, &allok, 1, MPI_INT, MPI_PROD, communicator);
         if (!allok) {
                 MPI_Finalize();
@@ -247 +247 @@
         }
 */
-    ep_lib::MPI_Abort(EP_COMM_WORLD,-1) ;
+    MPI_Abort(MPI_COMM_WORLD,-1) ;
   }
 /*
@@ -265 +265 @@
 {
         CMPIRouting MPIRoute(communicator);
-        ep_lib::MPI_Barrier(communicator);
+        MPI_Barrier(communicator);
         CTimer::get("buildLocalTree(initRoute)").resume();
         MPIRoute.init(route);
@@ -290 +290 @@
 
         int mpiRank;
-        ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+        MPI_Comm_rank(communicator, &mpiRank);
         localTree.leafs.reserve(nbLocalElements);
         for (int i = 0; i < nbLocalElements; i++)
@@ -316 +316 @@
   nb1=node.size() ; nb2=node2.size() ;
   nb=nb1+nb2 ;
-  ep_lib::MPI_Allreduce(&nb, &nbTot, 1, EP_LONG, EP_SUM, communicator) ;
+  MPI_Allreduce(&nb, &nbTot, 1, MPI_LONG, MPI_SUM, communicator) ;
   int commSize ;
-  ep_lib::MPI_Comm_size(communicator,&commSize) ;
+  MPI_Comm_size(communicator,&commSize) ;
   
         // make multiple of two
@@ -501 +501 @@
         // gather circles on this level of the cascade
         int pg_size;
-        ep_lib::MPI_Comm_size(cascade.level[level].pg_comm, &pg_size);
+        MPI_Comm_size(cascade.level[level].pg_comm, &pg_size);
         vector<Coord> allRootCentres(pg_size);
         vector<double> allRootRadia(pg_size);
-        ep_lib::MPI_Allgather(&rootCentre, 3, EP_DOUBLE, &allRootCentres[0], 3, EP_DOUBLE, cascade.level[level].pg_comm);
-        ep_lib::MPI_Allgather(&rootRadius, 1, EP_DOUBLE, &allRootRadia[0],   1, EP_DOUBLE, cascade.level[level].pg_comm);
+        MPI_Allgather(&rootCentre, 3, MPI_DOUBLE, &allRootCentres[0], 3, MPI_DOUBLE, cascade.level[level].pg_comm);
+        MPI_Allgather(&rootRadius, 1, MPI_DOUBLE, &allRootRadia[0],   1, MPI_DOUBLE, cascade.level[level].pg_comm);
 
         // now allRootsRadia and allRootCentres must be inserted into second levels of us and propagated to root

XIOS/trunk/extern/remap/src/parallel_tree.hpp

@@ -12 +12 @@
 {
 public:
-        CParallelTree(ep_lib::MPI_Comm comm);
+        CParallelTree(MPI_Comm comm);
         ~CParallelTree();
 
@@ -34 +34 @@
         vector<CSampleTree> treeCascade; // first for sample tree, then for routing tree
         CMPICascade cascade;
-  ep_lib::MPI_Comm communicator ;
+  MPI_Comm communicator ;
 
 };

XIOS/trunk/src/buffer_client.cpp

@@ -12 +12 @@
   size_t CClientBuffer::maxRequestSize = 0;
 
-  CClientBuffer::CClientBuffer(ep_lib::MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents)
+  CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents)
     : interComm(interComm)
     , serverRank(serverRank)
@@ -83 +83 @@
   bool CClientBuffer::checkBuffer(void)
   {
-    ep_lib::MPI_Status status;
+    MPI_Status status;
     int flag;
 
@@ -89 +89 @@
     {
       traceOff();
-      ep_lib::MPI_Test(&request, &flag, &status);
+      MPI_Test(&request, &flag, &status);
       traceOn();
       if (flag == true) pending = false;
@@ -98 +98 @@
       if (count > 0)
       {
-        ep_lib::MPI_Issend(buffer[current], count, EP_CHAR, serverRank, 20, interComm, &request);
+        MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request);
         pending = true;
         if (current == 1) current = 0;

XIOS/trunk/src/buffer_client.hpp

@@ -14 +14 @@
       static size_t maxRequestSize;
 
-      CClientBuffer(ep_lib::MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents);
+      CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents);
       ~CClientBuffer();
 
@@ -39 +39 @@
       bool pending;
 
-      ep_lib::MPI_Request request;
+      MPI_Request request;
 
       CBufferOut* retBuffer;
-      const ep_lib::MPI_Comm interComm;
+      const MPI_Comm interComm;
   };
 }

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;
       }

XIOS/trunk/src/client.hpp

@@ -10 +10 @@
     {
       public:
-        static void initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm);
+        static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm);
         static void finalize(void);
-        static void registerContext(const string& id, ep_lib::MPI_Comm contextComm);
+        static void registerContext(const string& id, MPI_Comm contextComm);
         static void callOasisEnddef(void) ;
 
-        static ep_lib::MPI_Comm intraComm;
-        static ep_lib::MPI_Comm interComm;
-        static std::list<ep_lib::MPI_Comm> contextInterComms;
+        static MPI_Comm intraComm;
+        static MPI_Comm interComm;
+        static std::list<MPI_Comm> contextInterComms;
         static int serverLeader;
         static bool is_MPI_Initialized ;
 
-        static ep_lib::MPI_Comm& getInterComm();
+        static MPI_Comm& getInterComm();
 
         //! Get global rank without oasis and current rank in model intraComm in case of oasis

XIOS/trunk/src/client_client_dht_template.hpp

@@ -40 +40 @@
   public:
     CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoInitMap,
-                             const ep_lib::MPI_Comm& clientIntraComm);
+                             const MPI_Comm& clientIntraComm);
 
     CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoInitMap,
-                             const ep_lib::MPI_Comm& clientIntraComm);
+                             const MPI_Comm& clientIntraComm);
 
     void computeIndexInfoMapping(const CArray<size_t,1>& indices);
@@ -55 +55 @@
 
   protected:
-    CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm);
+    CClientClientDHTTemplate(const MPI_Comm& clientIntraComm);
 
   protected:
@@ -62 +62 @@
     // Redistribute index and info among clients
     void computeDistributedIndex(const Index2InfoTypeMap& indexInfoInitMap,
-                                 const ep_lib::MPI_Comm& intraCommLevel,
+                                 const MPI_Comm& intraCommLevel,
                                  int level);
 
     void computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoInitMap,
-                                 const ep_lib::MPI_Comm& intraCommLevel,
+                                 const MPI_Comm& intraCommLevel,
                                  int level);
 
@@ -73 +73 @@
 
     void computeIndexInfoMappingLevel(const CArray<size_t,1>& indices,
-                                      const ep_lib::MPI_Comm& intraCommLevel,
+                                      const MPI_Comm& intraCommLevel,
                                       int level);
 
@@ -85 +85 @@
     // Send information to clients
     void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                           const ep_lib::MPI_Comm& clientIntraComm,
-                           std::vector<ep_lib::MPI_Request>& requestSendInfo);
-    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                           const ep_lib::MPI_Comm& clientIntraComm,
-                           ep_lib::MPI_Request* requestSendInfo);
+                           const MPI_Comm& clientIntraComm,
+                           std::vector<MPI_Request>& requestSendInfo);
 
     void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            std::vector<ep_lib::MPI_Request>& requestRecvInfo);
-    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                             const ep_lib::MPI_Comm& clientIntraComm,
-                             ep_lib::MPI_Request* requestRecvInfo);
-                                                        
+                            const MPI_Comm& clientIntraComm,
+                            std::vector<MPI_Request>& requestRecvInfo);
 
     // Send global index to clients
     void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            std::vector<ep_lib::MPI_Request>& requestSendIndexGlobal);
-    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            ep_lib::MPI_Request* requestSendIndexGlobal);
+                            const MPI_Comm& clientIntraComm,
+                            std::vector<MPI_Request>& requestSendIndexGlobal);
 
     void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                             const ep_lib::MPI_Comm& clientIntraComm,
-                             std::vector<ep_lib::MPI_Request>& requestRecvIndex);
-    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                              const ep_lib::MPI_Comm& clientIntraComm,
-                              ep_lib::MPI_Request* requestRecvIndex);
+                             const MPI_Comm& clientIntraComm,
+                             std::vector<MPI_Request>& requestRecvIndex);
 
     void sendRecvOnReturn(const std::vector<int>& sendNbRank, std::vector<int>& sendNbElements,

XIOS/trunk/src/client_client_dht_template_impl.hpp

@@ -14 +14 @@
 {
 template<typename T, typename H>
-CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm)
+CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -34 +34 @@
 template<typename T, typename H>
 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoMap,
-                                                        const ep_lib::MPI_Comm& clientIntraComm)
+                                                        const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -59 +59 @@
 template<typename T, typename H>
 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoMap,
-                                                        const ep_lib::MPI_Comm& clientIntraComm)
+                                                        const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -95 +95 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::computeIndexInfoMappingLevel(const CArray<size_t,1>& indices,
-                                                                 const ep_lib::MPI_Comm& commLevel,
+                                                                 const MPI_Comm& commLevel,
                                                                  int level)
 {
   int clientRank;
-  ep_lib::MPI_Comm_rank(commLevel,&clientRank);
+  MPI_Comm_rank(commLevel,&clientRank);
   int groupRankBegin = this->getGroupBegin()[level];
   int nbClient = this->getNbInGroup()[level];
@@ -169 +169 @@
     recvIndexBuff = new unsigned long[recvNbIndexCount];
 
-  int request_size = 0;
-  for (int idx = 0; idx < recvRankClient.size(); ++idx)
-  {
-    if (0 != recvNbIndexClientCount[idx])
-      request_size ++;
-  }
-
-  request_size += client2ClientIndex.size();
-
-  std::vector<ep_lib::MPI_Request> request(request_size);
+  std::vector<MPI_Request> request;
   std::vector<int>::iterator itbRecvIndex = recvRankClient.begin(), itRecvIndex,
                              iteRecvIndex = recvRankClient.end(),
@@ -185 +176 @@
   int currentIndex = 0;
   int nbRecvClient = recvRankClient.size();
-  int request_position = 0;
   for (int idx = 0; idx < nbRecvClient; ++idx)
   {
     if (0 != recvNbIndexClientCount[idx])
-      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]);
+      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request);
     currentIndex += recvNbIndexClientCount[idx];
   }
@@ -196 +186 @@
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
-    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]);
-
-  std::vector<ep_lib::MPI_Status> status(request.size());
-  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]);
+    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request);
+
+  std::vector<MPI_Status> status(request.size());
+  MPI_Waitall(request.size(), &request[0], &status[0]);
 
   CArray<size_t,1>* tmpGlobalIndex;
@@ -252 +242 @@
   }
 
-  int requestOnReturn_size=0;
-  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx)
-  {
-    if (0 != recvNbIndexOnReturn[idx])
-    {
-      requestOnReturn_size += 2;
-    }
-  }
-
-  for (int idx = 0; idx < nbRecvClient; ++idx)
-  {
-    if (0 != sendNbIndexOnReturn[idx])
-    {
-      requestOnReturn_size += 2;
-    }
-  }
-
-  int requestOnReturn_position=0;
-
-  std::vector<ep_lib::MPI_Request> requestOnReturn(requestOnReturn_size);
+  std::vector<MPI_Request> requestOnReturn;
   currentIndex = 0;
   for (int idx = 0; idx < recvRankOnReturn.size(); ++idx)
@@ -277 +248 @@
     if (0 != recvNbIndexOnReturn[idx])
     {
-      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]);
+      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn);
       recvInfoFromClients(recvRankOnReturn[idx],
                           recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
                           recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(),
-                          commLevel, &requestOnReturn[requestOnReturn_position++]);
+                          commLevel, requestOnReturn);
     }
     currentIndex += recvNbIndexOnReturn[idx];
@@ -315 +286 @@
 
       sendIndexToClients(rank, client2ClientIndexOnReturn[rank],
-                         sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]);
+                         sendNbIndexOnReturn[idx], commLevel, requestOnReturn);
       sendInfoToClients(rank, client2ClientInfoOnReturn[rank],
-                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, &requestOnReturn[requestOnReturn_position++]);
+                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn);
     }
     currentIndex += recvNbIndexClientCount[idx];
   }
 
-  std::vector<ep_lib::MPI_Status> statusOnReturn(requestOnReturn.size());
-  ep_lib::MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]);
+  std::vector<MPI_Status> statusOnReturn(requestOnReturn.size());
+  MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]);
 
   Index2VectorInfoTypeMap indexToInfoMapping;
@@ -389 +360 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoMap,
-                                                            const ep_lib::MPI_Comm& commLevel,
+                                                            const MPI_Comm& commLevel,
                                                             int level)
 {
   int clientRank;
-  ep_lib::MPI_Comm_rank(commLevel,&clientRank);
+  MPI_Comm_rank(commLevel,&clientRank);
   computeSendRecvRank(level, clientRank);
 
@@ -468 +439 @@
   // it will send a message to the correct clients.
   // Contents of the message are index and its corresponding informatioin
-  int request_size = 0;
-   for (int idx = 0; idx < recvRankClient.size(); ++idx)
-   {
-     if (0 != recvNbIndexClientCount[idx])
-     {
-       request_size += 2;
-     }
-   }
- 
-   request_size += client2ClientIndex.size();
-   request_size += client2ClientInfo.size();
- 
-   std::vector<ep_lib::MPI_Request> request(request_size);
-
+  std::vector<MPI_Request> request;
   int currentIndex = 0;
   int nbRecvClient = recvRankClient.size();
-  int request_position=0;
   for (int idx = 0; idx < nbRecvClient; ++idx)
   {
     if (0 != recvNbIndexClientCount[idx])
     {
-      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]);
-      //if(clientRank==0) printf("recv index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));
+      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request);
       recvInfoFromClients(recvRankClient[idx],
-                            recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
-                            recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(),
-                            commLevel, &request[request_position++]);
-      //if(clientRank==0) printf("recv info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));
+                          recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
+                          recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(),
+                          commLevel, request);
     }
     currentIndex += recvNbIndexClientCount[idx];
@@ -503 +458 @@
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
-  {  sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]);
-  }    //if(clientRank==0) printf("send index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));}
+    sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request);
   std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo,
                                                       iteInfo = client2ClientInfo.end();
   for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo)
-   { sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]);
-   }//   if(clientRank==0) printf("send info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));}
-
-  std::vector<ep_lib::MPI_Status> status(request.size());
-  
-  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]);
+    sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request);
+
+  std::vector<MPI_Status> status(request.size());
+  MPI_Waitall(request.size(), &request[0], &status[0]);
 
   Index2VectorInfoTypeMap indexToInfoMapping;
@@ -566 +518 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                                                       const ep_lib::MPI_Comm& clientIntraComm,
-                                                       std::vector<ep_lib::MPI_Request>& requestSendIndex)
-{
-  ep_lib::MPI_Request request;
+                                                       const MPI_Comm& clientIntraComm,
+                                                       std::vector<MPI_Request>& requestSendIndex)
+{
+  MPI_Request request;
   requestSendIndex.push_back(request);
-  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG,
+  MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG,
             clientDestRank, MPI_DHT_INDEX, clientIntraComm, &(requestSendIndex.back()));
-}
-
-/*!
-  Send message containing index to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] indices index to send
-  \param [in] indiceSize size of index array to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestSendIndex sending request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                                                       const ep_lib::MPI_Comm& clientIntraComm,
-                                                       ep_lib::MPI_Request* requestSendIndex)
-{
-  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG,
-            clientDestRank, MPI_DHT_INDEX, clientIntraComm, requestSendIndex);
 }
 
@@ -601 +536 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                                                         const ep_lib::MPI_Comm& clientIntraComm,
-                                                         std::vector<ep_lib::MPI_Request>& requestRecvIndex)
-{
-  ep_lib::MPI_Request request;
+                                                         const MPI_Comm& clientIntraComm,
+                                                         std::vector<MPI_Request>& requestRecvIndex)
+{
+  MPI_Request request;
   requestRecvIndex.push_back(request);
-  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG,
+  MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG,
             clientSrcRank, MPI_DHT_INDEX, clientIntraComm, &(requestRecvIndex.back()));
-}
-
-/*!
-  Receive message containing index to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] indices index to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestRecvIndex receiving request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                                                         const ep_lib::MPI_Comm& clientIntraComm,
-                                                         ep_lib::MPI_Request *requestRecvIndex)
-{
-  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG,
-            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, requestRecvIndex);
 }
 
@@ -636 +555 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                                                      const ep_lib::MPI_Comm& clientIntraComm,
-                                                      std::vector<ep_lib::MPI_Request>& requestSendInfo)
-{
-  ep_lib::MPI_Request request;
+                                                      const MPI_Comm& clientIntraComm,
+                                                      std::vector<MPI_Request>& requestSendInfo)
+{
+  MPI_Request request;
   requestSendInfo.push_back(request);
 
-  ep_lib::MPI_Isend(info, infoSize, EP_CHAR,
+  MPI_Isend(info, infoSize, MPI_CHAR,
             clientDestRank, MPI_DHT_INFO, clientIntraComm, &(requestSendInfo.back()));
-}
-
-/*!
-  Send message containing information to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] info info array to send
-  \param [in] infoSize info array size to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestSendInfo sending request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                                                      const ep_lib::MPI_Comm& clientIntraComm,
-                                                      ep_lib::MPI_Request *requestSendInfo)
-{
-  ep_lib::MPI_Isend(info, infoSize, EP_CHAR,
-            clientDestRank, MPI_DHT_INFO, clientIntraComm, requestSendInfo);
 }
 
@@ -673 +575 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                                                        const ep_lib::MPI_Comm& clientIntraComm,
-                                                        std::vector<ep_lib::MPI_Request>& requestRecvInfo)
-{
-  ep_lib::MPI_Request request;
+                                                        const MPI_Comm& clientIntraComm,
+                                                        std::vector<MPI_Request>& requestRecvInfo)
+{
+  MPI_Request request;
   requestRecvInfo.push_back(request);
 
-  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR,
+  MPI_Irecv(info, infoSize, MPI_CHAR,
             clientSrcRank, MPI_DHT_INFO, clientIntraComm, &(requestRecvInfo.back()));
-}
-
-/*!
-  Receive message containing information from other clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] info info array to receive
-  \param [in] infoSize info array size to receive
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestRecvInfo list of receiving request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                                                        const ep_lib::MPI_Comm& clientIntraComm,
-                                                        ep_lib::MPI_Request* requestRecvInfo)
-{
-  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR,
-            clientSrcRank, MPI_DHT_INFO, clientIntraComm, requestRecvInfo);
 }
 
@@ -766 +651 @@
 {
   recvNbElements.resize(recvNbRank.size());
-  std::vector<ep_lib::MPI_Request> request(sendNbRank.size()+recvNbRank.size());
-  std::vector<ep_lib::MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size());
+  std::vector<MPI_Request> request(sendNbRank.size()+recvNbRank.size());
+  std::vector<MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size());
 
   int nRequest = 0;
   for (int idx = 0; idx < recvNbRank.size(); ++idx)
   {
-    ep_lib::MPI_Irecv(&recvNbElements[0]+idx, 1, EP_INT,
+    MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT,
               recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]);
     ++nRequest;
@@ -779 +664 @@
   for (int idx = 0; idx < sendNbRank.size(); ++idx)
   {
-    ep_lib::MPI_Isend(&sendNbElements[0]+idx, 1, EP_INT,
+    MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT,
               sendNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]);
     ++nRequest;
   }
 
-  ep_lib::MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]);
+  MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]);
 }
 
@@ -811 +696 @@
   std::vector<int> recvBuff(recvBuffSize*2,0);
 
-  std::vector<ep_lib::MPI_Request> request(sendBuffSize+recvBuffSize);
-  std::vector<ep_lib::MPI_Status> requestStatus(sendBuffSize+recvBuffSize);
+  std::vector<MPI_Request> request(sendBuffSize+recvBuffSize);
+  std::vector<MPI_Status> requestStatus(sendBuffSize+recvBuffSize);
 
   int nRequest = 0;
   for (int idx = 0; idx < recvBuffSize; ++idx)
   {
-    ep_lib::MPI_Irecv(&recvBuff[0]+2*idx, 2, EP_INT,
+    MPI_Irecv(&recvBuff[0]+2*idx, 2, MPI_INT,
               recvRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]);
     ++nRequest;
@@ -831 +716 @@
   for (int idx = 0; idx < sendBuffSize; ++idx)
   {
-    ep_lib::MPI_Isend(&sendBuff[idx*2], 2, EP_INT,
+    MPI_Isend(&sendBuff[idx*2], 2, MPI_INT,
               sendRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]);
     ++nRequest;
   }
 
-  ep_lib::MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]);
+  MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]);
   int nbRecvRank = 0, nbRecvElements = 0;
   recvNbRank.clear();

XIOS/trunk/src/client_server_mapping.cpp

@@ -30 +30 @@
 */
 std::map<int,int> CClientServerMapping::computeConnectedClients(int nbServer, int nbClient,
-                                                                ep_lib::MPI_Comm& clientIntraComm,
+                                                                MPI_Comm& clientIntraComm,
                                                                 const std::vector<int>& connectedServerRank)
 {
@@ -62 +62 @@
 
   // get connected server for everybody
-  ep_lib::MPI_Allgather(&nbConnectedServer,1,EP_INT,recvCount,1,EP_INT,clientIntraComm) ;
+  MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ;
 
   displ[0]=0 ;
@@ -70 +70 @@
 
 
-  ep_lib::MPI_Allgatherv(sendBuff,nbConnectedServer,EP_INT,recvBuff,recvCount,displ,EP_INT,clientIntraComm) ;
+  MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ;
   for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ;
 

XIOS/trunk/src/client_server_mapping.hpp

@@ -37 +37 @@
 
     static std::map<int,int> computeConnectedClients(int nbServer, int nbClient,
-                                                     ep_lib::MPI_Comm& clientIntraComm,
+                                                     MPI_Comm& clientIntraComm,
                                                      const std::vector<int>& connectedServerRank);
 

XIOS/trunk/src/client_server_mapping_distributed.cpp

@@ -20 +20 @@
 
 CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
-                                                                 const ep_lib::MPI_Comm& clientIntraComm, bool isDataDistributed)
+                                                                 const MPI_Comm& clientIntraComm, bool isDataDistributed)
   : CClientServerMapping(), ccDHT_(0)
 {

XIOS/trunk/src/client_server_mapping_distributed.hpp

@@ -35 +35 @@
     /** Default constructor */
     CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
-                                    const ep_lib::MPI_Comm& clientIntraComm,
+                                    const MPI_Comm& clientIntraComm,
                                     bool isDataDistributed = true);
 

XIOS/trunk/src/context_client.cpp

@@ -21 +21 @@
     \cxtSer [in] cxtSer Pointer to context of server side. (It is only used in case of attached mode).
     */
-    CContextClient::CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_, CContext* cxtSer)
+    CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer)
      : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4)
     {
@@ -27 +27 @@
       intraComm = intraComm_;
       interComm = interComm_;
-      ep_lib::MPI_Comm_rank(intraComm, &clientRank);
-      ep_lib::MPI_Comm_size(intraComm, &clientSize);
+      MPI_Comm_rank(intraComm, &clientRank);
+      MPI_Comm_size(intraComm, &clientSize);
 
       int flag;
-      ep_lib::MPI_Comm_test_inter(interComm, &flag);
-      if (flag) ep_lib::MPI_Comm_remote_size(interComm, &serverSize);
-      else  ep_lib::MPI_Comm_size(interComm, &serverSize);
+      MPI_Comm_test_inter(interComm, &flag);
+      if (flag) MPI_Comm_remote_size(interComm, &serverSize);
+      else  MPI_Comm_size(interComm, &serverSize);
 
       computeLeader(clientRank, clientSize, serverSize, ranksServerLeader, ranksServerNotLeader);
@@ -102 +102 @@
         classId_in=event.getClassId() ;
 //        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_UINT64_T, MPI_SUM, intraComm) ; // MPI_UINT64_T standardized by MPI 3
-        ep_lib::MPI_Allreduce(&timeLine,&timeLine_out, 1, EP_LONG_LONG_INT, EP_SUM, intraComm) ; 
-        ep_lib::MPI_Allreduce(&typeId_in,&typeId, 1, EP_INT, EP_SUM, intraComm) ;
-        ep_lib::MPI_Allreduce(&classId_in,&classId, 1, EP_INT, EP_SUM, intraComm) ;
+        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_LONG_LONG_INT, MPI_SUM, intraComm) ; 
+        MPI_Allreduce(&typeId_in,&typeId, 1, MPI_INT, MPI_SUM, intraComm) ;
+        MPI_Allreduce(&classId_in,&classId, 1, MPI_INT, MPI_SUM, intraComm) ;
         if (typeId/clientSize!=event.getTypeId() || classId/clientSize!=event.getClassId() || timeLine_out/clientSize!=timeLine)
         {
@@ -343 +343 @@
        if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio;
      }
-     #ifdef _usingMPI
-     ep_lib::MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm);
-     #elif _usingEP
-     ep_lib::MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm);
-     #endif
+     MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm);
 
      if (minBufferSizeEventSizeRatio < 1.0)

XIOS/trunk/src/context_client.hpp

@@ -27 +27 @@
     public:
       // Contructor
-      CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* parentServer = 0);
+      CContextClient(CContext* parent, MPI_Comm intraComm, MPI_Comm interComm, CContext* parentServer = 0);
 
       // Send event to server
@@ -71 +71 @@
       int serverSize; //!< Size of server group
 
-      ep_lib::MPI_Comm interComm; //!< Communicator of server group
+      MPI_Comm interComm; //!< Communicator of server group
 
-      ep_lib::MPI_Comm intraComm; //!< Communicator of client group
+      MPI_Comm intraComm; //!< Communicator of client group
 
       map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers

XIOS/trunk/src/context_server.cpp

@@ -23 +23 @@
 {
 
-  CContextServer::CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm_,ep_lib::MPI_Comm interComm_)
+  CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_)
   {
     context=parent;
     intraComm=intraComm_;
-    ep_lib::MPI_Comm_size(intraComm,&intraCommSize);
-    ep_lib::MPI_Comm_rank(intraComm,&intraCommRank);
+    MPI_Comm_size(intraComm,&intraCommSize);
+    MPI_Comm_rank(intraComm,&intraCommRank);
 
     interComm=interComm_;
     int flag;
-    ep_lib::MPI_Comm_test_inter(interComm,&flag);
-    if (flag) ep_lib::MPI_Comm_remote_size(interComm,&commSize);
-    else  ep_lib::MPI_Comm_size(interComm,&commSize);
+    MPI_Comm_test_inter(interComm,&flag);
+    if (flag) MPI_Comm_remote_size(interComm,&commSize);
+    else  MPI_Comm_size(interComm,&commSize);
 
     currentTimeLine=0;
@@ -76 +76 @@
     int count;
     char * addr;
-    ep_lib::MPI_Status status;
+    MPI_Status status;
     map<int,CServerBuffer*>::iterator it;
     bool okLoop;
 
     traceOff();
-    #ifdef _usingMPI
     MPI_Iprobe(MPI_ANY_SOURCE, 20,interComm,&flag,&status);
-    #elif _usingEP
-    ep_lib::MPI_Iprobe(-2, 20,interComm,&flag,&status);
-    #endif
     traceOn();
 
     if (flag==true)
     {
-      #ifdef _usingMPI
       rank=status.MPI_SOURCE ;
-      #elif _usingEP
-      rank=status.ep_src ;
-      #endif
       okLoop = true;
       if (pendingRequest.find(rank)==pendingRequest.end())
@@ -106 +98 @@
 
             traceOff();
-            ep_lib::MPI_Iprobe(rank, 20,interComm,&flag,&status);
+            MPI_Iprobe(rank, 20,interComm,&flag,&status);
             traceOn();
             if (flag==true) listenPendingRequest(status) ;
@@ -115 +107 @@
   }
 
-  bool CContextServer::listenPendingRequest(ep_lib::MPI_Status& status)
+  bool CContextServer::listenPendingRequest(MPI_Status& status)
   {
     int count;
     char * addr;
     map<int,CServerBuffer*>::iterator it;
-    #ifdef _usingMPI
     int rank=status.MPI_SOURCE ;
-    #elif _usingEP
-    int rank=status.ep_src ;
-    #endif
 
     it=buffers.find(rank);
@@ -130 +118 @@
     {
        StdSize buffSize = 0;
-       ep_lib::MPI_Recv(&buffSize, 1, EP_LONG, rank, 20, interComm, &status);
+       MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status);
        mapBufferSize_.insert(std::make_pair(rank, buffSize));
        it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first;
@@ -137 +125 @@
     else
     {
-      ep_lib::MPI_Get_count(&status,EP_CHAR,&count);
+      MPI_Get_count(&status,MPI_CHAR,&count);
       if (it->second->isBufferFree(count))
       {
          addr=(char*)it->second->getBuffer(count);
-         ep_lib::MPI_Irecv(addr,count,EP_CHAR,rank,20,interComm,&pendingRequest[rank]);
+         MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]);
          bufferRequest[rank]=addr;
          return true;
@@ -153 +141 @@
   void CContextServer::checkPendingRequest(void)
   {
-    map<int,ep_lib::MPI_Request>::iterator it;
+    map<int,MPI_Request>::iterator it;
     list<int> recvRequest;
     list<int>::iterator itRecv;
@@ -159 +147 @@
     int flag;
     int count;
-    ep_lib::MPI_Status status;
+    MPI_Status status;
 
     for(it=pendingRequest.begin();it!=pendingRequest.end();it++)
@@ -165 +153 @@
       rank=it->first;
       traceOff();
-      ep_lib::MPI_Test(& it->second, &flag, &status);
+      MPI_Test(& it->second, &flag, &status);
       traceOn();
       if (flag==true)
       {
         recvRequest.push_back(rank);
-        ep_lib::MPI_Get_count(&status,EP_CHAR,&count);
+        MPI_Get_count(&status,MPI_CHAR,&count);
         processRequest(rank,bufferRequest[rank],count);
       }
@@ -230 +218 @@
          // The best way to properly solve this problem will be to use the event scheduler also in attached mode
          // for now just set up a MPI barrier
-         if (!CServer::eventScheduler && CXios::isServer) ep_lib::MPI_Barrier(intraComm) ;
+         if (!CServer::eventScheduler && CXios::isServer) MPI_Barrier(intraComm) ;
 
          CTimer::get("Process events").resume();

XIOS/trunk/src/context_server.hpp

@@ -14 +14 @@
     public:
 
-    CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm,ep_lib::MPI_Comm interComm) ;
+    CContextServer(CContext* parent,MPI_Comm intraComm,MPI_Comm interComm) ;
     bool eventLoop(bool enableEventsProcessing = true);
     void listen(void) ;
-    bool listenPendingRequest(ep_lib::MPI_Status& status) ;
+    bool listenPendingRequest(MPI_Status& status) ;
     void checkPendingRequest(void) ;
     void processRequest(int rank, char* buff,int count) ;
@@ -26 +26 @@
     bool hasPendingEvent(void) ;
 
-    ep_lib::MPI_Comm intraComm ;
+    MPI_Comm intraComm ;
     int intraCommSize ;
     int intraCommRank ;
 
-    ep_lib::MPI_Comm interComm ;
+    MPI_Comm interComm ;
     int commSize ;
 
     map<int,CServerBuffer*> buffers ;
-    map<int,ep_lib::MPI_Request> pendingRequest ;
+    map<int,MPI_Request> pendingRequest ;
     map<int,char*> bufferRequest ;
 

XIOS/trunk/src/cxios.cpp

@@ -26 +26 @@
   bool CXios::isClient ;
   bool CXios::isServer ;
-  ep_lib::MPI_Comm CXios::globalComm ;
+  MPI_Comm CXios::globalComm ;
   bool CXios::usingOasis ;
   bool CXios::usingServer = false;
@@ -90 +90 @@
 
     checkEventSync = getin<bool>("check_event_sync", checkEventSync);
-    #ifdef _usingMPI
+
     globalComm=MPI_COMM_WORLD ;
-    #elif _usingEP
-    ep_lib::MPI_Comm *ep_comm;
-    ep_lib::MPI_Info info;
-    ep_lib::MPI_Comm_create_endpoints(EP_COMM_WORLD->mpi_comm, 1, info, ep_comm);
-    ep_lib::passage = ep_comm;
-    globalComm=ep_lib::passage[0] ;
-    #endif
   }
 
@@ -107 +100 @@
   \param [in/out] returnComm communicator corresponding to group of client with same codeId
   */
-  void CXios::initClientSide(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm)
+  void CXios::initClientSide(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm)
   TRY
   {
+    initialize() ;
+
     isClient = true;
-    isServer = false;
-
-    initialize() ;
-
 
     CClient::initialize(codeId,localComm,returnComm) ;
     if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ;
-
 
     // If there are no server processes then we are in attached mode
@@ -177 +167 @@
   void CXios::initServerSide(void)
   {
-    isClient = false;
-    isServer = true;
-
     initServer();
     isClient = false;
     isServer = true;
+
     // Initialize all aspects MPI
     CServer::initialize();
@@ -235 +223 @@
         int firstPoolGlobalRank = secondaryServerGlobalRanks[0];
         int rankGlobal;
-        ep_lib::MPI_Comm_rank(globalComm, &rankGlobal);
+        MPI_Comm_rank(globalComm, &rankGlobal);
 
         // Merge registries defined on each pools
@@ -247 +235 @@
             globalRegistrySndServers.mergeRegistry(*globalRegistry) ;
             int registrySize = globalRegistrySndServers.size();
-            ep_lib::MPI_Send(&registrySize,1,EP_LONG,firstPoolGlobalRank,15,CXios::globalComm) ;
+            MPI_Send(&registrySize,1,MPI_LONG,firstPoolGlobalRank,15,CXios::globalComm) ;
             CBufferOut buffer(registrySize) ;
             globalRegistrySndServers.toBuffer(buffer) ;
-            ep_lib::MPI_Send(buffer.start(),registrySize,EP_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ;
+            MPI_Send(buffer.start(),registrySize,MPI_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ;
           }
         }
@@ -257 +245 @@
         if (rankGlobal == firstPoolGlobalRank)
         {
-          ep_lib::MPI_Status status;
+          MPI_Status status;
           char* recvBuff;
 
@@ -266 +254 @@
             int rank = secondaryServerGlobalRanks[i];
             int registrySize = 0;
-            ep_lib::MPI_Recv(&registrySize, 1, EP_LONG, rank, 15, CXios::globalComm, &status);
+            MPI_Recv(&registrySize, 1, MPI_LONG, rank, 15, CXios::globalComm, &status);
             recvBuff = new char[registrySize];
-            ep_lib::MPI_Recv(recvBuff, registrySize, EP_CHAR, rank, 15, CXios::globalComm, &status);
+            MPI_Recv(recvBuff, registrySize, MPI_CHAR, rank, 15, CXios::globalComm, &status);
             CBufferIn buffer(recvBuff, registrySize) ;
             CRegistry recvRegistry;

XIOS/trunk/src/cxios.hpp

@@ -15 +15 @@
     public:
      static void initialize(void) ;
-     static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ;
+     static void initClientSide(const string & codeId, MPI_Comm& localComm, MPI_Comm& returnComm) ;
      static void initServerSide(void) ;
      static void clientFinalize(void) ;
@@ -40 +40 @@
      static bool isServer ; //!< Check if xios is server
 
-     static ep_lib::MPI_Comm globalComm ; //!< Global communicator
+     static MPI_Comm globalComm ; //!< Global communicator
 
      static bool printLogs2Files; //!< Printing out logs into files

XIOS/trunk/src/dht_auto_indexing.cpp

@@ -22 +22 @@
 
   CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
-                                     const ep_lib::MPI_Comm& clientIntraComm)
+                                     const MPI_Comm& clientIntraComm)
     : CClientClientDHTTemplate<size_t>(clientIntraComm)
   {
@@ -28 +28 @@
     nbIndexOnProc_ = hashValue.size();
     size_t nbIndexAccum;
-    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm);
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
 
     // Broadcasting the total number of indexes
     int rank, size;
-    ep_lib::MPI_Comm_rank(clientIntraComm, &rank);
-    ep_lib::MPI_Comm_size(clientIntraComm, &size);
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
     if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
-    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm);
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
 
     CArray<size_t,1>::const_iterator itbIdx = hashValue.begin(), itIdx,
@@ -58 +58 @@
   */
   CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap,
-                                     const ep_lib::MPI_Comm& clientIntraComm)
+                                     const MPI_Comm& clientIntraComm)
     : CClientClientDHTTemplate<size_t>(clientIntraComm)
   {
@@ -64 +64 @@
     nbIndexOnProc_ = hashInitMap.size();
     size_t nbIndexAccum;
-    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm);
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
 
     int rank, size;
-    ep_lib::MPI_Comm_rank(clientIntraComm, &rank);
-    ep_lib::MPI_Comm_size(clientIntraComm, &size);
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
     if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
-    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm);
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
 
     Index2VectorInfoTypeMap::iterator itbIdx = hashInitMap.begin(), itIdx,

XIOS/trunk/src/dht_auto_indexing.hpp

@@ -25 +25 @@
 
     CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
-                     const ep_lib::MPI_Comm& clientIntraComm);
+                     const MPI_Comm& clientIntraComm);
 
     CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap,
-                     const ep_lib::MPI_Comm& clientIntraComm);
+                     const MPI_Comm& clientIntraComm);
 
     size_t getNbIndexesGlobal() const;

XIOS/trunk/src/event_scheduler.cpp

@@ -8 +8 @@
  
  
-  CEventScheduler::CEventScheduler(const ep_lib::MPI_Comm& comm) 
-  {
-    ep_lib::MPI_Comm_dup(comm, &communicator) ;
-    ep_lib::MPI_Comm_size(communicator,&mpiSize) ;
-    ep_lib::MPI_Comm_rank(communicator,&mpiRank);
+  CEventScheduler::CEventScheduler(const MPI_Comm& comm) 
+  {
+    MPI_Comm_dup(comm, &communicator) ;
+    MPI_Comm_size(communicator,&mpiSize) ;
+    MPI_Comm_rank(communicator,&mpiRank);
 
 
@@ -88 +88 @@
 
     pendingSentParentRequest.push(sentRequest) ;
-    ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ;
+    MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ;
     traceOn() ;
   } 
@@ -115 +115 @@
   {
     int completed ;
-    ep_lib::MPI_Status status ;
+    MPI_Status status ;
     int received ;
     SPendingRequest* recvRequest ;
@@ -135 +135 @@
     while(received)
     {
-      #ifdef _usingMPI
       MPI_Iprobe(MPI_ANY_SOURCE,1,communicator,&received, &status) ;
-      #elif _usingEP
-      ep_lib::MPI_Iprobe(-2,1,communicator,&received, &status) ;
-      #endif
       if (received)
       {
         recvRequest=new SPendingRequest ;
-        #ifdef _usingMPI
         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 1, communicator, &(recvRequest->request)) ;
-        #elif _usingEP
-        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 1, communicator, &(recvRequest->request)) ;
-        #endif
         pendingRecvParentRequest.push(recvRequest) ;
       }
@@ -157 +149 @@
     {
       recvRequest=pendingRecvParentRequest.front() ;
-      ep_lib::MPI_Test( &(recvRequest->request), &completed, &status) ;
+      MPI_Test( &(recvRequest->request), &completed, &status) ;
       if (completed) 
       {
@@ -177 +169 @@
 // function call only by parent mpi process
 
-    ep_lib::MPI_Status status ; 
+    MPI_Status status ; 
     int received ;
     received=true ;
@@ -185 +177 @@
     while(received)
     {
-      #ifdef _usingMPI
       MPI_Iprobe(MPI_ANY_SOURCE,0,communicator,&received, &status) ;
-      #elif _usingEP
-      ep_lib::MPI_Iprobe(-2,0,communicator,&received, &status) ;
-      #endif
       if (received)
       {
         recvRequest=new SPendingRequest ;
-        #ifdef _usingMPI
         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 0, communicator, &recvRequest->request) ;
-        #elif _usingEP
-        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 0, communicator, &recvRequest->request) ;
-        #endif
         pendingRecvChildRequest.push_back(recvRequest) ;
       }
@@ -206 +190 @@
     for(list<SPendingRequest*>::iterator it=pendingRecvChildRequest.begin(); it!=pendingRecvChildRequest.end() ; )
     {
-      ep_lib::MPI_Test(&((*it)->request),&received,&status) ;
+      MPI_Test(&((*it)->request),&received,&status) ;
       if (received)
       {
@@ -244 +228 @@
     for(list<SPendingRequest*>::iterator it=pendingSentChildRequest.begin(); it!=pendingSentChildRequest.end() ; )
     {
-      ep_lib::MPI_Test(&(*it)->request,&received,&status) ;
+      MPI_Test(&(*it)->request,&received,&status) ;
       if (received)
       {
@@ -267 +251 @@
       sentRequest->buffer[1]=contextHashId ;
       sentRequest->buffer[2]=lev+1 ;
-      ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ;
+      MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ;
       pendingSentChildRequest.push_back(sentRequest) ;
     }

XIOS/trunk/src/event_scheduler.hpp

@@ -26 +26 @@
         *  @param[in] comm : MPI communicator du duplicate for internal use
         */
-       CEventScheduler(const ep_lib::MPI_Comm& comm) ;
+       CEventScheduler(const MPI_Comm& comm) ;
 
 
@@ -151 +151 @@
        {
          size_t buffer[3] ;      /*!< communication buffer : timeLine, hashId, level */
-         ep_lib::MPI_Request request ;   /*!< pending MPI request */ 
+         MPI_Request request ;   /*!< pending MPI request */ 
        } ;
        
-       ep_lib::MPI_Comm communicator ;  /*!< Internal MPI communicator */ 
+       MPI_Comm communicator ;  /*!< Internal MPI communicator */ 
        int mpiRank ;            /*!< Rank in the communicator */
        int mpiSize ;            /*!< Size of the communicator */

XIOS/trunk/src/filter/spatial_transform_filter.cpp

@@ -224 +224 @@
 
       idxSendBuff = 0;
-      std::vector<ep_lib::MPI_Request> sendRecvRequest;
+      std::vector<MPI_Request> sendRecvRequest;
       for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff)
       {
@@ -234 +234 @@
           sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx));
         }
-        sendRecvRequest.push_back(ep_lib::MPI_Request());
-        ep_lib::MPI_Isend(sendBuff[idxSendBuff], countSize, EP_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
+        sendRecvRequest.push_back(MPI_Request());
+        MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
       }
 
@@ -252 +252 @@
         int srcRank = itRecv->first;
         int countSize = itRecv->second.size();
-        sendRecvRequest.push_back(ep_lib::MPI_Request());
-        ep_lib::MPI_Irecv(recvBuff + currentBuff, countSize, EP_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
+        sendRecvRequest.push_back(MPI_Request());
+        MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
         currentBuff += countSize;
       }
-      std::vector<ep_lib::MPI_Status> status(sendRecvRequest.size());
-      ep_lib::MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]);
+      std::vector<MPI_Status> status(sendRecvRequest.size());
+      MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]);
 
       dataCurrentDest.resize(*itNbListRecv);

XIOS/trunk/src/interface/c/icdata.cpp

@@ -60 +60 @@
    {
       std::string str;
-      ep_lib::MPI_Comm local_comm;
-      ep_lib::MPI_Comm return_comm;
+      MPI_Comm local_comm;
+      MPI_Comm return_comm;
 
       if (!cstr2string(client_id, len_client_id, str)) return;
 
       int initialized;
-      ep_lib::MPI_Initialized(&initialized);
-      #ifdef _usingMPI
+      MPI_Initialized(&initialized);
       if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
       else local_comm=MPI_COMM_NULL;
-      #elif _usingEP
-      if (initialized) local_comm=EP_Comm_f2c(f_local_comm);
-      else local_comm=EP_COMM_NULL;
-      #endif
       CXios::initClientSide(str, local_comm, return_comm);
-      #ifdef _usingMPI
       *f_return_comm=MPI_Comm_c2f(return_comm);
-      #elif _usingEP
-      *f_return_comm=*static_cast<MPI_Fint* >(EP_Comm_c2f(return_comm));
-      #endif
       CTimer::get("XIOS init").suspend();
       CTimer::get("XIOS").suspend();
@@ -89 +80 @@
    {
      std::string str;
-     ep_lib::MPI_Comm comm;
+     MPI_Comm comm;
 
      if (!cstr2string(context_id, len_context_id, str)) return;
      CTimer::get("XIOS").resume();
      CTimer::get("XIOS init context").resume();
-     #ifdef _usingMPI
      comm=MPI_Comm_f2c(*f_comm);
-     #elif _usingEP
-     comm=EP_Comm_f2c(f_comm);
-     #endif
      CClient::registerContext(str, comm);
      CTimer::get("XIOS init context").suspend();

XIOS/trunk/src/interface/c/oasis_cinterface.cpp

@@ -21 +21 @@
   }
 
-  void oasis_get_localcomm(ep_lib::MPI_Comm& comm)
+  void oasis_get_localcomm(MPI_Comm& comm)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_localcomm(&f_comm) ;
-    //comm=MPI_Comm_f2c(f_comm) ;
+    comm=MPI_Comm_f2c(f_comm) ;
   }
  
-  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id)
+  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ;
-    //comm_client_server=MPI_Comm_f2c(f_comm) ;
+    comm_client_server=MPI_Comm_f2c(f_comm) ;
   }
  
-  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id)
+  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ;
-    //comm_client_server=MPI_Comm_f2c(f_comm) ;
+    comm_client_server=MPI_Comm_f2c(f_comm) ;
   }
 }

XIOS/trunk/src/interface/c/oasis_cinterface.hpp

@@ -10 +10 @@
   void fxios_oasis_enddef(void) ;
   void fxios_oasis_finalize(void) ;
-  void fxios_oasis_get_localcomm(ep_lib::MPI_Fint* f_comm) ;
-  void fxios_oasis_get_intracomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
-  void fxios_oasis_get_intercomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
+  void fxios_oasis_get_localcomm(MPI_Fint* f_comm) ;
+  void fxios_oasis_get_intracomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
+  void fxios_oasis_get_intercomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
 }
  
@@ -20 +20 @@
   void oasis_enddef(void) ;
   void oasis_finalize(void) ;
-  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) ;
-  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ;
-  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ;
+  void oasis_get_localcomm(MPI_Comm& comm) ;
+  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) ;
+  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) ;
 }
 #endif

XIOS/trunk/src/io/inetcdf4.cpp

@@ -7 +7 @@
 namespace xios
 {
-  CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
+  CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
                        bool readMetaDataPar /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
   {
@@ -14 +14 @@
     {
       int commSize = 0;
-      ep_lib::MPI_Comm_size(*comm, &commSize);
+      MPI_Comm_size(*comm, &commSize);
       if (commSize <= 1)
         comm = NULL;
@@ -23 +23 @@
     // even if Parallel NetCDF ends up being used.
     if (mpi)
-      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, EP_INFO_NULL, this->ncidp);
+      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, MPI_INFO_NULL, this->ncidp);
     else
       CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp);

XIOS/trunk/src/io/inetcdf4.hpp

@@ -22 +22 @@
     public:
       /// Constructors ///
-      CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true,
+      CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true,
                 bool readMetaDataPar = false, const StdString& timeCounterName = "time_counter");
 

XIOS/trunk/src/io/nc4_data_input.cpp

@@ -10 +10 @@
 namespace xios
 {
-  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
+  CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
                                bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
     : SuperClass()

XIOS/trunk/src/io/nc4_data_input.hpp

@@ -23 +23 @@
 
     /// Constructors ///
-    CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true,
+    CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true,
                   bool readMetaDataPar = false, bool ugridConvention = false, const StdString& timeCounterName = "time_counter");
     CNc4DataInput(const CNc4DataInput& dataInput);       // Not implemented.
@@ -70 +70 @@
   private:
     /// Private attributes ///
-    ep_lib::MPI_Comm comm_file;
+    MPI_Comm comm_file;
     const StdString filename;
     bool isCollective;

XIOS/trunk/src/io/nc4_data_output.cpp

@@ -28 +28 @@
       CNc4DataOutput::CNc4DataOutput
          (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention,
-          ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName)
+          MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName)
             : SuperClass()
             , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName)

XIOS/trunk/src/io/nc4_data_output.hpp

@@ -27 +27 @@
                (CFile* file, const StdString & filename, bool exist, bool useClassicFormat,
                 bool useCFConvention,
-                ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true,
+                MPI_Comm comm_file, bool multifile, bool isCollective = true,
                 const StdString& timeCounterName = "time_counter");
 
@@ -117 +117 @@
 
             /// Propriétés privées ///
-            ep_lib::MPI_Comm comm_file;
+            MPI_Comm comm_file;
             const StdString filename;
             std::map<Time, StdSize> timeToRecordCache;

XIOS/trunk/src/io/netCdfInterface.cpp

@@ -10 +10 @@
 #include "netCdfInterface.hpp"
 #include "netCdfException.hpp"
-#include "ep_mpi.hpp"
+
 namespace xios
 {
@@ -47 +47 @@
 \return Status code
 */
-int CNetCdfInterface::createPar(const StdString& fileName, int cMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId)
-{
-  #ifdef _usingMPI
+int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId)
+{
   int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId);
-  #elif _usingEP
-  int status = xios::nc_create_par(fileName.c_str(), cMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId);
-  #endif
   if (NC_NOERR != status)
   {
@@ -104 +100 @@
 \return Status code
 */
-int CNetCdfInterface::openPar(const StdString& fileName, int oMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId)
-{
-  #ifdef _usingMPI
+int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId)
+{
   int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId);
-  #elif _usingEP
-  int status = xios::nc_open_par(fileName.c_str(), oMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId);
-  #endif
   if (NC_NOERR != status)
   {

XIOS/trunk/src/io/netCdfInterface.hpp

@@ -32 +32 @@
 
     //! Create a netcdf file on a parallel file system
-    static int createPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId);
+    static int createPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId);
 
     //! Open a netcdf file
@@ -38 +38 @@
 
     //! Open a netcdf file
-    static int openPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId);
+    static int openPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId);
 
     //! Close a netcdf file

XIOS/trunk/src/io/onetcdf4.cpp

@@ -15 +15 @@
       CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat,
                                                         bool useCFConvention,
-                           const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                           const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
         : path()
         , wmpi(false)
@@ -33 +33 @@
 
       void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
-                                 const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                                 const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
       {
          this->useClassicFormat = useClassicFormat;
@@ -44 +44 @@
          {
             int commSize = 0;
-            ep_lib::MPI_Comm_size(*comm, &commSize);
+            MPI_Comm_size(*comm, &commSize);
             if (commSize <= 1)
                comm = NULL;
@@ -58 +58 @@
             CTimer::get("Files : create").resume();
             if (wmpi)
-               CNetCdfInterface::createPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp);
+               CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::create(filename, mode, this->ncidp);
@@ -70 +70 @@
             CTimer::get("Files : open").resume();
             if (wmpi)
-               CNetCdfInterface::openPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp);
+               CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::open(filename, mode, this->ncidp);

XIOS/trunk/src/io/onetcdf4.hpp

@@ -28 +28 @@
             CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false,
                           bool useCFConvention = true,
-                      const ep_lib::MPI_Comm* comm = NULL, bool multifile = true,
+                      const MPI_Comm* comm = NULL, bool multifile = true,
                       const StdString& timeCounterName = "time_counter");
 
@@ -37 +37 @@
             /// Initialisation ///
             void initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,
-                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
+                            const MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
             void close(void);
             void sync(void);

XIOS/trunk/src/mpi.hpp

@@ -11 +11 @@
 #define OMPI_SKIP_MPICXX
 
-#ifdef _usingEP
-#include "ep_lib.hpp"
-#include "ep_declaration.hpp"
-#endif
-
 #include <mpi.h>
 
-#ifdef _usingMPI
-
-#define ep_lib  
-
-#define EP_INT MPI_INT
-#define EP_FLOAT MPI_FLOAT
-#define EP_DOUBLE MPI_DOUBLE
-#define EP_CHAR MPI_CHAR
-#define EP_LONG MPI_LONG
-#define EP_LONG_LONG_INT MPI_LONG_LONG_INT
-#define EP_UNSIGNED_LONG  MPI_UNSIGNED_LONG
-#define EP_UNSIGNED_CHAR  MPI_UNSIGNED_CHAR
-
-
-#define EP_COMM_WORLD MPI_COMM_WORLD
-#define EP_COMM_NULL MPI_COMM_NULL
-#define EP_INFO_NULL MPI_INFO_NULL
-
-#define EP_MAX MPI_MAX
-#define EP_MIN MPI_MIN
-#define EP_SUM MPI_SUM
-#define EP_LOR MPI_LOR
-
 #endif
-
-#endif

XIOS/trunk/src/node/axis.cpp

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

XIOS/trunk/src/node/axis.hpp

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

XIOS/trunk/src/node/context.cpp

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

XIOS/trunk/src/node/context.hpp

@@ -88 +88 @@
       public :
          // Initialize server or client
-         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);
+         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
+         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
          bool isInitialized(void);
 
@@ -263 +263 @@
          StdString idServer_;
          CGarbageCollector garbageCollector;
-         std::list<ep_lib::MPI_Comm> comms; //!< Communicators allocated internally
+         std::list<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(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return numberWrittenIndexes_[writtenSize];
    }
@@ -112 +112 @@
      \return the total number of indexes written by the servers
    */
-   int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return totalNumberWrittenIndexes_[writtenSize];
    }
@@ -125 +125 @@
      \return the offset of indexes written by each server
    */
-   int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return offsetWrittenIndexes_[writtenSize];
    }
    CATCH_DUMP_ATTR
 
-   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
+   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return compressedIndexToWriteOnServer[writtenSize];
    }
@@ -690 +690 @@
      int v ;
      v=ibegin ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,ibegin_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ;
      v=jbegin ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,jbegin_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ;
      v=ni ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,ni_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ;
      v=nj ;
-     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) ;
+     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) ;
 
       delete[] ibegin_g ;
@@ -1932 +1932 @@
           displs[0] = 0;
           int localCount = connectedServerRank_[nbServer].size() ;
-          ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
+          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
           for (int i = 0; i < clientSize-1; ++i)
           {
@@ -1938 +1938 @@
           }
           std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]);
-          ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
+          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
 
           if ((allConnectedServers.size() != nbServer) && (rank == 0))
@@ -2003 +2003 @@
    CATCH_DUMP_ATTR
 
-  void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
+  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
   TRY
   {
     int writtenCommSize;
-    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
+    MPI_Comm_size(writtenComm, &writtenCommSize);
     if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
       return;
@@ -2064 +2064 @@
       {
              
-        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);
+        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
         offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
       }

XIOS/trunk/src/node/domain.hpp

@@ -94 +94 @@
          bool isWrittenCompressed(const StdString& filename) const;
          
-         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);
+         int getNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
+         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
 
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
@@ -116 +116 @@
          
          void computeWrittenIndex();
-         void computeWrittenCompressedIndex(ep_lib::MPI_Comm);
+         void computeWrittenCompressedIndex(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(EP_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_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(EP_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
       , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
     {
@@ -307 +307 @@
 
       int color = allZoneEmpty ? 0 : 1;
-      ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
-      if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm);
+      MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
+      if (allZoneEmpty) MPI_Comm_free(&fileComm);
     }
     CATCH_DUMP_ATTR
@@ -554 +554 @@
          {
             int commSize, commRank;
-            ep_lib::MPI_Comm_size(fileComm, &commSize);
-            ep_lib::MPI_Comm_rank(fileComm, &commRank);
+            MPI_Comm_size(fileComm, &commSize);
+            MPI_Comm_rank(fileComm, &commRank);
 
             if (server->intraCommSize > 1)
@@ -634 +634 @@
     CContext* context = CContext::getCurrent();
     CContextServer* server = context->server;
-    ep_lib::MPI_Comm readComm = this->fileComm;
+    MPI_Comm readComm = this->fileComm;
 
     if (!allZoneEmpty)
@@ -677 +677 @@
       {
         int commSize, commRank;
-        ep_lib::MPI_Comm_size(readComm, &commSize);
-        ep_lib::MPI_Comm_rank(readComm, &commRank);
+        MPI_Comm_size(readComm, &commSize);
+        MPI_Comm_rank(readComm, &commRank);
 
         if (server->intraCommSize > 1)
@@ -722 +722 @@
         isOpen = false;
        }
-      if (fileComm != EP_COMM_NULL) ep_lib::MPI_Comm_free(&fileComm);
+      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm);
    }
    CATCH_DUMP_ATTR

XIOS/trunk/src/node/file.hpp

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

XIOS/trunk/src/node/grid.cpp

@@ -661 +661 @@
         {
           CContextServer* server = CContext::getCurrent()->server;      
-          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);
+          MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+          MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
           offsetWrittenIndexes_ -= numberWrittenIndexes_;
         }
@@ -856 +856 @@
          displs[0] = 0;
          int localCount = connectedServerRank_[receiverSize].size() ;
-         ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
+         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_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]);
-         ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
+         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_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 ep_lib::MPI_Comm& comm,
+  void CMesh::createMeshEpsilon(const 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;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    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;
-      ep_lib::MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+      MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
       nbEdgesAccum -= nbEdges_;
 
@@ -590 +590 @@
          unsigned long nodeCount = nodeIdx2Idx.size();
          unsigned long nodeStart, nbNodes;
-         ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
          int nNodes = nodeStart;
-         ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
          nbNodesGlo = nNodes;
 
@@ -683 +683 @@
       unsigned long nbFacesOnProc = nbFaces_;
       unsigned long nbFacesAccum;
-      ep_lib::MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+      MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
       nbFacesAccum -= nbFaces_;
 
@@ -807 +807 @@
 
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1028 +1028 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1298 +1298 @@
         unsigned long nodeCount = nodeIdx2Idx.size();
         unsigned long nodeStart, nbNodes;
-        ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nNodes = nodeStart;
-        ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbNodesGlo = nNodes;
 
@@ -1418 +1418 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1614 +1614 @@
    */
 
-  void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesNodeType(const 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;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1770 +1770 @@
    */
 
-  void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesEdgeType(const 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;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1951 +1951 @@
    */
 
-  void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm,
+  void CMesh::getGlobalNghbFaces(const int nghbType, const 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 ep_lib::MPI_Comm&,
+      void createMeshEpsilon(const MPI_Comm&,
                              const CArray<double, 1>&, const CArray<double, 1>&,
                              const CArray<double, 2>&, const CArray<double, 2>& );
 
-      void getGlobalNghbFaces(const int, const ep_lib::MPI_Comm&, const CArray<int, 1>&,
+      void getGlobalNghbFaces(const int, const 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 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 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 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>&);

XIOS/trunk/src/policy.cpp

@@ -49 +49 @@
 //}
 
-DivideAdaptiveComm::DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm)
+DivideAdaptiveComm::DivideAdaptiveComm(const MPI_Comm& mpiComm)
   : internalComm_(mpiComm), level_(0), groupBegin_(), nbInGroup_(), computed_(false)
 {
@@ -61 +61 @@
 
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(internalComm_,&mpiSize);
-  ep_lib::MPI_Comm_rank(internalComm_,&mpiRank);
+  MPI_Comm_size(internalComm_,&mpiSize);
+  MPI_Comm_rank(internalComm_,&mpiRank);
 
   int maxChild=1;

XIOS/trunk/src/policy.hpp

@@ -31 +31 @@
 {
 protected:
-  DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm);
+  DivideAdaptiveComm(const MPI_Comm& mpiComm);
 
   void computeMPICommLevel();
@@ -41 +41 @@
 
 protected:
-  const ep_lib::MPI_Comm& internalComm_;
+  const MPI_Comm& internalComm_;
   std::vector<std::vector<int> > groupParentsBegin_;
   std::vector<std::vector<int> > nbInGroupParents_;

XIOS/trunk/src/registry.cpp

@@ -191 +191 @@
   {
     int rank ;
-    ep_lib::MPI_Comm_rank(communicator,&rank);
+    MPI_Comm_rank(communicator,&rank);
     if (rank==0)
     {
@@ -197 +197 @@
       this->toBuffer(buffer) ;
       int size=buffer.count() ;
-      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ;
-      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
     }
     else
     {
       int size ;
-      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
       CBufferIn buffer(size) ;
-      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
       this->fromBuffer(buffer) ;
     }
@@ -214 +214 @@
   }
 
-  void CRegistry::gatherRegistry(const ep_lib::MPI_Comm& comm)
+  void CRegistry::gatherRegistry(const MPI_Comm& comm)
   {
     int rank,mpiSize ;
-    ep_lib::MPI_Comm_rank(comm,&rank);
-    ep_lib::MPI_Comm_size(comm,&mpiSize);
+    MPI_Comm_rank(comm,&rank);
+    MPI_Comm_size(comm,&mpiSize);
 
     int* sizes=new int[mpiSize] ;
@@ -224 +224 @@
     this->toBuffer(localBuffer) ;
     int localSize=localBuffer.count() ;
-    ep_lib::MPI_Gather(&localSize,1,EP_INT,sizes,1,EP_INT,0,comm) ;
+    MPI_Gather(&localSize,1,MPI_INT,sizes,1,MPI_INT,0,comm) ;
 
     char* globalBuffer ;
@@ -240 +240 @@
 
       globalBuffer=new char[globalBufferSize] ;
-      ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;
+      MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;
       for(int i=1;i<mpiSize;++i)
       {
@@ -251 +251 @@
       delete[] globalBuffer ;
     }
-    else  ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;   
+    else  MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;   
     delete[] sizes ;
     
@@ -261 +261 @@
   }
 
-  void CRegistry::hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm)
+  void CRegistry::hierarchicalGatherRegistry(const MPI_Comm& comm)
   {
     int mpiRank,mpiSize ;
-    ep_lib::MPI_Comm_rank(comm,&mpiRank);
-    ep_lib::MPI_Comm_size(comm,&mpiSize);    
+    MPI_Comm_rank(comm,&mpiRank);
+    MPI_Comm_size(comm,&mpiSize);    
 
     if (mpiSize>2)
@@ -272 +272 @@
       if (mpiRank<mpiSize/2+mpiSize%2) color=0 ;
       else color=1 ;
-      ep_lib::MPI_Comm commUp ;
-      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commUp) ,
+      MPI_Comm commUp ;
+      MPI_Comm_split(comm,color,mpiRank,&commUp) ,
       hierarchicalGatherRegistry(commUp) ;
-      ep_lib::MPI_Comm_free(&commUp) ;
+      MPI_Comm_free(&commUp) ;
     }
 
     if (mpiSize>1)
     {
-      ep_lib::MPI_Comm commDown ;
+      MPI_Comm commDown ;
       int color ;
       
       if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ;
       else color=1 ;
-      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commDown) ;
+      MPI_Comm_split(comm,color,mpiRank,&commDown) ;
       if (color==0) gatherRegistry(commDown) ;
-      ep_lib::MPI_Comm_free(&commDown) ;    
+      MPI_Comm_free(&commDown) ;    
     }
   }

XIOS/trunk/src/registry.hpp

@@ -23 +23 @@
 
 /** Constructor, the communicator is used for bcast or gather operation between MPI processes */
-      CRegistry(const ep_lib::MPI_Comm& comm=EP_COMM_WORLD) : communicator(comm) {}
+      CRegistry(const MPI_Comm& comm=MPI_COMM_WORLD) : communicator(comm) {}
 
 /** Copy constructor */
@@ -106 +106 @@
 
 /** use internally for recursivity */
-      void gatherRegistry(const ep_lib::MPI_Comm& comm) ;
+      void gatherRegistry(const MPI_Comm& comm) ;
 
 /** use internally for recursivity */
-      void hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) ;
+      void hierarchicalGatherRegistry(const MPI_Comm& comm) ;
 
 
@@ -120 +120 @@
 
 /** MPI communicator used for broadcast and gather operation */
-      ep_lib::MPI_Comm communicator ;
+      MPI_Comm communicator ;
   } ;
 

XIOS/trunk/src/server.cpp

@@ -18 +18 @@
 namespace xios
 {
-    ep_lib::MPI_Comm CServer::intraComm ;
-    std::list<ep_lib::MPI_Comm> CServer::interCommLeft ;
-    std::list<ep_lib::MPI_Comm> CServer::interCommRight ;
-    std::list<ep_lib::MPI_Comm> CServer::contextInterComms;
-    std::list<ep_lib::MPI_Comm> CServer::contextIntraComms;
+    MPI_Comm CServer::intraComm ;
+    std::list<MPI_Comm> CServer::interCommLeft ;
+    std::list<MPI_Comm> CServer::interCommRight ;
+    std::list<MPI_Comm> CServer::contextInterComms;
+    std::list<MPI_Comm> CServer::contextIntraComms;
     int CServer::serverLevel = 0 ;
     int CServer::nbContexts = 0;
@@ -48 +48 @@
     {
       int initialized ;
-      ep_lib::MPI_Initialized(&initialized) ;
+      MPI_Initialized(&initialized) ;
       if (initialized) is_MPI_Initialized=true ;
       else is_MPI_Initialized=false ;
@@ -59 +59 @@
         if (!is_MPI_Initialized)
         {
-          ep_lib::MPI_Init(NULL, NULL);
+          MPI_Init(NULL, NULL);
         }
         CTimer::get("XIOS").resume() ;
@@ -72 +72 @@
         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(&hashServer, 1, EP_LONG, hashAll, 1, EP_LONG, CXios::globalComm) ;
+        MPI_Allgather(&hashServer, 1, MPI_LONG, hashAll, 1, MPI_LONG, CXios::globalComm) ;
 
         map<unsigned long, int> colors ;
@@ -174 +174 @@
         // (2) Create intraComm
         if (serverLevel != 2) myColor=colors[hashServer];
-        ep_lib::MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ;
+        MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ;
 
         // (3) Create interComm
@@ -186 +186 @@
               clientLeader=it->second ;
               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::server (classical mode) "<<rank_<<" intraCommSize : "<<intraCommSize
                        <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
 
-              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
+              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
               interCommLeft.push_back(newComm) ;
             }
@@ -207 +207 @@
               clientLeader=it->second ;
               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::server (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize
                        <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
-              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
+              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
               interCommLeft.push_back(newComm) ;
             }
@@ -219 +219 @@
           {
             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 (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize
                 <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< sndServerGlobalRanks[i]<<endl ;
-            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ;
+            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ;
             interCommRight.push_back(newComm) ;
           }
@@ -232 +232 @@
           clientLeader = leaders[hashString(CXios::xiosCodeId)];
           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::server (server level 2) "<<rank_<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
 
-          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ;
+          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ;
           interCommLeft.push_back(newComm) ;
         }
@@ -253 +253 @@
 
         CTimer::get("XIOS").resume() ;
-        ep_lib::MPI_Comm localComm;
+        MPI_Comm localComm;
         oasis_get_localcomm(localComm);
-        ep_lib::MPI_Comm_rank(localComm,&rank_) ;
+        MPI_Comm_rank(localComm,&rank_) ;
 
 //      (1) Create server intraComm
         if (!CXios::usingServer2)
         {
-          ep_lib::MPI_Comm_dup(localComm, &intraComm);
+          MPI_Comm_dup(localComm, &intraComm);
         }
         else
         {
           int globalRank;
-          ep_lib::MPI_Comm_size(localComm,&size) ;
-          ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ;
+          MPI_Comm_size(localComm,&size) ;
+          MPI_Comm_rank(CXios::globalComm,&globalRank) ;
           srvGlobalRanks = new int[size] ;
-          ep_lib::MPI_Allgather(&globalRank, 1, EP_INT, srvGlobalRanks, 1, EP_INT, localComm) ;
+          MPI_Allgather(&globalRank, 1, MPI_INT, srvGlobalRanks, 1, MPI_INT, localComm) ;
 
           int reqNbProc = size*CXios::ratioServer2/100.;
@@ -276 +276 @@
                 << "It is impossible to dedicate the requested number of processes = "<<reqNbProc
                 <<" to secondary server. XIOS will run in the classical server mode."<<endl;
-            ep_lib::MPI_Comm_dup(localComm, &intraComm);
+            MPI_Comm_dup(localComm, &intraComm);
           }
           else
@@ -339 +339 @@
             }
             if (serverLevel != 2) myColor=0;
-            ep_lib::MPI_Comm_split(localComm, myColor, rank_, &intraComm) ;
+            MPI_Comm_split(localComm, myColor, rank_, &intraComm) ;
           }
         }
@@ -348 +348 @@
         vector<string>::iterator it ;
 
-        ep_lib::MPI_Comm newComm ;
+        MPI_Comm newComm ;
         int globalRank ;
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank);
+        MPI_Comm_rank(CXios::globalComm,&globalRank);
 
 //      (2) Create interComms with models
@@ -359 +359 @@
           {
             interCommLeft.push_back(newComm) ;
-            if (rank_==0) ep_lib::MPI_Send(&globalRank,1,EP_INT,0,0,newComm) ;
+            if (rank_==0) MPI_Send(&globalRank,1,MPI_INT,0,0,newComm) ;
           }
         }
@@ -365 +365 @@
 //      (3) Create interComms between primary and secondary servers
         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) ;
 
         if (serverLevel == 1)
@@ -375 +375 @@
             info(50)<<"intercommCreate::client (server level 1) "<<globalRank<<" intraCommSize : "<<intraCommSize
                 <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvSndLeader<<endl ;
-            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ;
+            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ;
             interCommRight.push_back(newComm) ;
           }
@@ -383 +383 @@
           info(50)<<"intercommCreate::server (server level 2)"<<globalRank<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvGlobalRanks[0] <<endl ;
-          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ;
+          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ;
           interCommLeft.push_back(newComm) ;
         }
@@ -393 +393 @@
 
 
-      ep_lib::MPI_Comm_rank(intraComm, &rank) ;
+      MPI_Comm_rank(intraComm, &rank) ;
       if (rank==0) isRoot=true;
       else isRoot=false;
@@ -406 +406 @@
       delete eventScheduler ;
 
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
-
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
+      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
+        MPI_Comm_free(&(*it));
+
+      for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++)
+        MPI_Comm_free(&(*it));
 
 //      for (std::list<MPI_Comm>::iterator it = interComm.begin(); it != interComm.end(); it++)
@@ -418 +418 @@
 //          MPI_Comm_free(&(*it));
 
-        for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
-          ep_lib::MPI_Comm_free(&(*it));
-
-      ep_lib::MPI_Comm_free(&intraComm);
+        for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
+          MPI_Comm_free(&(*it));
+
+      MPI_Comm_free(&intraComm);
 
       if (!is_MPI_Initialized)
       {
         if (CXios::usingOasis) oasis_finalize();
-        else ep_lib::MPI_Finalize() ;
+        else MPI_Finalize() ;
       }
       report(0)<<"Performance report : Time spent for XIOS : "<<CTimer::get("XIOS server").getCumulatedTime()<<endl  ;
@@ -465 +465 @@
      void CServer::listenFinalize(void)
      {
-        list<ep_lib::MPI_Comm>::iterator it, itr;
+        list<MPI_Comm>::iterator it, itr;
         int msg ;
         int flag ;
@@ -471 +471 @@
         for(it=interCommLeft.begin();it!=interCommLeft.end();it++)
         {
-           ep_lib::MPI_Status status ;
+           MPI_Status status ;
            traceOff() ;
-           ep_lib::MPI_Iprobe(0,0,*it,&flag,&status) ;
+           MPI_Iprobe(0,0,*it,&flag,&status) ;
            traceOn() ;
            if (flag==true)
            {
-              ep_lib::MPI_Recv(&msg,1,EP_INT,0,0,*it,&status) ;
+              MPI_Recv(&msg,1,MPI_INT,0,0,*it,&status) ;
               info(20)<<" CServer : Receive client finalize"<<endl ;
               // Sending server finalize message to secondary servers (if any)
               for(itr=interCommRight.begin();itr!=interCommRight.end();itr++)
               {
-                ep_lib::MPI_Send(&msg,1,EP_INT,0,0,*itr) ;
+                MPI_Send(&msg,1,MPI_INT,0,0,*itr) ;
               }
-              ep_lib::MPI_Comm_free(&(*it));
+              MPI_Comm_free(&(*it));
               interCommLeft.erase(it) ;
               break ;
@@ -493 +493 @@
          {
            int i,size ;
-           ep_lib::MPI_Comm_size(intraComm,&size) ;
-           ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size-1] ;
-           ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size-1] ;
-
-           for(int i=1;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,4,intraComm,&requests[i-1]) ;
-           ep_lib::MPI_Waitall(size-1,requests,status) ;
+           MPI_Comm_size(intraComm,&size) ;
+           MPI_Request* requests= new MPI_Request[size-1] ;
+           MPI_Status* status= new MPI_Status[size-1] ;
+
+           for(int i=1;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,4,intraComm,&requests[i-1]) ;
+           MPI_Waitall(size-1,requests,status) ;
 
            finished=true ;
@@ -510 +510 @@
      {
         int flag ;
-        ep_lib::MPI_Status status ;
+        MPI_Status status ;
         int msg ;
 
         traceOff() ;
-        ep_lib::MPI_Iprobe(0,4,intraComm, &flag, &status) ;
+        MPI_Iprobe(0,4,intraComm, &flag, &status) ;
         traceOn() ;
         if (flag==true)
         {
-           ep_lib::MPI_Recv(&msg,1,EP_INT,0,4,intraComm,&status) ;
+           MPI_Recv(&msg,1,MPI_INT,0,4,intraComm,&status) ;
            finished=true ;
         }
@@ -534 +534 @@
      {
         int flag ;
-        ep_lib::MPI_Status status ;
-        list<ep_lib::MPI_Comm>::iterator it;
+        MPI_Status status ;
+        list<MPI_Comm>::iterator it;
         int msg ;
         static int nbCompound=0 ;
         int size ;
         static bool sent=false ;
-        static ep_lib::MPI_Request* allRequests ;
-        static ep_lib::MPI_Status* allStatus ;
+        static MPI_Request* allRequests ;
+        static MPI_Status* allStatus ;
 
 
         if (sent)
         {
-          ep_lib::MPI_Comm_size(intraComm,&size) ;
-          ep_lib::MPI_Testall(size,allRequests, &flag, allStatus) ;
+          MPI_Comm_size(intraComm,&size) ;
+          MPI_Testall(size,allRequests, &flag, allStatus) ;
           if (flag==true)
           {
@@ -559 +559 @@
         for(it=interCommLeft.begin();it!=interCommLeft.end();it++)
         {
-           ep_lib::MPI_Status status ;
+           MPI_Status status ;
            traceOff() ;
-           ep_lib::MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5
+           MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5
            traceOn() ;
            if (flag==true)
            {
-              ep_lib::MPI_Recv(&msg,1,EP_INT,0,5,*it,&status) ; // tags oasis_endded = 5
+              MPI_Recv(&msg,1,MPI_INT,0,5,*it,&status) ; // tags oasis_endded = 5
               nbCompound++ ;
               if (nbCompound==interCommLeft.size())
               {
-                for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
+                for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
                 {
-                   ep_lib::MPI_Send(&msg,1,EP_INT,0,5,*it) ; // tags oasis_endded = 5
+                   MPI_Send(&msg,1,MPI_INT,0,5,*it) ; // tags oasis_endded = 5
                 }
-                ep_lib::MPI_Comm_size(intraComm,&size) ;
-                allRequests= new ep_lib::MPI_Request[size] ;
-                allStatus= new ep_lib::MPI_Status[size] ;
-                for(int i=0;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5
+                MPI_Comm_size(intraComm,&size) ;
+                allRequests= new MPI_Request[size] ;
+                allStatus= new MPI_Status[size] ;
+                for(int i=0;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5
                 sent=true ;
               }
@@ -590 +590 @@
      {
        int flag ;
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        const int root=0 ;
        int msg ;
@@ -607 +607 @@
          
        traceOff() ;
-       ep_lib::MPI_Iprobe(root,5,intraComm, &flag, &status) ;
+       MPI_Iprobe(root,5,intraComm, &flag, &status) ;
        traceOn() ;
        if (flag==true)
        {
-         ep_lib::MPI_Recv(&msg,1,EP_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5
+         MPI_Recv(&msg,1,MPI_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5
          boost::hash<string> hashString;
          size_t hashId = hashString("oasis_enddef");
@@ -626 +626 @@
      {
 
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        int flag ;
        static char* buffer ;
-       static ep_lib::MPI_Request request ;
+       static MPI_Request request ;
        static bool recept=false ;
        int rank ;
@@ -637 +637 @@
        {
          traceOff() ;
-         #ifdef _usingMPI
-         ep_lib::MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ;
-         #elif _usingEP
-         ep_lib::MPI_Iprobe(-2,1,CXios::globalComm, &flag, &status) ;
-         #endif
+         MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ;
          traceOn() ;
          if (flag==true)
          {
-           #ifdef _usingMPI
            rank=status.MPI_SOURCE ;
-           #elif _usingEP
-           rank=status.ep_src ;
-           #endif
-           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ;
+           MPI_Get_count(&status,MPI_CHAR,&count) ;
            buffer=new char[count] ;
-           ep_lib::MPI_Irecv((void*)buffer,count,EP_CHAR,rank,1,CXios::globalComm,&request) ;
+           MPI_Irecv((void*)buffer,count,MPI_CHAR,rank,1,CXios::globalComm,&request) ;
            recept=true ;
          }
@@ -659 +651 @@
        {
          traceOff() ;
-         ep_lib::MPI_Test(&request,&flag,&status) ;
+         MPI_Test(&request,&flag,&status) ;
          traceOn() ;
          if (flag==true)
          {
-           #ifdef _usingMPI
            rank=status.MPI_SOURCE ;
-           #elif _usingEP
-           rank=status.ep_src ;
-           #endif
-           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ;
+           MPI_Get_count(&status,MPI_CHAR,&count) ;
            recvContextMessage((void*)buffer,count) ;
            delete [] buffer ;
@@ -701 +689 @@
        {
          int size ;
-         ep_lib::MPI_Comm_size(intraComm,&size) ;
+         MPI_Comm_size(intraComm,&size) ;
 //         MPI_Request* requests= new MPI_Request[size-1] ;
 //         MPI_Status* status= new MPI_Status[size-1] ;
-         ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size] ;
-         ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size] ;
+         MPI_Request* requests= new MPI_Request[size] ;
+         MPI_Status* status= new MPI_Status[size] ;
 
          CMessage msg ;
@@ -717 +705 @@
          for(int i=0; i<size; i++)
          {
-           ep_lib::MPI_Isend(sendBuff,sendBuffer.count(),EP_CHAR,i,2,intraComm,&requests[i]) ;
+           MPI_Isend(sendBuff,sendBuffer.count(),MPI_CHAR,i,2,intraComm,&requests[i]) ;
          }
 
@@ -729 +717 @@
      void CServer::listenRootContext(void)
      {
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        int flag ;
        static std::vector<void*> buffers;
-       static std::vector<ep_lib::MPI_Request> requests ;
+       static std::vector<MPI_Request> requests ;
        static std::vector<int> counts ;
        static std::vector<bool> isEventRegistered ;
        static std::vector<bool> isEventQueued ;
-       ep_lib::MPI_Request request;
+       MPI_Request request;
 
        int rank ;
@@ -745 +733 @@
        // (1) Receive context id from the root, save it into a buffer
        traceOff() ;
-       ep_lib::MPI_Iprobe(root,2,intraComm, &flag, &status) ;
+       MPI_Iprobe(root,2,intraComm, &flag, &status) ;
        traceOn() ;
        if (flag==true)
        {
          counts.push_back(0);
-         ep_lib::MPI_Get_count(&status,EP_CHAR,&(counts.back())) ;
+         MPI_Get_count(&status,MPI_CHAR,&(counts.back())) ;
          buffers.push_back(new char[counts.back()]) ;
          requests.push_back(request);
-         ep_lib::MPI_Irecv((void*)(buffers.back()),counts.back(),EP_CHAR,root,2,intraComm,&(requests.back())) ;
+         MPI_Irecv((void*)(buffers.back()),counts.back(),MPI_CHAR,root,2,intraComm,&(requests.back())) ;
          isEventRegistered.push_back(false);
          isEventQueued.push_back(false);
@@ -762 +750 @@
        {
          // (2) If context id is received, register an event
-         ep_lib::MPI_Test(&requests[ctxNb],&flag,&status) ;
+         MPI_Test(&requests[ctxNb],&flag,&status) ;
          if (flag==true && !isEventRegistered[ctxNb])
          {
@@ -799 +787 @@
        // (1) create interComm (with a client)
        // (2) initialize client and server (contextClient and contextServer)
-       ep_lib::MPI_Comm inter;
+       MPI_Comm inter;
        if (serverLevel < 2)
        {
-         ep_lib::MPI_Comm contextInterComm;
-         ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm);
-         ep_lib::MPI_Intercomm_merge(contextInterComm,1,&inter);
-         ep_lib::MPI_Barrier(inter);
-         ep_lib::MPI_Comm_free(&inter);
+         MPI_Comm contextInterComm;
+         MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm);
+         MPI_Intercomm_merge(contextInterComm,1,&inter);
+         MPI_Barrier(inter);
+         MPI_Comm_free(&inter);
          context->initServer(intraComm,contextInterComm);
          contextInterComms.push_back(contextInterComm);
@@ -819 +807 @@
        else if (serverLevel == 2)
        {
-         ep_lib::MPI_Comm_dup(interCommLeft.front(), &inter);
+         MPI_Comm_dup(interCommLeft.front(), &inter);
          contextInterComms.push_back(inter);
          context->initServer(intraComm, contextInterComms.back());
@@ -830 +818 @@
        {
          int i = 0, size;
-         ep_lib::MPI_Comm_size(intraComm, &size) ;
-         for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i)
+         MPI_Comm_size(intraComm, &size) ;
+         for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i)
          {
            StdString str = contextId +"_server_" + boost::lexical_cast<string>(i);
@@ -841 +829 @@
            CBufferOut buffer(buff,messageSize) ;
            buffer<<msg ;
-           ep_lib::MPI_Send(buff, buffer.count(), EP_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ;
-           ep_lib::MPI_Comm_dup(*it, &inter);
+           MPI_Send(buff, buffer.count(), MPI_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ;
+           MPI_Comm_dup(*it, &inter);
            contextInterComms.push_back(inter);
-           ep_lib::MPI_Comm_dup(intraComm, &inter);
+           MPI_Comm_dup(intraComm, &inter);
            contextIntraComms.push_back(inter);
            context->initClient(contextIntraComms.back(), contextInterComms.back()) ;
@@ -874 +862 @@
      {
        int rank;
-       ep_lib::MPI_Comm_rank(intraComm,&rank);
+       MPI_Comm_rank(intraComm,&rank);
        return rank;
      }
@@ -897 +885 @@
       int size = 0;
       int id;
-      ep_lib::MPI_Comm_size(CXios::globalComm, &size);
+      MPI_Comm_size(CXios::globalComm, &size);
       while (size)
       {

XIOS/trunk/src/server.hpp

@@ -26 +26 @@
         static void registerContext(void* buff,int count, int leaderRank=0);
 
-        static ep_lib::MPI_Comm intraComm;
-        static std::list<ep_lib::MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server)
-        static std::list<ep_lib::MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool)
-        static std::list<ep_lib::MPI_Comm> contextInterComms;  // list of context intercomms
-        static std::list<ep_lib::MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers)
+        static MPI_Comm intraComm;
+        static std::list<MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server)
+        static std::list<MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool)
+        static std::list<MPI_Comm> contextInterComms;  // list of context intercomms
+        static std::list<MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers)
         static CEventScheduler* eventScheduler;
 

XIOS/trunk/src/timer.cpp

@@ -1 +1 @@
 #include "timer.hpp"
-//#include "mpi_std.hpp"
 #include "mpi.hpp"
 #include <string>
@@ -7 +6 @@
 #include <sstream>
 #include "tracer.hpp"
-//extern ::MPI_Comm MPI_COMM_WORLD;
 
 namespace xios
@@ -20 +18 @@
   double CTimer::getTime(void)
   {
-    MPI_COMM_WORLD;
     return MPI_Wtime();
   }

XIOS/trunk/src/tracer.cpp

@@ -1 +1 @@
 #include "tracer.hpp"
 #ifdef VTRACE
-//#include <vt_user.h>
-#include <VT.h>
+#include <vt_user.h>
 #endif
 #include <string>
@@ -13 +12 @@
   {
 #ifdef VTRACE
-    //VT_ON() ;
-    VT_traceon() ;
+    VT_ON() ;
 #endif
   }
@@ -21 +19 @@
   {
 #ifdef VTRACE
-    //VT_OFF() ;
-    VT_traceoff() ;
+    VT_OFF() ;
 #endif
   }
@@ -29 +26 @@
   {
 #ifdef VTRACE
-    //VT_USER_START(name.c_str()) ;
+    VT_USER_START(name.c_str()) ;
 #endif
   }
@@ -36 +33 @@
   {
 #ifdef VTRACE
-    //VT_USER_END(name.c_str()) ;
+    VT_USER_END(name.c_str()) ;
 #endif
   }

XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

@@ -272 +272 @@
 
     int* recvCount=new int[nbClient];
-    ep_lib::MPI_Allgather(&numValue,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+    MPI_Allgather(&numValue,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
     int* displ=new int[nbClient];
@@ -279 +279 @@
 
     // Each client have enough global info of axis
-    ep_lib::MPI_Allgatherv(sendIndexBuff,numValue,EP_INT,recvIndexBuff,recvCount,displ,EP_INT,client->intraComm);
-    ep_lib::MPI_Allgatherv(sendValueBuff,numValue,EP_DOUBLE,&(recvBuff[0]),recvCount,displ,EP_DOUBLE,client->intraComm);
+    MPI_Allgatherv(sendIndexBuff,numValue,MPI_INT,recvIndexBuff,recvCount,displ,MPI_INT,client->intraComm);
+    MPI_Allgatherv(sendValueBuff,numValue,MPI_DOUBLE,&(recvBuff[0]),recvCount,displ,MPI_DOUBLE,client->intraComm);
 
     for (int idx = 0; idx < srcSize; ++idx)

XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

@@ -161 +161 @@
     sendRankSizeMap[itIndex->first] = sendSize;
   }
-  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
   displ[0]=0 ;
@@ -168 +168 @@
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
-  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
-  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
+  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
+  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
   {
@@ -181 +181 @@
 
   // Sending global index of grid source to corresponding process as well as the corresponding mask
-  std::vector<ep_lib::MPI_Request> requests;
-  std::vector<ep_lib::MPI_Status> status;
+  std::vector<MPI_Request> requests;
+  std::vector<MPI_Status> status;
   std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
   std::unordered_map<int, double* > sendValueToDest;
@@ -192 +192 @@
     sendValueToDest[recvRank] = new double [recvSize];
 
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
   }
 
@@ -214 +214 @@
 
     // Send global index source and mask
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
   }
 
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
-
-
-  std::vector<ep_lib::MPI_Request>().swap(requests);
-  std::vector<ep_lib::MPI_Status>().swap(status);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
+
+
+  std::vector<MPI_Request>().swap(requests);
+  std::vector<MPI_Status>().swap(status);
 
   // Okie, on destination side, we will wait for information of masked index of source
@@ -231 +231 @@
     int recvSize = itSend->second;
 
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Irecv(recvValueFromSrc[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvValueFromSrc[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
   }
 
@@ -249 +249 @@
     }
     // Okie, now inform the destination which source index are masked
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendValueToDest[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendValueToDest[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
   }
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
 

XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp

@@ -70 +70 @@
         StdSize hashValue = hashFunc.hashVec(globalAxisIndex);
         std::vector<StdSize> recvBuff(client->clientSize);
-        ep_lib::MPI_Gather(&hashValue, 1, EP_UNSIGNED_LONG,
-                   &recvBuff[0], 1, EP_UNSIGNED_LONG,
+        MPI_Gather(&hashValue, 1, MPI_UNSIGNED_LONG,
+                   &recvBuff[0], 1, MPI_UNSIGNED_LONG,
                    0,
                    client->intraComm);
@@ -87 +87 @@
         }
 
-        ep_lib::MPI_Bcast(&nbLocalAxis[0], nbAxis, EP_INT,
+        MPI_Bcast(&nbLocalAxis[0], nbAxis, MPI_INT,
                   0, client->intraComm);
       }

XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp

@@ -434 +434 @@
   CContextClient* client=context->client;
 
-  ep_lib::MPI_Comm poleComme(EP_COMM_NULL);
-  #ifdef _usingMPI
+  MPI_Comm poleComme(MPI_COMM_NULL);
   MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme);
-  #elif _usingEP
-  ep_lib::MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? 0 : 1, 0, &poleComme);
-  #endif
-  if (EP_COMM_NULL != poleComme)
+  if (MPI_COMM_NULL != poleComme)
   {
     int nbClientPole;
-    ep_lib::MPI_Comm_size(poleComme, &nbClientPole);
+    MPI_Comm_size(poleComme, &nbClientPole);
 
     std::map<int,std::vector<std::pair<int,double> > >::iterator itePole = interMapValuePole.end(), itPole,
@@ -454 +450 @@
     std::vector<int> recvCount(nbClientPole,0);
     std::vector<int> displ(nbClientPole,0);
-    ep_lib::MPI_Allgather(&nbWeight,1,EP_INT,&recvCount[0],1,EP_INT,poleComme) ;
+    MPI_Allgather(&nbWeight,1,MPI_INT,&recvCount[0],1,MPI_INT,poleComme) ;
 
     displ[0]=0;
@@ -477 +473 @@
 
     // Gather all index and weight for pole
-    ep_lib::MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,EP_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],EP_INT,poleComme);
-    ep_lib::MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,EP_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],EP_DOUBLE,poleComme);
+    MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,MPI_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],MPI_INT,poleComme);
+    MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,MPI_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],MPI_DOUBLE,poleComme);
 
     std::map<int,double> recvTemp;
@@ -635 +631 @@
 
 
-  ep_lib::MPI_Allreduce(sendBuff, recvBuff, nbClient, EP_INT, EP_SUM, client->intraComm);
+  MPI_Allreduce(sendBuff, recvBuff, nbClient, MPI_INT, MPI_SUM, client->intraComm);
 
   int* sendIndexDestBuff = new int [sendBuffSize];
@@ -641 +637 @@
   double* sendWeightBuff = new double [sendBuffSize];
 
-  std::vector<ep_lib::MPI_Request> sendRequest;
+  std::vector<MPI_Request> sendRequest;
 
   int sendOffSet = 0, l = 0;
@@ -662 +658 @@
     }
 
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendIndexDestBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendIndexDestBuff + sendOffSet,
              k,
-             EP_INT,
+             MPI_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
              &sendRequest.back());
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendIndexSrcBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendIndexSrcBuff + sendOffSet,
              k,
-             EP_INT,
+             MPI_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
              client->intraComm,
              &sendRequest.back());
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendWeightBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendWeightBuff + sendOffSet,
              k,
-             EP_DOUBLE,
+             MPI_DOUBLE,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
@@ -697 +693 @@
   while (receivedSize < recvBuffSize)
   {
-    ep_lib::MPI_Status recvStatus;
-    #ifdef _usingMPI
+    MPI_Status recvStatus;
     MPI_Recv((recvIndexDestBuff + receivedSize),
              recvBuffSize,
-             EP_INT,
+             MPI_INT,
              MPI_ANY_SOURCE,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
              &recvStatus);
-    #elif _usingEP
-    ep_lib::MPI_Recv((recvIndexDestBuff + receivedSize),
+
+    int countBuff = 0;
+    MPI_Get_count(&recvStatus, MPI_INT, &countBuff);
+    clientSrcRank = recvStatus.MPI_SOURCE;
+
+    MPI_Recv((recvIndexSrcBuff + receivedSize),
              recvBuffSize,
-             EP_INT,
-             -2,
-             MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
-             client->intraComm,
-             &recvStatus);
-    #endif
-
-    int countBuff = 0;
-    ep_lib::MPI_Get_count(&recvStatus, EP_INT, &countBuff);
-    #ifdef _usingMPI
-    clientSrcRank = recvStatus.MPI_SOURCE;
-    #elif _usingEP
-    clientSrcRank = recvStatus.ep_src;
-    #endif
-
-    ep_lib::MPI_Recv((recvIndexSrcBuff + receivedSize),
-             recvBuffSize,
-             EP_INT,
+             MPI_INT,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
@@ -732 +714 @@
              &recvStatus);
 
-    ep_lib::MPI_Recv((recvWeightBuff + receivedSize),
+    MPI_Recv((recvWeightBuff + receivedSize),
              recvBuffSize,
-             EP_DOUBLE,
+             MPI_DOUBLE,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
@@ -748 +730 @@
   }
 
-  std::vector<ep_lib::MPI_Status> requestStatus(sendRequest.size());
-  #ifdef _usingMPI
+  std::vector<MPI_Status> requestStatus(sendRequest.size());
   MPI_Waitall(sendRequest.size(), &sendRequest[0], MPI_STATUS_IGNORE);
-  #elif _usingEP
-  std::vector<ep_lib::MPI_Status> waitstat(sendRequest.size());
-  ep_lib::MPI_Waitall(sendRequest.size(), &sendRequest[0], &waitstat[0]);
-  #endif
 
   delete [] sendIndexDestBuff;
@@ -768 +745 @@
  
 /*! Redefined some functions of CONetCDF4 to make use of them */
-CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const ep_lib::MPI_Comm comm)
+CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const MPI_Comm comm)
   : CNc4DataOutput(NULL, filename, false, false, true, comm, false, true) {}
 int CDomainAlgorithmInterpolate::WriteNetCdf::addDimensionWrite(const StdString& name, 
@@ -858 +835 @@
   }
 
-  ep_lib::MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, EP_LONG, EP_SUM, client->intraComm);
-  ep_lib::MPI_Scan(&localNbWeight, &startIndex, 1, EP_LONG, EP_SUM, client->intraComm);
+  MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, MPI_LONG, MPI_SUM, client->intraComm);
+  MPI_Scan(&localNbWeight, &startIndex, 1, MPI_LONG, MPI_SUM, client->intraComm);
   
   if (0 == globalNbWeight)

XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

@@ -136 +136 @@
       {
         distributed=domainListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]->isDistributed() ;
-        ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
+        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
     
       }
@@ -142 +142 @@
       {
         distributed=axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]->isDistributed() ;
-        ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
+        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
       }
       else //it's a scalar
@@ -238 +238 @@
   int sendValue = (computeGlobalIndexOnProc) ? 1 : 0;
   int recvValue = 0;
-  ep_lib::MPI_Allreduce(&sendValue, &recvValue, 1, EP_INT, EP_SUM, client->intraComm);
+  MPI_Allreduce(&sendValue, &recvValue, 1, MPI_INT, MPI_SUM, client->intraComm);
   computeGlobalIndexOnProc = (0 < recvValue);
 

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -514 +514 @@
     sendRankSizeMap[itIndex->first] = sendSize;
   }
-  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
   displ[0]=0 ;
@@ -521 +521 @@
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
-  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
-  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
+  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
+  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
   {
@@ -534 +534 @@
 
   // Sending global index of grid source to corresponding process as well as the corresponding mask
-  std::vector<ep_lib::MPI_Request> requests(recvRankSizeMap.size()*2 + globaIndexWeightFromSrcToDst.size()*2);
-  std::vector<ep_lib::MPI_Status> status;
+  std::vector<MPI_Request> requests;
+  std::vector<MPI_Status> status;
   std::unordered_map<int, unsigned char* > recvMaskDst;
   std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
-  int requests_position = 0;
   for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
   {
@@ -546 +545 @@
     recvGlobalIndexSrc[recvRank] = new unsigned long [recvSize];
 
-    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests[requests_position++]);
-    ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests[requests_position++]);
-
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back());
   }
 
@@ -587 +583 @@
 
     // Send global index source and mask
-    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests[requests_position++]);
-    ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendMaskDst[sendRank], sendSize, MPI_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back());
   }
 
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
   // Okie, now use the mask to identify which index source we need to send, then also signal the destination which masked index we will return
-  requests.resize(sendRankSizeMap.size() + recvRankSizeMap.size());
-  requests_position = 0;
-  std::vector<ep_lib::MPI_Status>().swap(status);
+  std::vector<MPI_Request>().swap(requests);
+  std::vector<MPI_Status>().swap(status);
   // Okie, on destination side, we will wait for information of masked index of source
   for (std::map<int,int>::const_iterator itSend = sendRankSizeMap.begin(); itSend != sendRankSizeMap.end(); ++itSend)
@@ -608 +601 @@
     int recvSize = itSend->second;
 
-    ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(sendMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
   }
 
@@ -646 +638 @@
 
     // Okie, now inform the destination which source index are masked
-    ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
   }
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
   // Cool, now we can fill in local index of grid destination (counted for masked index)