Changeset 1601 for XIOS/dev/dev_trunk_omp/src/io

Timestamp:

11/19/18 15:52:54 (6 years ago)

Author:

yushan

Message:

branch_openmp merged with trunk r1597

Location:

XIOS/dev/dev_trunk_omp/src/io

Files:

• inetcdf4.cpp (modified) (3 diffs)
• inetcdf4.hpp (modified) (2 diffs)
• nc4_data_input.cpp (modified) (2 diffs)
• nc4_data_input.hpp (modified) (3 diffs)
• nc4_data_output.cpp (modified) (1 diff)
• nc4_data_output.hpp (modified) (3 diffs)
• netCdfInterface.cpp (modified) (56 diffs)
• netCdfInterface.hpp (modified) (2 diffs)
• netcdf.hpp (modified) (4 diffs)
• onetcdf4.cpp (modified) (6 diffs)
• onetcdf4.hpp (modified) (3 diffs)

XIOS/dev/dev_trunk_omp/src/io/inetcdf4.cpp

@@ -2 +2 @@
 #include "netCdfInterface.hpp"
 #include "netCdf_cf_constant.hpp"
-
+#include "ep_mpi.hpp"
 #include <boost/algorithm/string.hpp>
 
 namespace xios
 {
-  CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
+  CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
                        bool readMetaDataPar /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
   {
@@ -14 +14 @@
     {
       int commSize = 0;
-      MPI_Comm_size(*comm, &commSize);
+      ep_lib::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, MPI_INFO_NULL, this->ncidp);
+      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, to_mpi_comm((*comm)->mpi_comm), to_mpi_info(MPI_INFO_NULL), this->ncidp);
     else
       CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp);

XIOS/dev/dev_trunk_omp/src/io/inetcdf4.hpp

@@ -7 +7 @@
 #include "array_new.hpp"
 
-#include "mpi.hpp"
+#include "mpi_std.hpp"
 #include "netcdf.hpp"
 
@@ -22 +22 @@
     public:
       /// Constructors ///
-      CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true,
+      CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true,
                 bool readMetaDataPar = false, const StdString& timeCounterName = "time_counter");
 

XIOS/dev/dev_trunk_omp/src/io/nc4_data_input.cpp

@@ -10 +10 @@
 namespace xios
 {
-  CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
+  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
                                bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
     : SuperClass()
@@ -55 +55 @@
     CArray<double,1> fieldData(grid->getWrittenDataSize());
     if (!field->default_value.isEmpty()) fieldData = field->default_value;
-
+    #ifdef _usingEP
+      SuperClass::type = ONE_FILE;
+      printf("SuperClass::type = %d\n", SuperClass::type);
+    #endif
+        
     switch (SuperClass::type)
     {

XIOS/dev/dev_trunk_omp/src/io/nc4_data_input.hpp

@@ -3 +3 @@
 
 /// XIOS headers ///
+#include "mpi_std.hpp"
 #include "xios_spl.hpp"
 #include "data_input.hpp"
@@ -23 +24 @@
 
     /// Constructors ///
-    CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true,
+    CNc4DataInput(const StdString& filename, ep_lib::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 +71 @@
   private:
     /// Private attributes ///
-    MPI_Comm comm_file;
+    ep_lib::MPI_Comm comm_file;
     const StdString filename;
     bool isCollective;

XIOS/dev/dev_trunk_omp/src/io/nc4_data_output.cpp

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

XIOS/dev/dev_trunk_omp/src/io/nc4_data_output.hpp

@@ -4 +4 @@
 /// XIOS headers ///
 #include "xios_spl.hpp"
+#include "mpi_std.hpp"
 #include "onetcdf4.hpp"
 #include "data_output.hpp"
@@ -27 +28 @@
                (CFile* file, const StdString & filename, bool exist, bool useClassicFormat,
                 bool useCFConvention,
-                MPI_Comm comm_file, bool multifile, bool isCollective = true,
+                ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true,
                 const StdString& timeCounterName = "time_counter");
 
@@ -117 +118 @@
 
             /// Propriétés privées ///
-            MPI_Comm comm_file;
+            ep_lib::MPI_Comm comm_file;
             const StdString filename;
             std::map<Time, StdSize> timeToRecordCache;

XIOS/dev/dev_trunk_omp/src/io/netCdfInterface.cpp

@@ -10 +10 @@
 #include "netCdfInterface.hpp"
 #include "netCdfException.hpp"
-
+#include "ep_mpi.hpp"
 namespace xios
 {
@@ -22 +22 @@
 int CNetCdfInterface::create(const StdString& fileName, int cMode, int& ncId)
 {
-  int status = nc_create(fileName.c_str(), cMode, &ncId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_create"<<std::endl;
+    status = nc_create(fileName.c_str(), cMode, &ncId);
+    info(100)<<"end nc_create"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -49 +55 @@
 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);
+  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, to_mpi_info(MPI_INFO_NULL), &ncId);
+
   if (NC_NOERR != status)
   {
@@ -74 +81 @@
 int CNetCdfInterface::open(const StdString& fileName, int oMode, int& ncId)
 {
-  int status = nc_open(fileName.c_str(), oMode, &ncId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_open"<<std::endl;
+    status = nc_open(fileName.c_str(), oMode, &ncId);
+    info(100)<<"end nc_open"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -102 +115 @@
 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);
+  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, to_mpi_info(MPI_INFO_NULL), &ncId);
+  
   if (NC_NOERR != status)
   {
@@ -125 +139 @@
 int CNetCdfInterface::close(int ncId)
 {
-  int status = nc_close(ncId);
+  int status = NC_NOERR;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_close"<<std::endl;
+    status = nc_close(ncId);
+    info(100)<<"end nc_close"<<std::endl;
+  }
+      
   if (NC_NOERR != status)
   {
@@ -147 +168 @@
 int CNetCdfInterface::reDef(int ncId)
 {
-  int status = nc_redef(ncId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_reDef"<<std::endl;
+    status = nc_redef(ncId);
+    info(100)<<"end nc_reDef"<<std::endl;
+  }
+  
   if (NC_NOERR != status)
   {
@@ -169 +197 @@
 int CNetCdfInterface::endDef(int ncId)
 {
-  int status = nc_enddef(ncId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_enddef"<<std::endl;
+    status = nc_enddef(ncId);
+    info(100)<<"end nc_enddef"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -194 +228 @@
 int CNetCdfInterface::inqNcId(int ncid, const StdString& grpName, int& grpId)
 {
-  int status = nc_inq_ncid(ncid, grpName.c_str(), &grpId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_ncid"<<std::endl;
+    status = nc_inq_ncid(ncid, grpName.c_str(), &grpId);
+    info(100)<<"end nc_inq_ncid"<<std::endl;
+  }
+  
   if (NC_NOERR != status)
   {
@@ -220 +261 @@
 int CNetCdfInterface::inqVarId(int ncid, const StdString& varName, int& varId)
 {
-  int status = nc_inq_varid(ncid, varName.c_str(), &varId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_varid"<<std::endl;
+    status = nc_inq_varid(ncid, varName.c_str(), &varId);
+    info(100)<<"end nc_inq_varid"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -245 +292 @@
 int CNetCdfInterface::inqDimId(int ncid, const StdString& dimName, int& dimId)
 {
-  int status = nc_inq_dimid(ncid, dimName.c_str(), &dimId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_dimid"<<std::endl;
+    status = nc_inq_dimid(ncid, dimName.c_str(), &dimId);
+    info(100)<<"end nc_inq_dimid"<<std::endl;
+  }
+  
   if (NC_NOERR != status)
   {
@@ -271 +325 @@
 {
   char varNameBuff[NC_MAX_NAME + 1];
-  int status = nc_inq_varname(ncid, varId, varNameBuff);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_varname"<<std::endl;
+    status = nc_inq_varname(ncid, varId, varNameBuff);
+    info(100)<<"end nc_inq_varname"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -295 +355 @@
 int CNetCdfInterface::inqUnLimDim(int ncid, int& dimId)
 {
-  int status = nc_inq_unlimdim(ncid, &dimId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_unlimdim"<<std::endl;
+    status = nc_inq_unlimdim(ncid, &dimId);
+    info(100)<<"end nc_inq_unlimdim"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -321 +387 @@
 {
   char fullNameIn[NC_MAX_NAME + 1];
-  int status = nc_inq_dimname(ncid, dimId, fullNameIn);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_dimname"<<std::endl;
+    status = nc_inq_dimname(ncid, dimId, fullNameIn);
+    info(100)<<"end nc_inq_dimname"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -346 +418 @@
 int CNetCdfInterface::inqDimLen(int ncid, int dimId, StdSize& dimLen)
 {
-  int status = nc_inq_dimlen(ncid, dimId, &dimLen);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_dimlen"<<std::endl;
+    status = nc_inq_dimlen(ncid, dimId, &dimLen);
+    info(100)<<"end nc_inq_dimlen"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -371 +449 @@
 int CNetCdfInterface::inqVarNDims(int ncid, int varId, int& nDims)
 {
-  int status = nc_inq_varndims(ncid, varId, &nDims);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_varndims"<<std::endl;
+    status = nc_inq_varndims(ncid, varId, &nDims);
+    info(100)<<"end nc_inq_varndims"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -396 +480 @@
 int CNetCdfInterface::inqVarDimId(int ncid, int varId, int* dimIds)
 {
-  int status = nc_inq_vardimid(ncid, varId, dimIds);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_vardimid"<<std::endl;
+    status = nc_inq_vardimid(ncid, varId, dimIds);
+    info(100)<<"end nc_inq_vardimid"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -422 +512 @@
 int CNetCdfInterface::inqDimIds(int ncid, int& nDims, int* dimIds, int includeParents)
 {
-  int status = nc_inq_dimids(ncid, &nDims, dimIds, includeParents);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_dimids"<<std::endl;
+    status = nc_inq_dimids(ncid, &nDims, dimIds, includeParents);
+    info(100)<<"end nc_inq_dimids"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -449 +545 @@
   StdSize strlen = 0;
   std::vector<char> buff;
-  int status = nc_inq_grpname_full(ncid, &strlen, NULL);
-  if (NC_NOERR == status)
-  {
-    buff.resize(strlen + 1);
-    status = nc_inq_grpname_full(ncid, NULL, &buff[0]);
-  }
-
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_grpname_full"<<std::endl;
+    status = nc_inq_grpname_full(ncid, &strlen, NULL);
+    info(100)<<"end nc_inq_grpname_full"<<std::endl;
+  
+    if (NC_NOERR == status)
+    {
+      buff.resize(strlen + 1);
+      status = nc_inq_grpname_full(ncid, NULL, &buff[0]);
+    }
+    info(100)<<"start nc_inq_grpname_full"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -482 +585 @@
 int CNetCdfInterface::inqGrpIds(int ncid, int& numgrps, int* ncids)
 {
-  int status = nc_inq_grps(ncid, &numgrps, ncids);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_grps"<<std::endl;
+    status = nc_inq_grps(ncid, &numgrps, ncids);
+    info(100)<<"end nc_inq_grps"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -507 +616 @@
 int CNetCdfInterface::inqVarIds(int ncid, int& nvars, int* varids)
 {
-  int status = nc_inq_varids(ncid, &nvars, varids);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_varids"<<std::endl;
+    status = nc_inq_varids(ncid, &nvars, varids);
+    info(100)<<"end nc_inq_varids"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -534 +649 @@
 int CNetCdfInterface::inqAtt(int ncid, int varid, const StdString& name, nc_type& type, size_t& len)
 {
-  int status = nc_inq_att(ncid, varid, name.c_str(), &type, &len);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_att"<<std::endl;
+    status = nc_inq_att(ncid, varid, name.c_str(), &type, &len);
+    info(100)<<"end nc_inq_att"<<std::endl;
+  }
+  
   if (NC_NOERR != status)
   {
@@ -558 +680 @@
 int CNetCdfInterface::inqNAtts(int ncid, int& ngatts)
 {
-  int status = nc_inq_natts(ncid, &ngatts);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_natts"<<std::endl;
+    status = nc_inq_natts(ncid, &ngatts);
+    info(100)<<"end nc_inq_natts"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -583 +711 @@
 int CNetCdfInterface::inqVarNAtts(int ncid, int varid, int& natts)
 {
-  int status = nc_inq_varnatts(ncid, varid, &natts);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_varnatts"<<std::endl;
+    status = nc_inq_varnatts(ncid, varid, &natts);
+    info(100)<<"end nc_inq_varnatts"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -604 +738 @@
 {
   std::vector<char> attName(NC_MAX_NAME + 1,' ');
-  int status = nc_inq_attname(ncid, varid, attnum, &attName[0]);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_inq_attname"<<std::endl;
+    status = nc_inq_attname(ncid, varid, attnum, &attName[0]);
+    info(100)<<"end nc_inq_attname"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -635 +775 @@
 int CNetCdfInterface::defGrp(int parentNcid, const StdString& grpName, int& grpId)
 {
-  int status = nc_def_grp(parentNcid, grpName.c_str(), &grpId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_grp"<<std::endl;
+    status = nc_def_grp(parentNcid, grpName.c_str(), &grpId);
+    info(100)<<"end nc_def_grp"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -660 +806 @@
 int CNetCdfInterface::defDim(int ncid, const StdString& dimName, StdSize dimLen, int& dimId)
 {
-  int status = nc_def_dim(ncid, dimName.c_str(), dimLen, &dimId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_dim"<<std::endl;
+    status = nc_def_dim(ncid, dimName.c_str(), dimLen, &dimId);
+    info(100)<<"end nc_def_dim"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -691 +843 @@
                              int nDims, const int dimIds[], int& varId)
 {
-  int status = nc_def_var(ncid, varName.c_str(), xtype, nDims, dimIds, &varId);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_var"<<std::endl;
+    status = nc_def_var(ncid, varName.c_str(), xtype, nDims, dimIds, &varId);
+    info(100)<<"end nc_def_var"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -720 +878 @@
 int CNetCdfInterface::defVarChunking(int ncid, int varId, int storage, StdSize chunkSize[])
 {
-  int status = nc_def_var_chunking(ncid, varId, storage, chunkSize);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_var_chunking"<<std::endl;
+    status = nc_def_var_chunking(ncid, varId, storage, chunkSize);
+    info(100)<<"end nc_def_var_chunking"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -748 +912 @@
   
   if (compressionLevel == 0) return NC_NOERR ;
-  int status = nc_def_var_deflate(ncid, varId, (compressionLevel > 0), (compressionLevel > 0), compressionLevel);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_var_deflate"<<std::endl;
+    status = nc_def_var_deflate(ncid, varId, (compressionLevel > 0), (compressionLevel > 0), compressionLevel);
+    info(100)<<"end nc_def_var_deflate"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -774 +944 @@
 {
   int old_fill_mode;
-  int status = nc_set_fill(ncid, fill ? NC_FILL: NC_NOFILL, &old_fill_mode);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_set_fill"<<std::endl;
+    status = nc_set_fill(ncid, fill ? NC_FILL: NC_NOFILL, &old_fill_mode);
+    info(100)<<"end nc_set_fill"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -801 +977 @@
 int CNetCdfInterface::defVarFill(int ncid, int varId, int noFill, void* fillValue)
 {
-  int status = nc_def_var_fill(ncid, varId, noFill, fillValue);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_def_var_fill"<<std::endl;
+    status = nc_def_var_fill(ncid, varId, noFill, fillValue);
+    info(100)<<"end nc_def_var_fill"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -829 +1011 @@
 int CNetCdfInterface::varParAccess(int ncid, int varId, int access)
 {
-  int status = nc_var_par_access(ncid, varId, access);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_var_par_access"<<std::endl;
+    status = nc_var_par_access(ncid, varId, access);
+    info(100)<<"end nc_var_par_access"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -852 +1040 @@
 int CNetCdfInterface::sync(int ncid)
 {
-  int status = nc_sync(ncid);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_sync"<<std::endl;
+    status = nc_sync(ncid);
+    info(100)<<"end nc_sync"<<std::endl;
+  }
   if (NC_NOERR != status)
   {
@@ -872 +1066 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, double* data)
 {
-  return nc_get_att_double(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_double"<<std::endl;
+    status = nc_get_att_double(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_double"<<std::endl;
+  }
+  return status;
 }
 
@@ -878 +1079 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, float* data)
 {
-  return nc_get_att_float(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_float"<<std::endl;
+    status = nc_get_att_float(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_float"<<std::endl;
+  }
+  return status;
 }
 
@@ -884 +1092 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, int* data)
 {
-  return nc_get_att_int(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_int"<<std::endl;
+    status = nc_get_att_int(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_int"<<std::endl;
+  }
+  return status; 
 }
 
@@ -890 +1105 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, long* data)
 {
-  return nc_get_att_long(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_long"<<std::endl;
+    status = nc_get_att_long(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_long"<<std::endl;
+  }
+  return status;
 }
 
@@ -896 +1118 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, short* data)
 {
-  return nc_get_att_short(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_short"<<std::endl;
+    status = nc_get_att_short(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_short"<<std::endl;
+  }
+  return status;
 }
 
@@ -902 +1131 @@
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, char* data)
 {
-  return nc_get_att_text(ncid, varid, attrName, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_att_text"<<std::endl;
+    status = nc_get_att_text(ncid, varid, attrName, data);
+    info(100)<<"end nc_get_att_text"<<std::endl;
+  }
+  return status;
 }
 
@@ -910 +1146 @@
                                    StdSize numVal, const double* data)
 {
-  return nc_put_att_double(ncid, varid, attrName, NC_DOUBLE, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_double"<<std::endl;
+    status = nc_put_att_double(ncid, varid, attrName, NC_DOUBLE, numVal, data);
+    info(100)<<"end nc_put_att_double"<<std::endl;
+  }
+  return status;
 }
 
@@ -917 +1160 @@
                                    StdSize numVal, const float* data)
 {
-  return nc_put_att_float(ncid, varid, attrName, NC_FLOAT, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_float"<<std::endl;
+    status = nc_put_att_float(ncid, varid, attrName, NC_FLOAT, numVal, data);
+    info(100)<<"end nc_put_att_float"<<std::endl;
+  }
+  return status;
 }
 
@@ -924 +1174 @@
                                    StdSize numVal, const int* data)
 {
-  return nc_put_att_int(ncid, varid, attrName, NC_INT, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_int"<<std::endl;
+    status = nc_put_att_int(ncid, varid, attrName, NC_INT, numVal, data);
+    info(100)<<"end nc_put_att_int"<<std::endl;
+  }
+  return status;
 }
 
@@ -931 +1188 @@
                                    StdSize numVal, const long* data)
 {
-  return nc_put_att_long(ncid, varid, attrName, NC_LONG, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_long"<<std::endl;
+    status = nc_put_att_long(ncid, varid, attrName, NC_LONG, numVal, data);
+    info(100)<<"end nc_put_att_long"<<std::endl;
+  }
+  return status;
 }
 
@@ -938 +1202 @@
                                    StdSize numVal, const short* data)
 {
-  return nc_put_att_short(ncid, varid, attrName, NC_SHORT, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_short"<<std::endl;
+    status = nc_put_att_short(ncid, varid, attrName, NC_SHORT, numVal, data);
+    info(100)<<"end nc_put_att_short"<<std::endl;
+  }
+  return status;
 }
 
@@ -945 +1216 @@
                                    StdSize numVal, const char* data)
 {
-  return nc_put_att_text(ncid, varid, attrName, numVal, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_att_text"<<std::endl;
+    status = nc_put_att_text(ncid, varid, attrName, numVal, data);
+    info(100)<<"end nc_put_att_text"<<std::endl;
+  }
+  return status;
 }
 
@@ -952 +1230 @@
 int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, double* data)
 {
-  return nc_get_vara_double(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_vara_double"<<std::endl;
+    status = nc_get_vara_double(ncid, varid, start, count, data);
+    info(100)<<"end nc_get_vara_double"<<std::endl;
+  }
+  return status;
 }
 
@@ -958 +1243 @@
 int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, float* data)
 {
-  return nc_get_vara_float(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_vara_float"<<std::endl;
+    status = nc_get_vara_float(ncid, varid, start, count, data);
+    info(100)<<"end nc_get_vara_float"<<std::endl;
+  }
+  return status; 
 }
 
@@ -964 +1256 @@
 int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, int* data)
 {
-  return nc_get_vara_int(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_vara_int"<<std::endl;
+    status = nc_get_vara_int(ncid, varid, start, count, data);
+    info(100)<<"end nc_get_vara_int"<<std::endl;
+  }
+  return status; 
 }
 
@@ -970 +1269 @@
 int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, char* data)
 {
-  return nc_get_vara_text(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_get_vara_text"<<std::endl;
+    status = nc_get_vara_text(ncid, varid, start, count, data);
+    info(100)<<"end nc_get_vara_text"<<std::endl;
+  }
+  return status;
 }
 
@@ -977 +1283 @@
 int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const double* data)
 {
-  return nc_put_vara_double(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_vara_double"<<std::endl;
+    status = nc_put_vara_double(ncid, varid, start, count, data);
+    info(100)<<"end nc_put_vara_double"<<std::endl;
+  }
+  return status;
 }
 
@@ -983 +1296 @@
 int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const float* data)
 {
-  return nc_put_vara_float(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_vara_float"<<std::endl;
+    status = nc_put_vara_float(ncid, varid, start, count, data);
+    info(100)<<"end nc_put_vara_float"<<std::endl;
+  }
+  return status;
 }
 
@@ -989 +1309 @@
 int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const int* data)
 {
-  return nc_put_vara_int(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_vara_int"<<std::endl;
+    status = nc_put_vara_int(ncid, varid, start, count, data);
+    info(100)<<"end nc_put_vara_int"<<std::endl;
+  }
+  return status;
 }
 
@@ -995 +1322 @@
 int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const char* data)
 {
-  return nc_put_vara_text(ncid, varid, start, count, data);
+  int status;
+  #pragma omp critical (_netcdf)
+  {
+    info(100)<<"start nc_put_vara_text"<<std::endl;
+    status = nc_put_vara_text(ncid, varid, start, count, data);
+    info(100)<<"end nc_put_vara_text"<<std::endl;
+  }
+  return status;
 }
 
@@ -1008 +1342 @@
 {
    int varId = 0;
-   return (NC_NOERR == (nc_inq_varid(ncId, varName.c_str(), &varId)));
+   int status;
+   #pragma omp critical (_netcdf)
+   {
+     info(100)<<"start isVarExisted"<<std::endl;
+     status = nc_inq_varid(ncId, varName.c_str(), &varId);
+     info(100)<<"end isVarExisted"<<std::endl;
+   }
+   return (NC_NOERR == status);
 }
 
@@ -1014 +1355 @@
 {
    int dimId = 0;
-   return (NC_NOERR == (nc_inq_dimid(ncId, dimName.c_str(), &dimId)));
+   int status;
+   #pragma omp critical (_netcdf)
+   {
+     info(100)<<"start isDimExisted"<<std::endl;
+     status = nc_inq_dimid(ncId, dimName.c_str(), &dimId);
+     info(100)<<"end isDimExisted"<<std::endl;
+   }
+   return (NC_NOERR == status);
 }
 

XIOS/dev/dev_trunk_omp/src/io/netCdfInterface.hpp

@@ -10 +10 @@
 #define __NETCDF_INTERFACE_HPP_
 
+#include "mpi_std.hpp"
 #include "xios_spl.hpp"
 
@@ -16 +17 @@
 #endif
 
-#include "mpi.hpp"
+
 #include "netcdf.hpp"
 

XIOS/dev/dev_trunk_omp/src/io/netcdf.hpp

@@ -1 +1 @@
 #ifndef __XIOS_NETCDF_HPP__
 #define __XIOS_NETCDF_HPP__
-#include "mpi.hpp"
+#include "mpi_std.hpp"
 #define MPI_INCLUDED
 #include <netcdf.h>
@@ -33 +33 @@
   {
 #if defined(USING_NETCDF_PAR)
-    return ::nc_create_par(path, cmode, comm, info, ncidp) ;
+    int status;
+    #pragma omp critical (_netcdf)
+    {
+      status = ::nc_create_par(path, cmode, comm, info, ncidp) ;
+    }
+    return status;
 #else
     ERROR("int nc_create_par(const char *path, int cmode, MPI_Comm comm, MPI_Info info,int *ncidp)",
@@ -44 +49 @@
   {
 #if defined(USING_NETCDF_PAR)
-    return ::nc_open_par(path, mode, comm, info, ncidp) ;
+    int status;
+    #pragma omp critical (_netcdf)
+    {
+      status = ::nc_open_par(path, mode, comm, info, ncidp) ;
+    }
+    return status;
 #else
     ERROR("int nc_open_par(const char *path, int mode, MPI_Comm comm, MPI_Info info,int *ncidp)",
@@ -55 +65 @@
   {
 #if defined(USING_NETCDF_PAR)
-    return ::nc_var_par_access(ncid, varid, par_access) ;
+    int status = ::nc_var_par_access(ncid, varid, par_access) ;
+    
+    return status;
 #else
     ERROR("int nc_var_par_access(int ncid, int varid, int par_access)",

XIOS/dev/dev_trunk_omp/src/io/onetcdf4.cpp

@@ -3 +3 @@
 #include "onetcdf4.hpp"
 #include "group_template.hpp"
-#include "mpi.hpp"
+#include "ep_mpi.hpp"
 #include "netcdf.hpp"
 #include "netCdfInterface.hpp"
@@ -15 +15 @@
       CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat,
                                                         bool useCFConvention,
-                           const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                           const ep_lib::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 MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                                 const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
       {
          this->useClassicFormat = useClassicFormat;
@@ -44 +44 @@
          {
             int commSize = 0;
-            MPI_Comm_size(*comm, &commSize);
+            ep_lib::MPI_Comm_size(*comm, &commSize);
             if (commSize <= 1)
                comm = NULL;
@@ -58 +58 @@
             CTimer::get("Files : create").resume();
             if (wmpi)
-               CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
+               CNetCdfInterface::createPar(filename, mode, to_mpi_comm((*comm)->mpi_comm), to_mpi_info(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, MPI_INFO_NULL, this->ncidp);
+               CNetCdfInterface::openPar(filename, mode, to_mpi_comm((*comm)->mpi_comm), to_mpi_info(MPI_INFO_NULL), this->ncidp);
             else
                CNetCdfInterface::open(filename, mode, this->ncidp);

XIOS/dev/dev_trunk_omp/src/io/onetcdf4.hpp

@@ -4 +4 @@
 /// XIOS headers ///
 #include "xios_spl.hpp"
+#include "mpi_std.hpp"
 #include "exception.hpp"
 #include "data_output.hpp"
 #include "array_new.hpp"
-#include "mpi.hpp"
 #include "netcdf.hpp"
 
@@ -28 +28 @@
             CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false,
                           bool useCFConvention = true,
-                      const MPI_Comm* comm = NULL, bool multifile = true,
+                      const ep_lib::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 MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
+                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
             void close(void);
             void sync(void);