IO direct from FOM

IO/PackData.cpp

@@ -0,0 +1,105 @@
+#include "IO/PackData.h"
+
+#include <string.h>
+
+
+/********************************************************
+* Concrete implimentations for packing/unpacking        *
+********************************************************/
+// unsigned char
+template<>
+size_t packsize<unsigned char>( const unsigned char& rhs )
+{
+    return sizeof(unsigned char);
+}
+template<>
+void pack<unsigned char>( const unsigned char& rhs, char *buffer )
+{
+    memcpy(buffer,&rhs,sizeof(unsigned char));
+}
+template<>
+void unpack<unsigned char>( unsigned char& data, const char *buffer )
+{
+    memcpy(&data,buffer,sizeof(unsigned char));
+}
+// char
+template<>
+size_t packsize<char>( const char& rhs )
+{
+    return sizeof(char);
+}
+template<>
+void pack<char>( const char& rhs, char *buffer )
+{
+    memcpy(buffer,&rhs,sizeof(char));
+}
+template<>
+void unpack<char>( char& data, const char *buffer )
+{
+    memcpy(&data,buffer,sizeof(char));
+}
+// int
+template<>
+size_t packsize<int>( const int& rhs )
+{
+    return sizeof(int);
+}
+template<>
+void pack<int>( const int& rhs, char *buffer )
+{
+    memcpy(buffer,&rhs,sizeof(int));
+}
+template<>
+void unpack<int>( int& data, const char *buffer )
+{
+    memcpy(&data,buffer,sizeof(int));
+}
+// unsigned int
+template<>
+size_t packsize<unsigned int>( const unsigned int& rhs )
+{
+    return sizeof(unsigned int);
+}
+template<>
+void pack<unsigned int>( const unsigned int& rhs, char *buffer )
+{
+    memcpy(buffer,&rhs,sizeof(int));
+}
+template<>
+void unpack<unsigned int>( unsigned int& data, const char *buffer )
+{
+    memcpy(&data,buffer,sizeof(int));
+}
+// size_t
+template<>
+size_t packsize<size_t>( const size_t& rhs )
+{
+    return sizeof(size_t);
+}
+template<>
+void pack<size_t>( const size_t& rhs, char *buffer )
+{
+    memcpy(buffer,&rhs,sizeof(size_t));
+}
+template<>
+void unpack<size_t>( size_t& data, const char *buffer )
+{
+    memcpy(&data,buffer,sizeof(size_t));
+}
+// std::string
+template<>
+size_t packsize<std::string>( const std::string& rhs )
+{
+    return rhs.size()+1;
+}
+template<>
+void pack<std::string>( const std::string& rhs, char *buffer )
+{
+    memcpy(buffer,rhs.c_str(),rhs.size()+1);
+}
+template<>
+void unpack<std::string>( std::string& data, const char *buffer )
+{
+    data = std::string(buffer);
+}
+

IO/PackData.h

@@ -0,0 +1,78 @@
+// This file contains unctions to pack/unpack data structures
+#ifndef included_PackData
+#define included_PackData
+
+#include <vector>
+#include <set>
+#include <map>
+
+
+//! Template function to return the buffer size required to pack a class
+template<class TYPE>
+size_t packsize( const TYPE& rhs );
+
+//! Template function to pack a class to a buffer
+template<class TYPE>
+void pack( const TYPE& rhs, char *buffer );
+
+//! Template function to unpack a class from a buffer
+template<class TYPE>
+void unpack( TYPE& data, const char *buffer );
+
+
+//! Template function to return the buffer size required to pack a std::vector
+template<class TYPE>
+size_t packsize( const std::vector<TYPE>& rhs );
+
+//! Template function to pack a class to a buffer
+template<class TYPE>
+void pack( const std::vector<TYPE>& rhs, char *buffer );
+
+//! Template function to pack a class to a buffer
+template<class TYPE>
+void unpack( std::vector<TYPE>& data, const char *buffer );
+
+
+//! Template function to return the buffer size required to pack a std::pair
+template<class TYPE1, class TYPE2>
+size_t packsize( const std::pair<TYPE1,TYPE2>& rhs );
+
+//! Template function to pack a class to a buffer
+template<class TYPE1, class TYPE2>
+void pack( const std::pair<TYPE1,TYPE2>& rhs, char *buffer );
+
+//! Template function to pack a class to a buffer
+template<class TYPE1, class TYPE2>
+void unpack( std::pair<TYPE1,TYPE2>& data, const char *buffer );
+
+
+//! Template function to return the buffer size required to pack a std::map
+template<class TYPE1, class TYPE2>
+size_t packsize( const std::map<TYPE1,TYPE2>& rhs );
+
+//! Template function to pack a class to a buffer
+template<class TYPE1, class TYPE2>
+void pack( const std::map<TYPE1,TYPE2>& rhs, char *buffer );
+
+//! Template function to pack a class to a buffer
+template<class TYPE1, class TYPE2>
+void unpack( std::map<TYPE1,TYPE2>& data, const char *buffer );
+
+
+//! Template function to return the buffer size required to pack a std::set
+template<class TYPE>
+size_t packsize( const std::set<TYPE>& rhs );
+
+//! Template function to pack a class to a buffer
+template<class TYPE>
+void pack( const std::set<TYPE>& rhs, char *buffer );
+
+//! Template function to pack a class to a buffer
+template<class TYPE>
+void unpack( std::set<TYPE>& data, const char *buffer );
+
+
+#include "IO/PackData.hpp"
+
+#endif
+

IO/PackData.hpp

@@ -0,0 +1,155 @@
+// This file functions to pack/unpack data structures
+#ifndef included_PackData_hpp
+#define included_PackData_hpp
+
+#include "IO/PackData.h"
+
+#include <string.h>
+#include <vector>
+#include <set>
+#include <map>
+
+
+
+/********************************************************
+* Default instantiations for std::vector                *
+********************************************************/
+template<class TYPE>
+size_t packsize( const std::vector<TYPE>& rhs )
+{
+    size_t bytes = sizeof(size_t);
+    for (size_t i=0; i<rhs.size(); i++)
+        bytes += packsize(rhs[i]);
+    return bytes;
+}
+template<class TYPE>
+void pack( const std::vector<TYPE>& rhs, char *buffer )
+{
+    size_t size = rhs.size();
+    memcpy(buffer,&size,sizeof(size_t));
+    size_t pos = sizeof(size_t);
+    for (size_t i=0; i<rhs.size(); i++) {
+        pack(rhs[i],&buffer[pos]);
+        pos += packsize(rhs[i]);
+    }
+}
+template<class TYPE>
+void unpack( std::vector<TYPE>& data, const char *buffer )
+{
+    size_t size;
+    memcpy(&size,buffer,sizeof(size_t));
+    data.clear();
+    data.resize(size);
+    size_t pos = sizeof(size_t);
+    for (size_t i=0; i<data.size(); i++) {
+        unpack(data[i],&buffer[pos]);
+        pos += packsize(data[i]);
+    }
+}
+
+
+/********************************************************
+* Default instantiations for std::pair                  *
+********************************************************/
+template<class TYPE1, class TYPE2>
+size_t packsize( const std::pair<TYPE1,TYPE2>& rhs )
+{
+    return packsize(rhs.first)+packsize(rhs.second);
+}
+template<class TYPE1, class TYPE2>
+void pack( const std::pair<TYPE1,TYPE2>& rhs, char *buffer )
+{
+    pack(rhs.first,buffer);
+    pack(rhs.second,&buffer[packsize(rhs.first)]);
+}
+template<class TYPE1, class TYPE2>
+void unpack( std::pair<TYPE1,TYPE2>& data, const char *buffer )
+{
+    unpack(data.first,buffer);
+    unpack(data.second,&buffer[packsize(data.first)]);
+}
+
+
+/********************************************************
+* Default instantiations for std::map                   *
+********************************************************/
+template<class TYPE1, class TYPE2>
+size_t packsize( const std::map<TYPE1,TYPE2>& rhs )
+{
+    size_t bytes = sizeof(size_t);
+    typename std::map<TYPE1,TYPE2>::const_iterator it;
+    for (it=rhs.begin(); it!=rhs.end(); ++it) {
+        bytes += packsize(it->first);
+        bytes += packsize(it->second);
+    }
+    return bytes;
+}
+template<class TYPE1, class TYPE2>
+void pack( const std::map<TYPE1,TYPE2>& rhs, char *buffer )
+{
+    size_t N = rhs.size();
+    pack(N,buffer);
+    size_t pos = sizeof(size_t);
+    typename std::map<TYPE1,TYPE2>::const_iterator it;
+    for (it=rhs.begin(); it!=rhs.end(); ++it) {
+        pack(it->first,&buffer[pos]);   pos+=packsize(it->first);
+        pack(it->second,&buffer[pos]);  pos+=packsize(it->second);
+    }
+}
+template<class TYPE1, class TYPE2>
+void unpack( std::map<TYPE1,TYPE2>& data, const char *buffer )
+{
+    size_t N = 0;
+    unpack(N,buffer);
+    size_t pos = sizeof(size_t);
+    data.clear();
+    for (size_t i=0; i<N; i++) {
+        std::pair<TYPE1,TYPE2> tmp;
+        unpack(tmp.first,&buffer[pos]);   pos+=packsize(tmp.first);
+        unpack(tmp.second,&buffer[pos]);  pos+=packsize(tmp.second);
+        data.insert(tmp);
+    }
+}
+
+
+/********************************************************
+* Default instantiations for std::set                   *
+********************************************************/
+template<class TYPE>
+size_t packsize( const std::set<TYPE>& rhs )
+{
+    size_t bytes = sizeof(size_t);
+    typename std::set<TYPE>::const_iterator it;
+    for (it=rhs.begin(); it!=rhs.end(); ++it) {
+        bytes += packsize(*it);
+    }
+    return bytes;
+}
+template<class TYPE>
+void pack( const std::set<TYPE>& rhs, char *buffer )
+{
+    size_t N = rhs.size();
+    pack(N,buffer);
+    size_t pos = sizeof(size_t);
+    typename std::set<TYPE>::const_iterator it;
+    for (it=rhs.begin(); it!=rhs.end(); ++it) {
+        pack(*it);   pos+=packsize(*it);
+    }
+}
+template<class TYPE>
+void unpack( std::set<TYPE>& data, const char *buffer )
+{
+    size_t N = 0;
+    unpack(N,buffer);
+    size_t pos = sizeof(size_t);
+    data.clear();
+    for (size_t i=0; i<N; i++) {
+        TYPE tmp;
+        unpack(tmp,&buffer[pos]);   pos+=packsize(tmp);
+        data.insert(tmp);
+    }
+}
+
+
+#endif
+

IO/netcdf.cpp

@@ -1,6 +1,6 @@
 #include "IO/netcdf.h"
 #include "common/Utilities.h"
-#include "common/MPI_Helpers.h"
+#include "common/MPI.h"
 
 #include "ProfilerApp.h"
 
@@ -116,10 +116,10 @@ std::string VariableTypeName( VariableType type )
 /****************************************************
 * Open/close a file                                 *
 ****************************************************/
-int open( const std::string& filename, FileMode mode, MPI_Comm comm )
+int open( const std::string& filename, FileMode mode, const Utilities::MPI& comm )
 {
     int fid = 0;
-    if ( comm == MPI_COMM_NULL ) {
+    if ( comm.isNull() ) {
         if ( mode == READ ) {
             int err = nc_open( filename.c_str(), NC_NOWRITE, &fid );
             CHECK_NC_ERR( err );
@@ -134,13 +134,13 @@ int open( const std::string& filename, FileMode mode, MPI_Comm comm )
         }
     } else {
         if ( mode == READ ) {
-            int err = nc_open_par( filename.c_str(), NC_MPIPOSIX, comm, MPI_INFO_NULL, &fid );
+            int err = nc_open_par( filename.c_str(), NC_MPIPOSIX, comm.getCommunicator(), MPI_INFO_NULL, &fid );
             CHECK_NC_ERR( err );
         } else if ( mode == WRITE ) {
-            int err = nc_open_par( filename.c_str(), NC_WRITE|NC_MPIPOSIX, comm, MPI_INFO_NULL, &fid );
+            int err = nc_open_par( filename.c_str(), NC_WRITE|NC_MPIPOSIX, comm.getCommunicator(), MPI_INFO_NULL, &fid );
             CHECK_NC_ERR( err );
         } else if ( mode == CREATE ) {
-            int err = nc_create_par( filename.c_str(), NC_NETCDF4|NC_MPIIO, comm, MPI_INFO_NULL, &fid );
+            int err = nc_create_par( filename.c_str(), NC_NETCDF4|NC_MPIIO, comm.getCommunicator(), MPI_INFO_NULL, &fid );
             CHECK_NC_ERR( err );
         } else {
             ERROR("Unknown file mode");
@@ -375,7 +375,7 @@ Array<TYPE> getVar( int fid, const std::string& var, const std::vector<int>& sta
     std::vector<size_t> var_size = getVarDim( fid, var );
     for (int d=0; d<(int)var_size.size(); d++) {
         if ( start[d]<0 || start[d]+stride[d]*(count[d]-1)>(int)var_size[d] ) {
-            int rank = comm_rank(MPI_COMM_WORLD);
+            int rank = Utilities::MPI(MPI_COMM_WORLD).getRank();
             char tmp[1000];
             sprintf(tmp,"%i: Range exceeded array dimension:\n"
                 "   start[%i]=%i, count[%i]=%i, stride[%i]=%i, var_size[%i]=%i",

IO/netcdf.h

@@ -5,7 +5,7 @@
 #include <vector>
 
 #include "common/Array.h"
-#include "common/MPI_Helpers.h"
+#include "common/MPI.h"
 #include "common/Communication.h"
 
 
@@ -32,7 +32,7 @@ std::string VariableTypeName( VariableType type );
  * @param mode          Open the file for reading or writing
  * @param comm          MPI communicator to use (MPI_COMM_WORLD: don't use parallel netcdf)
 */
-int open( const std::string& filename, FileMode mode, MPI_Comm comm=MPI_COMM_NULL );
+int open( const std::string& filename, FileMode mode, const Utilities::MPI& comm=MPI_COMM_NULL );
 
 
 /*!