Code owners
Assign users and groups as approvers for specific file changes. Learn more.
ADIOS.h 21.78 KiB
/*
* ADIOS.h
*
* Created on: Oct 3, 2016
* Author: wfg
*/
#ifndef ADIOS_H_
#define ADIOS_H_
/// \cond EXCLUDE_FROM_DOXYGEN
#include <string>
#include <vector>
#include <memory> //shared_ptr
#include <ostream>
#include <set>
#include <map>
#include <complex>
/// \endcond
#ifdef HAVE_MPI
#include <mpi.h>
#else
#include "mpidummy.h"
#endif
#include "core/Transform.h"
#include "core/Variable.h"
#include "core/VariableCompound.h"
#include "core/Method.h"
#include "core/Support.h"
#include "functions/adiosTemplates.h"
namespace adios
{
class Engine;
/**
* @brief Unique class interface between user application and ADIOS library
*/
class ADIOS
{
public: // PUBLIC Constructors and Functions define the User Interface with ADIOS
#ifdef HAVE_MPI
MPI_Comm m_MPIComm = MPI_COMM_NULL; ///< only used as reference to MPI communicator passed from parallel constructor, MPI_Comm is a pointer itself. Public as called from C
#else
MPI_Comm m_MPIComm = 0; ///< only used as reference to MPI communicator passed from parallel constructor, MPI_Comm is a pointer itself. Public as called from C
#endif
int m_RankMPI = 0; ///< current MPI rank process
int m_SizeMPI = 1; ///< current MPI processes size
std::string m_HostLanguage = "C++";
/**
* @brief ADIOS empty constructor. Used for non XML config file API calls.
*/
ADIOS( const bool debugMode = false );
/**
* @brief Serial constructor for config file
* @param configFileName passed to m_ConfigFile
* @param debugMode true: on throws exceptions and do additional checks, false: off (faster, but unsafe)
*/
ADIOS( const std::string configFileName, const bool debugMode = false );
/**
* @brief Parallel constructor for XML config file and MPI
* @param configFileName passed to m_XMLConfigFile
* @param mpiComm MPI communicator ...const to be discussed
* @param debugMode true: on, false: off (faster, but unsafe)
*/
ADIOS( const std::string configFileName, const MPI_Comm mpiComm, const bool debugMode = false );
/**
* @brief Parallel MPI communicator without XML config file
* @param mpiComm MPI communicator passed to m_MPIComm*
* @param debugMode true: on, false: off (faster)
*/
ADIOS( const MPI_Comm mpiComm, const bool debugMode = false );
~ADIOS( ); ///< empty, using STL containers for memory management
void InitMPI( ); ///< sets rank and size in m_rank and m_Size, respectively.
/**
* Look for template specialization
* @param name
* @param dimensions
* @param globalDimensions
* @param globalOffsets
* @return
*/
template<class T> inline
Variable<T>& DefineVariable( const std::string name, const Dims dimensions = Dims{1},
const Dims globalDimensions = Dims( ),
const Dims globalOffsets = Dims() )
{
throw std::invalid_argument( "ERROR: type not supported for variable " + name + " in call to DefineVariable\n" );
}
template<class T> inline
Variable<T>& GetVariable( const std::string name )
{
throw std::invalid_argument( "ERROR: type not supported for variable " + name + " in call to GetVariable\n" );
}
template<class T>
VariableCompound& DefineVariableCompound( const std::string name, const Dims dimensions = Dims{1},
const Dims globalDimensions = Dims(),
const Dims globalOffsets = Dims() )
{
CheckVariableInput( name, dimensions );
m_Compound.emplace_back( name, sizeof(T), dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<T>(), m_Compound.size()-1 ) );
return m_Compound.back();
}
VariableCompound& GetVariableCompound( const std::string name );
/**
* Declares a new method
* @param name must be unique
* @param type supported type : "Writer" (default), "DataMan"...future: "Sirius"
*/
Method& DeclareMethod( const std::string methodName, const std::string type = "BPWriter" );
/** * @brief Open to Write, Read. Creates a new engine from previously defined method
* @param streamName unique stream or file name
* @param accessMode "w" or "write", "r" or "read", "a" or "append"
* @param mpiComm option to modify communicator from ADIOS class constructor
* @param method looks for corresponding Method object in ADIOS to initialize the engine
* @param cores optional parameter for threaded operations
* @return Derived class of base Engine depending on Method parameters, shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open( const std::string streamName, const std::string accessMode, MPI_Comm mpiComm,
const Method& method, const unsigned int cores = 1 );
/**
* @brief Open to Write, Read. Creates a new engine from previously defined method.
* Reuses MPI communicator from ADIOS constructor.
* @param streamName unique stream or file name
* @param accessMode "w" or "write", "r" or "read", "a" or "append"
* @param method contains engine parameters
* @param cores optional parameter for threaded operations
* @return Derived class of base Engine depending on Method parameters, shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open( const std::string streamName, const std::string accessMode, const Method& method,
const unsigned int cores = 1 );
/**
* Version required by the XML config file implementation, searches method inside ADIOS through a unique name
* @param streamName unique stream or file name
* @param accessMode "w" or "write", "r" or "read", "a" or "append"
* @param mpiComm mpi Communicator
* @param methodName used to search method object inside ADIOS object
* @param cores optional parameter for threaded operations
* @return Derived class of base Engine depending on Method parameters, shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open( const std::string streamName, const std::string accessMode, MPI_Comm mpiComm,
const std::string methodName, const unsigned int cores = 1 );
/**
* Version required by the XML config file implementation, searches method inside ADIOS through a unique name.
* Reuses ADIOS MPI Communicator from constructor.
* @param streamName unique stream or file name
* @param accessMode "w" or "write", "r" or "read", "a" or "append"
* @param methodName used to search method object inside ADIOS object
* @param cores optional parameter for threaded operations
* @return Derived class of base Engine depending on Method parameters, shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open( const std::string streamName, const std::string accessMode,
const std::string methodName, const unsigned int cores = 1 );
/**
* @brief Dumps groups information to a file stream or standard output.
* Note that either the user closes this fileStream or it's closed at the end.
* @param logStream either std::cout standard output, or a std::ofstream file
*/
void MonitorVariables( std::ostream& logStream );
private: //no const to allow default empty and copy constructors
std::vector< Variable<char> > m_Char; ///< Key: variable name, Value: variable of type char
std::vector< Variable<unsigned char> > m_UChar; ///< Key: variable name, Value: variable of type unsigned char
std::vector< Variable<short> > m_Short; ///< Key: variable name, Value: variable of type short
std::vector< Variable<unsigned short> > m_UShort; ///< Key: variable name, Value: variable of type unsigned short
std::vector< Variable<int> > m_Int; ///< Key: variable name, Value: variable of type int
std::vector< Variable<unsigned int> > m_UInt; ///< Key: variable name, Value: variable of type unsigned int
std::vector< Variable<long int> > m_LInt; ///< Key: variable name, Value: variable of type long int
std::vector< Variable<unsigned long int> > m_ULInt; ///< Key: variable name, Value: variable of type unsigned long int
std::vector< Variable<long long int> > m_LLInt; ///< Key: variable name, Value: variable of type long long int
std::vector< Variable<unsigned long long int> > m_ULLInt; ///< Key: variable name, Value: variable of type unsigned long long int std::vector< Variable<float> > m_Float; ///< Key: variable name, Value: variable of type float
std::vector< Variable<double> > m_Double; ///< Key: variable name, Value: variable of type double
std::vector< Variable<long double> > m_LDouble; ///< Key: variable name, Value: variable of type double
std::vector< Variable<std::complex<float>> > m_CFloat; ///< Key: variable name, Value: variable of type complex<float>
std::vector< Variable<std::complex<double>> > m_CDouble; ///< Key: variable name, Value: variable of type complex<float>
std::vector< Variable<std::complex<long double>> > m_CLDouble; ///< Key: variable name, Value: variable of type complex<float>
std::vector< VariableCompound > m_Compound; ///< Key: variable name, Value: compound type variable
std::string m_ConfigFile; ///< XML File to be read containing configuration information
bool m_DebugMode = false; ///< if true will do more checks, exceptions, warnings, expect slower code
//Variables
std::map< std::string, std::pair< std::string, unsigned int > > m_Variables; ///< Makes variable name unique, key: variable name, value: pair.first = type, pair.second = index in corresponding vector of Variable
std::vector< std::shared_ptr<Transform> > m_Transforms; ///< transforms associated with ADIOS run
/**
* @brief List of Methods (engine metadata) defined from either ADIOS XML configuration file or the DeclareMethod function.
* <pre>
* Key: std::string unique method name
* Value: Method class
* </pre>
*/
std::map< std::string, Method > m_Methods;
std::set< std::string > m_EngineNames; ///< set used to check Engine name uniqueness in debug mode
/**
* @brief Checks for group existence in m_Groups, if failed throws std::invalid_argument exception
* @param itGroup m_Groups iterator, usually from find function
* @param groupName unique name, passed for thrown exception only
* @param hint adds information to thrown exception
*/
void CheckVariableInput( const std::string name, const Dims& dimensions ) const;
/**
* Checks for variable name, if not found throws an invalid exception
* @param itVariable iterator pointing to the variable name in m_Variables
* @param name variable name
* @param hint message to be thrown for debugging purporses
*/
void CheckVariableName( std::map< std::string, std::pair< std::string, unsigned int > >::const_iterator itVariable,
const std::string name, const std::string hint ) const;
/**
* @brief Checks for method existence in m_Methods, if failed throws std::invalid_argument exception
* @param itMethod m_Methods iterator, usually from find function
* @param methodName unique name, passed for thrown exception only
* @param hint adds information to thrown exception
*/
void CheckMethod( std::map< std::string, Method >::const_iterator itMethod,
const std::string methodName, const std::string hint ) const;
template< class T >
unsigned int GetVariableIndex( const std::string name )
{
auto itVariable = m_Variables.find( name );
CheckVariableName( itVariable, name, "in call to GetVariable<" + GetType<T>() + ">, or call to GetVariableCompound if <T> = <compound>\n" );
return itVariable->second.second;
}
};
//template specializations of DefineVariable:
template<> inline
Variable<char>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_Char.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode ); m_Variables.emplace( name, std::make_pair( GetType<char>(), m_Char.size()-1 ) );
return m_Char.back();
}
template<> inline
Variable<unsigned char>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_UChar.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned char>(), m_UChar.size()-1 ) );
return m_UChar.back();
}
template<> inline
Variable<short>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_Short.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned char>(), m_Short.size()-1 ) );
return m_Short.back();
}
template<> inline
Variable<unsigned short>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_UShort.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned short>(), m_UShort.size()-1 ) );
return m_UShort.back();
}
template<> inline
Variable<int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_Int.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<int>(), m_Int.size()-1 ) );
return m_Int.back();
}
template<> inline
Variable<unsigned int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_UInt.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned int>(), m_UInt.size()-1 ) );
return m_UInt.back();
}
template<> inline
Variable<long int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_LInt.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<long int>(), m_LInt.size()-1 ) );
return m_LInt.back();
}
template<> inline
Variable<unsigned long int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_ULInt.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned long int>(), m_ULInt.size()-1 ) );
return m_ULInt.back();
}
template<> inline
Variable<long long int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_LLInt.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<long long int>(), m_LLInt.size()-1 ) );
return m_LLInt.back();
}
template<> inline
Variable<unsigned long long int>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_ULLInt.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<unsigned long long int>(), m_ULLInt.size()-1 ) );
return m_ULLInt.back();
}
template<> inline
Variable<float>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_Float.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<float>(), m_Float.size()-1 ) );
return m_Float.back();
}
template<> inline
Variable<double>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_Double.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<double>(), m_Double.size()-1 ) );
return m_Double.back();
}
template<> inline
Variable<long double>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_LDouble.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<long double>(), m_LDouble.size()-1 ) );
return m_LDouble.back();
}
template<> inline
Variable<std::complex<float>>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{ CheckVariableInput( name, dimensions );
m_CFloat.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<std::complex<float>>(), m_CFloat.size()-1 ) );
return m_CFloat.back();
}
template<> inline
Variable<std::complex<double>>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_CDouble.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<std::complex<double>>(), m_CDouble.size()-1 ) );
return m_CDouble.back();
}
template<> inline
Variable<std::complex<long double>>& ADIOS::DefineVariable( const std::string name, const Dims dimensions,
const Dims globalDimensions, const Dims globalOffsets )
{
CheckVariableInput( name, dimensions );
m_CLDouble.emplace_back( name, dimensions, globalDimensions, globalOffsets, m_DebugMode );
m_Variables.emplace( name, std::make_pair( GetType<std::complex<double>>(), m_CLDouble.size()-1 ) );
return m_CLDouble.back();
}
//Get template specialization
template<> inline
Variable<char>& ADIOS::GetVariable( const std::string name )
{ return m_Char[ GetVariableIndex<char>(name) ]; }
template<> inline
Variable<unsigned char>& ADIOS::GetVariable( const std::string name )
{ return m_UChar[ GetVariableIndex<unsigned char>(name) ]; }
template<> inline
Variable<short>& ADIOS::GetVariable( const std::string name )
{ return m_Short[ GetVariableIndex<short>(name) ]; }
template<> inline
Variable<unsigned short>& ADIOS::GetVariable( const std::string name )
{ return m_UShort[ GetVariableIndex<unsigned short>(name) ]; }
template<> inline
Variable<int>& ADIOS::GetVariable( const std::string name )
{ return m_Int[ GetVariableIndex<int>(name) ]; }
template<> inline
Variable<unsigned int>& ADIOS::GetVariable( const std::string name )
{ return m_UInt[ GetVariableIndex<unsigned int>(name) ]; }
template<> inline
Variable<long int>& ADIOS::GetVariable( const std::string name )
{ return m_LInt[ GetVariableIndex<unsigned int>(name) ]; }
template<> inline
Variable<unsigned long int>& ADIOS::GetVariable( const std::string name )
{ return m_ULInt[ GetVariableIndex<unsigned long int>(name) ]; }
template<> inline
Variable<long long int>& ADIOS::GetVariable( const std::string name )
{ return m_LLInt[ GetVariableIndex<long long int>(name) ]; }
template<> inline
Variable<unsigned long long int>& ADIOS::GetVariable( const std::string name )
{ return m_ULLInt[ GetVariableIndex<unsigned long long int>(name) ]; }
template<> inline
Variable<float>& ADIOS::GetVariable( const std::string name )
{ return m_Float[ GetVariableIndex<float>(name) ]; }
template<> inline
Variable<double>& ADIOS::GetVariable( const std::string name )
{ return m_Double[ GetVariableIndex<double>(name) ]; }
template<> inline
Variable<long double>& ADIOS::GetVariable( const std::string name )
{ return m_LDouble[ GetVariableIndex<long double>(name) ]; }
template<> inline
Variable<std::complex<float>>& ADIOS::GetVariable( const std::string name )
{ return m_CFloat[ GetVariableIndex<std::complex<float>>(name) ]; }
template<> inline
Variable<std::complex<double>>& ADIOS::GetVariable( const std::string name )
{ return m_CDouble[ GetVariableIndex<std::complex<double>>(name) ]; }
template<> inline
Variable<std::complex<long double>>& ADIOS::GetVariable( const std::string name )
{ return m_CLDouble[ GetVariableIndex<std::complex<long double>>(name) ]; }
} //end namespace
#endif /* ADIOS_H_ */