Changeset 1642 for XIOS/dev/branch_openmp/extern/src_ep_dev

Timestamp:

01/23/19 10:31:44 (5 years ago)

Author:

yushan

Message:

dev on ADA. add flag switch _usingEP/_usingMPI

Location:

XIOS/dev/branch_openmp/extern/src_ep_dev

Files:

• ep_allgather.cpp (modified) (1 diff)
• ep_allgatherv.cpp (modified) (2 diffs)
• ep_allocate.cpp (modified) (1 diff)
• ep_create.cpp (modified) (2 diffs)
• ep_declaration.cpp (modified) (7 diffs)
• ep_declaration.hpp (modified) (3 diffs)
• ep_exscan.cpp (modified) (21 diffs)
• ep_finalize.cpp (modified) (1 diff)
• ep_fortran.cpp (modified) (3 diffs)
• ep_gatherv.cpp (modified) (1 diff)
• ep_intercomm.cpp (modified) (12 diffs)
• ep_lib.cpp (modified) (2 diffs)
• ep_lib.hpp (modified) (1 diff)
• ep_lib_fortran.hpp (modified) (1 diff)
• ep_merge.cpp (modified) (2 diffs)
• ep_message.cpp (modified) (2 diffs)
• ep_mpi.hpp (modified) (1 diff)
• ep_probe.cpp (modified) (4 diffs)
• ep_recv.cpp (modified) (1 diff)
• ep_reduce.cpp (modified) (19 diffs)
• ep_reduce_scatter.cpp (modified) (1 diff)
• ep_scan.cpp (modified) (42 diffs)
• ep_scatter.cpp (modified) (3 diffs)
• ep_scatterv.cpp (modified) (5 diffs)
• ep_split.cpp (modified) (5 diffs)
• ep_type.hpp (modified) (1 diff)
• ep_win.cpp (modified) (3 diffs)

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_allgather.cpp

@@ -92 +92 @@
       int local_sendcount = num_ep * count;
 
-      ::MPI_Allgather(&local_sendcount, 1, to_mpi_type(MPI_INT), mpi_recvcounts, 1, to_mpi_type(MPI_INT), to_mpi_comm(comm->mpi_comm));
+      ::MPI_Allgather(&local_sendcount, 1, to_mpi_type(EP_INT), mpi_recvcounts, 1, to_mpi_type(EP_INT), to_mpi_comm(comm->mpi_comm));
 
       mpi_displs[0] = 0;

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_allgatherv.cpp

@@ -56 +56 @@
     vector<int>local_displs(num_ep, 0);
 
-    MPI_Gather_local(&sendcount, 1, MPI_INT, local_recvcounts.data(), 0, comm);
+    MPI_Gather_local(&sendcount, 1, EP_INT, local_recvcounts.data(), 0, comm);
     for(int i=1; i<num_ep; i++) local_displs[i] = local_displs[i-1] + local_recvcounts[i-1]; 
 
@@ -75 +75 @@
 
       int local_sendcount = std::accumulate(local_recvcounts.begin(), local_recvcounts.end(), 0);
-      ::MPI_Allgather(&local_sendcount, 1, to_mpi_type(MPI_INT), mpi_recvcounts.data(), 1, to_mpi_type(MPI_INT), to_mpi_comm(comm->mpi_comm));
+      ::MPI_Allgather(&local_sendcount, 1, to_mpi_type(EP_INT), mpi_recvcounts.data(), 1, to_mpi_type(EP_INT), to_mpi_comm(comm->mpi_comm));
 
       for(int i=1; i<mpi_size; i++)

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_allocate.cpp

@@ -33 +33 @@
 
     int num_ep_max;
-    MPI_Allreduce(&num_ep, &num_ep_max, 1, MPI_INT, MPI_MAX, comm);
+    MPI_Allreduce(&num_ep, &num_ep_max, 1, EP_INT, MPI_MAX, comm);
 
     assert(num_ep_max > 1);

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_create.cpp

@@ -73 +73 @@
     }
 
-    ::MPI_Allgather(&num_ep, 1, to_mpi_type(MPI_INT), &recv_num_ep[0], 1, to_mpi_type(MPI_INT), mpi_base_comm);
+    ::MPI_Allgather(&num_ep, 1, to_mpi_type(EP_INT), &recv_num_ep[0], 1, to_mpi_type(EP_INT), mpi_base_comm);
 
 
@@ -124 +124 @@
       for(int j=0; j<recv_num_ep[i]; j++)
       {
-        out_comm_hdls[0]->ep_rank_map->insert(std::pair< int, std::pair<int,int> >(ind, j, i));
+        //out_comm_hdls[0]->ep_rank_map->insert(std::pair< int, std::pair<int,int> >(ind, j, i));
+        (*(out_comm_hdls[0]->ep_rank_map))[ind] = std::make_pair(j,i);//->insert(std::pair< int, std::pair<int,int> >(ind, j, i));
         ind++;
       }

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_declaration.cpp

@@ -4 +4 @@
 
 ::MPI_Comm MPI_COMM_WORLD_STD = MPI_COMM_WORLD;
-#undef MPI_COMM_WORLD
+//#undef MPI_COMM_WORLD
 
 
 ::MPI_Comm MPI_COMM_NULL_STD = MPI_COMM_NULL;
-#undef MPI_COMM_NULL
+//#undef MPI_COMM_NULL
 
 
 ::MPI_Request MPI_REQUEST_NULL_STD = MPI_REQUEST_NULL;
-#undef MPI_REQUEST_NULL
+//#undef MPI_REQUEST_NULL
 
 ::MPI_Info MPI_INFO_NULL_STD = MPI_INFO_NULL;
-#undef MPI_INFO_NULL
+//#undef MPI_INFO_NULL
 
 ::MPI_Datatype MPI_INT_STD = MPI_INT;
@@ -26 +26 @@
 ::MPI_Datatype MPI_UINT64_T_STD = MPI_UINT64_T;
 ::MPI_Datatype MPI_LONG_LONG_INT_STD = MPI_LONG_LONG_INT;
-
+::MPI_Datatype MPI_LONG_LONG_STD = MPI_LONG_LONG;
+/*
 #undef MPI_INT
 #undef MPI_FLOAT
@@ -36 +37 @@
 #undef MPI_UINT64_T
 #undef MPI_LONG_LONG_INT
-
+*/
 
 ::MPI_Op MPI_SUM_STD = MPI_SUM;
@@ -43 +44 @@
 ::MPI_Op MPI_LOR_STD = MPI_LOR;
 ::MPI_Op MPI_REPLACE_STD = MPI_REPLACE;
-
+/*
 #undef MPI_SUM
 #undef MPI_MAX
@@ -49 +50 @@
 #undef MPI_LOR
 #undef MPI_REPLACE
-
+*/
 
 // _STD defined in ep_type.cpp
@@ -62 +63 @@
 extern ::MPI_Datatype MPI_UINT64_T_STD;
 extern ::MPI_Datatype MPI_LONG_LONG_INT_STD;
+extern ::MPI_Datatype MPI_LONG_LONG_STD;
+
 
 
@@ -77 +80 @@
 extern ::MPI_Info MPI_INFO_NULL_STD;
 
-ep_lib::MPI_Datatype MPI_INT = &MPI_INT_STD;
-ep_lib::MPI_Datatype MPI_FLOAT = &MPI_FLOAT_STD;
-ep_lib::MPI_Datatype MPI_DOUBLE = &MPI_DOUBLE_STD;
-ep_lib::MPI_Datatype MPI_CHAR = &MPI_CHAR_STD;
-ep_lib::MPI_Datatype MPI_LONG = &MPI_LONG_STD;
-ep_lib::MPI_Datatype MPI_UNSIGNED_LONG = &MPI_UNSIGNED_LONG_STD;
-ep_lib::MPI_Datatype MPI_UNSIGNED_CHAR = &MPI_UNSIGNED_CHAR_STD;
-ep_lib::MPI_Datatype MPI_UINT64_T = &MPI_UINT64_T_STD;
-ep_lib::MPI_Datatype MPI_LONG_LONG_INT = &MPI_LONG_LONG_INT_STD;
-
-
-ep_lib::MPI_Op MPI_SUM = &MPI_SUM_STD;
-ep_lib::MPI_Op MPI_MAX = &MPI_MAX_STD;
-ep_lib::MPI_Op MPI_MIN = &MPI_MIN_STD;
-ep_lib::MPI_Op MPI_LOR = &MPI_LOR_STD;
-ep_lib::MPI_Op MPI_REPLACE = &MPI_REPLACE_STD;
-
-ep_lib::ep_comm EP_COMM_WORLD(&MPI_COMM_WORLD_STD);
-ep_lib::ep_comm EP_COMM_NULL(&MPI_COMM_NULL_STD);
-
-ep_lib::MPI_Comm MPI_COMM_WORLD = &EP_COMM_WORLD;
-ep_lib::MPI_Comm MPI_COMM_NULL = &EP_COMM_NULL;
-
-//ep_lib::ep_status EP_STATUS_IGNORE(&MPI_STATUS_IGNORE_STD);
-ep_lib::ep_request EP_REQUEST_NULL(&MPI_REQUEST_NULL_STD);
-ep_lib::ep_info EP_INFO_NULL(&MPI_INFO_NULL_STD);
-
-//ep_lib::MPI_Status MPI_STATUS_IGNORE = &EP_STATUS_IGNORE;
-ep_lib::MPI_Request MPI_REQUEST_NULL = &EP_REQUEST_NULL;
-ep_lib::MPI_Info MPI_INFO_NULL = &EP_INFO_NULL;
+ep_lib::MPI_Datatype EP_INT = &MPI_INT_STD;
+ep_lib::MPI_Datatype EP_FLOAT = &MPI_FLOAT_STD;
+ep_lib::MPI_Datatype EP_DOUBLE = &MPI_DOUBLE_STD;
+ep_lib::MPI_Datatype EP_CHAR = &MPI_CHAR_STD;
+ep_lib::MPI_Datatype EP_LONG = &MPI_LONG_STD;
+ep_lib::MPI_Datatype EP_UNSIGNED_LONG = &MPI_UNSIGNED_LONG_STD;
+ep_lib::MPI_Datatype EP_UNSIGNED_CHAR = &MPI_UNSIGNED_CHAR_STD;
+ep_lib::MPI_Datatype EP_UINT64_T = &MPI_UINT64_T_STD;
+ep_lib::MPI_Datatype EP_LONG_LONG_INT = &MPI_LONG_LONG_INT_STD;
+ep_lib::MPI_Datatype EP_LONG_LONG = &MPI_LONG_LONG_STD;
 
 
 
+ep_lib::MPI_Op EP_SUM = &MPI_SUM_STD;
+ep_lib::MPI_Op EP_MAX = &MPI_MAX_STD;
+ep_lib::MPI_Op EP_MIN = &MPI_MIN_STD;
+ep_lib::MPI_Op EP_LOR = &MPI_LOR_STD;
+ep_lib::MPI_Op EP_REPLACE = &MPI_REPLACE_STD;
+
+ep_lib::ep_comm EP_COMM_WORLD_t(&MPI_COMM_WORLD_STD);
+ep_lib::ep_comm EP_COMM_NULL_t(&MPI_COMM_NULL_STD);
+
+ep_lib::MPI_Comm EP_COMM_WORLD = &EP_COMM_WORLD_t;
+ep_lib::MPI_Comm EP_COMM_NULL = &EP_COMM_NULL_t;
+
+//ep_lib::ep_status EP_STATUS_IGNORE(&MPI_STATUS_IGNORE_STD);
+ep_lib::ep_request EP_REQUEST_NULL_t(&MPI_REQUEST_NULL_STD);
+ep_lib::ep_info EP_INFO_NULL_t(&MPI_INFO_NULL_STD);
+
+//ep_lib::MPI_Status MPI_STATUS_IGNORE = &EP_STATUS_IGNORE;
+ep_lib::MPI_Request EP_REQUEST_NULL = &EP_REQUEST_NULL_t;
+ep_lib::MPI_Info EP_INFO_NULL = &EP_INFO_NULL_t;
+
+
+

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_declaration.hpp

@@ -1 +1 @@
 #ifndef EP_DECLARATION_HPP_INCLUDED
 #define EP_DECLARATION_HPP_INCLUDED
-
+/*
 #undef MPI_INT
 #undef MPI_FLOAT
@@ -18 +18 @@
 #undef MPI_REPLACE
 
-#undef MPI_COMM_WORLD
+//#undef MPI_COMM_WORLD
 #undef MPI_COMM_NULL
 
@@ -24 +24 @@
 #undef MPI_STATUS_IGNORE
 #undef MPI_INFO_NULL
+*/
+extern ep_lib::MPI_Datatype EP_INT;
+extern ep_lib::MPI_Datatype EP_FLOAT;
+extern ep_lib::MPI_Datatype EP_DOUBLE;
+extern ep_lib::MPI_Datatype EP_CHAR;
+extern ep_lib::MPI_Datatype EP_LONG;
+extern ep_lib::MPI_Datatype EP_UNSIGNED_LONG;
+extern ep_lib::MPI_Datatype EP_UNSIGNED_CHAR;
+extern ep_lib::MPI_Datatype EP_UINT64_T;
+extern ep_lib::MPI_Datatype EP_LONG_LONG_INT;
+extern ep_lib::MPI_Datatype EP_LONG_LONG;
 
-extern ep_lib::MPI_Datatype MPI_INT;
-extern ep_lib::MPI_Datatype MPI_FLOAT;
-extern ep_lib::MPI_Datatype MPI_DOUBLE;
-extern ep_lib::MPI_Datatype MPI_CHAR;
-extern ep_lib::MPI_Datatype MPI_LONG;
-extern ep_lib::MPI_Datatype MPI_UNSIGNED_LONG;
-extern ep_lib::MPI_Datatype MPI_UNSIGNED_CHAR;
-extern ep_lib::MPI_Datatype MPI_UINT64_T;
-extern ep_lib::MPI_Datatype MPI_LONG_LONG_INT;
 
-extern ep_lib::MPI_Op MPI_SUM;
-extern ep_lib::MPI_Op MPI_MAX;
-extern ep_lib::MPI_Op MPI_MIN;
-extern ep_lib::MPI_Op MPI_LOR;
-extern ep_lib::MPI_Op MPI_REPLACE;
+extern ep_lib::MPI_Op EP_SUM;
+extern ep_lib::MPI_Op EP_MAX;
+extern ep_lib::MPI_Op EP_MIN;
+extern ep_lib::MPI_Op EP_LOR;
+extern ep_lib::MPI_Op EP_REPLACE;
 
-extern ep_lib::MPI_Comm MPI_COMM_WORLD;
-extern ep_lib::MPI_Comm MPI_COMM_NULL;
+extern ep_lib::MPI_Comm EP_COMM_WORLD;
+extern ep_lib::MPI_Comm EP_COMM_NULL;
 
-extern ep_lib::MPI_Status MPI_STATUS_IGNORE;
-extern ep_lib::MPI_Request MPI_REQUEST_NULL;
-extern ep_lib::MPI_Info MPI_INFO_NULL;
-
+extern ep_lib::MPI_Status EP_STATUS_IGNORE;
+extern ep_lib::MPI_Request EP_REQUEST_NULL;
+extern ep_lib::MPI_Info EP_INFO_NULL;
 
 #endif // EP_DECLARATION_HPP_INCLUDED

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_exscan.cpp

@@ -78 +78 @@
     MPI_Barrier_local(comm);
 
-    if(op == MPI_SUM)
-    {
-      if(datatype == MPI_INT )
+    if(op == EP_SUM)
+    {
+      if(datatype == EP_INT )
       {
         assert(datasize == sizeof(int));
@@ -87 +87 @@
       }
      
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -95 +95 @@
       
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -102 +102 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -109 +109 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -116 +116 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -123 +123 @@
       }
       
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));
@@ -139 +139 @@
     }
 
-    else if(op == MPI_MAX)
-    {
-      if(datatype == MPI_INT )
+    else if(op == EP_MAX)
+    {
+      if(datatype == EP_INT )
       {
         assert(datasize == sizeof(int));
@@ -148 +148 @@
       }
 
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -155 +155 @@
       }
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -162 +162 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -169 +169 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -176 +176 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -183 +183 @@
       }
      
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));
@@ -197 +197 @@
     }
 
-    else if(op == MPI_MIN)
-    {
-      if(datatype == MPI_INT )
+    else if(op == EP_MIN)
+    {
+      if(datatype == EP_INT )
       {
         assert(datasize == sizeof(int));
@@ -206 +206 @@
       }
 
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -213 +213 @@
       }
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -220 +220 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -227 +227 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -234 +234 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -241 +241 @@
       }
 
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_finalize.cpp

@@ -9 +9 @@
   int MPI_Finalize()
   {
-    #pragma omp master
+    //pragma omp master
     {
       printf("calling EP Finalize\n");

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_fortran.cpp

@@ -8 +8 @@
 
 
-namespace ep_lib
-{
+//namespace ep_lib
+//{
 
-  void* EP_Comm_c2f(MPI_Comm comm)
+  void* EP_Comm_c2f(ep_lib::MPI_Comm comm)
   {
     Debug("MPI_Comm_c2f");
-    void* fint = new ::MPI_Fint;
+    void* fint = new MPI_Fint;
     #ifdef _intelmpi
-    *static_cast< ::MPI_Fint*>(fint) = (::MPI_Fint)(to_mpi_comm(comm->mpi_comm));
+    //*static_cast< ::MPI_Fint*>(fint) = (::MPI_Fint)(to_mpi_comm(comm->mpi_comm));
+    *static_cast< MPI_Fint*>(fint) = MPI_Comm_c2f(to_mpi_comm(comm->mpi_comm));
     #elif _openmpi
-    *static_cast< ::MPI_Fint*>(fint) = MPI_Comm_c2f(to_mpi_comm(comm->mpi_comm));
+    *static_cast< MPI_Fint*>(fint) = MPI_Comm_c2f(to_mpi_comm(comm->mpi_comm));
     #endif
     
-    std::map<std::pair< ::MPI_Fint, int>, MPI_Comm > ::iterator it;
+    std::map<std::pair< MPI_Fint, int>, ep_lib::MPI_Comm > ::iterator it;
     
     #pragma omp critical (fc_comm_map)
     {
-      it = fc_comm_map.find(std::make_pair(*static_cast< ::MPI_Fint*>(fint), omp_get_thread_num()));
-      if(it == fc_comm_map.end())
+      it = ep_lib::fc_comm_map.find(std::make_pair(*static_cast< MPI_Fint*>(fint), omp_get_thread_num()));
+      if(it == ep_lib::fc_comm_map.end())
       {
-        fc_comm_map.insert(std::make_pair( std::make_pair( *static_cast< ::MPI_Fint*>(fint), omp_get_thread_num()) , comm));
-        printf("EP_Comm_c2f : MAP %p insert: %d, %d, %p\n", &fc_comm_map, *static_cast< ::MPI_Fint*>(fint), omp_get_thread_num(), comm->ep_comm_ptr);
+        ep_lib::fc_comm_map.insert(std::make_pair( std::make_pair( *static_cast< MPI_Fint*>(fint), omp_get_thread_num()) , comm));
+        printf("EP_Comm_c2f : MAP %p insert: %d, %d, %p\n", &(ep_lib::fc_comm_map), *static_cast< MPI_Fint*>(fint), omp_get_thread_num(), comm->ep_comm_ptr);
       }
     }
@@ -38 +39 @@
   }
 
-  MPI_Comm EP_Comm_f2c(void* comm)
+  ep_lib::MPI_Comm EP_Comm_f2c(void* comm)
   {
     Debug("MPI_Comm_f2c");
     
     
-    std::map<std::pair< ::MPI_Fint, int>, MPI_Comm > ::iterator it;
+    std::map<std::pair< MPI_Fint, int>, ep_lib::MPI_Comm > ::iterator it;
     
     #pragma omp critical (fc_comm_map)
-    it = fc_comm_map.find(std::make_pair(*static_cast< ::MPI_Fint*>(comm), omp_get_thread_num()));
+    it = ep_lib::fc_comm_map.find(std::make_pair(*static_cast< MPI_Fint*>(comm), omp_get_thread_num()));
     
-    if(it != fc_comm_map.end())
+    if(it != ep_lib::fc_comm_map.end())
     {
-      MPI_Comm comm_ptr;
+      ep_lib::MPI_Comm comm_ptr;
       comm_ptr = it->second;
-      printf("EP_Comm_f2c : MAP %p find: %d, %d, %p\n", &fc_comm_map, it->first.first, it->first.second, comm_ptr->ep_comm_ptr);
+      printf("EP_Comm_f2c : MAP %p find: %d, %d, %p\n", &(ep_lib::fc_comm_map), it->first.first, it->first.second, comm_ptr->ep_comm_ptr);
       return  comm_ptr;
     }
@@ -58 +59 @@
       
     
+    MPI_Comm *base_comm = new MPI_Comm;
     #ifdef _intelmpi
-    ::MPI_Comm *base_comm = new ::MPI_Comm;
-    *base_comm = (::MPI_Comm)(*static_cast< ::MPI_Fint*>(comm));
+    *base_comm = (MPI_Comm)(*static_cast< MPI_Fint*>(comm));
     #elif _openmpi
-    ::MPI_Comm *base_comm = ::MPI_Comm_f2c(*static_cast< ::MPI_Fint*>(comm));
+    *base_comm = MPI_Comm_f2c(*static_cast< MPI_Fint*>(comm));
     #endif
 
-    if(*base_comm != to_mpi_comm(MPI_COMM_NULL->mpi_comm))
+    if(*base_comm != to_mpi_comm(EP_COMM_NULL->mpi_comm))
     {
       if(omp_get_thread_num() == 0)
       {
         int num_ep = omp_get_num_threads();
-        MPI_Comm *new_comm;
-        MPI_Info info;
-        MPI_Comm_create_endpoints(base_comm, num_ep, info, new_comm);
-        passage = new_comm;
+        ep_lib::MPI_Comm *new_comm;
+        ep_lib::MPI_Info info;
+        ep_lib::MPI_Comm_create_endpoints(base_comm, num_ep, info, new_comm);
+        ep_lib::passage = new_comm;
       }
       #pragma omp barrier
 
-      MPI_Comm return_comm = passage[omp_get_thread_num()];
+      ep_lib::MPI_Comm return_comm = ep_lib::passage[omp_get_thread_num()];
       return return_comm;
         
     }
-    return MPI_COMM_NULL;
+    return EP_COMM_NULL;
 
   }
 
-}
+//}
 
 

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_gatherv.cpp

@@ -87 +87 @@
     }
 
-    MPI_Bcast(recvcounts, ep_size, MPI_INT, root, comm);
-    MPI_Bcast(displs, ep_size, MPI_INT, root, comm);
+    MPI_Bcast(recvcounts, ep_size, EP_INT, root, comm);
+    MPI_Bcast(displs, ep_size, EP_INT, root, comm);
 
-    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&sendcount, 1, MPI_INT, local_recvcounts.data(), root_ep_loc, comm);
-    else                          MPI_Gather_local(&sendcount, 1, MPI_INT, local_recvcounts.data(), 0, comm);
+    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&sendcount, 1, EP_INT, local_recvcounts.data(), root_ep_loc, comm);
+    else                          MPI_Gather_local(&sendcount, 1, EP_INT, local_recvcounts.data(), 0, comm);
 
 

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_intercomm.cpp

@@ -33 +33 @@
     }
     
-    MPI_Bcast(mpi_rank_of_leader, 2, MPI_INT, local_leader, local_comm);
+    MPI_Bcast(mpi_rank_of_leader, 2, EP_INT, local_leader, local_comm);
     
     if(mpi_rank_of_leader[0] != mpi_rank_of_leader[1])
@@ -86 +86 @@
       MPI_Comm_rank(peer_comm, &local_leader_rank_in_peer);
       ::MPI_Comm_rank(to_mpi_comm(peer_comm->mpi_comm), &local_leader_rank_in_peer_mpi);
-      ::MPI_Comm_rank(to_mpi_comm(MPI_COMM_WORLD->mpi_comm), &local_leader_rank_in_world);
+      ::MPI_Comm_rank(to_mpi_comm(EP_COMM_WORLD->mpi_comm), &local_leader_rank_in_world);
 
       send_quadruple[0] = ep_size;
@@ -99 +99 @@
       if(remote_leader > local_leader_rank_in_peer)
       {
-        MPI_Isend(send_quadruple, 4, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Isend(send_quadruple, 4, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
        
-        MPI_Irecv(recv_quadruple, 4, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Irecv(recv_quadruple, 4, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
       }
       else
       {
-        MPI_Irecv(recv_quadruple, 4, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Irecv(recv_quadruple, 4, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
           
-        MPI_Isend(send_quadruple, 4, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Isend(send_quadruple, 4, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
       }
@@ -123 +123 @@
     }
 
-    MPI_Bcast(send_quadruple, 4, MPI_INT, local_leader, local_comm);
-    MPI_Bcast(recv_quadruple, 4, MPI_INT, local_leader, local_comm);
+    MPI_Bcast(send_quadruple, 4, EP_INT, local_leader, local_comm);
+    MPI_Bcast(recv_quadruple, 4, EP_INT, local_leader, local_comm);
 
     if(!is_local_leader)
@@ -152 +152 @@
 
     int rank_in_world;
-    ::MPI_Comm_rank(to_mpi_comm(MPI_COMM_WORLD->mpi_comm), &rank_in_world);
+    ::MPI_Comm_rank(to_mpi_comm(EP_COMM_WORLD->mpi_comm), &rank_in_world);
 
     int *ranks_in_world_local  = new int[ep_size];
     int *ranks_in_world_remote = new int[remote_ep_size];
 
-    MPI_Allgather(&rank_in_world, 1, MPI_INT, ranks_in_world_local, 1, MPI_INT, local_comm);
+    MPI_Allgather(&rank_in_world, 1, EP_INT, ranks_in_world_local, 1, EP_INT, local_comm);
 
     if(is_local_leader)
@@ -166 +166 @@
       if(remote_leader > local_leader_rank_in_peer)
       {
-        MPI_Isend(ranks_in_world_local,  ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Isend(ranks_in_world_local,  ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
        
-        MPI_Irecv(ranks_in_world_remote, remote_ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Irecv(ranks_in_world_remote, remote_ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
       }
       else
       {
-        MPI_Irecv(ranks_in_world_remote, remote_ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Irecv(ranks_in_world_remote, remote_ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
           
-        MPI_Isend(ranks_in_world_local,  ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Isend(ranks_in_world_local,  ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
       }
@@ -185 +185 @@
     }
 
-    MPI_Bcast(ranks_in_world_remote, remote_ep_size, MPI_INT, local_leader, local_comm);
+    MPI_Bcast(ranks_in_world_remote, remote_ep_size, EP_INT, local_leader, local_comm);
 
 #ifdef _showinfo
@@ -313 +313 @@
       int *mpi_rank_list = new int[mpi_size];
 
-      ::MPI_Allgather(&ownership, 1, to_mpi_type(MPI_INT), ownership_list, 1, to_mpi_type(MPI_INT), to_mpi_comm(local_comm->mpi_comm));
-      ::MPI_Allgather(&mpi_rank,  1, to_mpi_type(MPI_INT), mpi_rank_list,  1, to_mpi_type(MPI_INT), to_mpi_comm(local_comm->mpi_comm));
+      ::MPI_Allgather(&ownership, 1, to_mpi_type(EP_INT), ownership_list, 1, to_mpi_type(EP_INT), to_mpi_comm(local_comm->mpi_comm));
+      ::MPI_Allgather(&mpi_rank,  1, to_mpi_type(EP_INT), mpi_rank_list,  1, to_mpi_type(EP_INT), to_mpi_comm(local_comm->mpi_comm));
 
       
@@ -347 +347 @@
       }
 
-      ::MPI_Bcast(&local_leader_rank_in_extracted_comm, 1, to_mpi_type(MPI_INT), local_comm->ep_rank_map->at(local_leader).second, to_mpi_comm(local_comm->mpi_comm));
+      ::MPI_Bcast(&local_leader_rank_in_extracted_comm, 1, to_mpi_type(EP_INT), local_comm->ep_rank_map->at(local_leader).second, to_mpi_comm(local_comm->mpi_comm));
 
       ::MPI_Comm *intracomm = new ::MPI_Comm;
-      bool is_real_involved = ownership && extracted_comm != to_mpi_comm(MPI_COMM_NULL->mpi_comm);
+      bool is_real_involved = ownership && extracted_comm != to_mpi_comm(EP_COMM_NULL->mpi_comm);
 
       if(is_real_involved)
@@ -489 +489 @@
     int *remote_rank_info = new int[2*remote_ep_size];
 
-    MPI_Allgather(rank_info, 2, MPI_INT, local_rank_info, 2, MPI_INT, local_comm);
+    MPI_Allgather(rank_info, 2, EP_INT, local_rank_info, 2, EP_INT, local_comm);
 
     if(is_local_leader)
@@ -498 +498 @@
       if(priority)
       {
-        MPI_Isend(local_rank_info, 2*ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Isend(local_rank_info, 2*ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
        
-        MPI_Irecv(remote_rank_info, 2*remote_ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Irecv(remote_rank_info, 2*remote_ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
         MPI_Wait(&request, &status);
       }
       else
       {
-        MPI_Irecv(remote_rank_info, 2*remote_ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
-        MPI_Wait(&request, &status);
-          
-        MPI_Isend(local_rank_info, 2*ep_size, MPI_INT, remote_leader, tag, peer_comm, &request);
-        MPI_Wait(&request, &status);
-      }
-    }
-
-    MPI_Bcast(remote_rank_info, 2*remote_ep_size, MPI_INT, local_leader, local_comm);
+        MPI_Irecv(remote_rank_info, 2*remote_ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Wait(&request, &status);
+        
+        MPI_Isend(local_rank_info, 2*ep_size, EP_INT, remote_leader, tag, peer_comm, &request);
+        MPI_Wait(&request, &status);
+      }
+    }
+
+    MPI_Bcast(remote_rank_info, 2*remote_ep_size, EP_INT, local_leader, local_comm);
 
     for(int i=0; i<remote_ep_size; i++)
@@ -537 +537 @@
     }
     */
-    
+   //MPI_Barrier(*newintercomm); 
+   //MPI_Barrier(*newintercomm); 
+   //MPI_Barrier(*newintercomm); 
  
   }

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_lib.cpp

@@ -131 +131 @@
   bool valid_type(MPI_Datatype datatype)
   {
-    if(   datatype == MPI_INT 
-       || datatype == MPI_FLOAT
-       || datatype == MPI_DOUBLE 
-       || datatype == MPI_CHAR 
-       || datatype == MPI_LONG 
-       || datatype == MPI_UNSIGNED_LONG
-       || datatype == MPI_LONG_LONG)
+    if(   datatype == EP_INT 
+       || datatype == EP_FLOAT
+       || datatype == EP_DOUBLE 
+       || datatype == EP_CHAR 
+       || datatype == EP_LONG 
+       || datatype == EP_UNSIGNED_LONG
+       || datatype == EP_LONG_LONG)
     {
       return true;
@@ -148 +148 @@
   bool valid_op(MPI_Op op)
   {
-    if(   op == MPI_MAX 
-       || op == MPI_MIN
-       || op == MPI_SUM
-       || op == MPI_LOR)
+    if(   op == EP_MAX 
+       || op == EP_MIN
+       || op == EP_SUM
+       || op == EP_LOR)
     {
       return true;

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_lib.hpp

@@ -51 +51 @@
   int MPI_Imrecv(void *buf, int count, MPI_Datatype datatype, MPI_Message *message, MPI_Request *request);
 
+  int my_recv  (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status *status);
+  int my_irecv (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request *request);
 
   int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status);
   int MPI_Testall(int count, MPI_Request *array_of_requests, int *flag, MPI_Status *array_of_statuses);
 
+  int my_test(MPI_Request *request, int *flag, MPI_Status *status);
+  int my_testall(int count, MPI_Request *array_of_requests, int *flag, MPI_Status *array_of_statuses);
+  
   int MPI_Wait(MPI_Request *request, MPI_Status *status);
   int MPI_Waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses);
 
+  int my_wait(MPI_Request *request, MPI_Status *status);
+  int my_waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses);
 
   int MPI_Iprobe(int source, int tag, MPI_Comm comm, int *flag, MPI_Status *status);

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_lib_fortran.hpp

@@ -4 +4 @@
 #include "ep_type.hpp"
 
-namespace ep_lib
-{
+//namespace ep_lib
+//{
 
-  void* EP_Comm_c2f(MPI_Comm comm);
-  MPI_Comm EP_Comm_f2c(void* comm);
-}
+  void* EP_Comm_c2f(ep_lib::MPI_Comm comm);
+  ep_lib::MPI_Comm EP_Comm_f2c(void* comm);
+//}
 
 

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_merge.cpp

@@ -36 +36 @@
     int sum_high;
     
-    MPI_Allreduce(&int_high, &sum_high, 1, MPI_INT, MPI_SUM, *newintracomm);
+    MPI_Allreduce(&int_high, &sum_high, 1, EP_INT, EP_SUM, *newintracomm);
 
     if(sum_high==0 || sum_high==ep_size+remote_ep_size)
@@ -55 +55 @@
 
     
-    MPI_Allgather(my_triple, 3, MPI_INT, my_triple_list, 3, MPI_INT, *newintracomm); 
+    MPI_Allgather(my_triple, 3, EP_INT, my_triple_list, 3, EP_INT, *newintracomm); 
 
 

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_message.cpp

@@ -147 +147 @@
     {
       Debug("Message probing for intracomm\n");
-     
+/*     
       #pragma omp critical (_mpi_call)
       {
@@ -158 +158 @@
       }
 
-      
+*/    
+      ::MPI_Improbe(MPI_ANY_SOURCE, MPI_ANY_TAG, to_mpi_comm(comm->mpi_comm), &flag, &message, &status);      
+
       if(flag)
       {

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_mpi.hpp

@@ -1 +1 @@
 #ifndef EP_MPI_HPP_INCLUDED
 #define EP_MPI_HPP_INCLUDED
-
+#ifdef _usingEP
 #include "ep_type.hpp"
-
+#endif
 MPI_Datatype to_mpi_type(ep_lib::MPI_Datatype type);
 MPI_Op       to_mpi_op(ep_lib::MPI_Op op);

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_probe.cpp

@@ -68 +68 @@
     *flag = false;
     
-    Message_Check(comm);
-
-    #pragma omp flush
-
     #pragma omp critical (_query)
     for(Message_list::iterator it = comm->ep_comm_ptr->message_queue->begin(); it!= comm->ep_comm_ptr->message_queue->end(); ++it)
@@ -98 +94 @@
       }
     }
+    if(*flag) return 0;
+    
+    Message_Check(comm);
+
+    #pragma omp flush
+
+    #pragma omp critical (_query)
+    for(Message_list::iterator it = comm->ep_comm_ptr->message_queue->begin(); it!= comm->ep_comm_ptr->message_queue->end(); ++it)
+    {
+      bool src_matched = src<0? true: (*it)->ep_src == src;
+      bool tag_matched = tag<0? true: (*it)->ep_tag == tag;
+      
+      if(src_matched && tag_matched)        
+      {
+        Debug("find message\n");
+         
+        status->mpi_status = new ::MPI_Status(*static_cast< ::MPI_Status*>((*it)->mpi_status));
+        status->ep_src = (*it)->ep_src;
+        status->ep_tag = (*it)->ep_tag;
+        
+        if(comm->is_intercomm)
+        {
+          for(INTER_RANK_MAP::iterator iter = comm->inter_rank_map->begin(); iter != comm->inter_rank_map->end(); iter++)
+          {
+            if(iter->second == (*it)->ep_src) status->ep_src=iter->first;
+          }
+        }
+
+        *flag = true;
+        break;
+      }
+    }
+    if(*flag) return 0;
   }
 
@@ -129 +158 @@
     *flag = false;
     
-    Message_Check(comm);
-    
-    #pragma omp flush
-
     #pragma omp critical (_query)
     if(! comm->ep_comm_ptr->message_queue->empty())
@@ -179 +204 @@
       }
     }
+
+    if(*flag) return 0;
+   
+    Message_Check(comm);
+    
+    #pragma omp flush
+
+    #pragma omp critical (_query)
+    if(! comm->ep_comm_ptr->message_queue->empty())
+    {
+      for(Message_list::iterator it = comm->ep_comm_ptr->message_queue->begin(); it!= comm->ep_comm_ptr->message_queue->end(); ++it)
+      {
+                                          
+        bool src_matched = src<0? true: (*it)->ep_src == src;
+        bool tag_matched = tag<0? true: (*it)->ep_tag == tag;
+        
+        if(src_matched && tag_matched)
+        {
+          *flag = true;
+
+          status->mpi_status = new ::MPI_Status(*static_cast< ::MPI_Status*>((*it)->mpi_status));
+          memcheck("new "<< status->mpi_status << " : in ep_lib::MPI_Improbe, status->mpi_status = new ::MPI_Status");
+          status->ep_src = (*it)->ep_src;
+          status->ep_tag = (*it)->ep_tag;
+
+          (*message)->mpi_message = new ::MPI_Message(*static_cast< ::MPI_Message*>((*it)->mpi_message));
+          memcheck("new "<< (*message)->mpi_message <<" : in ep_lib::MPI_Improbe, (*message)->mpi_message = new ::MPI_Message");
+          (*message)->ep_src = (*it)->ep_src;
+          (*message)->ep_tag = (*it)->ep_tag;
+                                      
+
+          #pragma omp critical (_query2)
+          {              
+            memcheck("delete "<< (*it)->mpi_message <<" : in ep_lib::Message_Check, delete (*it)->mpi_message");
+            memcheck("delete "<< (*it)->mpi_status <<" : in ep_lib::Message_Check, delete (*it)->mpi_status");
+            memcheck("delete "<< (*it) <<" : in ep_lib::Message_Check, delete (*it)");
+            
+            
+            delete (*it)->mpi_message;     
+            delete (*it)->mpi_status; 
+            delete *it;
+            
+                       
+            comm->ep_comm_ptr->message_queue->erase(it);
+            memcheck("message_queue["<<mpi_rank<<","<<ep_rank_loc<<"]->size = "<<comm->ep_comm_ptr->message_queue->size());
+            #pragma omp flush
+          }
+          
+          break;
+        }
+
+      }
+    }
+
+    if(*flag) return 0;
+
   }
 

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_recv.cpp

@@ -22 +22 @@
   int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status *status)
   {
-
     if(!comm->is_ep) return MPI_Recv_mpi(buf, count, datatype, src, tag, comm, status);
     

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_reduce.cpp

@@ -80 +80 @@
       memcpy(recvbuf, comm->my_buffer->void_buffer[0], datasize * count);
 
-      if(op == MPI_MAX)
-      {
-        if(datatype == MPI_INT)
+      if(op == EP_MAX)
+      {
+        if(datatype == EP_INT)
         {
           assert(datasize == sizeof(int));
@@ -96 +96 @@
         }
 
-        else if(datatype == MPI_DOUBLE)
+        else if(datatype == EP_DOUBLE)
         {
           assert(datasize == sizeof(double));
@@ -103 +103 @@
         }
 
-        else if(datatype == MPI_CHAR)
+        else if(datatype == EP_CHAR)
         {
           assert(datasize == sizeof(char));
@@ -110 +110 @@
         }
 
-        else if(datatype == MPI_LONG)
+        else if(datatype == EP_LONG)
         {
           assert(datasize == sizeof(long));
@@ -117 +117 @@
         }
 
-        else if(datatype == MPI_UNSIGNED_LONG)
+        else if(datatype == EP_UNSIGNED_LONG)
         {
           assert(datasize == sizeof(unsigned long));
@@ -124 +124 @@
         }
 
-        else if(datatype == MPI_LONG_LONG_INT)
+        else if(datatype == EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long));
@@ -139 +139 @@
       }
 
-      else if(op == MPI_MIN)
-      {
-        if(datatype ==MPI_INT)
+      else if(op == EP_MIN)
+      {
+        if(datatype ==EP_INT)
         {
           assert(datasize == sizeof(int));
@@ -155 +155 @@
         }
 
-        else if(datatype == MPI_DOUBLE)
+        else if(datatype == EP_DOUBLE)
         {
           assert(datasize == sizeof(double));
@@ -162 +162 @@
         }
 
-        else if(datatype == MPI_CHAR)
+        else if(datatype == EP_CHAR)
         {
           assert(datasize == sizeof(char));
@@ -169 +169 @@
         }
 
-        else if(datatype == MPI_LONG)
+        else if(datatype == EP_LONG)
         {
           assert(datasize == sizeof(long));
@@ -176 +176 @@
         }
 
-        else if(datatype == MPI_UNSIGNED_LONG)
+        else if(datatype == EP_UNSIGNED_LONG)
         {
           assert(datasize == sizeof(unsigned long));
@@ -183 +183 @@
         }
 
-        else if(datatype == MPI_LONG_LONG_INT)
+        else if(datatype == EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long));
@@ -199 +199 @@
 
 
-      else if(op == MPI_SUM)
-      {
-        if(datatype==MPI_INT)
+      else if(op == EP_SUM)
+      {
+        if(datatype==EP_INT)
         {
           assert(datasize == sizeof(int));
@@ -215 +215 @@
         }
 
-        else if(datatype == MPI_DOUBLE)
+        else if(datatype == EP_DOUBLE)
         {
           assert(datasize == sizeof(double));
@@ -222 +222 @@
         }
 
-        else if(datatype == MPI_CHAR)
+        else if(datatype == EP_CHAR)
         {
           assert(datasize == sizeof(char));
@@ -229 +229 @@
         }
 
-        else if(datatype == MPI_LONG)
+        else if(datatype == EP_LONG)
         {
           assert(datasize == sizeof(long));
@@ -236 +236 @@
         }
 
-        else if(datatype ==MPI_UNSIGNED_LONG)
+        else if(datatype ==EP_UNSIGNED_LONG)
         {
           assert(datasize == sizeof(unsigned long));
@@ -243 +243 @@
         }
         
-        else if(datatype ==MPI_LONG_LONG_INT)
+        else if(datatype ==EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long));
@@ -258 +258 @@
       }
 
-      else if(op == MPI_LOR)
-      {
-        if(datatype != MPI_INT)
+      else if(op == EP_LOR)
+      {
+        if(datatype != EP_INT)
           printf("datatype Error, must be MPI_INT\n");
         else

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_reduce_scatter.cpp

@@ -61 +61 @@
 
     int my_recvcount = recvcounts[ep_rank];
-    MPI_Gather_local(&my_recvcount, 1, MPI_INT, local_recvcounts.data(), 0, comm);
-    MPI_Bcast_local(local_recvcounts.data(), num_ep, MPI_INT, 0, comm);
+    MPI_Gather_local(&my_recvcount, 1, EP_INT, local_recvcounts.data(), 0, comm);
+    MPI_Bcast_local(local_recvcounts.data(), num_ep, EP_INT, 0, comm);
 
     int my_displs = std::accumulate(recvcounts, recvcounts+ep_rank, 0);
-    MPI_Gather_local(&my_displs, 1, MPI_INT, local_displs.data(), 0, comm);
-    MPI_Bcast_local(local_displs.data(), num_ep, MPI_INT, 0, comm);
+    MPI_Gather_local(&my_displs, 1, EP_INT, local_displs.data(), 0, comm);
+    MPI_Bcast_local(local_displs.data(), num_ep, EP_INT, 0, comm);
 
     

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_scan.cpp

@@ -60 +60 @@
     if(ep_rank_loc == 0 && mpi_rank != 0)
     {
-      if(op == MPI_SUM)
-      {
-        if(datatype == MPI_INT)
+      if(op == EP_SUM)
+      {
+        if(datatype == EP_INT)
         {
           assert(datasize == sizeof(int));
@@ -68 +68 @@
         }
           
-        else if(datatype == MPI_FLOAT)
+        else if(datatype == EP_FLOAT)
         {
           assert( datasize == sizeof(float));
@@ -74 +74 @@
         } 
              
-        else if(datatype == MPI_DOUBLE )
+        else if(datatype == EP_DOUBLE )
         {
           assert( datasize == sizeof(double));
@@ -80 +80 @@
         }
       
-        else if(datatype == MPI_CHAR)
+        else if(datatype == EP_CHAR)
         {
           assert( datasize == sizeof(char));
@@ -86 +86 @@
         } 
           
-        else if(datatype == MPI_LONG)
+        else if(datatype == EP_LONG)
         {
           assert( datasize == sizeof(long));
@@ -93 +93 @@
           
             
-        else if(datatype == MPI_UNSIGNED_LONG)
+        else if(datatype == EP_UNSIGNED_LONG)
         {
           assert(datasize == sizeof(unsigned long));
@@ -99 +99 @@
         }
         
-        else if(datatype == MPI_LONG_LONG_INT)
+        else if(datatype == EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long int));
@@ -112 +112 @@
       }
 
-      else if(op == MPI_MAX)
-      {
-        if(datatype == MPI_INT)
+      else if(op == EP_MAX)
+      {
+        if(datatype == EP_INT)
         {
           assert( datasize == sizeof(int));
@@ -120 +120 @@
         } 
           
-        else if(datatype == MPI_FLOAT )
+        else if(datatype == EP_FLOAT )
         {
           assert( datasize == sizeof(float));
@@ -126 +126 @@
         }
 
-        else if(datatype == MPI_DOUBLE )
+        else if(datatype == EP_DOUBLE )
         {
           assert( datasize == sizeof(double));
@@ -132 +132 @@
         }
       
-        else if(datatype == MPI_CHAR )
+        else if(datatype == EP_CHAR )
         {
           assert(datasize == sizeof(char));
@@ -138 +138 @@
         }
       
-        else if(datatype == MPI_LONG)
+        else if(datatype == EP_LONG)
         {
           assert( datasize == sizeof(long));
@@ -144 +144 @@
         } 
             
-        else if(datatype == MPI_UNSIGNED_LONG)
+        else if(datatype == EP_UNSIGNED_LONG)
         {
           assert( datasize == sizeof(unsigned long));
@@ -150 +150 @@
         } 
             
-        else if(datatype == MPI_LONG_LONG_INT)
+        else if(datatype == EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long int));
@@ -163 +163 @@
       }
 
-      else if(op == MPI_MIN)
-      {
-        if(datatype == MPI_INT )
+      else if(op == EP_MIN)
+      {
+        if(datatype == EP_INT )
         {
           assert (datasize == sizeof(int));
@@ -171 +171 @@
         }
           
-        else if(datatype == MPI_FLOAT )
+        else if(datatype == EP_FLOAT )
         {
           assert( datasize == sizeof(float));
@@ -177 +177 @@
         }
              
-        else if(datatype == MPI_DOUBLE )
+        else if(datatype == EP_DOUBLE )
         {
           assert( datasize == sizeof(double));
@@ -183 +183 @@
         }
       
-        else if(datatype == MPI_CHAR )
+        else if(datatype == EP_CHAR )
         {
           assert( datasize == sizeof(char));
@@ -189 +189 @@
         }
       
-        else if(datatype == MPI_LONG )
+        else if(datatype == EP_LONG )
         { 
           assert( datasize == sizeof(long));
@@ -195 +195 @@
         }
             
-        else if(datatype == MPI_UNSIGNED_LONG )
+        else if(datatype == EP_UNSIGNED_LONG )
         {
           assert( datasize == sizeof(unsigned long));
@@ -201 +201 @@
         }
             
-        else if(datatype == MPI_LONG_LONG_INT)
+        else if(datatype == EP_LONG_LONG_INT)
         {
           assert(datasize == sizeof(long long int));
@@ -235 +235 @@
 
 
-    if(op == MPI_SUM)
-    {
-      if(datatype == MPI_INT )
+    if(op == EP_SUM)
+    {
+      if(datatype == EP_INT )
       {
         assert (datasize == sizeof(int));
@@ -244 +244 @@
       }
      
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -252 +252 @@
       
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -259 +259 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -266 +266 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -273 +273 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -280 +280 @@
       }
       
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));
@@ -296 +296 @@
     }
 
-    else if(op == MPI_MAX)
-    {
-      if(datatype == MPI_INT)
+    else if(op == EP_MAX)
+    {
+      if(datatype == EP_INT)
       {
         assert(datasize == sizeof(int));
@@ -305 +305 @@
       }
 
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -312 +312 @@
       }
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -319 +319 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -326 +326 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -333 +333 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -340 +340 @@
       }
      
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));
@@ -355 +355 @@
     }
 
-    else if(op == MPI_MIN)
-    {
-      if(datatype == MPI_INT )
+    else if(op == EP_MIN)
+    {
+      if(datatype == EP_INT )
       {
         assert(datasize == sizeof(int));
@@ -364 +364 @@
       }
 
-      else if(datatype == MPI_FLOAT )
+      else if(datatype == EP_FLOAT )
       {
         assert(datasize == sizeof(float));
@@ -371 +371 @@
       }
 
-      else if(datatype == MPI_DOUBLE )
+      else if(datatype == EP_DOUBLE )
       {
         assert(datasize == sizeof(double));
@@ -378 +378 @@
       }
 
-      else if(datatype == MPI_CHAR )
+      else if(datatype == EP_CHAR )
       {
         assert(datasize == sizeof(char));
@@ -385 +385 @@
       }
 
-      else if(datatype == MPI_LONG )
+      else if(datatype == EP_LONG )
       {
         assert(datasize == sizeof(long));
@@ -392 +392 @@
       }
 
-      else if(datatype == MPI_UNSIGNED_LONG )
+      else if(datatype == EP_UNSIGNED_LONG )
       {
         assert(datasize == sizeof(unsigned long));
@@ -399 +399 @@
       }
 
-      else if(datatype == MPI_LONG_LONG_INT )
+      else if(datatype == EP_LONG_LONG_INT )
       {
         assert(datasize == sizeof(long long int));

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_scatter.cpp

@@ -73 +73 @@
     std::vector<int>ranks(ep_size);
 
-    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&ep_rank, 1, MPI_INT, local_ranks.data(), root_ep_loc, comm);
-    else                          MPI_Gather_local(&ep_rank, 1, MPI_INT, local_ranks.data(), 0, comm);
+    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&ep_rank, 1, EP_INT, local_ranks.data(), root_ep_loc, comm);
+    else                          MPI_Gather_local(&ep_rank, 1, EP_INT, local_ranks.data(), 0, comm);
 
 
@@ -91 +91 @@
         displs[i] = displs[i-1] + recvcounts[i-1];
 
-      ::MPI_Gatherv(local_ranks.data(), num_ep, to_mpi_type(MPI_INT), ranks.data(), recvcounts.data(), displs.data(), to_mpi_type(MPI_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
+      ::MPI_Gatherv(local_ranks.data(), num_ep, to_mpi_type(EP_INT), ranks.data(), recvcounts.data(), displs.data(), to_mpi_type(EP_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
     }
 
@@ -109 +109 @@
     {
       int local_sendcount = num_ep * count;
-      ::MPI_Gather(&local_sendcount, 1, to_mpi_type(MPI_INT), recvcounts.data(), 1, to_mpi_type(MPI_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
+      ::MPI_Gather(&local_sendcount, 1, to_mpi_type(EP_INT), recvcounts.data(), 1, to_mpi_type(EP_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
       
       if(is_root) for(int i=1; i<mpi_size; i++) displs[i] = displs[i-1] + recvcounts[i-1];

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_scatterv.cpp

@@ -76 +76 @@
     std::vector<int>ranks(ep_size);
 
-    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&ep_rank, 1, MPI_INT, local_ranks.data(), root_ep_loc, comm);
-    else                          MPI_Gather_local(&ep_rank, 1, MPI_INT, local_ranks.data(), 0, comm);
+    if(mpi_rank == root_mpi_rank) MPI_Gather_local(&ep_rank, 1, EP_INT, local_ranks.data(), root_ep_loc, comm);
+    else                          MPI_Gather_local(&ep_rank, 1, EP_INT, local_ranks.data(), 0, comm);
 
 
@@ -94 +94 @@
         my_displs[i] = my_displs[i-1] + recvcounts[i-1];
 
-      ::MPI_Gatherv(local_ranks.data(), num_ep, to_mpi_type(MPI_INT), ranks.data(), recvcounts.data(), my_displs.data(), to_mpi_type(MPI_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
+      ::MPI_Gatherv(local_ranks.data(), num_ep, to_mpi_type(EP_INT), ranks.data(), recvcounts.data(), my_displs.data(), to_mpi_type(EP_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
     }
 
@@ -112 +112 @@
     void* local_sendbuf;
     int local_sendcount;
-    if(mpi_rank == root_mpi_rank) MPI_Reduce_local(&recvcount, &local_sendcount, 1, MPI_INT, MPI_SUM, root_ep_loc, comm);
-    else                          MPI_Reduce_local(&recvcount, &local_sendcount, 1, MPI_INT, MPI_SUM, 0, comm);
+    if(mpi_rank == root_mpi_rank) MPI_Reduce_local(&recvcount, &local_sendcount, 1, EP_INT, EP_SUM, root_ep_loc, comm);
+    else                          MPI_Reduce_local(&recvcount, &local_sendcount, 1, EP_INT, EP_SUM, 0, comm);
 
     if(is_master) 
@@ -119 +119 @@
       local_sendbuf = new void*[datasize * local_sendcount];
  
-      ::MPI_Gather(&local_sendcount, 1, to_mpi_type(MPI_INT), recvcounts.data(), 1, to_mpi_type(MPI_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
+      ::MPI_Gather(&local_sendcount, 1, to_mpi_type(EP_INT), recvcounts.data(), 1, to_mpi_type(EP_INT), root_mpi_rank, to_mpi_comm(comm->mpi_comm));
 
       if(is_root) for(int i=1; i<mpi_size; i++) my_displs[i] = my_displs[i-1] + recvcounts[i-1];
@@ -129 +129 @@
     std::vector<int>local_displs(num_ep, 0);
 
-    MPI_Gather_local(&recvcount, 1, MPI_INT, local_sendcounts.data(), 0, comm);
-    MPI_Bcast_local(local_sendcounts.data(), num_ep, MPI_INT, 0, comm);
+    MPI_Gather_local(&recvcount, 1, EP_INT, local_sendcounts.data(), 0, comm);
+    MPI_Bcast_local(local_sendcounts.data(), num_ep, EP_INT, 0, comm);
     for(int i=1; i<num_ep; i++)
       local_displs[i] = local_displs[i-1] + local_sendcounts[i-1];

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_split.cpp

@@ -54 +54 @@
     vector<int> all_color_loc(num_ep);
 
-    MPI_Allgather(&color, 1, MPI_INT, all_color.data(), 1, MPI_INT, comm);
-    MPI_Allgather_local(&color, 1, MPI_INT, all_color_loc.data(), comm);
+    MPI_Allgather(&color, 1, EP_INT, all_color.data(), 1, EP_INT, comm);
+    MPI_Allgather_local(&color, 1, EP_INT, all_color_loc.data(), comm);
 
     list<int> color_list(all_color.begin(), all_color.end());
@@ -106 +106 @@
     
 
-    MPI_Allgather(&key, 1, MPI_INT, all_key.data(),1, MPI_INT, comm);
-    MPI_Allgather_local(&key, 1, MPI_INT, all_key_loc.data(), comm);
+    MPI_Allgather(&key, 1, EP_INT, all_key.data(),1, EP_INT, comm);
+    MPI_Allgather_local(&key, 1, EP_INT, all_key_loc.data(), comm);
     
     vector<int> all_ep_rank(ep_size);
@@ -115 +115 @@
     vector<int> colored_ep_rank_loc[num_color];
     
-    MPI_Allgather(&ep_rank, 1, MPI_INT, all_ep_rank.data(),1, MPI_INT, comm);
-    MPI_Allgather_local(&ep_rank, 1, MPI_INT, all_ep_rank_loc.data(), comm);
+    MPI_Allgather(&ep_rank, 1, EP_INT, all_ep_rank.data(),1, EP_INT, comm);
+    MPI_Allgather_local(&ep_rank, 1, EP_INT, all_ep_rank_loc.data(), comm);
 
     for(int i=0; i<num_ep; i++)
@@ -270 +270 @@
         if(new_ep_rank_loc == 0) my_triple_vector_recv.resize(3*new_ep_size);
         
-        MPI_Gather_local(my_triple, 3, MPI_INT, my_triple_vector.data(), 0, *newcomm);
+        MPI_Gather_local(my_triple, 3, EP_INT, my_triple_vector.data(), 0, *newcomm);
         
         if(new_ep_rank_loc == 0)
@@ -277 +277 @@
           int *displs = new int[new_mpi_size];
           int new_num_epx3 = new_num_ep * 3;
-          ::MPI_Allgather(&new_num_epx3, 1, to_mpi_type(MPI_INT), recvcounts, 1, to_mpi_type(MPI_INT), to_mpi_comm((*newcomm)->mpi_comm));
+          ::MPI_Allgather(&new_num_epx3, 1, to_mpi_type(EP_INT), recvcounts, 1, to_mpi_type(EP_INT), to_mpi_comm((*newcomm)->mpi_comm));
           displs[0]=0;
           for(int i=1; i<new_mpi_size; i++)
             displs[i] = displs[i-1] + recvcounts[i-1];
              
-          ::MPI_Allgatherv(my_triple_vector.data(), 3*new_num_ep, to_mpi_type(MPI_INT), my_triple_vector_recv.data(), recvcounts, displs, to_mpi_type(MPI_INT), to_mpi_comm((*newcomm)->mpi_comm));
+          ::MPI_Allgatherv(my_triple_vector.data(), 3*new_num_ep, to_mpi_type(EP_INT), my_triple_vector_recv.data(), recvcounts, displs, to_mpi_type(EP_INT), to_mpi_comm((*newcomm)->mpi_comm));
           
           for(int i=0; i<new_ep_size; i++)
           {
-            (*newcomm)->ep_comm_ptr->comm_list[0]->ep_rank_map->insert(std::pair< int, std::pair<int,int> >(my_triple_vector_recv[3*i], my_triple_vector_recv[3*i+1], my_triple_vector_recv[3*i+2]));
+            //(*newcomm)->ep_comm_ptr->comm_list[0]->ep_rank_map->insert(std::pair< int, std::pair<int,int> >(my_triple_vector_recv[3*i], my_triple_vector_recv[3*i+1], my_triple_vector_recv[3*i+2]));
+            (*((*newcomm)->ep_comm_ptr->comm_list[0]->ep_rank_map)) [ my_triple_vector_recv[3*i] ] = std::make_pair(my_triple_vector_recv[3*i+1], my_triple_vector_recv[3*i+2]);
           }
           

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_type.hpp

@@ -68 +68 @@
     
     MPI_Fint() {}
-    MPI_Fint(void* fint);
+    MPI_Fint(void* fint) {mpi_fint = fint;};
                                  
   };

XIOS/dev/branch_openmp/extern/src_ep_dev/ep_win.cpp

@@ -21 +21 @@
 
     int num_ep_max;
-    MPI_Allreduce(&num_ep, &num_ep_max, 1, MPI_INT, MPI_MAX, comm);
+    MPI_Allreduce(&num_ep, &num_ep_max, 1, EP_INT, EP_MAX, comm);
 
     assert(num_ep_max > 1);
@@ -88 +88 @@
     
     int num_ep_max;
-    MPI_Allreduce(&num_ep, &num_ep_max, 1, MPI_INT, MPI_MAX, (*win)->comm);
+    MPI_Allreduce(&num_ep, &num_ep_max, 1, EP_INT, EP_MAX, (*win)->comm);
 
     //printf("rank_loc = %d, thread_num = %d, num_ep_max = %d\n", rank_loc, omp_get_thread_num(), num_ep_max);
@@ -139 +139 @@
     
     int num_ep_max;
-    MPI_Allreduce(&num_ep, &num_ep_max, 1, MPI_INT, MPI_MAX, win->comm);
+    MPI_Allreduce(&num_ep, &num_ep_max, 1, EP_INT, EP_MAX, win->comm);
 
     if(num_ep == 1)