From 0f3d4d5d20a03ef3cec46161594bc1445e7afe8c Mon Sep 17 00:00:00 2001
From: wfg <wfg@pc0098504.ornl.gov>
Date: Tue, 21 Feb 2017 17:19:02 -0500
Subject: [PATCH] Added DataMan Reader class and examples
Run ./buildDataman.sh see contents for detailed info
---
buildDataman.sh | 21 +-
examples/hello/datamanReader/Makefile | 32 +++
.../datamanReader/helloDataManReader.cpp | 80 ++++++++
.../helloDataManReader_nompi.cpp | 60 ++++++
.../hello/{dataman => datamanWriter}/Makefile | 0
.../helloDataManWriter.cpp | 0
.../helloDataManWriter_nompi.cpp | 20 --
include/core/Engine.h | 53 ++---
include/engine/dataman/DataManReader.h | 105 ++++++++++
include/engine/dataman/DataManWriter.h | 12 +-
src/ADIOS.cpp | 5 +
src/core/Engine.cpp | 31 +--
src/engine/dataman/DataManReader.cpp | 187 ++++++++++++++++++
src/engine/dataman/DataManWriter.cpp | 70 ++++---
14 files changed, 582 insertions(+), 94 deletions(-)
create mode 100644 examples/hello/datamanReader/Makefile
create mode 100644 examples/hello/datamanReader/helloDataManReader.cpp
create mode 100644 examples/hello/datamanReader/helloDataManReader_nompi.cpp
rename examples/hello/{dataman => datamanWriter}/Makefile (100%)
rename examples/hello/{dataman => datamanWriter}/helloDataManWriter.cpp (100%)
rename examples/hello/{dataman => datamanWriter}/helloDataManWriter_nompi.cpp (81%)
create mode 100644 include/engine/dataman/DataManReader.h
create mode 100644 src/engine/dataman/DataManReader.cpp
diff --git a/buildDataman.sh b/buildDataman.sh
index bf57df38d..3a942c6ef 100755
--- a/buildDataman.sh
+++ b/buildDataman.sh
@@ -14,21 +14,32 @@ echo
echo
echo "#################################################################"
-echo "Building Dataman example"
+echo "Building Dataman Reader and Writer examples"
echo "#################################################################"
-make -C ./examples/hello/dataman
+make -C ./examples/hello/datamanWriter
+echo
+make -C ./examples/hello/datamanReader
echo
echo
echo "#################################################################"
-echo "Running helloDataman_nompi.exe example"
+echo "Running nompi.exe examples"
+echo "#################################################################"
+echo "#################################################################"
+echo "DataMan writer"
+echo "#################################################################"
+./examples/hello/datamanWriter/helloDataManWriter_nompi.exe
+
+echo "#################################################################"
+echo "DataMan reader"
echo "#################################################################"
-./examples/hello/dataman/helloDataMan_nompi.exe
+./examples/hello/datamanReader/helloDataManReader_nompi.exe
echo
echo
echo "#################################################################"
echo "To run mpi version with 4 mpi processes: "
-echo "mpirun -n 4 ./examples/hello/dataman/helloDataman.exe"
+echo "mpirun -n 4 ./examples/hello/datamanWriter/helloDatamanWriter.exe"
+echo "mpirun -n 4 ./examples/hello/datamanReader/helloDatamanReader.exe"
echo "END"
echo "################################################################"
diff --git a/examples/hello/datamanReader/Makefile b/examples/hello/datamanReader/Makefile
new file mode 100644
index 000000000..1da287a7e
--- /dev/null
+++ b/examples/hello/datamanReader/Makefile
@@ -0,0 +1,32 @@
+# Makefile for testing purposes, will build libadios.a
+# Created on: Oct 4, 2016
+# Author: wfg
+
+
+BASE_NAME=helloDataManReader
+
+CC=g++ # Compiling with defaults
+MPICC=mpic++
+
+#ADIOS LOCATION
+ADIOS_DIR=../../..
+ADIOS_LIB=$(ADIOS_DIR)/lib/libadios.a
+ADIOS_NOMPI_LIB=$(ADIOS_DIR)/lib/libadios_nompi.a
+
+ADIOS_INCLUDE=-I$(ADIOS_DIR)/include
+
+
+#FLAGS
+CFLAGS=-Wall -O0 -g -Wpedantic -std=c++11
+
+all: mpi nompi
+
+mpi: $(ADIOS_LIB) $(ADIOS_HFiles)
+ $(MPICC) $(CFLAGS) $(ADIOS_INCLUDE) -DHAVE_MPI $(BASE_NAME).cpp -o $(BASE_NAME).exe $(ADIOS_LIB) -lpthread
+
+nompi: $(ADIOS_NOMPI_LIB) $(NoMPI_HFiles)
+ $(CC) $(CFLAGS) $(ADIOS_INCLUDE) $(BASE_NAME)_nompi.cpp -o $(BASE_NAME)_nompi.exe $(ADIOS_NOMPI_LIB) -lpthread
+
+clean:
+ rm *.exe;
+
diff --git a/examples/hello/datamanReader/helloDataManReader.cpp b/examples/hello/datamanReader/helloDataManReader.cpp
new file mode 100644
index 000000000..9b315d702
--- /dev/null
+++ b/examples/hello/datamanReader/helloDataManReader.cpp
@@ -0,0 +1,80 @@
+/*
+ * helloWriter.cpp
+ *
+ * Created on: Feb 16, 2017
+ * Author: wfg
+ */
+
+
+
+#include <vector>
+#include <iostream>
+
+
+#include <mpi.h>
+
+
+#include "ADIOS_CPP.h"
+
+
+int main( int argc, char* argv [] )
+{
+ MPI_Init( &argc, &argv );
+ int rank;
+ MPI_Comm_rank( MPI_COMM_WORLD, &rank );
+ const bool adiosDebug = true;
+ adios::ADIOS adios( MPI_COMM_WORLD, adiosDebug );
+
+
+ try
+ {
+ //Define method for engine creation, it is basically straight-forward parameters
+ adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataManReader" ); //default method type is BPWriter
+ datamanSettings.SetParameters( "peer-to-peer=yes" );
+ datamanSettings.AddTransport( "Mdtm", "localIP=128.0.0.0.1", "remoteIP=128.0.0.0.2", "tolerances=1,2,3" );
+ //datamanSettings.AddTransport( "ZeroMQ", "localIP=128.0.0.0.1.1", "remoteIP=128.0.0.0.2.1", "tolerances=1,2,3" ); not yet supported , will throw an exception
+
+ //Create engine smart pointer to DataManReader Engine due to polymorphism,
+ //Open returns a smart pointer to Engine containing the Derived class DataManReader
+ auto datamanReader = adios.Open( "myDoubles.bp", "r", datamanSettings );
+
+ if( datamanReader == nullptr )
+ throw std::ios_base::failure( "ERROR: failed to create DataMan I/O engine at Open\n" );
+
+ adios::Variable<double>* ioMyDoubles = datamanReader->InquireVariableDouble( "ioMyDoubles" );
+ if( ioMyDoubles == nullptr )
+ std::cout << "Variable ioMyDoubles not read...yet\n";
+
+ datamanReader->Close( );
+
+ }
+ catch( std::invalid_argument& e )
+ {
+ if( rank == 0 )
+ {
+ std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+ }
+ catch( std::ios_base::failure& e )
+ {
+ if( rank == 0 )
+ {
+ std::cout << "System exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+ }
+ catch( std::exception& e )
+ {
+ if( rank == 0 )
+ {
+ std::cout << "Exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+ }
+
+ MPI_Finalize( );
+
+ return 0;
+
+}
diff --git a/examples/hello/datamanReader/helloDataManReader_nompi.cpp b/examples/hello/datamanReader/helloDataManReader_nompi.cpp
new file mode 100644
index 000000000..11c17a138
--- /dev/null
+++ b/examples/hello/datamanReader/helloDataManReader_nompi.cpp
@@ -0,0 +1,60 @@
+/*
+ * helloADIOSNoXML_OOP.cpp
+ *
+ * Created on: Jan 9, 2017
+ * Author: wfg
+ */
+
+#include <vector>
+#include <iostream>
+
+#include "ADIOS_CPP.h"
+
+
+int main( int argc, char* argv [] )
+{
+ const bool adiosDebug = true;
+ adios::ADIOS adios( adiosDebug );
+
+ try
+ {
+ //Define method for engine creation, it is basically straight-forward parameters
+ adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataManReader" ); //default method type is BPWriter
+ datamanSettings.SetParameters( "peer-to-peer=yes" );
+ datamanSettings.AddTransport( "Mdtm", "localIP=128.0.0.0.1", "remoteIP=128.0.0.0.2", "tolerances=1,2,3" );
+ //datamanSettings.AddTransport( "ZeroMQ", "localIP=128.0.0.0.1.1", "remoteIP=128.0.0.0.2.1", "tolerances=1,2,3" ); not yet supported , will throw an exception
+
+ //Create engine smart pointer to DataManReader Engine due to polymorphism,
+ //Open returns a smart pointer to Engine containing the Derived class DataManReader
+ auto datamanReader = adios.Open( "myDoubles.bp", "r", datamanSettings );
+
+ if( datamanReader == nullptr )
+ throw std::ios_base::failure( "ERROR: failed to create DataMan I/O engine at Open\n" );
+
+ adios::Variable<double>* ioMyDoubles = datamanReader->InquireVariableDouble( "ioMyDoubles" );
+ if( ioMyDoubles == nullptr )
+ std::cout << "Variable ioMyDoubles not read...yet\n";
+
+ datamanReader->Close( );
+ }
+ catch( std::invalid_argument& e )
+ {
+ std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+ catch( std::ios_base::failure& e )
+ {
+ std::cout << "System exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+ catch( std::exception& e )
+ {
+ std::cout << "Exception, STOPPING PROGRAM\n";
+ std::cout << e.what() << "\n";
+ }
+
+ return 0;
+}
+
+
+
diff --git a/examples/hello/dataman/Makefile b/examples/hello/datamanWriter/Makefile
similarity index 100%
rename from examples/hello/dataman/Makefile
rename to examples/hello/datamanWriter/Makefile
diff --git a/examples/hello/dataman/helloDataManWriter.cpp b/examples/hello/datamanWriter/helloDataManWriter.cpp
similarity index 100%
rename from examples/hello/dataman/helloDataManWriter.cpp
rename to examples/hello/datamanWriter/helloDataManWriter.cpp
diff --git a/examples/hello/dataman/helloDataManWriter_nompi.cpp b/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
similarity index 81%
rename from examples/hello/dataman/helloDataManWriter_nompi.cpp
rename to examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
index fb0f3c351..9e591367c 100644
--- a/examples/hello/dataman/helloDataManWriter_nompi.cpp
+++ b/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
@@ -42,26 +42,6 @@ int main( int argc, char* argv [] )
//datamanWriter->Write( "myDoubles", myDoubles.data() ); //you can write either by string or by object
datamanWriter->Write( ioMyDoubles, myDoubles.data() ); // Base class Engine own the Write<T> that will call overloaded Write from Derived
datamanWriter->Close( );
-
-
-// auto datamanReader = adios.Open( "myDoubles.bp", "r", datamanSettings );
-//
-// if( datamanReader == nullptr )
-// throw std::ios_base::failure( "ERROR: failed to create DataMan I/O engine at Open\n" );
-//
-// adios::Variable<double>& readMyDoubles = datamanReader->Inquire<double>( "myDoubles" );
-// std::cout << "Hello dataman Reader\n";
-// for( auto value : readMyDoubles.m_Values )
-// {
-// std::cout << value << "\n";
-// }
-//
-//
-// datamanReader->Close( );
-
-
-
-
}
catch( std::invalid_argument& e )
{
diff --git a/include/core/Engine.h b/include/core/Engine.h
index 9fe6adaac..a3b2d4ca3 100644
--- a/include/core/Engine.h
+++ b/include/core/Engine.h
@@ -169,31 +169,34 @@ public:
virtual void Write( const std::string variableName, const void* values );
//Read API
-// template< class T >
-// virtual Variable<T>* InquireVariable( const std::string name )
-// {
-// return InquireVariable<T>( name );
-// }
-//
-// virtual Variable<char>* InquireVariable( const std::string name );
-// virtual Variable<unsigned char>* InquireVariable( const std::string name );
-// virtual Variable<short>* InquireVariable( const std::string name );
-// virtual Variable<unsigned short>* InquireVariable( const std::string name );
-// virtual Variable<int>* InquireVariable( const std::string name );
-// virtual Variable<unsigned int>* InquireVariable( const std::string name );
-// virtual Variable<long int>* InquireVariable( const std::string name );
-// virtual Variable<unsigned long int>* InquireVariable( const std::string name );
-// virtual Variable<long long int>* InquireVariable( const std::string name );
-// virtual Variable<unsigned long long int>* InquireVariable( const std::string name );
-// virtual Variable<float>* InquireVariable( const std::string name );
-// virtual Variable<double>* InquireVariable( const std::string name );
-// virtual Variable<long double>* InquireVariable( const std::string name );
-// virtual Variable<std::complex<float>>* InquireVariable( const std::string name );
-// virtual Variable<std::complex<double>>* InquireVariable( const std::string name );
-// virtual Variable<std::complex<long double>>* InquireVariable( const std::string name );
-
-
- virtual void Close( const int transportIndex = -1 ); ///< Closes a particular transport, or all if -1
+ /**
+ * Inquires and (optionally) allocates and copies the contents of a variable
+ * If success: it returns a pointer to the internal stored variable object in ADIOS class.
+ * If failure: it returns nullptr
+ * @param name variable name to look for
+ * @param readIn if true: reads the full variable and payload, allocating values in memory, if false: internal payload is nullptr
+ * @return success: it returns a pointer to the internal stored variable object in ADIOS class, failure: nullptr
+ */
+ virtual Variable<void>* InquireVariable( const std::string name, const bool readIn = true );
+ virtual Variable<char>* InquireVariableChar( const std::string name, const bool readIn = true );
+ virtual Variable<unsigned char>* InquireVariableUChar( const std::string name, const bool readIn = true );
+ virtual Variable<short>* InquireVariableShort( const std::string name, const bool readIn = true );
+ virtual Variable<unsigned short>* InquireVariableUShort( const std::string name, const bool readIn = true );
+ virtual Variable<int>* InquireVariableInt( const std::string name, const bool readIn = true );
+ virtual Variable<unsigned int>* InquireVariableUInt( const std::string name, const bool readIn = true );
+ virtual Variable<long int>* InquireVariableLInt( const std::string name, const bool readIn = true );
+ virtual Variable<unsigned long int>* InquireVariableULInt( const std::string name, const bool readIn = true );
+ virtual Variable<long long int>* InquireVariableLLInt( const std::string name, const bool readIn = true );
+ virtual Variable<unsigned long long int>* InquireVariableULLInt( const std::string name, const bool readIn = true );
+ virtual Variable<float>* InquireVariableFloat( const std::string name, const bool readIn = true );
+ virtual Variable<double>* InquireVariableDouble( const std::string name, const bool readIn = true );
+ virtual Variable<long double>* InquireVariableLDouble( const std::string name, const bool readIn = true );
+ virtual Variable<std::complex<float>>* InquireVariableCFloat( const std::string name, const bool readIn = true );
+ virtual Variable<std::complex<double>>* InquireVariableCDouble( const std::string name, const bool readIn = true );
+ virtual Variable<std::complex<long double>>* InquireVariableCLDouble( const std::string name, const bool readIn = true );
+ virtual VariableCompound* InquireVariableCompound( const std::string name, const bool readIn = true );
+
+ virtual void Close( const int transportIndex = -1 ) = 0; ///< Closes a particular transport, or all if -1
protected:
diff --git a/include/engine/dataman/DataManReader.h b/include/engine/dataman/DataManReader.h
new file mode 100644
index 000000000..d0a51d079
--- /dev/null
+++ b/include/engine/dataman/DataManReader.h
@@ -0,0 +1,105 @@
+/*
+ * DataManReader.h
+ *
+ * Created on: Feb 21, 2017
+ * Author: wfg
+ */
+
+#ifndef DATAMANREADER_H_
+#define DATAMANREADER_H_
+
+#include <iostream> //std::cout << Needs to go
+
+#include "core/Engine.h"
+#include "format/BP1Writer.h"
+
+//supported capsules
+#include "capsule/heap/STLVector.h"
+
+
+
+namespace adios
+{
+
+class DataManReader : public Engine
+{
+
+public:
+
+ /**
+ * Constructor for single BP capsule engine, writes in BP format into a single heap capsule
+ * @param name unique name given to the engine
+ * @param accessMode
+ * @param mpiComm
+ * @param method
+ * @param debugMode
+ * @param hostLanguage
+ */
+ DataManReader( ADIOS& adios, const std::string name, const std::string accessMode, MPI_Comm mpiComm,
+ const Method& method, const bool debugMode = false, const unsigned int cores = 1 );
+
+ ~DataManReader( );
+
+ Variable<void>* InquireVariable( const std::string name, const bool readIn = true );
+ Variable<char>* InquireVariableChar( const std::string name, const bool readIn = true );
+ Variable<unsigned char>* InquireVariableUChar( const std::string name, const bool readIn = true );
+ Variable<short>* InquireVariableShort( const std::string name, const bool readIn = true );
+ Variable<unsigned short>* InquireVariableUShort( const std::string name, const bool readIn = true );
+ Variable<int>* InquireVariableInt( const std::string name, const bool readIn = true );
+ Variable<unsigned int>* InquireVariableUInt( const std::string name, const bool readIn = true );
+ Variable<long int>* InquireVariableLInt( const std::string name, const bool readIn = true );
+ Variable<unsigned long int>* InquireVariableULInt( const std::string name, const bool readIn = true );
+ Variable<long long int>* InquireVariableLLInt( const std::string name, const bool readIn = true );
+ Variable<unsigned long long int>* InquireVariableULLInt( const std::string name, const bool readIn = true );
+ Variable<float>* InquireVariableFloat( const std::string name, const bool readIn = true );
+ Variable<double>* InquireVariableDouble( const std::string name, const bool readIn = true );
+ Variable<long double>* InquireVariableLDouble( const std::string name, const bool readIn = true );
+ Variable<std::complex<float>>* InquireVariableCFloat( const std::string name, const bool readIn = true );
+ Variable<std::complex<double>>* InquireVariableCDouble( const std::string name, const bool readIn = true );
+ Variable<std::complex<long double>>* InquireVariableCLDouble( const std::string name, const bool readIn = true );
+
+ /**
+ * Not implemented
+ * @param name
+ * @param readIn
+ * @return
+ */
+ VariableCompound* InquireVariableCompound( const std::string name, const bool readIn = true );
+
+
+ void Close( const int transportIndex = -1 );
+
+private:
+
+ capsule::STLVector m_Buffer; ///< heap capsule, contains data and metadata buffers
+ format::BP1Writer m_BP1Writer; ///< format object will provide the required BP functionality to be applied on m_Buffer and m_Transports
+
+
+ void Init( ); ///< calls InitCapsules and InitTransports based on Method, called from constructor
+ void InitCapsules( );
+ void InitTransports( ); ///< from Transports
+
+ std::string GetMdtmParameter( const std::string parameter, const std::map<std::string,std::string>& mdtmParameters );
+
+
+ template< class T >
+ Variable<T>* InquireVariableCommon( const std::string name, const bool readIn )
+ {
+ std::cout << "Hello DatamanReader from rank " << m_RankMPI << "\n";
+ std::cout << "Trying to read variable " << name << " from one of the variables coming from a WAN transport\n";
+
+ //here read variable metadata (dimensions, type, etc.)...then create a Variable like below:
+ //Variable<T>& variable = m_ADIOS.DefineVariable<T>( m_Name + "/" + name, )
+ //return &variable; //return address if success
+ return nullptr; //on failure
+ }
+
+
+
+};
+
+
+} //end namespace
+
+
+#endif /* DATAMANREADER_H_ */
diff --git a/include/engine/dataman/DataManWriter.h b/include/engine/dataman/DataManWriter.h
index 04a3848a3..9df1c6b60 100644
--- a/include/engine/dataman/DataManWriter.h
+++ b/include/engine/dataman/DataManWriter.h
@@ -8,8 +8,8 @@
#ifndef DATAMANWRITER_H_
#define DATAMANWRITER_H_
-#include <iostream> //must be removed
-#include <unistd.h> //must be removed
+#include <iostream> //std::cout must be removed, only used for hello example
+#include <unistd.h> //sleep must be removed
#include "core/Engine.h"
#include "format/BP1Writer.h"
@@ -35,7 +35,7 @@ public:
* @param hostLanguage
*/
DataManWriter( ADIOS& adios, const std::string name, const std::string accessMode, MPI_Comm mpiComm,
- const Method& method, const bool debugMode = false, const unsigned int cores = 1 );
+ const Method& method, const bool debugMode = false, const unsigned int cores = 1 );
~DataManWriter( );
@@ -67,6 +67,8 @@ public:
void Write( const std::string variableName, const double* values );
void Write( const std::string variableName, const long double* values );
+ void Close( const int transportIndex = -1 );
+
private:
capsule::STLVector m_Buffer; ///< heap capsule, contains data and metadata buffers
@@ -86,9 +88,9 @@ private:
template<class T>
- void WriteVariable( Variable<T>& variable, const T* values )
+ void WriteVariableCommon( Variable<T>& variable, const T* values )
{
- //here comes your magic at Writting now variable.m_UserValues has the data passed by the user
+ //here comes your magic at Writing now variable.m_UserValues has the data passed by the user
//set variable
variable.m_AppValues = values;
m_WrittenVariables.insert( variable.m_Name );
diff --git a/src/ADIOS.cpp b/src/ADIOS.cpp
index edae670b8..a7b36c80e 100644
--- a/src/ADIOS.cpp
+++ b/src/ADIOS.cpp
@@ -20,6 +20,7 @@
//Engines
#include "engine/bp/BPWriter.h"
#include "engine/dataman/DataManWriter.h"
+#include "engine/dataman/DataManReader.h"
namespace adios
@@ -108,6 +109,10 @@ std::shared_ptr<Engine> ADIOS::Open( const std::string name, const std::string a
{
return std::make_shared<DataManWriter>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
}
+ else if( type == "DataManReader" )
+ {
+ return std::make_shared<DataManReader>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
+ }
else if( type == "Vis" )
{
//return std::make_shared<Vis>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
diff --git a/src/core/Engine.cpp b/src/core/Engine.cpp
index fc4ef69f9..c41544fe2 100644
--- a/src/core/Engine.cpp
+++ b/src/core/Engine.cpp
@@ -75,19 +75,26 @@ void Engine::Write( const std::string variableName, const std::complex<long doub
void Engine::Write( const std::string variableName, const void* values ){ }
+//READ
+Variable<void>* Engine::InquireVariable( const std::string name, const bool readIn ){ return nullptr; }
+Variable<char>* Engine::InquireVariableChar( const std::string name, const bool readIn ){ return nullptr; }
+Variable<unsigned char>* Engine::InquireVariableUChar( const std::string name, const bool readIn ){ return nullptr; }
+Variable<short>* Engine::InquireVariableShort( const std::string name, const bool readIn ){ return nullptr; }
+Variable<unsigned short>* Engine::InquireVariableUShort( const std::string name, const bool readIn ){ return nullptr; }
+Variable<int>* Engine::InquireVariableInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<unsigned int>* Engine::InquireVariableUInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<long int>* Engine::InquireVariableLInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<unsigned long int>* Engine::InquireVariableULInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<long long int>* Engine::InquireVariableLLInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<unsigned long long int>* Engine::InquireVariableULLInt( const std::string name, const bool readIn ){ return nullptr; }
+Variable<float>* Engine::InquireVariableFloat( const std::string name, const bool readIn ){ return nullptr; }
+Variable<double>* Engine::InquireVariableDouble( const std::string name, const bool readIn ){ return nullptr; }
+Variable<long double>* Engine::InquireVariableLDouble( const std::string name, const bool readIn ){ return nullptr; }
+Variable<std::complex<float>>* Engine::InquireVariableCFloat( const std::string name, const bool readIn ){ return nullptr; }
+Variable<std::complex<double>>* Engine::InquireVariableCDouble( const std::string name, const bool readIn ){ return nullptr; }
+Variable<std::complex<long double>>* Engine::InquireVariableCLDouble( const std::string name, const bool readIn ){ return nullptr; }
+VariableCompound* Engine::InquireVariableCompound( const std::string name, const bool readIn ){ return nullptr; }
-void Engine::Close( const int transportIndex )
-{
- if( transportIndex == -1 ) //close all transports
- {
- for( auto& transport : m_Transports )
- transport->Close( );
- }
- else
- {
- m_Transports[transportIndex]->Close( ); //here need to pass the buffer
- }
-}
//PROTECTED
void Engine::Init( )
diff --git a/src/engine/dataman/DataManReader.cpp b/src/engine/dataman/DataManReader.cpp
new file mode 100644
index 000000000..d74000178
--- /dev/null
+++ b/src/engine/dataman/DataManReader.cpp
@@ -0,0 +1,187 @@
+/*
+ * DataManReader.cpp
+ *
+ * Created on: Feb 21, 2017
+ * Author: wfg
+ */
+
+
+#include "engine/dataman/DataManReader.h"
+
+#include "core/Support.h"
+#include "functions/adiosFunctions.h" //CSVToVector
+
+//supported transports
+#include "transport/file/FD.h" // uses POSIX
+#include "transport/file/FP.h" // uses C FILE*
+#include "transport/file/FStream.h" // uses C++ fstream
+#include "transport/wan/MdtmMan.h" //uses Mdtm library
+
+
+namespace adios
+{
+
+DataManReader::DataManReader( ADIOS& adios, const std::string name, const std::string accessMode, MPI_Comm mpiComm,
+ const Method& method, const bool debugMode, const unsigned int cores ):
+ Engine( adios, "DataManReader", name, accessMode, mpiComm, method, debugMode, cores, " DataManReader constructor (or call to ADIOS Open).\n" ),
+ m_Buffer( accessMode, m_RankMPI, m_DebugMode )
+{
+ Init( );
+}
+
+DataManReader::~DataManReader( )
+{ }
+
+void DataManReader::Init( )
+{
+ if( m_DebugMode == true )
+ {
+ if( m_AccessMode != "r" && m_AccessMode != "read" )
+ throw std::invalid_argument( "ERROR: DataManReader doesn't support access mode " + m_AccessMode +
+ ", in call to ADIOS Open or DataManReader constructor\n" );
+ }
+
+ InitCapsules( );
+ InitTransports( );
+}
+
+
+Variable<void>* DataManReader::InquireVariable( const std::string name, const bool readIn ) //not yet implemented
+{ return nullptr; }
+
+Variable<char>* DataManReader::InquireVariableChar( const std::string name, const bool readIn )
+{ return InquireVariableCommon<char>( name, readIn ); }
+
+Variable<unsigned char>* DataManReader::InquireVariableUChar( const std::string name, const bool readIn )
+{ return InquireVariableCommon<unsigned char>( name, readIn ); }
+
+Variable<short>* DataManReader::InquireVariableShort( const std::string name, const bool readIn )
+{ return InquireVariableCommon<short>( name, readIn ); }
+
+Variable<unsigned short>* DataManReader::InquireVariableUShort( const std::string name, const bool readIn )
+{ return InquireVariableCommon<unsigned short>( name, readIn ); }
+
+Variable<int>* DataManReader::InquireVariableInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<int>( name, readIn ); }
+
+Variable<unsigned int>* DataManReader::InquireVariableUInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<unsigned int>( name, readIn ); }
+
+Variable<long int>* DataManReader::InquireVariableLInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<long int>( name, readIn ); }
+
+Variable<unsigned long int>* DataManReader::InquireVariableULInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<unsigned long int>( name, readIn ); }
+
+Variable<long long int>* DataManReader::InquireVariableLLInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<long long int>( name, readIn ); }
+
+Variable<unsigned long long int>* DataManReader::InquireVariableULLInt( const std::string name, const bool readIn )
+{ return InquireVariableCommon<unsigned long long int>( name, readIn ); }
+
+Variable<float>* DataManReader::InquireVariableFloat( const std::string name, const bool readIn )
+{ return InquireVariableCommon<float>( name, readIn ); }
+
+Variable<double>* DataManReader::InquireVariableDouble( const std::string name, const bool readIn )
+{ return InquireVariableCommon<double>( name, readIn ); }
+
+Variable<long double>* DataManReader::InquireVariableLDouble( const std::string name, const bool readIn )
+{ return InquireVariableCommon<long double>( name, readIn ); }
+
+Variable<std::complex<float>>* DataManReader::InquireVariableCFloat( const std::string name, const bool readIn )
+{ return InquireVariableCommon<std::complex<float>>( name, readIn ); }
+
+Variable<std::complex<double>>* DataManReader::InquireVariableCDouble( const std::string name, const bool readIn )
+{ return InquireVariableCommon<std::complex<double>>( name, readIn ); }
+
+Variable<std::complex<long double>>* DataManReader::InquireVariableCLDouble( const std::string name, const bool readIn )
+{ return InquireVariableCommon<std::complex<long double>>( name, readIn ); }
+
+VariableCompound* DataManReader::InquireVariableCompound( const std::string name, const bool readIn )
+{ return nullptr; }
+
+
+void DataManReader::Close( const int transportIndex )
+{
+
+}
+
+
+//PRIVATE
+void DataManReader::InitCapsules( )
+{
+ //here init memory capsules
+}
+
+
+void DataManReader::InitTransports( ) //maybe move this?
+{
+ TransportNamesUniqueness( );
+
+ for( const auto& parameters : m_Method.m_TransportParameters )
+ {
+ auto itTransport = parameters.find( "transport" );
+
+ if( itTransport->second == "Mdtm" || itTransport->second == "MdtmMan" )
+ {
+ const std::string localIP( GetMdtmParameter( "localIP", parameters ) ); //mandatory
+ const std::string remoteIP( GetMdtmParameter( "remoteIP", parameters ) ); //mandatory
+ const std::string prefix( GetMdtmParameter( "prefix", parameters ) );
+ const int numberOfPipes = std::stoi( GetMdtmParameter( "pipes", parameters ) );
+ const std::vector<int> tolerances = CSVToVectorInt( GetMdtmParameter( "tolerances", parameters ) );
+ const std::vector<int> priorities = CSVToVectorInt( GetMdtmParameter( "priorities", parameters ) );
+
+ m_Transports.push_back( std::make_shared<transport::MdtmMan>( localIP, remoteIP, m_AccessMode, prefix, numberOfPipes,
+ tolerances, priorities, m_MPIComm, m_DebugMode ) );
+ }
+ else if( itTransport->second == "Zmq" )
+ {
+
+ }
+ else
+ {
+ if( m_DebugMode == true )
+ throw std::invalid_argument( "ERROR: transport + " + itTransport->second + " not supported, in " +
+ m_Name + m_EndMessage );
+ }
+ }
+}
+
+
+std::string DataManReader::GetMdtmParameter( const std::string parameter, const std::map<std::string,std::string>& mdtmParameters )
+{
+ auto itParam = mdtmParameters.find( parameter );
+ if( itParam != mdtmParameters.end() ) //found
+ {
+ return itParam->second; //return value
+ }
+ // if not found
+ //mandatory ones
+ if( parameter == "localIP" || parameter == "remoteIP" )
+ {
+ if( m_DebugMode == true )
+ throw std::invalid_argument( "ERROR: " + parameter + " parameter not found in Method, in call to DataManWriter constructor\n" );
+ }
+ else if( parameter == "prefix" )
+ {
+ return "";
+ }
+ else if( parameter == "pipes" )
+ {
+ return "0"; // or 1?
+ }
+ else if( parameter == "tolerances" ) //so far empty string
+ {
+
+ }
+ else if( parameter == "priority" )
+ {
+
+ }
+
+ return ""; //return empty string
+}
+
+
+
+}
diff --git a/src/engine/dataman/DataManWriter.cpp b/src/engine/dataman/DataManWriter.cpp
index d04c21857..a549f6ae4 100644
--- a/src/engine/dataman/DataManWriter.cpp
+++ b/src/engine/dataman/DataManWriter.cpp
@@ -25,7 +25,7 @@ namespace adios
DataManWriter::DataManWriter( ADIOS& adios, const std::string name, const std::string accessMode, MPI_Comm mpiComm,
const Method& method, const bool debugMode, const unsigned int cores ):
- Engine( adios, "DataManWriter", name, accessMode, mpiComm, method, debugMode, cores, " Dataman constructor (or call to ADIOS Open).\n" ),
+ Engine( adios, "DataManWriter", name, accessMode, mpiComm, method, debugMode, cores, " DataManWriter constructor (or call to ADIOS Open).\n" ),
m_Buffer( accessMode, m_RankMPI, m_DebugMode )
{
Init( );
@@ -38,90 +38,106 @@ DataManWriter::~DataManWriter( )
void DataManWriter::Init( )
{
+ if( m_DebugMode == true )
+ {
+ if( m_AccessMode != "w" && m_AccessMode != "write" && m_AccessMode != "a" && m_AccessMode != "append" )
+ throw std::invalid_argument( "ERROR: DataManWriter doesn't support access mode " + m_AccessMode +
+ ", in call to ADIOS Open or DataManWriter constructor\n" );
+ }
+
InitCapsules( );
InitTransports( );
}
void DataManWriter::Write( Variable<char>& variable, const char* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<unsigned char>& variable, const unsigned char* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<short>& variable, const short* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<unsigned short>& variable, const unsigned short* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<int>& variable, const int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<unsigned int>& variable, const unsigned int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<long int>& variable, const long int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<unsigned long int>& variable, const unsigned long int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<long long int>& variable, const long long int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<float>& variable, const float* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<double>& variable, const double* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( Variable<long double>& variable, const long double* values )
-{ WriteVariable( variable, values ); }
+{ WriteVariableCommon( variable, values ); }
void DataManWriter::Write( const std::string variableName, const char* values )
-{ WriteVariable( m_ADIOS.GetVariable<char>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<char>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const unsigned char* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned char>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<unsigned char>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const short* values )
-{ WriteVariable( m_ADIOS.GetVariable<short>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<short>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const unsigned short* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned short>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<unsigned short>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const int* values )
-{ WriteVariable( m_ADIOS.GetVariable<int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const unsigned int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<unsigned int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<long int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<long int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const unsigned long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned long int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<unsigned long int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const long long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<long long int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<long long int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const unsigned long long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned long long int>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<unsigned long long int>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const float* values )
-{ WriteVariable( m_ADIOS.GetVariable<float>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<float>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const double* values )
-{ WriteVariable( m_ADIOS.GetVariable<double>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<double>( variableName ), values ); }
void DataManWriter::Write( const std::string variableName, const long double* values )
-{ WriteVariable( m_ADIOS.GetVariable<long double>( variableName ), values ); }
+{ WriteVariableCommon( m_ADIOS.GetVariable<long double>( variableName ), values ); }
+
+
+
+void DataManWriter::Close( const int transportIndex )
+{
+ //here close IPs and deallocate or free/close resources (if using STL no need for memory deallocation)
+}
+
+//PRIVATE functions below
void DataManWriter::InitCapsules( )
{
//here init memory capsules
--
GitLab