diff --git a/Makefile b/Makefile
index 86b405b8d6fb215b39fc4d13322042cc9cf72a7a..7dc1c449713f6f3163a65a3f05e686ddce49a2db 100644
--- a/Makefile
+++ b/Makefile
@@ -13,7 +13,7 @@ AR:=ar
MPICC:=mpic++
LIBS:= -L$(SYS_LIB) -L$(LOCAL_LIB)
-CFLAGS:=-c -Wall -Wpedantic -Woverloaded-virtual -std=c++11 -O0 -g
+CFLAGS:=-c -Wall -Wpedantic -std=c++11 -O0 -g
ARFLAGS:=rcs
#ADIOS
@@ -21,8 +21,11 @@ HFiles:=$(shell find ./include -type f -name "*.h")
CPPFiles:=$(shell find ./src -type f -name "*.cpp")
INC:=-I./include
VPATH = ./src ./src/core ./src/functions \
- ./src/engine ./src/engine/writer ./src/engine/dataman \
- ./src/capsule ./src/transform ./src/transport ./src/format
+ ./src/engine/bp ./src/engine/dataman \
+ ./src/transport/file ./src/transport/wan \
+ ./src/capsule/heap ./src/capsule/shmem \
+ ./src/transform \
+ ./src/format
#SEPARATE EXTERNAL LIBRARIES HANDLING in Makefile.libs
export $(HFiles) $(CPPFiles) $(CFLAGS) $(LIBS)
diff --git a/examples/hello/compound/Makefile b/examples/hello/compound/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..60eac201256d193410cbf9e4bf74fff50ebad6ac
--- /dev/null
+++ b/examples/hello/compound/Makefile
@@ -0,0 +1,31 @@
+# Makefile for testing purposes, will build helloWriter_OOP_mpi (make or make mpi) or helloWriter_OOP_nompi (make nompi)
+# Created on: Oct 4, 2016
+# Author: wfg
+
+BASE_NAME=helloCompound
+
+#COMPILERS
+CC=g++
+MPICC=mpic++
+
+#ADIOS LOCATION
+ADIOS_DIR=../../..
+ADIOS_INCLUDE=-I$(ADIOS_DIR)/include
+ADIOS_LIB=$(ADIOS_DIR)/lib/libadios.a
+ADIOS_NOMPI_LIB=$(ADIOS_DIR)/lib/libadios_nompi.a
+
+#FLAGS
+CFLAGS=-Wall -Wpedantic -std=c++11 -O0 -g
+LDFLAGS=
+
+all: mpi nompi
+
+mpi: $(ADIOS_LIB) $(ADIOS_HFiles)
+ $(MPICC) $(CFLAGS) $(ADIOS_INCLUDE) -DHAVE_MPI $(BASE_NAME).cpp -o $(BASE_NAME).exe $(ADIOS_LIB) $(LDFLAGS) -lpthread
+
+nompi: $(ADIOS_NOMPI_LIB) $(NoMPI_HFiles)
+ $(CC) $(CFLAGS) $(ADIOS_INCLUDE) $(BASE_NAME)_nompi.cpp -o $(BASE_NAME)_nompi.exe $(ADIOS_NOMPI_LIB) $(LDFLAGS) -lpthread
+
+clean:
+ rm *.exe
+
\ No newline at end of file
diff --git a/examples/hello/compound/helloCompound.cpp b/examples/hello/compound/helloCompound.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c34e3f5b43961b5f2102b7095827b9c2ca906b4b
--- /dev/null
+++ b/examples/hello/compound/helloCompound.cpp
@@ -0,0 +1,104 @@
+/*
+ * helloCompound.cpp
+ *
+ * Created on: Feb 20, 2017
+ * Author: wfg
+ */
+
+#include <vector>
+#include <iostream>
+#include <cstddef> // offsetof
+
+
+#include <mpi.h>
+
+
+#include "ADIOS_CPP.h"
+
+
+struct Particle
+{
+ char Type[10]; ///< alpha, beta, gamma, etc.
+ double Position[3]; ///< x, y, z
+ double Velocity[3]; ///< Vx, Vy, Vz
+};
+
+
+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 );
+
+ //Application variable
+ std::vector<double> myDoubles = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ const std::size_t Nx = myDoubles.size();
+
+ Particle myParticle;
+ sprintf( myParticle.Type, "%s", "photon" );
+ myParticle.Position[0] = 0;
+ myParticle.Position[1] = 1;
+ myParticle.Position[2] = 2;
+
+ myParticle.Velocity[0] = 10;
+ myParticle.Velocity[1] = 11;
+ myParticle.Velocity[2] = 12;
+
+ try
+ {
+ //Define variable and local size
+ adios::Variable<double>& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", adios::Dims{Nx} );
+
+ adios::VariableCompound& ioMyParticle = adios.DefineVariableCompound<Particle>( "myParticle", adios::Dims{1} );
+ ioMyParticle.InsertMember<std::string>( "Type", offsetof(Particle,Type) );
+ ioMyParticle.InsertMember<std::vector<double>>( "Position", offsetof(Particle,Position) );
+ ioMyParticle.InsertMember<std::vector<double>>( "Velocity", offsetof(Particle,Velocity) );
+
+ //Define method for engine creation, it is basically straight-forward parameters
+ adios::Method& bpWriterSettings = adios.DeclareMethod( "SingleFile" ); //default method type is BPWriter
+ bpWriterSettings.AddTransport( "File", "have_metadata_file=yes" ); //uses default POSIX library
+
+ //Create engine smart pointer due to polymorphism,
+ //Open returns a smart pointer to Engine containing the Derived class Writer
+ auto bpWriter = adios.Open( "myDoubles.bp", "w", bpWriterSettings );
+
+ if( bpWriter == nullptr )
+ throw std::ios_base::failure( "ERROR: couldn't create bpWriter at Open\n" );
+
+ bpWriter->Write( ioMyDoubles, myDoubles.data() ); // Base class Engine own the Write<T> that will call overloaded Write from Derived
+ bpWriter->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/compound/helloCompound_nompi.cpp b/examples/hello/compound/helloCompound_nompi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1bb0cb1a959677c05a47b37addf18a350522169d
--- /dev/null
+++ b/examples/hello/compound/helloCompound_nompi.cpp
@@ -0,0 +1,87 @@
+/*
+ * helloCompound.cpp
+ *
+ * Created on: Feb 20, 2017
+ * Author: wfg
+ */
+
+#include <vector>
+#include <iostream>
+#include <cstddef> // offsetof
+#include <cstdio>
+
+#include "ADIOS_CPP.h"
+
+
+struct Particle
+{
+ char Type[10]; ///< alpha, beta, gamma, etc.
+ double Position[3]; ///< x, y, z
+ double Velocity[3]; ///< Vx, Vy, Vz
+};
+
+
+int main( int argc, char* argv [] )
+{
+ const bool adiosDebug = true;
+ adios::ADIOS adios( adiosDebug );
+
+ //Application variable
+ std::vector<double> myDoubles = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ const std::size_t Nx = myDoubles.size();
+
+ Particle myParticle;
+ sprintf( myParticle.Type, "%s", "photon" );
+ myParticle.Position[0] = 0;
+ myParticle.Position[1] = 1;
+ myParticle.Position[2] = 2;
+
+ myParticle.Velocity[0] = 10;
+ myParticle.Velocity[1] = 11;
+ myParticle.Velocity[2] = 12;
+
+ try
+ {
+ //Define variable and local size
+ adios::Variable<double>& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", adios::Dims{Nx} );
+
+ adios::VariableCompound& ioMyParticle = adios.DefineVariableCompound<Particle>( "myParticle" );
+ ioMyParticle.InsertMember<char>( "Type", offsetof(Particle,Type) );
+ ioMyParticle.InsertMember<double>( "Position", offsetof(Particle,Position) );
+ ioMyParticle.InsertMember<double>( "Velocity", offsetof(Particle,Velocity) );
+
+ //Define method for engine creation, it is basically straight-forward parameters
+ adios::Method& bpWriterSettings = adios.DeclareMethod( "SingleFile" ); //default method type is BPWriter
+ bpWriterSettings.AddTransport( "File", "have_metadata_file=yes" ); //uses default POSIX library
+
+ //Create engine smart pointer due to polymorphism,
+ //Open returns a smart pointer to Engine containing the Derived class Writer
+ auto bpWriter = adios.Open( "myDoubles.bp", "w", bpWriterSettings );
+
+ if( bpWriter == nullptr )
+ throw std::ios_base::failure( "ERROR: couldn't create bpWriter at Open\n" );
+
+ bpWriter->Write( ioMyDoubles, myDoubles.data() ); // Base class Engine own the Write<T> that will call overloaded Write from Derived
+ bpWriter->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/dataman/Makefile
index 64efaa2a4a3c30103831febc991815633b58f634..3b8cfcce537bbe8ddce4a3e116cfcff7059e272a 100644
--- a/examples/hello/dataman/Makefile
+++ b/examples/hello/dataman/Makefile
@@ -3,7 +3,7 @@
# Author: wfg
-BASE_NAME=helloDataMan
+BASE_NAME=helloDataManWriter
CC=g++ # Compiling with defaults
MPICC=mpic++
diff --git a/examples/hello/dataman/helloDataMan.cpp b/examples/hello/dataman/helloDataManWriter.cpp
similarity index 93%
rename from examples/hello/dataman/helloDataMan.cpp
rename to examples/hello/dataman/helloDataManWriter.cpp
index c6c1f653e366e895ca770aa70f8729375b0549d4..e9e961e997f3b706d7b8f6dae20bfba3a82a5dc9 100644
--- a/examples/hello/dataman/helloDataMan.cpp
+++ b/examples/hello/dataman/helloDataManWriter.cpp
@@ -35,8 +35,8 @@ int main( int argc, char* argv [] )
auto& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", {Nx} );
//Define method for engine creation, it is basically straight-forward parameters
- adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataMan" ); //default method type is Writer
- datamanSettings.SetParameters( "peer-to-peer=yes", "optimize=yes", "compress=yes" );
+ adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataManWriter" ); //default method type is Writer
+ datamanSettings.SetParameters( "peer-to-peer=yes", "real_time=yes", "compress=no" );
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
diff --git a/examples/hello/dataman/helloDataMan_nompi.cpp b/examples/hello/dataman/helloDataManWriter_nompi.cpp
similarity index 74%
rename from examples/hello/dataman/helloDataMan_nompi.cpp
rename to examples/hello/dataman/helloDataManWriter_nompi.cpp
index fe7ebbafd5da3c5bc668535b5652c28df3ddcf71..fb0f3c35185e39d6c8e85c85328ccaacd94d2067 100644
--- a/examples/hello/dataman/helloDataMan_nompi.cpp
+++ b/examples/hello/dataman/helloDataManWriter_nompi.cpp
@@ -24,11 +24,11 @@ int main( int argc, char* argv [] )
{
//Define variable and local size
//Define variable and local size
- auto& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", {Nx} );
+ auto& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", adios::Dims{Nx} );
//Define method for engine creation, it is basically straight-forward parameters
- adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataMan" ); //default method type is Writer
- datamanSettings.SetParameters( "peer-to-peer=yes", "optimize=yes", "compress=yes" );
+ adios::Method& datamanSettings = adios.DeclareMethod( "WAN", "DataManWriter" ); //default method type is Writer
+ datamanSettings.SetParameters( "peer-to-peer=yes", "real_time=yes", "compress=no" );
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
@@ -42,6 +42,26 @@ 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/examples/hello/writer/Makefile b/examples/hello/writer/Makefile
index 30851e670e052a65824167c3d545ce7a272facaa..b63e867e402f007f5e7d78eb9bb6241b778968cb 100644
--- a/examples/hello/writer/Makefile
+++ b/examples/hello/writer/Makefile
@@ -15,7 +15,7 @@ ADIOS_LIB=$(ADIOS_DIR)/lib/libadios.a
ADIOS_NOMPI_LIB=$(ADIOS_DIR)/lib/libadios_nompi.a
#FLAGS
-CFLAGS=-Wall -Wpedantic -Woverloaded-virtual -std=c++11 -O0 -g
+CFLAGS=-Wall -Wpedantic -std=c++11 -O0 -g
LDFLAGS=
all: mpi nompi
diff --git a/examples/hello/writer/helloWriter.cpp b/examples/hello/writer/helloWriter.cpp
index 9667b3ae484d563344e62e75aced778aa644aa6b..3bc89f0c1d4d8481bc431e274ec9c41f85aaa343 100644
--- a/examples/hello/writer/helloWriter.cpp
+++ b/examples/hello/writer/helloWriter.cpp
@@ -35,8 +35,8 @@ int main( int argc, char* argv [] )
auto& ioMyDoubles = adios.DefineVariable<double>( "myDoubles", adios::Dims{Nx} );
//Define method for engine creation, it is basically straight-forward parameters
- adios::Method& bpWriterSettings = adios.DeclareMethod( "SinglePOSIXFile" ); //default method type is Writer
- bpWriterSettings.AddTransport( "POSIX", "have_metadata_file=yes" );
+ adios::Method& bpWriterSettings = adios.DeclareMethod( "SingleFile" ); //default method type is BPWriter
+ bpWriterSettings.AddTransport( "File", "have_metadata_file=yes" ); //uses default POSIX library
//Create engine smart pointer due to polymorphism,
//Open returns a smart pointer to Engine containing the Derived class Writer
diff --git a/include/ADIOS.h b/include/ADIOS.h
index 001334b700a30ddfb2ec300672faa5e5e72db962..a1e8c701e06e9c6eb1f8525fcbb11b7bdded49e0 100644
--- a/include/ADIOS.h
+++ b/include/ADIOS.h
@@ -15,6 +15,7 @@
#include <ostream>
#include <set>
#include <map>
+#include <complex>
/// \endcond
#ifdef HAVE_MPI
@@ -25,6 +26,7 @@
#include "core/Transform.h"
#include "core/Variable.h"
+#include "core/VariableCompound.h"
#include "core/Method.h"
#include "core/Support.h"
#include "functions/adiosTemplates.h"
@@ -54,20 +56,6 @@ public: // PUBLIC Constructors and Functions define the User Interface with ADIO
std::string m_HostLanguage = "C++";
- 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
-
/**
* @brief ADIOS empty constructor. Used for non XML config file API calls.
*/
@@ -113,20 +101,30 @@ public: // PUBLIC Constructors and Functions define the User Interface with ADIO
//throw std::invalid_argument( "ERROR: type not supported for variable " + name + "\n" );
}
-
template<class T> inline
Variable<T>& GetVariable( const std::string name )
+ { }
+
+
+ template<class T>
+ VariableCompound& DefineVariableCompound( const std::string name, const Dims dimensions = Dims{1},
+ const Dims globalDimensions = Dims(),
+ const Dims globalOffsets = Dims() )
{
- //throw std::invalid_argument( "ERROR: variable " + name + " and type don't match in call to GetVariable\n" );
+ 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 = "Writer" );
+ Method& DeclareMethod( const std::string methodName, const std::string type = "BPWriter" );
/**
@@ -190,6 +188,24 @@ public: // PUBLIC Constructors and Functions define the User Interface with ADIO
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
@@ -239,7 +255,7 @@ private: //no const to allow default empty and copy constructors
unsigned int GetVariableIndex( const std::string name )
{
auto itVariable = m_Variables.find( name );
- CheckVariableName( itVariable, name, "in call to GetVariable<" + GetType<T>() + ">" );
+ CheckVariableName( itVariable, name, "in call to GetVariable<" + GetType<T>() + ">, or call to GetVariableCompound if <T> = <compound>\n" );
return itVariable->second.second;
}
diff --git a/include/ADIOS_CPP.h b/include/ADIOS_CPP.h
index 033de1873b91eecbaea946bc5e52b406a7ec4d6d..0292313fd538bdbe9667780bc486d0dd45ac0d40 100644
--- a/include/ADIOS_CPP.h
+++ b/include/ADIOS_CPP.h
@@ -13,10 +13,9 @@
#include "core/Method.h"
#include "core/Engine.h"
-#include "engine/writer/Writer.h"
-#include "engine/dataman/DataMan.h"
-
#include "core/Transform.h"
+#include "engine/bp/BPWriter.h"
+#include "engine/dataman/DataManWriter.h"
#include "transform/BZip2.h"
diff --git a/include/capsule/Heap.h b/include/capsule/heap/STLVector.h
similarity index 77%
rename from include/capsule/Heap.h
rename to include/capsule/heap/STLVector.h
index 5a1fa8d1966093e046b8b646eb6bd9c75cebaaef..1ae8ce9f5c65f0f4304d6f349677d00b2c2517cc 100644
--- a/include/capsule/Heap.h
+++ b/include/capsule/heap/STLVector.h
@@ -5,8 +5,8 @@
* Author: wfg
*/
-#ifndef HEAP_H_
-#define HEAP_H_
+#ifndef STLVECTOR_H_
+#define STLVECTOR_H_
/// \cond EXCLUDE_FROM_DOXYGEN
#include <vector>
@@ -18,11 +18,13 @@
namespace adios
{
+namespace capsule
+{
/**
* Data and Metadata buffers are allocated in the Heap
*/
-class Heap : public Capsule
+class STLVector : public Capsule
{
public:
@@ -36,9 +38,9 @@ public:
* @param rankMPI MPI rank
* @param debugMode true: extra checks, slower
*/
- Heap( const std::string accessMode, const int rankMPI, const bool debugMode = false );
+ STLVector( const std::string accessMode, const int rankMPI, const bool debugMode = false );
- ~Heap( );
+ ~STLVector( );
char* GetData( );
char* GetMetadata( );
@@ -52,14 +54,9 @@ public:
};
-
-
-
+} //end namespace capsule
} //end namespace
-
-
-
-#endif /* HEAP_H_ */
+#endif /* STLVECTOR_H_ */
diff --git a/include/capsule/ShmSystemV.h b/include/capsule/shmem/ShmSystemV.h
similarity index 100%
rename from include/capsule/ShmSystemV.h
rename to include/capsule/shmem/ShmSystemV.h
diff --git a/include/core/Engine.h b/include/core/Engine.h
index 2255cbf9db60cd5d4fe0b4b40cc2d7017e26c39f..9fe6adaace30f4c9a3e59c6957a1cc9f271dc079 100644
--- a/include/core/Engine.h
+++ b/include/core/Engine.h
@@ -15,6 +15,7 @@
#include <memory> //std::shared_ptr
#include <map>
#include <utility> //std::pair
+#include <complex> //std::complex
/// \endcond
#ifdef HAVE_MPI
@@ -26,6 +27,7 @@
#include "ADIOS.h"
#include "core/Method.h"
#include "core/Variable.h"
+#include "core/VariableCompound.h"
#include "core/Transform.h"
#include "core/Transport.h"
#include "core/Capsule.h"
@@ -88,19 +90,57 @@ public:
Write( variable, values );
}
- virtual void Write( Variable<char>& variable, const char* values ) = 0;
- virtual void Write( Variable<unsigned char>& variable, const unsigned char* values ) = 0;
- virtual void Write( Variable<short>& variable, const short* values ) = 0;
- virtual void Write( Variable<unsigned short>& variable, const unsigned short* values ) = 0;
- virtual void Write( Variable<int>& variable, const int* values ) = 0;
- virtual void Write( Variable<unsigned int>& variable, const unsigned int* values ) = 0;
- virtual void Write( Variable<long int>& variable, const long int* values ) = 0;
- virtual void Write( Variable<unsigned long int>& variable, const unsigned long int* values ) = 0;
- virtual void Write( Variable<long long int>& variable, const long long int* values ) = 0;
- virtual void Write( Variable<unsigned long long int>& variable, const unsigned long long int* values ) = 0;
- virtual void Write( Variable<float>& variable, const float* values ) = 0;
- virtual void Write( Variable<double>& variable, const double* values ) = 0;
- virtual void Write( Variable<long double>& variable, const long double* values ) = 0;
+ /**
+ * String version
+ * @param variableName
+ * @param values
+ */
+ template< class T >
+ void Write( const std::string variableName, const T* values )
+ {
+ Write( variableName, values );
+ }
+
+ /**
+ * Single value version
+ * @param variable
+ * @param values
+ */
+ template< class T >
+ void Write( Variable<T>& variable, const T& values )
+ {
+ Write( variable, &values );
+ }
+
+ /**
+ * Single value version using string as variable handlers
+ * @param variableName
+ * @param values
+ */
+ template< class T >
+ void Write( const std::string variableName, const T& values )
+ {
+ Write( variableName, &values );
+ }
+
+ virtual void Write( Variable<char>& variable, const char* values );
+ virtual void Write( Variable<unsigned char>& variable, const unsigned char* values );
+ virtual void Write( Variable<short>& variable, const short* values );
+ virtual void Write( Variable<unsigned short>& variable, const unsigned short* values );
+ virtual void Write( Variable<int>& variable, const int* values );
+ virtual void Write( Variable<unsigned int>& variable, const unsigned int* values );
+ virtual void Write( Variable<long int>& variable, const long int* values );
+ virtual void Write( Variable<unsigned long int>& variable, const unsigned long int* values );
+ virtual void Write( Variable<long long int>& variable, const long long int* values );
+ virtual void Write( Variable<unsigned long long int>& variable, const unsigned long long int* values );
+ virtual void Write( Variable<float>& variable, const float* values );
+ virtual void Write( Variable<double>& variable, const double* values );
+ virtual void Write( Variable<long double>& variable, const long double* values );
+ virtual void Write( Variable<std::complex<float>>& variable, const std::complex<float>* values );
+ virtual void Write( Variable<std::complex<double>>& variable, const std::complex<double>* values );
+ virtual void Write( Variable<std::complex<long double>>& variable, const std::complex<long double>* values );
+ virtual void Write( VariableCompound& variable, const void* values );
+
/**
* @brief Write functions can be overridden by derived classes. Base class behavior is to:
@@ -110,19 +150,48 @@ public:
* @param variableName
* @param values coming from user app
*/
- virtual void Write( const std::string variableName, const char* values ) = 0;
- virtual void Write( const std::string variableName, const unsigned char* values ) = 0;
- virtual void Write( const std::string variableName, const short* values ) = 0;
- virtual void Write( const std::string variableName, const unsigned short* values ) = 0;
- virtual void Write( const std::string variableName, const int* values ) = 0;
- virtual void Write( const std::string variableName, const unsigned int* values ) = 0;
- virtual void Write( const std::string variableName, const long int* values ) = 0;
- virtual void Write( const std::string variableName, const unsigned long int* values ) = 0;
- virtual void Write( const std::string variableName, const long long int* values ) = 0;
- virtual void Write( const std::string variableName, const unsigned long long int* values ) = 0;
- virtual void Write( const std::string variableName, const float* values ) = 0;
- virtual void Write( const std::string variableName, const double* values ) = 0;
- virtual void Write( const std::string variableName, const long double* values ) = 0;
+ virtual void Write( const std::string variableName, const char* values );
+ virtual void Write( const std::string variableName, const unsigned char* values );
+ virtual void Write( const std::string variableName, const short* values );
+ virtual void Write( const std::string variableName, const unsigned short* values );
+ virtual void Write( const std::string variableName, const int* values );
+ virtual void Write( const std::string variableName, const unsigned int* values );
+ virtual void Write( const std::string variableName, const long int* values );
+ virtual void Write( const std::string variableName, const unsigned long int* values );
+ virtual void Write( const std::string variableName, const long long int* values );
+ virtual void Write( const std::string variableName, const unsigned long long int* values );
+ virtual void Write( const std::string variableName, const float* values );
+ virtual void Write( const std::string variableName, const double* values );
+ virtual void Write( const std::string variableName, const long double* values );
+ virtual void Write( const std::string variableName, const std::complex<float>* values );
+ virtual void Write( const std::string variableName, const std::complex<double>* values );
+ virtual void Write( const std::string variableName, const std::complex<long double>* values );
+ 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
diff --git a/include/core/Variable.h b/include/core/Variable.h
index 24f54ef135a282efa27addc0239b777e1a3f67a9..036e68e3daf927bcbe094356760f4d104ef6c322 100644
--- a/include/core/Variable.h
+++ b/include/core/Variable.h
@@ -15,16 +15,13 @@
#include <ostream> //std::ostream in MonitorGroups
/// \endcond
+#include "core/VariableBase.h"
#include "core/Transform.h"
-#include "functions/adiosFunctions.h"
-#include "functions/adiosTemplates.h"
-
namespace adios
{
-using Dims = std::vector<size_t>;
struct TransformData
{
@@ -37,39 +34,18 @@ struct TransformData
* @param Base (parent) class for template derived (child) class CVariable. Required to put CVariable objects in STL containers.
*/
template< class T >
-class Variable
+class Variable : public VariableBase
{
public:
- const std::string m_Name; ///< variable name
- const std::string m_Type; ///< variable type
-
- Dims m_Dimensions;
- std::string m_DimensionsCSV; ///< comma separated list for variables to search for local dimensions
-
- Dims m_GlobalDimensions;
- std::string m_GlobalDimensionsCSV; ///< comma separated list for variables to search for global dimensions
-
- Dims m_GlobalOffsets;
- std::string m_GlobalOffsetsCSV; ///< comma separated list for variables to search for global offsets
-
- const bool m_DebugMode = false;
-
const T* m_AppValues = nullptr; ///< pointer to values passed from user in ADIOS Write, it might change in ADIOS Read
std::vector<T> m_Values; ///< Vector variable returned to user, might be used for zero-copy?
-
- bool m_IsScalar = false;
- const bool m_IsDimension = false;
std::vector< TransformData > m_Transforms; ///< associated transforms, sequence determines application order, e.g. first Transforms[0] then Transforms[1]. Pointer used as reference (no memory management).
- Variable( const std::string name, const Dims dimensions, const Dims globalDimensions, const Dims globalOffsets, const bool debugMode ):
- m_Name{ name },
- m_Type{ GetType<T>() },
- m_Dimensions{ dimensions },
- m_GlobalDimensions{ globalDimensions },
- m_GlobalOffsets{ globalOffsets },
- m_DebugMode{ debugMode }
+ Variable<T>( const std::string name, const Dims dimensions, const Dims globalDimensions, const Dims globalOffsets,
+ const bool debugMode ):
+ VariableBase( name, GetType<T>(), sizeof(T), dimensions, globalDimensions, globalOffsets, debugMode )
{
if( m_Dimensions == Dims{1} )
m_IsScalar = true;
@@ -82,7 +58,6 @@ public:
m_Transforms.emplace_back( transform, BuildParametersMap( parameters, m_DebugMode ) ); //need to check
}
-
void Monitor( std::ostream& logInfo ) const noexcept
{
logInfo << "Variable: " << m_Name << "\n";
@@ -103,27 +78,9 @@ public:
}
logInfo << " ...";
}
-
logInfo << "\n";
}
- /**
- * Returns the payload size in bytes
- * @return TotalSize * sizeof(T)
- */
- std::size_t PayLoadSize( ) const noexcept
- {
- return GetTotalSize( m_Dimensions ) * sizeof(T);
- }
-
- /**
- * Returns the total size
- * @return number of elements
- */
- std::size_t TotalSize( ) const noexcept
- {
- return GetTotalSize( m_Dimensions );
- }
};
diff --git a/include/core/VariableBase.h b/include/core/VariableBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..07d6602f7d31bc412f825c9bac52bcfde3ed8526
--- /dev/null
+++ b/include/core/VariableBase.h
@@ -0,0 +1,95 @@
+/*
+ * VariableBase.h
+ *
+ * Created on: Feb 20, 2017
+ * Author: wfg
+ */
+
+#ifndef VARIABLEBASE_H_
+#define VARIABLEBASE_H_
+
+/// \cond EXCLUDE_FROM_DOXYGEN
+#include <vector>
+#include <string>
+/// \endcond
+
+#include "functions/adiosFunctions.h" //GetTotalSize
+#include "functions/adiosTemplates.h" //GetType<T>
+
+
+namespace adios
+{
+
+using Dims = std::vector<std::size_t>;
+
+
+class VariableBase
+{
+
+public:
+
+ const std::string m_Name; ///< variable name
+ const std::string m_Type; ///< variable type
+ const std::size_t m_ElementSize; ///< Variable -> sizeof(T), VariableCompound -> from constructor
+
+ bool m_IsScalar = false;
+ const bool m_IsDimension = false;
+
+
+ VariableBase( const std::string name, const std::string type, const std::size_t elementSize,
+ const Dims dimensions, const Dims globalDimensions, const Dims globalOffsets,
+ const bool debugMode ):
+ m_Name{ name },
+ m_Type{ type },
+ m_ElementSize{ elementSize },
+ m_Dimensions{ dimensions },
+ m_GlobalDimensions{ globalDimensions },
+ m_GlobalOffsets{ globalOffsets },
+ m_DebugMode{ debugMode }
+ { }
+
+ virtual ~VariableBase( )
+ { }
+
+
+ std::size_t DimensionsSize( ) const noexcept
+ {
+ return m_Dimensions.size();
+ }
+
+ /**
+ * Returns the payload size in bytes
+ * @return TotalSize * sizeof(T)
+ */
+ std::size_t PayLoadSize( ) const noexcept
+ {
+ return GetTotalSize( m_Dimensions ) * m_ElementSize;
+ }
+
+ /**
+ * Returns the total size
+ * @return number of elements
+ */
+ std::size_t TotalSize( ) const noexcept
+ {
+ return GetTotalSize( m_Dimensions );
+ }
+
+
+//protected: off for now
+
+ Dims m_Dimensions; ///< array of local dimensions
+ Dims m_GlobalDimensions; ///< array of global dimensions
+ Dims m_GlobalOffsets; ///< array of global offsets
+ const bool m_DebugMode = false;
+
+
+};
+
+
+
+
+}
+
+
+#endif /* VARIABLEBASE_H_ */
diff --git a/include/core/VariableCompound.h b/include/core/VariableCompound.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fda61ab485d8007eea108a90ab1b114d6231987
--- /dev/null
+++ b/include/core/VariableCompound.h
@@ -0,0 +1,67 @@
+/*
+ * VariableCompound.h
+ *
+ * Created on: Feb 20, 2017
+ * Author: wfg
+ */
+
+#ifndef VARIABLECOMPOUND_H_
+#define VARIABLECOMPOUND_H_
+
+#include "core/VariableBase.h"
+
+namespace adios
+{
+
+struct CompoundElement
+{
+ const std::string m_Name;
+ const std::size_t m_Offset;
+ const std::string m_Type;
+};
+
+
+/**
+ * @param Base (parent) class for template derived (child) class CVariable. Required to put CVariable objects in STL containers.
+ */
+class VariableCompound : public VariableBase
+{
+
+public:
+
+ const void* m_AppValue = nullptr;
+
+
+ VariableCompound( const std::string name, const std::size_t sizeOfStruct, const Dims dimensions,
+ const Dims globalDimensions, const Dims globalOffsets, const bool debugMode ):
+ VariableBase( name, "compound", sizeOfStruct, dimensions, globalDimensions, globalOffsets, debugMode )
+ { }
+
+ template< class U >
+ void InsertMember( const std::string name, const std::size_t offset )
+ {
+ m_Elements.push_back( CompoundElement{ name, offset, GetType<U>() } );
+ }
+
+ void Monitor( std::ostream& logInfo ) const noexcept
+ {
+ logInfo << "Variable Compound: " << m_Name << "\n";
+ logInfo << "Type: " << m_Type << "\n";
+ logInfo << "Size: " << TotalSize() << " elements\n";
+ logInfo << "Payload: " << PayLoadSize() << " bytes\n";
+ }
+
+
+private:
+
+ std::vector<CompoundElement> m_Elements; ///< vector of element types
+
+};
+
+
+
+
+} //end namespace
+
+
+#endif /* VARIABLECOMPOUND_H_ */
diff --git a/include/engine/writer/Writer.h b/include/engine/bp/BPWriter.h
similarity index 80%
rename from include/engine/writer/Writer.h
rename to include/engine/bp/BPWriter.h
index 8e9fc634b339a8f33c80b3f56a804408aaae94bb..33d09c7d6d790e12a0361b0475b530630d778215 100644
--- a/include/engine/writer/Writer.h
+++ b/include/engine/bp/BPWriter.h
@@ -5,19 +5,20 @@
* Author: wfg
*/
-#ifndef WRITER_H_
-#define WRITER_H_
+#ifndef BPWRITER_H_
+#define BPWRITER_H_
#include "core/Engine.h"
#include "format/BP1Writer.h"
-#include "capsule/Heap.h"
+
+//supported capsules
+#include "capsule/heap/STLVector.h"
namespace adios
{
-
-class Writer : public Engine
+class BPWriter : public Engine
{
public:
@@ -30,10 +31,10 @@ public:
* @param method
* @param debugMode
*/
- Writer( 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 );
+ BPWriter( 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 );
- ~Writer( );
+ ~BPWriter( );
void Write( Variable<char>& variable, const char* values );
void Write( Variable<unsigned char>& variable, const unsigned char* values );
@@ -44,10 +45,14 @@ public:
void Write( Variable<long int>& variable, const long int* values );
void Write( Variable<unsigned long int>& variable, const unsigned long int* values );
void Write( Variable<long long int>& variable, const long long int* values );
- void Write( Variable<unsigned long long int>& variable, const unsigned long long int* values ) ;
+ void Write( Variable<unsigned long long int>& variable, const unsigned long long int* values );
void Write( Variable<float>& variable, const float* values );
void Write( Variable<double>& variable, const double* values );
void Write( Variable<long double>& variable, const long double* values );
+ void Write( Variable<std::complex<float>>& variable, const std::complex<float>* values );
+ void Write( Variable<std::complex<double>>& variable, const std::complex<double>* values );
+ void Write( Variable<std::complex<long double>>& variable, const std::complex<long double>* values );
+ void Write( VariableCompound& variable, const void* values );
void Write( const std::string variableName, const char* values );
void Write( const std::string variableName, const unsigned char* values );
@@ -62,19 +67,22 @@ public:
void Write( const std::string variableName, const float* values );
void Write( const std::string variableName, const double* values );
void Write( const std::string variableName, const long double* values );
+ void Write( const std::string variableName, const std::complex<float>* values );
+ void Write( const std::string variableName, const std::complex<double>* values );
+ void Write( const std::string variableName, const std::complex<long double>* values );
+ void Write( const std::string variableName, const void* values );
void Close( const int transportIndex = -1 );
private:
- Heap m_Buffer; ///< heap capsule
+ capsule::STLVector m_Buffer; ///< heap capsule using STL std::vector<char>
format::BP1Writer m_BP1Writer; ///< format object will provide the required BP functionality to be applied on m_Buffer and m_Transports
format::BP1MetadataSet m_MetadataSet; ///< metadata set accompanying the heap buffer data in bp format. Needed by m_BP1Writer
std::size_t m_MaxBufferSize;
float m_GrowthFactor = 1.5;
bool m_TransportFlush = false; ///< true: transport flush happened, buffer must be reset
-
void Init( );
void InitTransports( );
void InitProcessGroup( );
@@ -138,4 +146,4 @@ private:
} //end namespace adios
-#endif /* WRITER_H_ */
+#endif /* BPWRITER_H_ */
diff --git a/include/engine/dataman/DataMan.h b/include/engine/dataman/DataManWriter.h
similarity index 91%
rename from include/engine/dataman/DataMan.h
rename to include/engine/dataman/DataManWriter.h
index 10d13a1201467145ec59bbc2c5fcc11f5fb1ca6c..04a3848a3a76ed8f950f4e6e95553a5bba4e5501 100644
--- a/include/engine/dataman/DataMan.h
+++ b/include/engine/dataman/DataManWriter.h
@@ -5,21 +5,22 @@
* Author: wfg
*/
-#ifndef DATAMAN_H_
-#define DATAMAN_H_
+#ifndef DATAMANWRITER_H_
+#define DATAMANWRITER_H_
#include <iostream> //must be removed
#include <unistd.h> //must be removed
#include "core/Engine.h"
-#include "capsule/Heap.h"
#include "format/BP1Writer.h"
+//supported capsules
+#include "capsule/heap/STLVector.h"
namespace adios
{
-class DataMan : public Engine
+class DataManWriter : public Engine
{
public:
@@ -33,10 +34,10 @@ public:
* @param debugMode
* @param hostLanguage
*/
- DataMan( ADIOS& adios, const std::string name, const std::string accessMode, MPI_Comm mpiComm,
+ 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 );
- ~DataMan( );
+ ~DataManWriter( );
void Write( Variable<char>& variable, const char* values );
void Write( Variable<unsigned char>& variable, const unsigned char* values );
@@ -68,7 +69,7 @@ public:
private:
- Heap m_Buffer; ///< heap capsule, contains data and metadata buffers
+ 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
@@ -120,4 +121,4 @@ private:
-#endif /* DATAMAN_H_ */
+#endif /* DATAMANWRITER_H_ */
diff --git a/include/format/BP1Writer.h b/include/format/BP1Writer.h
index dd20dbc9695d4119e9dd3b566ca15243f8eccc88..9b697dc6d87bd27745c9fc8516567bf9bd43965a 100644
--- a/include/format/BP1Writer.h
+++ b/include/format/BP1Writer.h
@@ -19,7 +19,7 @@
#include "BP1.h"
#include "core/Variable.h"
#include "core/Capsule.h"
-#include "capsule/Heap.h"
+#include "capsule/heap/STLVector.h"
#include "functions/adiosTemplates.h"
#include "functions/adiosFunctions.h"
@@ -65,7 +65,7 @@ public:
void WriteProcessGroupIndex( const bool isFortran, const std::string name, const unsigned int processID,
const std::string timeStepName, const unsigned int timeStep,
const std::vector< std::shared_ptr<Transport> >& transports,
- Heap& buffer,
+ capsule::STLVector& buffer,
BP1MetadataSet& metadataSet ) const noexcept;
/**
* Writes a process group index PGIndex and list of methods (from transports), done at Open or aggregation of new time step
@@ -102,7 +102,7 @@ public:
indexSize += variable.m_Name.size();
// characteristics 3 and 4, check variable number of dimensions
- const std::size_t dimensions = variable.m_Dimensions.size(); //number of commas in CSV + 1
+ const std::size_t dimensions = variable.DimensionsSize(); //number of commas in CSV + 1
indexSize += 28 * dimensions; //28 bytes per dimension
indexSize += 1; //id
@@ -144,7 +144,7 @@ public:
* @param metadataSet
*/
template< class T >
- void WriteVariableIndex( const Variable<T>& variable, Heap& buffer, BP1MetadataSet& metadataSet ) const noexcept
+ void WriteVariableIndex( const Variable<T>& variable, capsule::STLVector& buffer, BP1MetadataSet& metadataSet ) const noexcept
{
// adapt this part to local variables
std::vector<char*> dataBuffers{ buffer.m_Data.data() };
diff --git a/include/functions/adiosTemplates.h b/include/functions/adiosTemplates.h
index 96d0969a128adb4baf291b752f57dbb229fb1391..b13e6fcb51530440b92d5c8cf96e9ccef2a146cf 100644
--- a/include/functions/adiosTemplates.h
+++ b/include/functions/adiosTemplates.h
@@ -13,6 +13,7 @@
#include <vector>
#include <thread>
#include <set>
+#include <complex>
/// \endcond
@@ -24,8 +25,7 @@ namespace adios
* Get the primitive type in a string from a template
* @return if T is a char, returns string = "char"
*/
-template< class T> inline std::string GetType( ) noexcept { return ""; }
-
+template< class T> inline std::string GetType( ) noexcept { return "compound"; }
template<> inline std::string GetType<char>() noexcept { return "char"; }
template<> inline std::string GetType<unsigned char>() noexcept { return "unsigned char"; }
template<> inline std::string GetType<short>() noexcept { return "short"; }
@@ -39,6 +39,10 @@ template<> inline std::string GetType<unsigned long long int>() noexcept { retur
template<> inline std::string GetType<float>() noexcept { return "float"; }
template<> inline std::string GetType<double>() noexcept { return "double"; }
template<> inline std::string GetType<long double>() noexcept { return "long double"; }
+template<> inline std::string GetType<std::complex<float>>() noexcept { return "float complex"; }
+template<> inline std::string GetType<std::complex<double>>() noexcept { return "double complex"; }
+template<> inline std::string GetType<std::complex<long double>>() noexcept { return "long double complex"; }
+
/**
diff --git a/include/transport/POSIX.h b/include/transport/file/FD.h
similarity index 60%
rename from include/transport/POSIX.h
rename to include/transport/file/FD.h
index 9dea1b463b10d43ca47c19087010433d9b7c5fcd..4c005ccbb8f85adb1c1a3fbada36ecb1a8b0174a 100644
--- a/include/transport/POSIX.h
+++ b/include/transport/file/FD.h
@@ -5,8 +5,8 @@
* Author: wfg
*/
-#ifndef POSIX_H_
-#define POSIX_H_
+#ifndef FD_H_
+#define FD_H_
#include "core/Transport.h"
@@ -14,16 +14,20 @@
namespace adios
{
+namespace transport
+{
-
-class POSIX : public Transport
+/**
+ * File descriptor transport using the POSIX library
+ */
+class FD : public Transport
{
public:
- POSIX( MPI_Comm mpiComm, const bool debugMode );
+ FD( MPI_Comm mpiComm, const bool debugMode );
- ~POSIX( );
+ ~FD( );
void Open( const std::string name, const std::string accessMode );
@@ -38,7 +42,8 @@ private:
};
-} //end namespace
-#endif /* POSIX_H_ */
+} //end namespace transport
+} //end namespace
+#endif /* FD_H_ */
diff --git a/include/transport/File.h b/include/transport/file/FP.h
similarity index 60%
rename from include/transport/File.h
rename to include/transport/file/FP.h
index a9b763828f905cfab0a4f0ce6396a902c81f7d60..2ac13458722228a83d5bac8356a6c4e2406cd215 100644
--- a/include/transport/File.h
+++ b/include/transport/file/FP.h
@@ -5,29 +5,32 @@
* Author: wfg
*/
-#ifndef FILE_H_
-#define FILE_H_
-
+#ifndef FP_H_
+#define FP_H_
+/// \cond EXCLUDE_FROM_DOXYGEN
#include <stdio.h> // FILE*
+/// \endcond
#include "core/Transport.h"
namespace adios
{
+namespace transport
+{
/**
- * Class that defines a transport method using C file pointer to streams FILE*
+ * Class that defines a transport method using C file pointer (FP) to streams FILE*
*/
-class File : public Transport
+class FP : public Transport
{
public:
- File( MPI_Comm mpiComm, const bool debugMode );
+ FP( MPI_Comm mpiComm, const bool debugMode );
- ~File( );
+ ~FP( );
void Open( const std::string name, const std::string accessMode );
@@ -47,9 +50,10 @@ private:
};
+} //end namespace transport
} //end namespace
-#endif /* FILE_H_ */
+#endif /* FP_H_ */
diff --git a/include/transport/FStream.h b/include/transport/file/FStream.h
similarity index 81%
rename from include/transport/FStream.h
rename to include/transport/file/FStream.h
index feedb3a7b3398a3fa3f97baa62ed63822647ca2a..fed11ac1fa1a63221e57b4e8930bc0688a33ff56 100644
--- a/include/transport/FStream.h
+++ b/include/transport/file/FStream.h
@@ -1,5 +1,5 @@
/*
- * CFStream.h
+ * FStream.h
*
* Created on: Oct 18, 2016
* Author: wfg
@@ -8,17 +8,20 @@
#ifndef FSTREAM_H_
#define FSTREAM_H_
-
+/// \cond EXCLUDE_FROM_DOXYGEN
#include <fstream>
+/// \endcond
#include "core/Transport.h"
namespace adios
{
+namespace transport
+{
/**
- * Class that defines a transport method using C++ file streams
+ * File stream transport using C++ fstream
*/
class FStream : public Transport
{
@@ -47,6 +50,7 @@ private:
};
+} //end namespace transport
} //end namespace
diff --git a/include/transport/MPIFile.h b/include/transport/file/MPI_File.h
similarity index 65%
rename from include/transport/MPIFile.h
rename to include/transport/file/MPI_File.h
index 57389b334e9edc38fcaaaf67e7838ef144b9d528..0e5d1892a4ff44eb81584deadacaa7f92b1ca7f7 100644
--- a/include/transport/MPIFile.h
+++ b/include/transport/file/MPI_File.h
@@ -5,26 +5,31 @@
* Author: wfg
*/
-#ifndef MPIFILE_H_
-#define MPIFILE_H_
+#ifndef MPI_FILE_H_
+#define MPI_FILE_H_
+
+/// \cond EXCLUDE_FROM_DOXYGEN
#include <mpi.h>
+/// \endcond
namespace adios
{
+namespace transport
+{
/**
* Class that defines a transport method using C++ file streams
*/
-class MPIFile : public Transport
+class MPI_File : public Transport
{
public:
- MPIFile( MPI_Comm mpiComm, const bool debugMode );
+ MPI_File( MPI_Comm mpiComm, const bool debugMode );
- ~MPIFile( );
+ ~MPI_File( );
void Open( const std::string streamName, const std::string accessMode );
@@ -45,11 +50,11 @@ private:
-
+} //end namespace transport
} //end namespace
-#endif /* MPIFILE_H_ */
+#endif /* MPI_FILE_H_ */
diff --git a/include/transport/MdtmMan.h b/include/transport/wan/MdtmMan.h
similarity index 98%
rename from include/transport/MdtmMan.h
rename to include/transport/wan/MdtmMan.h
index c6e0285bd4b5fd442c12a1d7e1523b77098d2210..6752a58d3f562c302d7f2f00fe83aaa30430b4c9 100644
--- a/include/transport/MdtmMan.h
+++ b/include/transport/wan/MdtmMan.h
@@ -15,6 +15,8 @@
namespace adios
{
+namespace transport
+{
class MdtmMan : public Transport
{
@@ -126,6 +128,7 @@ private:
};
+} //end namespace transport
} //end namespace
diff --git a/src/ADIOS.cpp b/src/ADIOS.cpp
index a5fd9a0f096c3cc7e50acb4c98e483c00ad2e478..edae670b8983e628f98029d5b996715596905f4c 100644
--- a/src/ADIOS.cpp
+++ b/src/ADIOS.cpp
@@ -13,12 +13,13 @@
/// \endcond
#include "ADIOS.h"
+
+
#include "functions/adiosFunctions.h"
//Engines
-#include "engine/writer/Writer.h"
-#include "engine/dataman/DataMan.h"
-//#include "engine/vis/Vis.h"
+#include "engine/bp/BPWriter.h"
+#include "engine/dataman/DataManWriter.h"
namespace adios
@@ -94,18 +95,18 @@ std::shared_ptr<Engine> ADIOS::Open( const std::string name, const std::string a
const std::string type( method.m_Type );
- if( type == "Writer" || type == "writer" )
+ if( type == "BPWriter" || type == "bpwriter" )
{
- return std::make_shared<Writer>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
+ return std::make_shared<BPWriter>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
}
else if( type == "SIRIUS" || type == "sirius" || type == "Sirius" )
{
//not yet supported
//return std::make_shared<engine::DataMan>( name, accessMode, mpiComm, method, m_DebugMode, cores, m_HostLanguage );
}
- else if( type == "DataMan" )
+ else if( type == "DataManWriter" )
{
- return std::make_shared<DataMan>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
+ return std::make_shared<DataManWriter>( *this, name, accessMode, mpiComm, method, m_DebugMode, cores );
}
else if( type == "Vis" )
{
@@ -149,6 +150,12 @@ std::shared_ptr<Engine> ADIOS::Open( const std::string name, const std::string a
}
+VariableCompound& ADIOS::GetVariableCompound( const std::string name )
+{
+ return m_Compound[ GetVariableIndex<void>(name) ];
+}
+
+
void ADIOS::MonitorVariables( std::ostream& logStream )
{
logStream << "\tVariable \t Type\n";
diff --git a/src/capsule/Heap.cpp b/src/capsule/heap/STLVector.cpp
similarity index 73%
rename from src/capsule/Heap.cpp
rename to src/capsule/heap/STLVector.cpp
index ef099762ff2322ed228b7381b81fd79f5b64221b..27455f29b1b146166fe70c812773246fea81b280 100644
--- a/src/capsule/Heap.cpp
+++ b/src/capsule/heap/STLVector.cpp
@@ -10,14 +10,16 @@
#include <stdexcept> //std::runtime_error
/// \endcond
-#include "capsule/Heap.h"
+#include "capsule/heap/STLVector.h"
namespace adios
{
+namespace capsule
+{
-Heap::Heap( const std::string accessMode, const int rankMPI, const bool debugMode ):
+STLVector::STLVector( const std::string accessMode, const int rankMPI, const bool debugMode ):
Capsule( "Heap", accessMode, rankMPI, debugMode ),
m_Data( 16777216, '\0' )
{
@@ -25,35 +27,35 @@ Heap::Heap( const std::string accessMode, const int rankMPI, const bool debugMod
}
-Heap::~Heap( )
+STLVector::~STLVector( )
{ }
-char* Heap::GetData( )
+char* STLVector::GetData( )
{
return m_Data.data( );
}
-char* Heap::GetMetadata( )
+char* STLVector::GetMetadata( )
{
return m_Metadata.data( );
}
-std::size_t Heap::GetDataSize( ) const
+std::size_t STLVector::GetDataSize( ) const
{
return m_Data.size( );
}
-std::size_t Heap::GetMetadataSize( ) const
+std::size_t STLVector::GetMetadataSize( ) const
{
return m_Metadata.size( );
}
-void Heap::ResizeData( const std::size_t size )
+void STLVector::ResizeData( const std::size_t size )
{
if( m_DebugMode == true )
{
@@ -67,7 +69,7 @@ void Heap::ResizeData( const std::size_t size )
}
}
-void Heap::ResizeMetadata( const std::size_t size )
+void STLVector::ResizeMetadata( const std::size_t size )
{
if( m_DebugMode == true )
{
@@ -82,4 +84,5 @@ void Heap::ResizeMetadata( const std::size_t size )
}
+} //end namespace heap
} //end namespace
diff --git a/src/capsule/ShmSystemV.cpp b/src/capsule/shmem/ShmSystemV.cpp
similarity index 97%
rename from src/capsule/ShmSystemV.cpp
rename to src/capsule/shmem/ShmSystemV.cpp
index 40b5ccba05ab14a39a91db16fc46aa38ef3f26d5..8d3d508ac8894ed68dbbdf9b8216ae5071c94104 100644
--- a/src/capsule/ShmSystemV.cpp
+++ b/src/capsule/shmem/ShmSystemV.cpp
@@ -4,11 +4,13 @@
* Created on: Dec 22, 2016
* Author: wfg
*/
-
+/// \cond EXCLUDE_FROM_DOXYGEN
#include <sys/shm.h>
#include <ios> //std::ios_base::failure
+/// \endcond
+
-#include "capsule/ShmSystemV.h"
+#include "capsule/shmem/ShmSystemV.h"
namespace adios
diff --git a/src/core/Engine.cpp b/src/core/Engine.cpp
index 8e3dcb4ac1a5fa124b3bfdc29d11a9830622468a..fc4ef69f9798b692e7cda1b5d2364281c9441325 100644
--- a/src/core/Engine.cpp
+++ b/src/core/Engine.cpp
@@ -37,9 +37,46 @@ Engine::~Engine( )
{ }
-//PROTECTED
-
-void Engine::Close( int transportIndex )
+//should these functions throw an exception?
+void Engine::Write( Variable<char>& variable, const char* values ){ }
+void Engine::Write( Variable<unsigned char>& variable, const unsigned char* values ){ }
+void Engine::Write( Variable<short>& variable, const short* values ){ }
+void Engine::Write( Variable<unsigned short>& variable, const unsigned short* values ){ }
+void Engine::Write( Variable<int>& variable, const int* values ){ }
+void Engine::Write( Variable<unsigned int>& variable, const unsigned int* values ){ }
+void Engine::Write( Variable<long int>& variable, const long int* values ){ }
+void Engine::Write( Variable<unsigned long int>& variable, const unsigned long int* values ){ }
+void Engine::Write( Variable<long long int>& variable, const long long int* values ){ }
+void Engine::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values ){ }
+void Engine::Write( Variable<float>& variable, const float* values ){ }
+void Engine::Write( Variable<double>& variable, const double* values ){ }
+void Engine::Write( Variable<long double>& variable, const long double* values ){ }
+void Engine::Write( Variable<std::complex<float>>& variable, const std::complex<float>* values ){ }
+void Engine::Write( Variable<std::complex<double>>& variable, const std::complex<double>* values ){ }
+void Engine::Write( Variable<std::complex<long double>>& variable, const std::complex<long double>* values ){ }
+void Engine::Write( VariableCompound& variable, const void* values ){ }
+
+void Engine::Write( const std::string variableName, const char* values ){ }
+void Engine::Write( const std::string variableName, const unsigned char* values ){ }
+void Engine::Write( const std::string variableName, const short* values ){ }
+void Engine::Write( const std::string variableName, const unsigned short* values ){ }
+void Engine::Write( const std::string variableName, const int* values ){ }
+void Engine::Write( const std::string variableName, const unsigned int* values ){ }
+void Engine::Write( const std::string variableName, const long int* values ){ }
+void Engine::Write( const std::string variableName, const unsigned long int* values ){ }
+void Engine::Write( const std::string variableName, const long long int* values ){ }
+void Engine::Write( const std::string variableName, const unsigned long long int* values ){ }
+void Engine::Write( const std::string variableName, const float* values ){ }
+void Engine::Write( const std::string variableName, const double* values ){ }
+void Engine::Write( const std::string variableName, const long double* values ){ }
+void Engine::Write( const std::string variableName, const std::complex<float>* values ){ }
+void Engine::Write( const std::string variableName, const std::complex<double>* values ){ }
+void Engine::Write( const std::string variableName, const std::complex<long double>* values ){ }
+void Engine::Write( const std::string variableName, const void* values ){ }
+
+
+
+void Engine::Close( const int transportIndex )
{
if( transportIndex == -1 ) //close all transports
{
@@ -52,6 +89,7 @@ void Engine::Close( int transportIndex )
}
}
+//PROTECTED
void Engine::Init( )
{ }
@@ -109,4 +147,5 @@ bool Engine::TransportNamesUniqueness( ) const
}
+
} //end namespace
diff --git a/src/engine/writer/Writer.cpp b/src/engine/bp/BPWriter.cpp
similarity index 53%
rename from src/engine/writer/Writer.cpp
rename to src/engine/bp/BPWriter.cpp
index 7ddc5a5627a8f0be79859d6d73fe485a3a5d65ca..9157987336394f953b9c4ca8ccb51b0465cfe39d 100644
--- a/src/engine/writer/Writer.cpp
+++ b/src/engine/bp/BPWriter.cpp
@@ -1,42 +1,39 @@
/*
- * SingleBP.cpp
+ * BPWriter.cpp
*
* Created on: Dec 19, 2016
* Author: wfg
*/
-#include "engine/writer/Writer.h"
-#include "functions/adiosFunctions.h" //GetTotalSize
+#include "engine/bp/BPWriter.h"
+#include "ADIOS.h"
-//supported capsules
-#include "capsule/Heap.h"
//supported transports
-#include "transport/POSIX.h"
-#include "transport/FStream.h"
-#include "transport/File.h"
+#include "transport/file/FD.h"
+#include "transport/file/FP.h"
+#include "transport/file/FStream.h"
-#include "ADIOS.h"
namespace adios
{
-Writer::Writer( ADIOS& adios, const std::string name, const std::string accessMode, const MPI_Comm mpiComm,
- const Method& method, const bool debugMode, const unsigned int cores ):
- Engine( adios, "Writer", name, accessMode, mpiComm, method, debugMode, cores, " Writer constructor (or call to ADIOS Open).\n" ),
- m_Buffer{ Heap( accessMode, m_RankMPI, m_DebugMode ) },
+BPWriter::BPWriter( ADIOS& adios, const std::string name, const std::string accessMode, const MPI_Comm mpiComm,
+ const Method& method, const bool debugMode, const unsigned int cores ):
+ Engine( adios, "BPWriter", name, accessMode, mpiComm, method, debugMode, cores, " BPWriter constructor (or call to ADIOS Open).\n" ),
+ m_Buffer{ capsule::STLVector( accessMode, m_RankMPI, m_DebugMode ) },
m_MaxBufferSize{ m_Buffer.m_Data.max_size() }
{
Init( );
}
-Writer::~Writer( )
+BPWriter::~BPWriter( )
{ }
-void Writer::Init( )
+void BPWriter::Init( )
{
auto itGrowthFactor = m_Method.m_Parameters.find( "buffer_growth" );
if( itGrowthFactor != m_Method.m_Parameters.end() )
@@ -55,101 +52,123 @@ void Writer::Init( )
InitTransports( );
InitProcessGroup( );
-
}
-void Writer::Write( Variable<char>& variable, const char* values )
+void BPWriter::Write( Variable<char>& variable, const char* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<unsigned char>& variable, const unsigned char* values )
+void BPWriter::Write( Variable<unsigned char>& variable, const unsigned char* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<short>& variable, const short* values )
+void BPWriter::Write( Variable<short>& variable, const short* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<unsigned short>& variable, const unsigned short* values )
+void BPWriter::Write( Variable<unsigned short>& variable, const unsigned short* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<int>& variable, const int* values )
+void BPWriter::Write( Variable<int>& variable, const int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<unsigned int>& variable, const unsigned int* values )
+void BPWriter::Write( Variable<unsigned int>& variable, const unsigned int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<long int>& variable, const long int* values )
+void BPWriter::Write( Variable<long int>& variable, const long int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<unsigned long int>& variable, const unsigned long int* values )
+void BPWriter::Write( Variable<unsigned long int>& variable, const unsigned long int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<long long int>& variable, const long long int* values )
+void BPWriter::Write( Variable<long long int>& variable, const long long int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values )
+void BPWriter::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<float>& variable, const float* values )
+void BPWriter::Write( Variable<float>& variable, const float* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<double>& variable, const double* values )
+void BPWriter::Write( Variable<double>& variable, const double* values )
{ WriteVariable( variable, values ); }
-void Writer::Write( Variable<long double>& variable, const long double* values )
+void BPWriter::Write( Variable<long double>& variable, const long double* values )
{ WriteVariable( variable, values ); }
+void BPWriter::Write( Variable<std::complex<float>>& variable, const std::complex<float>* values )
+{ }
+
+void BPWriter::Write( Variable<std::complex<double>>& variable, const std::complex<double>* values )
+{ }
+
+void BPWriter::Write( Variable<std::complex<long double>>& variable, const std::complex<long double>* values )
+{ }
+
+void BPWriter::Write( VariableCompound& variable, const void* values )
+{ }
+
//String version
-void Writer::Write( const std::string variableName, const char* values )
+void BPWriter::Write( const std::string variableName, const char* values )
{ WriteVariable( m_ADIOS.GetVariable<char>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const unsigned char* values )
+void BPWriter::Write( const std::string variableName, const unsigned char* values )
{ WriteVariable( m_ADIOS.GetVariable<unsigned char>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const short* values )
+void BPWriter::Write( const std::string variableName, const short* values )
{ WriteVariable( m_ADIOS.GetVariable<short>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const unsigned short* values )
+void BPWriter::Write( const std::string variableName, const unsigned short* values )
{ WriteVariable( m_ADIOS.GetVariable<unsigned short>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const int* values )
+void BPWriter::Write( const std::string variableName, const int* values )
{ WriteVariable( m_ADIOS.GetVariable<int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const unsigned int* values )
+void BPWriter::Write( const std::string variableName, const unsigned int* values )
{ WriteVariable( m_ADIOS.GetVariable<unsigned int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const long int* values )
+void BPWriter::Write( const std::string variableName, const long int* values )
{ WriteVariable( m_ADIOS.GetVariable<long int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const unsigned long int* values )
+void BPWriter::Write( const std::string variableName, const unsigned long int* values )
{ WriteVariable( m_ADIOS.GetVariable<unsigned long int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const long long int* values )
+void BPWriter::Write( const std::string variableName, const long long int* values )
{ WriteVariable( m_ADIOS.GetVariable<long long int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const unsigned long long int* values )
+void BPWriter::Write( const std::string variableName, const unsigned long long int* values )
{ WriteVariable( m_ADIOS.GetVariable<unsigned long long int>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const float* values )
+void BPWriter::Write( const std::string variableName, const float* values )
{ WriteVariable( m_ADIOS.GetVariable<float>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const double* values )
+void BPWriter::Write( const std::string variableName, const double* values )
{ WriteVariable( m_ADIOS.GetVariable<double>( variableName ), values ); }
-void Writer::Write( const std::string variableName, const long double* values )
+void BPWriter::Write( const std::string variableName, const long double* values )
{ WriteVariable( m_ADIOS.GetVariable<long double>( variableName ), values ); }
+void BPWriter::Write( const std::string variableName, const std::complex<float>* values )
+{ }
+
+void BPWriter::Write( const std::string variableName, const std::complex<double>* values )
+{ }
+
+void BPWriter::Write( const std::string variableName, const std::complex<long double>* values )
+{ }
+
+void BPWriter::Write( const std::string variableName, const void* values )
+{ }
-void Writer::Close( const int transportIndex )
+void BPWriter::Close( const int transportIndex )
{
- //BP1Writer to update the metadata indices
+ //BP1BPWriter to update the metadata indices
//merge all metadata indices in capsule.m_Metadata buffer or capsule.m_Data buffer (depends on transport predefined functionality)
- //BP1Writer to write to corresponding transport
+ //BP1BPWriter to write to corresponding transport
if( transportIndex == -1 ) // all transports
{
@@ -168,7 +187,7 @@ void Writer::Close( const int transportIndex )
}
-void Writer::InitTransports( )
+void BPWriter::InitTransports( )
{
if( m_DebugMode == true )
{
@@ -182,40 +201,44 @@ void Writer::InitTransports( )
for( const auto& parameters : m_Method.m_TransportParameters )
{
auto itTransport = parameters.find( "transport" );
-
- if( itTransport->second == "POSIX" )
- {
- auto file = std::make_shared<POSIX>( m_MPIComm, m_DebugMode );
- m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
- m_Transports.push_back( std::move( file ) );
- }
- else if( itTransport->second == "File" )
+ if( itTransport->second == "file" || itTransport->second == "File" )
{
- auto file = std::make_shared<File>( m_MPIComm, m_DebugMode );
- m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
- m_Transports.push_back( std::move( file ) );
- }
- else if( itTransport->second == "FStream" )
- {
- auto file = std::make_shared<FStream>( m_MPIComm, m_DebugMode );
- m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
- m_Transports.push_back( std::move( file ) );
- }
- else if( itTransport->second == "MPIFile" ) //not yet supported
- {
- //m_Transports.push_back( std::make_shared<MPIFile>( m_MPIComm, m_DebugMode ) );
- }
- else
- {
- if( m_DebugMode == true )
- throw std::invalid_argument( "ERROR: transport + " + itTransport->second + " not supported, in " +
- m_Name + m_EndMessage );
+ auto itLibrary = parameters.find( "library" );
+ if( itLibrary == parameters.end() || itLibrary->second == "POSIX" ) //use default POSIX
+ {
+ auto file = std::make_shared<transport::FD>( m_MPIComm, m_DebugMode );
+ m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
+ m_Transports.push_back( std::move( file ) );
+ }
+ else if( itLibrary->second == "FILE*" )
+ {
+ auto file = std::make_shared<transport::FP>( m_MPIComm, m_DebugMode );
+ m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
+ m_Transports.push_back( std::move( file ) );
+
+ }
+ else if( itLibrary->second == "fstream" || itLibrary->second == "std::fstream" )
+ {
+ auto file = std::make_shared<transport::FStream>( m_MPIComm, m_DebugMode );
+ m_BP1Writer.OpenRankFiles( m_Name, m_AccessMode, *file );
+ m_Transports.push_back( std::move( file ) );
+ }
+ else if( itLibrary->second == "MPI-IO" )
+ {
+
+ }
+ else
+ {
+ if( m_DebugMode == true )
+ throw std::invalid_argument( "ERROR: transport + " + itTransport->second + " not supported, in " +
+ m_Name + m_EndMessage );
+ }
}
}
}
-void Writer::InitProcessGroup( )
+void BPWriter::InitProcessGroup( )
{
if( m_AccessMode == "a" )
{
@@ -226,7 +249,7 @@ void Writer::InitProcessGroup( )
-void Writer::WriteProcessGroupIndex( )
+void BPWriter::WriteProcessGroupIndex( )
{
//pg = process group
const std::string pgName( std::to_string( m_RankMPI ) ); //using rank as name
@@ -243,7 +266,7 @@ void Writer::WriteProcessGroupIndex( )
// const bool isFortran = ( m_HostLanguage == "Fortran" ) ? true : false;
// const unsigned int processID = static_cast<unsigned int> ( m_RankMPI );
-// m_BP1Writer.WriteProcessGroupIndex( isFortran, name, processID, timeStepName, timeStep, m_Transports,
+// m_BP1BPWriter.WriteProcessGroupIndex( isFortran, name, processID, timeStepName, timeStep, m_Transports,
// m_Buffer.m_Data, m_Buffer.m_DataPosition, m_Buffer.m_DataAbsolutePosition,
// m_MetadataSet.PGIndex, m_MetadataSet.PGIndexPosition );
@@ -256,7 +279,7 @@ void Writer::WriteProcessGroupIndex( )
}
-bool Writer::CheckBuffersAllocation( const std::size_t indexSize, const std::size_t payloadSize )
+bool BPWriter::CheckBuffersAllocation( const std::size_t indexSize, const std::size_t payloadSize )
{
//Check if data in buffer needs to be reallocated
const std::size_t dataSize = payloadSize + indexSize + 10; //adding some bytes tolerance
@@ -274,4 +297,3 @@ bool Writer::CheckBuffersAllocation( const std::size_t indexSize, const std::siz
} //end namespace adios
-
diff --git a/src/engine/dataman/DataMan.cpp b/src/engine/dataman/DataMan.cpp
deleted file mode 100644
index 96212d60a7bc64866d1e861db7486ef03b8f99dc..0000000000000000000000000000000000000000
--- a/src/engine/dataman/DataMan.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * DataMan.cpp
- *
- * Created on: Jan 10, 2017
- * Author: wfg
- */
-
-#include <iostream>
-
-
-#include "engine/dataman/DataMan.h"
-#include "core/Support.h"
-#include "functions/adiosFunctions.h" //CSVToVector
-
-//supported capsules
-#include "capsule/Heap.h"
-
-//supported transports
-#include "transport/POSIX.h"
-#include "transport/FStream.h"
-#include "transport/File.h"
-#include "transport/MdtmMan.h"
-
-
-namespace adios
-{
-
-DataMan::DataMan( 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, "DataMan", name, accessMode, mpiComm, method, debugMode, cores, " Dataman constructor (or call to ADIOS Open).\n" ),
- m_Buffer( accessMode, m_RankMPI, m_DebugMode )
-{
- Init( );
-}
-
-
-DataMan::~DataMan( )
-{ }
-
-
-void DataMan::Init( )
-{
- InitCapsules( );
- InitTransports( );
-}
-
-
-void DataMan::Write( Variable<char>& variable, const char* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<unsigned char>& variable, const unsigned char* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<short>& variable, const short* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<unsigned short>& variable, const unsigned short* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<int>& variable, const int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<unsigned int>& variable, const unsigned int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<long int>& variable, const long int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<unsigned long int>& variable, const unsigned long int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<long long int>& variable, const long long int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<float>& variable, const float* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<double>& variable, const double* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( Variable<long double>& variable, const long double* values )
-{ WriteVariable( variable, values ); }
-
-void DataMan::Write( const std::string variableName, const char* values )
-{ WriteVariable( m_ADIOS.GetVariable<char>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const unsigned char* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned char>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const short* values )
-{ WriteVariable( m_ADIOS.GetVariable<short>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const unsigned short* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned short>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const int* values )
-{ WriteVariable( m_ADIOS.GetVariable<int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const unsigned int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<long int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const unsigned long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned long int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const long long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<long long int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const unsigned long long int* values )
-{ WriteVariable( m_ADIOS.GetVariable<unsigned long long int>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const float* values )
-{ WriteVariable( m_ADIOS.GetVariable<float>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const double* values )
-{ WriteVariable( m_ADIOS.GetVariable<double>( variableName ), values ); }
-
-void DataMan::Write( const std::string variableName, const long double* values )
-{ WriteVariable( m_ADIOS.GetVariable<long double>( variableName ), values ); }
-
-
-void DataMan::InitCapsules( )
-{
- //here init memory capsules
-}
-
-
-void DataMan::InitTransports( ) //maybe move this?
-{
- TransportNamesUniqueness( );
-
- for( const auto& parameters : m_Method.m_TransportParameters )
- {
- auto itTransport = parameters.find( "transport" );
-
- if( itTransport->second == "POSIX" )
- {
- m_Transports.push_back( std::make_shared<POSIX>( m_MPIComm, m_DebugMode ) );
- }
- else if( itTransport->second == "File" )
- {
- m_Transports.push_back( std::make_shared<File>( m_MPIComm, m_DebugMode ) );
- }
- else if( itTransport->second == "FStream" )
- {
- m_Transports.push_back( std::make_shared<FStream>( m_MPIComm, m_DebugMode ) );
- }
- else 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<MdtmMan>( localIP, remoteIP, m_AccessMode, prefix, numberOfPipes,
- tolerances, priorities, m_MPIComm, m_DebugMode ) );
- }
- else if( itTransport->second == "MPIFile" )
- {
- //m_Transports.push_back( std::make_shared<MPIFile>( m_MPIComm, m_DebugMode ) ); //not yet supported
- }
- else
- {
- if( m_DebugMode == true )
- throw std::invalid_argument( "ERROR: transport + " + itTransport->second + " not supported, in " +
- m_Name + m_EndMessage );
- }
- }
-}
-
-
-std::string DataMan::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 DataMan 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
-}
-
-
-} //end namespace adios
-
-
-
diff --git a/src/engine/dataman/DataManWriter.cpp b/src/engine/dataman/DataManWriter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d04c2185713403a04fee179df6b6c51026f9dab4
--- /dev/null
+++ b/src/engine/dataman/DataManWriter.cpp
@@ -0,0 +1,200 @@
+/*
+ * DataMan.cpp
+ *
+ * Created on: Jan 10, 2017
+ * Author: wfg
+ */
+
+#include <iostream> //needs to go away, this is just for demo purposes
+
+#include "engine/dataman/DataManWriter.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
+{
+
+
+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" ),
+ m_Buffer( accessMode, m_RankMPI, m_DebugMode )
+{
+ Init( );
+}
+
+
+DataManWriter::~DataManWriter( )
+{ }
+
+
+void DataManWriter::Init( )
+{
+ InitCapsules( );
+ InitTransports( );
+}
+
+
+void DataManWriter::Write( Variable<char>& variable, const char* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<unsigned char>& variable, const unsigned char* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<short>& variable, const short* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<unsigned short>& variable, const unsigned short* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<int>& variable, const int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<unsigned int>& variable, const unsigned int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<long int>& variable, const long int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<unsigned long int>& variable, const unsigned long int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<long long int>& variable, const long long int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<unsigned long long int>& variable, const unsigned long long int* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<float>& variable, const float* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<double>& variable, const double* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( Variable<long double>& variable, const long double* values )
+{ WriteVariable( variable, values ); }
+
+void DataManWriter::Write( const std::string variableName, const char* values )
+{ WriteVariable( 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 ); }
+
+void DataManWriter::Write( const std::string variableName, const short* values )
+{ WriteVariable( 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 ); }
+
+void DataManWriter::Write( const std::string variableName, const int* values )
+{ WriteVariable( 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 ); }
+
+void DataManWriter::Write( const std::string variableName, const long int* values )
+{ WriteVariable( 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 ); }
+
+void DataManWriter::Write( const std::string variableName, const long long int* values )
+{ WriteVariable( 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 ); }
+
+void DataManWriter::Write( const std::string variableName, const float* values )
+{ WriteVariable( m_ADIOS.GetVariable<float>( variableName ), values ); }
+
+void DataManWriter::Write( const std::string variableName, const double* values )
+{ WriteVariable( 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 ); }
+
+
+void DataManWriter::InitCapsules( )
+{
+ //here init memory capsules
+}
+
+
+void DataManWriter::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 DataManWriter::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
+}
+
+
+} //end namespace adios
diff --git a/src/format/BP1Writer.cpp b/src/format/BP1Writer.cpp
index d5bbaf46bb66f8c8dfbdcb0536ad05bffcba914e..09a1e8cac84ec84959ba27c756ba70d867844bbb 100644
--- a/src/format/BP1Writer.cpp
+++ b/src/format/BP1Writer.cpp
@@ -23,10 +23,11 @@ std::size_t BP1Writer::GetProcessGroupIndexSize( const std::string name, const s
return ( name.length() + timeStepName.length() + 23 ) + ( 3 + numberOfTransports ); //should be sufficient for data and metadata pgindices
}
+
void BP1Writer::WriteProcessGroupIndex( const bool isFortran, const std::string name, const unsigned int processID,
const std::string timeStepName, const unsigned int timeStep,
const std::vector< std::shared_ptr<Transport> >& transports,
- Heap& buffer, BP1MetadataSet& metadataSet ) const noexcept
+ capsule::STLVector& buffer, BP1MetadataSet& metadataSet ) const noexcept
{
// adapt this part to local variables
std::vector<char*> dataBuffers{ buffer.m_Data.data() };
@@ -45,9 +46,9 @@ void BP1Writer::WriteProcessGroupIndex( const bool isFortran, const std::string
buffer.m_DataPosition = dataPositions[0];
buffer.m_DataAbsolutePosition = dataAbsolutePositions[0];
metadataSet.PGIndexPosition = metadataPositions[0];
-
}
+
void BP1Writer::WriteProcessGroupIndex( const bool isFortran, const std::string name, const unsigned int processID,
const std::string timeStepName, const unsigned int timeStep,
const std::vector< std::shared_ptr<Transport> >& transports,
diff --git a/src/functions/adiosFunctions.cpp b/src/functions/adiosFunctions.cpp
index e0ec7ce420ff8a132bce14f589cb7336eb0d630a..fa18131dea59adab2f6277ed3846e34fa3932603 100644
--- a/src/functions/adiosFunctions.cpp
+++ b/src/functions/adiosFunctions.cpp
@@ -9,6 +9,7 @@
#include <fstream>
#include <sstream>
#include <stdexcept>
+#include <ios> //std::ios_base::failure
#include <thread> //std::thread
#include <cstring> //std::memcpy
#include <algorithm> //std::count
diff --git a/src/transport/POSIX.cpp b/src/transport/file/FD.cpp
similarity index 85%
rename from src/transport/POSIX.cpp
rename to src/transport/file/FD.cpp
index bf7c40b6e0d94dcbd491c7038b03418c7ba0ddec..8f2ef36e0cd41eee53c24cfb7f8ce73fe7af2c47 100644
--- a/src/transport/POSIX.cpp
+++ b/src/transport/file/FD.cpp
@@ -1,5 +1,5 @@
/*
- * POSIX.cpp
+ * FD.cpp file descriptor
*
* Created on: Oct 6, 2016
* Author: wfg
@@ -15,19 +15,20 @@
/// \endcond
-#include "transport/POSIX.h"
+#include "transport/file/FD.h"
namespace adios
{
+namespace transport
+{
-
-POSIX::POSIX( MPI_Comm mpiComm, const bool debugMode ):
- Transport( "POSIX", mpiComm, debugMode )
+FD::FD( MPI_Comm mpiComm, const bool debugMode ):
+ Transport( "FD", mpiComm, debugMode )
{ }
-POSIX::~POSIX( )
+FD::~FD( )
{
if( m_FileDescriptor != -1 )
{
@@ -36,7 +37,7 @@ POSIX::~POSIX( )
}
-void POSIX::Open( const std::string name, const std::string accessMode )
+void FD::Open( const std::string name, const std::string accessMode )
{
m_Name = name;
m_AccessMode = accessMode;
@@ -63,7 +64,7 @@ void POSIX::Open( const std::string name, const std::string accessMode )
}
-void POSIX::Write( const char* buffer, std::size_t size )
+void FD::Write( const char* buffer, std::size_t size )
{
auto writtenSize = write( m_FileDescriptor, buffer, size );
@@ -82,7 +83,7 @@ void POSIX::Write( const char* buffer, std::size_t size )
}
-void POSIX::Close( )
+void FD::Close( )
{
int status = close( m_FileDescriptor );
@@ -95,4 +96,5 @@ void POSIX::Close( )
}
+} //end namespace transport
}//end namespace
diff --git a/src/transport/File.cpp b/src/transport/file/FP.cpp
similarity index 74%
rename from src/transport/File.cpp
rename to src/transport/file/FP.cpp
index 4a5f9f3cb68051e2723fdde74ea44401f6597859..b9f1e26d2f652bb889fbf036ac3ba4d5f28bd2c0 100644
--- a/src/transport/File.cpp
+++ b/src/transport/file/FP.cpp
@@ -1,32 +1,37 @@
/*
- * File.cpp
+ * FP.cpp
*
* Created on: Jan 6, 2017
* Author: wfg
*/
+/// \cond EXCLUDE_FROM_DOXYGEN
#include <ios> //std::ios_base::failure
+/// \endcond
-#include "transport/File.h"
+
+#include "transport/file/FP.h"
namespace adios
{
+namespace transport
+{
-File::File( MPI_Comm mpiComm, const bool debugMode ):
+FP::FP( MPI_Comm mpiComm, const bool debugMode ):
Transport( "File", mpiComm, debugMode )
{ }
-File::~File( )
+FP::~FP( )
{
if( m_File != NULL )
fclose( m_File );
}
-void File::Open( const std::string name, const std::string accessMode )
+void FP::Open( const std::string name, const std::string accessMode )
{
m_Name = name;
m_AccessMode = accessMode;
@@ -49,7 +54,7 @@ void File::Open( const std::string name, const std::string accessMode )
}
-void File::SetBuffer( char* buffer, std::size_t size )
+void FP::SetBuffer( char* buffer, std::size_t size )
{
int status = setvbuf( m_File, buffer, _IOFBF, size );
@@ -62,7 +67,7 @@ void File::SetBuffer( char* buffer, std::size_t size )
}
-void File::Write( const char* buffer, std::size_t size )
+void FP::Write( const char* buffer, std::size_t size )
{
fwrite( buffer, sizeof(char), size, m_File );
@@ -70,22 +75,22 @@ void File::Write( const char* buffer, std::size_t size )
{
if( ferror( m_File ) )
throw std::ios_base::failure( "ERROR: couldn't write to file " + m_Name +
- ", in call to File write\n" );
+ ", in call to FP write\n" );
}
}
-void File::Flush( )
+void FP::Flush( )
{
fflush( m_File );
}
-void File::Close( )
+void FP::Close( )
{
fclose( m_File );
}
-
+} //end namespace transport
} //end namespace
diff --git a/src/transport/FStream.cpp b/src/transport/file/FStream.cpp
similarity index 90%
rename from src/transport/FStream.cpp
rename to src/transport/file/FStream.cpp
index c299a639ebdca4f970a18172f0d1801dc22b55a3..e471b2f6a61184aa0ca66588725010b811e37137 100644
--- a/src/transport/FStream.cpp
+++ b/src/transport/file/FStream.cpp
@@ -9,11 +9,13 @@
#include <stdexcept>
/// \endcond
-#include "transport/FStream.h"
+#include "transport/file/FStream.h"
namespace adios
{
+namespace transport
+{
FStream::FStream( MPI_Comm mpiComm, const bool debugMode ):
@@ -60,8 +62,7 @@ void FStream::Write( const char* buffer, std::size_t size )
if( m_DebugMode == true )
{
if( !m_FStream )
- throw std::ios_base::failure( "ERROR: couldn't write to file " + m_Name +
- ", in call to FStream write\n" );
+ throw std::ios_base::failure( "ERROR: couldn't write to file " + m_Name + ", in call to FStream write\n" );
}
}
@@ -78,5 +79,6 @@ void FStream::Close( )
}
+} //end namespace transport
} //end namespace
diff --git a/src/transport/MdtmMan.cpp b/src/transport/wan/MdtmMan.cpp
similarity index 95%
rename from src/transport/MdtmMan.cpp
rename to src/transport/wan/MdtmMan.cpp
index a043647a399437de84a7903878e1ca32489a0791..6df6b1951c763519db378426a6b2a2a8f8f030ea 100644
--- a/src/transport/MdtmMan.cpp
+++ b/src/transport/wan/MdtmMan.cpp
@@ -7,13 +7,14 @@
-#include "transport/MdtmMan.h"
+#include "transport/wan/MdtmMan.h"
namespace adios
{
-
+namespace transport
+{
MdtmMan::MdtmMan( const std::string localIP, const std::string remoteIP, const std::string mode, const std::string prefix,
const int numberOfPipes, const std::vector<int> tolerances, const std::vector<int> priorities,
@@ -91,5 +92,5 @@ void MdtmMan::OnReceive( nlohmann::json& jData )
-
+} //end namespace transport
} //end namespace