diff --git a/doc/CodingGuidelines b/doc/CodingGuidelines
index 270bee0db8b57cad89202f2a7ee308ed25b23ddf..9f378bf44ea6d82375695ad00894583951cfb23d 100644
--- a/doc/CodingGuidelines
+++ b/doc/CodingGuidelines
@@ -27,7 +27,7 @@ Objectives:
C++ coding guidelines, all mandatory in no particular order:
-Text style for readability (Coding format setup in Eclipse with Window > Preferences > C/C++ > CodeStyle > Formatters )
+Text style for readability ( using clang-format, 80 columns line width )
1) Use meaningful English words (time not t, rank not r or rk), well-known acronyms (MPI, XML, CFD, GMRES, etc.)
or well-known short names (Config, Comm, 2D, 3D).
Examples: timeInitial instead of tIni, or work instead of wrk
@@ -35,43 +35,26 @@ Text style for readability (Coding format setup in Eclipse with Window > Prefere
2) Avoid "_" in names, adds unnecessary length (specially when mixed with STL containers) to the variable name and could conflict with name mangling.
Reserve it for prefix of special cases (see class members and lambda functions).
Use upper case letter instead:
- Don't: std::vector< std::vector<double> > this_is_my_very_very_long_two_dimensional_vector_name
- Do: std::vector< std::vector<double> > thisIsMyVeryVeryLongTwoDimensionalVectorName
-
-3) Use 4 spaces instead of tab. Tab behaves different in other editors (vi, emacs, gedit, slickedit, code blocks, etc.)
-4) Use 4 spaces for nested logic structure indentation (like in Python), Eclipse has a CTRL+I option to set it automatically.
- if( number1 < 1 )
- {
- if( number2 < 2 )
- {
- ....
- }
- }
-
-
-5) Brackets: use an extra space for brackets. Only one line conditionals can skip having brackets.
- Do:
- if( number < 1 )
- {
- number = 4;
- ...
- }
-
- Don't:
- if( number < 1 ){
- number = 4; .....
- .....}
-
- It's ok to omit brackets in one line conditionals:
- if( itMap == map.end() ) throw std::invalid_argument( "ERROR: not found in map\n" );
-
-6) Prefer the keyword "using" over "typedef". Only rename very long complex or custom types,
+
+ Don't: std::vector< std::vector<double> >
+ this_is_my_very_very_long_two_dimensional_vector_name;
+
+ Do: std::vector< std::vector<double> >
+ thisIsMyVeryVeryLongTwoDimensionalVectorName;
+
+3) Prefer the keyword "using" over "typedef". Only rename very long complex or custom types,
do not rename standard types (int, double, std::vector)
Don't: typedef std::vector<std::vector< std::map<std::string,double> >> MapIn2DVector;
Do: using std::vector<std::vector< std::map<std::string,double> >> = MapIn2DVector;
See 1) for Exception: when redefining long types with the keyword "using"
some mnemonics and short names are allowed, document scope of using (local, class, file, etc.), though
+
+4) The project uses ADIOS2 clang-format: http://releases.llvm.org/3.8.0/tools/clang/docs/ClangFormatStyleOptions.html
+ See Contributing.md for more information. In summary:
+ Lines no longer than 80 characters.
+ Always use braces { and }, even for 1 line "if" blocks and loops ("for", "while", etc.)
+ Use 4 spaces for indentation.
Documentation/Comments
@@ -108,8 +91,6 @@ Classes / Structs
1) Classes will be initialized with an upper case letter, example: ( ADIOS, NETCDF, PHDF5, Transform, Group, etc. )
2) Class member variables will use hungarian notation "m_" prefix followed an upper case letter: m_XMLConfig, m_GlobalSize. While member functions will have the same rules as regular functions (e.g. start with an upper case letter).
3) Reserve structs for public member variables only, Structs should not have member functions, inheritance or private members. Structs will be initialized with an upper case letter and member variables won't use hungarian notation as classes.
-
-
4) Only allow one header and one source file per class ( e.g. class Transport in Transport.h and Transport.cpp), do not define several classes in the same file.
Structs are always define in one header file, ( e.g. Attribute in Attribute.h )
One EXCEPTION: structs with static member variables, which must be defined in a source (*.cpp) file
@@ -144,12 +125,12 @@ const / constexpr correctness, macro, and include statements
4) Use const in function arguments (value or references) if the state of the argument is not changed.
5) Always use include guards in headers (*.h), Eclipse does it automatically at file creation
using the file name.
- (e.g. in CADIOS.h start with #ifndef CADIOS_H_
- #define CADIOS_H_ )
+ (e.g. in ADIOS.h start with #ifndef ADIOS_H_
+ #define ADIOS_H_ )
6) Only include header files at the beginning of the file (#include <cmath>). Make each *.h file self-contained.
Don't include the same header file in *.cpp already defined in an included *.h file.
- Example: if cmath is included in CADIOS.h, which is included by CADIOS.cpp,
- then don't include cmath in CADIOS.cpp
+ Example: if cmath is included in ADIOS.h, which is included by ADIOS.cpp,
+ then don't include cmath in ADIOS.cpp
Avoid mixing C-like equivalents
diff --git a/examples/heatTransfer/IO_adios2.cpp b/examples/heatTransfer/IO_adios2.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aea0493ca7dfbbea62f9568f63c4a289bbaa1bba
--- /dev/null
+++ b/examples/heatTransfer/IO_adios2.cpp
@@ -0,0 +1,115 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * IO_ADIOS2.cpp
+ *
+ * Created on: Feb 2017
+ * Author: Norbert Podhorszki
+ */
+
+#include "IO.h"
+#include "ADIOS_CPP.h"
+
+#include <string>
+
+static int rank_saved;
+adios::ADIOS *ad = nullptr;
+std::shared_ptr<adios::Engine> bpWriter;
+adios::Variable<double> *varT = nullptr;
+
+IO::IO(const Settings &s, MPI_Comm comm)
+{
+ rank_saved = s.rank;
+ m_outputfilename = s.outputfile + ".bp";
+ ad = new adios::ADIOS("adios2.xml", comm, adios::Verbose::INFO);
+
+ // Define method for engine creation
+ // 1. Get method def from config file or define new one
+
+ adios::Method &bpWriterSettings = ad->DeclareMethod("output");
+ if (!bpWriterSettings.IsUserDefined())
+ {
+ // if not defined by user, we can change the default settings
+ bpWriterSettings.SetEngine("BP"); // BP is the default engine
+ bpWriterSettings.AllowThreads(
+ 1); // allow 1 extra thread for data processing
+ bpWriterSettings.AddTransport(
+ "File", "lucky=yes"); // ISO-POSIX file is the default transport
+ // Passing parameters to the transport
+ bpWriterSettings.SetParameters(
+ "have_metadata_file",
+ "yes"); // Passing parameters to the engine
+ bpWriterSettings.SetParameters(
+ "Aggregation",
+ std::to_string((s.nproc + 1) / 2)); // number of aggregators
+ }
+
+ // define T as 2D global array
+ varT = &ad->DefineVariable<double>(
+ "T", {s.gndx, s.gndy}, // Global dimensions
+ {s.ndx,
+ s.ndy}, // local size, could be defined later using SetSelection()
+ {s.offsx, s.offsy} // offset of the local array in the global space
+ );
+
+ // add transform to variable
+ // adios::Transform tr = adios::transform::BZIP2( );
+ // varT.AddTransform( tr, "" );
+ // varT.AddTransform( tr,"accuracy=0.001" ); // for ZFP
+
+ bpWriter = ad->Open(m_outputfilename, "w", comm, bpWriterSettings);
+
+ // ad->Open(m_outputfilename, "w", comm, bpWriterSettings);
+
+ if (bpWriter == nullptr)
+ throw std::ios_base::failure("ERROR: failed to open ADIOS bpWriter\n");
+}
+
+IO::~IO()
+{
+ bpWriter->Close();
+ delete ad;
+}
+
+void /*IO::*/ old_style_write(int step, const HeatTransfer &ht,
+ const Settings &s, MPI_Comm comm)
+{
+ bpWriter->Write<double>(*varT, ht.data_noghost().data());
+ bpWriter->Advance();
+}
+
+void IO::write(int step, const HeatTransfer &ht, const Settings &s,
+ MPI_Comm comm)
+{
+ /* This selection is redundant and not required, since we defined
+ * the selection already in DefineVariable(). It is here just as an example.
+ */
+ // Make a selection to describe the local dimensions of the variable we
+ // write
+ // and
+ // its offsets in the global spaces. This could have been done in
+ // adios.DefineVariable()
+ adios::Selection sel = adios.SelectionBoundingBox(
+ {s.ndx, s.ndy},
+ {s.offsx, s.offsy}); // local dims and offsets; both as list
+ var2D.SetSelection(sel);
+
+ /* Select the area that we want to write from the data pointer we pass to
+ the
+ writer.
+ Think HDF5 memspace, just not hyperslabs, only a bounding box selection.
+ Engine will copy this bounding box from the data pointer into the output
+ buffer.
+ Size of the bounding box should match the "space" selection which was
+ given
+ above.
+ Default memspace is always the full selection.
+ */
+ adios::Selection memspace =
+ adios.SelectionBoundingBox({s.ndx, s.ndy}, {1, 1});
+ var2D.SetMemorySelection(memspace);
+
+ bpWriter->Write<double>(*varT, ht.data());
+ bpWriter->Advance();
+}
diff --git a/examples/heatTransfer/write/IO_adios2.cpp b/examples/heatTransfer/write/IO_adios2.cpp
index 8af454f718bb406174c7e116018eafb000eb28e4..72d118ea15748e2d9852879ccc7f519f184ba72f 100644
--- a/examples/heatTransfer/write/IO_adios2.cpp
+++ b/examples/heatTransfer/write/IO_adios2.cpp
@@ -28,30 +28,29 @@ IO::IO(const Settings &s, MPI_Comm comm)
// 1. Get method def from config file or define new one
adios::Method &bpWriterSettings = ad->DeclareMethod("output");
- if (!bpWriterSettings.isUserDefined())
+ if (!bpWriterSettings.IsUserDefined())
{
// if not defined by user, we can change the default settings
bpWriterSettings.SetEngine("BPFileWriter"); // BP is the default engine
- bpWriterSettings.AllowThreads(
- 1); // allow 1 extra thread for data processing
+ bpWriterSettings.AllowThreads(1); // for data processing
+
bpWriterSettings.AddTransport(
"File", "lucky=yes"); // ISO-POSIX file is the default transport
// Passing parameters to the transport
- bpWriterSettings.SetParameters(
- "have_metadata_file",
- "yes"); // Passing parameters to the engine
- bpWriterSettings.SetParameters(
- "Aggregation",
- std::to_string((s.nproc + 1) / 2)); // number of aggregators
+
+ const std::string aggregatorsParam("Aggregators=" +
+ std::to_string((s.nproc + 1) / 2));
+ bpWriterSettings.SetParameters("have_metadata_file=yes",
+ aggregatorsParam);
}
// define T as 2D global array
varT = &ad->DefineVariable<double>(
"T",
- // Global dimensions
- {s.gndx, s.gndy},
// local size, could be defined later using SetSelection()
{s.ndx, s.ndy},
+ // Global dimensions
+ {s.gndx, s.gndy},
// offset of the local array in the global space
{s.offsx, s.offsy});
@@ -60,8 +59,7 @@ IO::IO(const Settings &s, MPI_Comm comm)
// varT.AddTransform( tr, "" );
// varT.AddTransform( tr,"accuracy=0.001" ); // for ZFP
- bpWriter = ad->Open(m_outputfilename, "w", comm, bpWriterSettings,
- adios::IOMode::COLLECTIVE);
+ bpWriter = ad->Open(m_outputfilename, "w", comm, bpWriterSettings);
if (bpWriter == nullptr)
throw std::ios_base::failure("ERROR: failed to open ADIOS bpWriter\n");
diff --git a/examples/hello/bpWriter/helloBPWriter.cpp b/examples/hello/bpWriter/helloBPWriter.cpp
index 29d46647d65a0673ff523d234a56a415df115aaf..6dc601b17ba973c57d4a642197f34c0793d9ab86 100644
--- a/examples/hello/bpWriter/helloBPWriter.cpp
+++ b/examples/hello/bpWriter/helloBPWriter.cpp
@@ -18,8 +18,10 @@
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
- int rank;
+ int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+ MPI_Comm_size(MPI_COMM_WORLD, &size);
+
const bool adiosDebug = true;
adios::ADIOS adios(MPI_COMM_WORLD, adios::Verbose::INFO, adiosDebug);
@@ -49,8 +51,10 @@ int main(int argc, char *argv[])
// Define variable and local size
adios::Variable<double> &ioMyDoubles =
adios.DefineVariable<double>("myDoubles", {Nx});
+
adios::Variable<float> &ioMyMatrix =
adios.DefineVariable<float>("myMatrix", {rows, columns});
+
adios::Variable<float> &ioMyMatrix2 =
adios.DefineVariable<float>("myMatrix2", {rows, columns});
@@ -66,8 +70,7 @@ int main(int argc, char *argv[])
// 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,
- adios::IOMode::COLLECTIVE);
+ auto bpWriter = adios.Open("myDoubles.bp", "w", bpWriterSettings);
if (bpWriter == nullptr)
throw std::ios_base::failure(
diff --git a/examples/hello/bpWriter/helloBPWriter_nompi.cpp b/examples/hello/bpWriter/helloBPWriter_nompi.cpp
index 7c8b7ee24119d01ea4cc32ce4b72af09b789603b..68e3fcf6a79548e893939d24e264861b89861168 100644
--- a/examples/hello/bpWriter/helloBPWriter_nompi.cpp
+++ b/examples/hello/bpWriter/helloBPWriter_nompi.cpp
@@ -54,8 +54,7 @@ int main(int /*argc*/, char ** /*argv*/)
// Open returns a smart pointer to Engine containing the Derived class
// Writer
auto bpFileWriter =
- adios.Open("myDoubles_nompi.bp", "w", bpWriterSettings,
- adios::IOMode::COLLECTIVE);
+ adios.Open("myDoubles_nompi.bp", "w", bpWriterSettings);
if (bpFileWriter == nullptr)
{
diff --git a/examples/hello/datamanWriter/helloDataManWriter.cpp b/examples/hello/datamanWriter/helloDataManWriter.cpp
index c4d7ac1ad5e14820d15cdcea74bc99cec3bebefa..c6894ed08557c237aef3953a217172504a0a9066 100644
--- a/examples/hello/datamanWriter/helloDataManWriter.cpp
+++ b/examples/hello/datamanWriter/helloDataManWriter.cpp
@@ -43,7 +43,7 @@ int main(int argc, char *argv[])
// Define method for engine creation, it is basically straight-forward
// parameters
adios::Method &datamanSettings = adios.DeclareMethod("WAN");
- if (!datamanSettings.isUserDefined())
+ if (!datamanSettings.IsUserDefined())
{
// if not defined by user, we can change the default settings
datamanSettings.SetEngine("DataManWriter");
@@ -72,8 +72,7 @@ int main(int argc, char *argv[])
// adios::DataManWriter datamanWriter;
- auto datamanWriter = adios.Open("myDoubles.bp", "w", datamanSettings,
- adios::IOMode::INDEPENDENT);
+ auto datamanWriter = adios.Open("myDoubles.bp", "w", datamanSettings);
if (datamanWriter == nullptr)
throw std::ios_base::failure(
diff --git a/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp b/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
index d6b1e3068f6447cd2985fb16b5983227972230cf..fa7158c37011db4a33088b714a925627348cb925 100644
--- a/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
+++ b/examples/hello/datamanWriter/helloDataManWriter_nompi.cpp
@@ -44,7 +44,7 @@ int main(int argc, char *argv[])
// Define method for engine creation, it is basically straight-forward
// parameters
adios::Method &datamanSettings = adios.DeclareMethod("WAN");
- if (!datamanSettings.isUserDefined())
+ if (!datamanSettings.IsUserDefined())
{
// if not defined by user, we can change the default settings
datamanSettings.SetEngine("DataManWriter");
@@ -63,8 +63,7 @@ int main(int argc, char *argv[])
// Create engine smart pointer to DataMan Engine due to polymorphism,
// Open returns a smart pointer to Engine containing the Derived class
// DataMan
- auto datamanWriter = adios.Open("myDoubles.bp", "w", datamanSettings,
- adios::IOMode::INDEPENDENT);
+ auto datamanWriter = adios.Open("myDoubles.bp", "w", datamanSettings);
if (datamanWriter == nullptr)
throw std::ios_base::failure(
diff --git a/examples/hello/timeBP/timeBPWriter.cpp b/examples/hello/timeBP/timeBPWriter.cpp
index b9ae445debe12905c0614549778632eb32758a6b..3bcff1b4376a3157bb262ee60095a4dcf684b88c 100644
--- a/examples/hello/timeBP/timeBPWriter.cpp
+++ b/examples/hello/timeBP/timeBPWriter.cpp
@@ -49,8 +49,10 @@ int main(int argc, char *argv[])
// Define variable and local size
adios::Variable<double> &ioMyDoubles =
adios.DefineVariable<double>("myDoubles", {Nx});
+
adios::Variable<float> &ioMyMatrix =
adios.DefineVariable<float>("myMatrix", {rows, columns});
+
adios::Variable<float> &ioMyMatrix2 =
adios.DefineVariable<float>("myMatrix2", {rows, columns});
diff --git a/include/ADIOS.h b/include/ADIOS.h
index 56a469c3ee7a7e62abc6ec10f5b61821e55fd4b0..e389c9bdd42a5eaa18342dbfb8b4dccb0d5d40a0 100644
--- a/include/ADIOS.h
+++ b/include/ADIOS.h
@@ -2,11 +2,9 @@
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*
- * ADIOS.h
- *
+ * ADIOS.\ *
* Created on: Oct 3, 2016
- * Author: wfg
- */
+ * Author: wfg`123 */
#ifndef ADIOS_H_
#define ADIOS_H_
@@ -43,15 +41,16 @@ class Engine;
class ADIOS
{
public:
- MPI_Comm m_MPIComm = MPI_COMM_SELF; ///< only used as reference to MPI
- /// communicator passed from parallel
- /// constructor, MPI_Comm is a pointer
- /// itself. Public as called from C
+ /**
+ * Passed from parallel constructor, MPI_Comm is a pointer itself.
+ * Public as called from C
+ */
+ MPI_Comm m_MPIComm = MPI_COMM_SELF;
int m_RankMPI = 0; ///< current MPI rank process
int m_SizeMPI = 1; ///< current MPI processes size
- std::string m_HostLanguage = "C++";
+ std::string m_HostLanguage = "C++"; ///< changed by language bindings
/**
* @brief ADIOS empty constructor. Used for non XML config file API calls.
@@ -61,21 +60,22 @@ public:
/**
* @brief Serial constructor for config file, only allowed and compiled in
* libadios_nompi.a
- * @param config XML config file
+ * @param configFile XML config file (maybe support different formats in the
+ * future?)
* @param debugMode true: on throws exceptions and do additional checks,
* false: off (faster, but unsafe)
*/
- ADIOS(std::string config, const Verbose verbose = Verbose::WARN,
+ ADIOS(const std::string configFile, const Verbose verbose = Verbose::WARN,
const bool debugMode = false);
/**
* @brief Parallel constructor for XML config file and MPI
- * @param config XML config file
+ * @param config XML config file (maybe support different formats in the
+ * future?)
* @param mpiComm MPI communicator ...const to be discussed
* @param debugMode true: on, false: off (faster, but unsafe)
*/
-
- ADIOS(std::string config, MPI_Comm mpiComm,
+ ADIOS(const std::string configFile, MPI_Comm mpiComm,
const Verbose verbose = Verbose::WARN, const bool debugMode = false);
/**
@@ -91,28 +91,27 @@ public:
void InitMPI(); ///< sets rank and size in m_rank and m_Size, respectively.
/**
- * Look for template specialization
- * @param name
+ * Define a Variable for I/O. Default is a local scalar to be compatible
+ * with ADIOS1
+ * @param name variable name, must be unique
* @param dimensions
- * @param globalDimensions
- * @param globalOffsets
- * @return
+ * @param selections
+ * @param offsets
+ * @return reference to Variable object
*/
template <class T>
Variable<T> &DefineVariable(const std::string &name,
- const Dims dimensions = Dims{1},
- const Dims globalDimensions = Dims(),
- const Dims globalOffsets = Dims());
+ const Dims localDimensions = Dims{1},
+ const Dims globalDimensions = Dims{},
+ const Dims offsets = Dims{});
template <class T>
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());
+ VariableCompound &DefineVariableCompound(
+ const std::string &name, const Dims globalDimensions = Dims{},
+ const Dims localDimensions = Dims{1}, const Dims offsets = Dims{});
VariableCompound &GetVariableCompound(const std::string &name);
@@ -126,7 +125,7 @@ public:
* Use method.isUserDefined() to distinguish between the two cases.
* @param methodName must be unique
*/
- Method &DeclareMethod(const std::string &methodName);
+ Method &DeclareMethod(const std::string methodName);
/**
* @brief Open to Write, Read. Creates a new engine from previously defined
@@ -147,10 +146,8 @@ public:
* shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open(const std::string &streamName,
- const std::string &accessMode,
- MPI_Comm mpiComm, const Method &method,
- const IOMode iomode = IOMode::INDEPENDENT,
- const float timeout_sec = 0.0);
+ const std::string accessMode, MPI_Comm mpiComm,
+ const Method &method);
/**
* @brief Open to Write, Read. Creates a new engine from previously defined
@@ -169,10 +166,8 @@ public:
* shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open(const std::string &streamName,
- const std::string &accessMode,
- const Method &method,
- const IOMode iomode = IOMode::INDEPENDENT,
- const float timeout_sec = 0.0);
+ const std::string accessMode,
+ const Method &method);
/**
* Version required by the XML config file implementation, searches method
@@ -190,11 +185,8 @@ public:
* shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open(const std::string &streamName,
- const std::string &accessMode,
- MPI_Comm mpiComm,
- const std::string &methodName,
- const IOMode iomode = IOMode::INDEPENDENT,
- const float timeout_sec = 0.0);
+ const std::string accessMode, MPI_Comm mpiComm,
+ const std::string methodName);
/**
* Version required by the XML config file implementation, searches method
@@ -212,10 +204,8 @@ public:
* shared_ptr for potential flexibility
*/
std::shared_ptr<Engine> Open(const std::string &streamName,
- const std::string &accessMode,
- const std::string &methodName,
- const IOMode iomode = IOMode::INDEPENDENT,
- const float timeout_sec = 0.0);
+ const std::string accessMode,
+ const std::string methodName);
/**
* @brief Open to Read all steps from a file. No streaming, advancing is
@@ -233,10 +223,9 @@ public:
* @return Derived class of base Engine depending on Method parameters,
* shared_ptr for potential flexibility
*/
- std::shared_ptr<Engine>
- OpenFileReader(const std::string &fileName, MPI_Comm mpiComm,
- const Method &method,
- const IOMode iomode = IOMode::INDEPENDENT);
+ std::shared_ptr<Engine> OpenFileReader(const std::string &fileName,
+ MPI_Comm mpiComm,
+ const Method &method);
/**
* @brief Open to Read all steps from a file. No streaming, advancing is
@@ -254,10 +243,9 @@ public:
* @return Derived class of base Engine depending on Method parameters,
* shared_ptr for potential flexibility
*/
- std::shared_ptr<Engine>
- OpenFileReader(const std::string &fileName, MPI_Comm mpiComm,
- const std::string &methodName,
- const IOMode iomode = IOMode::INDEPENDENT);
+ std::shared_ptr<Engine> OpenFileReader(const std::string &fileName,
+ MPI_Comm mpiComm,
+ const std::string methodName);
/**
* @brief Dumps groups information to a file stream or standard output.
@@ -334,7 +322,7 @@ protected: // no const to allow default empty and copy constructors
std::map<std::string,
std::pair<std::string, unsigned int>>::const_iterator
itVariable,
- const std::string &name, const std::string &hint) const;
+ const std::string &name, const std::string hint) const;
/**
* @brief Checks for method existence in m_Methods, if failed throws
@@ -344,15 +332,15 @@ protected: // no const to allow default empty and copy constructors
* @param hint adds information to thrown exception
*/
void CheckMethod(std::map<std::string, Method>::const_iterator itMethod,
- const std::string &methodName,
- const std::string &hint) const;
+ const std::string methodName,
+ const std::string hint) const;
template <class T>
unsigned int GetVariableIndex(const std::string &name);
// Helper function for DefineVariable
template <class T>
- std::map<unsigned int, Variable<T>> &GetVarMap();
+ std::map<unsigned int, Variable<T>> &GetVariableMap();
};
// Explicit declaration of the template methods
@@ -363,7 +351,7 @@ protected: // no const to allow default empty and copy constructors
extern template unsigned int ADIOS::GetVariableIndex<T>( \
const std::string &name); \
template <> \
- std::map<unsigned int, Variable<T>> &ADIOS::GetVarMap<T>();
+ std::map<unsigned int, Variable<T>> &ADIOS::GetVariableMap<T>();
ADIOS_FOREACH_TYPE_1ARG(declare_template_instantiation)
extern template unsigned int ADIOS::GetVariableIndex<void>(const std::string &);
#undef declare_template_instantiation
diff --git a/include/capsule/heap/STLVector.h b/include/capsule/heap/STLVector.h
index 35adb47188b1739a3c0fc114b16a009bbb67f65b..18c7f348d2dd84a2688313b7c4e70138c75b4ec7 100644
--- a/include/capsule/heap/STLVector.h
+++ b/include/capsule/heap/STLVector.h
@@ -41,7 +41,8 @@ public:
* @param rankMPI MPI rank
* @param debugMode true: extra checks, slower
*/
- STLVector(std::string accessMode, int rankMPI, bool debugMode = false);
+ STLVector(const std::string accessMode, const int rankMPI,
+ const bool debugMode = false);
~STLVector() = default;
diff --git a/include/core/Capsule.h b/include/core/Capsule.h
index 8993025f50dd2cc513ba6b868b42cde3ec06f490..609aab8471b21ca8178d91f0e6c64127f9f024d3 100644
--- a/include/core/Capsule.h
+++ b/include/core/Capsule.h
@@ -30,12 +30,11 @@ public:
const std::string m_Type; ///< buffer type
const std::string m_AccessMode; ///< 'w': write, 'r': read, 'a': append
- size_t m_DataPosition = 0; ///< position in current data buffer (not
- /// included data flushed to transports)
- size_t m_DataAbsolutePosition =
- 0; ///< includes the data flushed to transports
+ std::size_t m_DataPosition = 0; ///< position in current data buffer (not
+ /// included data flushed to transports)
+ std::size_t m_DataAbsolutePosition = 0; ///< include bytes flushed
- size_t m_MetadataPosition = 0; ///< position in metadata buffer
+ std::size_t m_MetadataPosition = 0; ///< position in metadata buffer
/**
* Base class constructor providing type from derived class and accessMode
@@ -44,8 +43,8 @@ public:
* @param rankMPI current MPI rank
* @param debugMode
*/
- Capsule(std::string type, std::string accessMode, int rankMPI,
- bool debugMode);
+ Capsule(const std::string type, const std::string accessMode,
+ const int rankMPI, const bool debugMode);
virtual ~Capsule() = default;
@@ -53,12 +52,11 @@ public:
virtual char *
GetMetadata() = 0; ///< return the pointer to the raw metadata buffer
- virtual size_t GetDataSize() const = 0; ///< get current data buffer size
- virtual size_t
- GetMetadataSize() const = 0; ///< get current metadata buffer size
+ virtual std::size_t GetDataSize() const = 0; ///< data buffer size
+ virtual std::size_t GetMetadataSize() const = 0; ///< metadata buffer size
- virtual void ResizeData(size_t size); ///< resize data buffer
- virtual void ResizeMetadata(size_t size); ///< resize metadata buffer
+ virtual void ResizeData(std::size_t size); ///< resize data buffer
+ virtual void ResizeMetadata(std::size_t size); ///< resize metadata buffer
protected:
const int m_RankMPI = 0; ///< current MPI rank
diff --git a/include/core/Engine.h b/include/core/Engine.h
index 7b3f3fede5803acb574c995180acb368fce51a6f..31fce6ca8ca62bbea20c08979eb78a5161abdad2 100644
--- a/include/core/Engine.h
+++ b/include/core/Engine.h
@@ -12,7 +12,8 @@
#define ENGINE_H_
/// \cond EXCLUDE_FROM_DOXYGEN
-#include <complex> //std::complex
+#include <complex> //std::complex
+#include <functional> //std::function
#include <map>
#include <memory> //std::shared_ptr
#include <string>
@@ -26,7 +27,6 @@
#include "ADIOSTypes.h"
#include "core/Capsule.h"
#include "core/Method.h"
-#include "core/Profiler.h"
#include "core/Transform.h"
#include "core/Transport.h"
#include "core/Variable.h"
@@ -73,20 +73,16 @@ public:
* @param accessMode
* @param mpiComm
* @param method
- * @param debugMode
- * @param nthreads
* @param endMessage
*/
- Engine(ADIOS &adios, std::string engineType, std::string name,
- std::string accessMode, MPI_Comm mpiComm, const Method &method,
- bool debugMode, unsigned int nthreads, std::string endMessage);
+ Engine(ADIOS &adios, const std::string engineType, const std::string &name,
+ const std::string accessMode, MPI_Comm mpiComm, const Method &method,
+ const std::string endMessage);
virtual ~Engine() = default;
/** @brief Let ADIOS allocate memory for a variable, which can be used by
- * the
- * user.
- *
+ * the user.
* To decrease the cost of copying memory, a user may let ADIOS allocate the
* memory for a user-variable,
* according to the definition of an ADIOS-variable. The memory will be part
@@ -95,11 +91,9 @@ public:
* A variable that has been allocated this way (cannot have its local
* dimensions changed, and AdvanceAsync() should be
* used instead of Advance() and the user-variable must not be modified by
- * the
- * application until the notification arrives.
+ * the application until the notification arrives.
* This is required so that any reader can access the written data before
- * the
- * application overwrites it.
+ * the application overwrites it.
* @param var Variable with defined local dimensions and offsets in global
* space
* @param fillValue Fill the allocated array with this value
@@ -391,7 +385,7 @@ public:
* Indicates that a new step is going to be written as new variables come
* in.
*/
- virtual void Advance(float timeout_sec = 0.0);
+ virtual void Advance(const float timeout_sec = 0.0);
/**
* Indicates that a new step is going to be written as new variables come
@@ -399,7 +393,7 @@ public:
* @param mode Advance mode, there are different options for writers and
* readers
*/
- virtual void Advance(AdvanceMode mode, float timeout_sec = 0.0);
+ virtual void Advance(AdvanceMode mode, const float timeout_sec = 0.0);
/** @brief Advance asynchronously and get a callback when readers release
* access to the buffered step.
@@ -427,42 +421,70 @@ public:
* @return success: it returns a pointer to the internal stored variable
* object in ADIOS class, failure: nullptr
*/
- virtual Variable<void> *InquireVariable(const std::string name,
+ virtual Variable<void> *InquireVariable(const std::string &variableName,
const bool readIn = true);
- virtual Variable<char> *InquireVariableChar(const std::string name,
+ virtual Variable<char> *InquireVariableChar(const std::string &variableName,
const bool readIn = true);
virtual Variable<unsigned char> *
- InquireVariableUChar(const std::string name, const bool readIn = true);
- virtual Variable<short> *InquireVariableShort(const std::string name,
- const bool readIn = true);
+ InquireVariableUChar(const std::string &variableName,
+ const bool readIn = true);
+ virtual Variable<short> *
+ InquireVariableShort(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<unsigned short> *
- InquireVariableUShort(const std::string name, const bool readIn = true);
- virtual Variable<int> *InquireVariableInt(const std::string name,
+ InquireVariableUShort(const std::string &variableName,
+ const bool readIn = true);
+
+ virtual Variable<int> *InquireVariableInt(const std::string &variableName,
const bool readIn = true);
virtual Variable<unsigned int> *
- InquireVariableUInt(const std::string name, const bool readIn = true);
- virtual Variable<long int> *InquireVariableLInt(const std::string name,
- const bool readIn = true);
+ InquireVariableUInt(const std::string &variableName,
+ const bool readIn = true);
+
+ virtual Variable<long int> *
+ InquireVariableLInt(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<unsigned long int> *
- InquireVariableULInt(const std::string name, const bool readIn = true);
+ InquireVariableULInt(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<long long int> *
- InquireVariableLLInt(const std::string name, const bool readIn = true);
+ InquireVariableLLInt(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<unsigned long long int> *
- InquireVariableULLInt(const std::string name, const bool readIn = true);
- virtual Variable<float> *InquireVariableFloat(const std::string name,
- const bool readIn = true);
- virtual Variable<double> *InquireVariableDouble(const std::string name,
- const bool readIn = true);
+ InquireVariableULLInt(const std::string &variableName,
+ const bool readIn = true);
+
+ virtual Variable<float> *
+ InquireVariableFloat(const std::string &variableName,
+ const bool readIn = true);
+
+ virtual Variable<double> *
+ InquireVariableDouble(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<long double> *
- InquireVariableLDouble(const std::string name, const bool readIn = true);
+ InquireVariableLDouble(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<std::complex<float>> *
- InquireVariableCFloat(const std::string name, const bool readIn = true);
+ InquireVariableCFloat(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<std::complex<double>> *
- InquireVariableCDouble(const std::string name, const bool readIn = true);
+ InquireVariableCDouble(const std::string &variableName,
+ const bool readIn = true);
+
virtual Variable<std::complex<long double>> *
- InquireVariableCLDouble(const std::string name, const bool readIn = true);
- virtual VariableCompound *InquireVariableCompound(const std::string name,
- const bool readIn = true);
+ InquireVariableCLDouble(const std::string &variableName,
+ const bool readIn = true);
+
+ virtual VariableCompound *
+ InquireVariableCompound(const std::string &variableName,
+ const bool readIn = true);
/** Return the names of all variables present in a stream/file opened for
* reading
@@ -471,42 +493,36 @@ public:
*/
std::vector<std::string> VariableNames();
- virtual void
- Close(const int transportIndex =
- -1) = 0; ///< Closes a particular transport, or all if -1
+ /**
+ * Closes a particular transport, or all if -1
+ * @param transportIndex order from Method AddTransport
+ */
+ virtual void Close(const int transportIndex = -1) = 0;
protected:
- ADIOS
- &m_ADIOS; ///< reference to ADIOS object that creates this Engine at Open
+ ADIOS &m_ADIOS; ///< creates Engine at Open
std::vector<std::shared_ptr<Transport>>
- m_Transports; ///< transports managed
- const bool m_DebugMode =
- false; ///< true: additional checks, false: by-pass checks
- unsigned int m_nThreads = 0;
+ m_Transports; ///< transports managed
+ const bool m_DebugMode = false; ///< true: additional exceptions checks
+ unsigned int m_nThreads = 0; ///< from Method nthreads
const std::string
m_EndMessage; ///< added to exceptions to improve debugging
- std::set<std::string> m_WrittenVariables; ///< contains the names of the
- /// variables that are being written
+ std::set<std::string> m_WrittenVariables;
- virtual void
- Init(); ///< Initialize m_Capsules and m_Transports, called from constructor
- virtual void
- InitParameters(); ///< Initialize parameters from Method, called
- /// from Initi in constructor
- virtual void
- InitTransports(); ///< Initialize transports from Method, called
- /// from Init in constructor
+ virtual void Init(); ///< Initialize m_Capsules and m_Transports
+ virtual void InitParameters(); ///< Initialize parameters from Method
+ virtual void InitTransports(); ///< Initialize transports from Method
/**
* Used to verify parameters in m_Method containers
- * @param itParam iterator to a certain parameter
+ * @param itParameter iterator to a certain parameter
* @param parameters map of parameters, from m_Method
* @param parameterName used if exception is thrown to provide debugging
* information
* @param hint used if exception is thrown to provide debugging information
*/
void CheckParameter(
- const std::map<std::string, std::string>::const_iterator itParam,
+ const std::map<std::string, std::string>::const_iterator itParameter,
const std::map<std::string, std::string> ¶meters,
const std::string parameterName, const std::string hint) const;
diff --git a/include/core/Method.h b/include/core/Method.h
index c1e60c151f5769948ae3a3f29a365ae6d7254e05..dc40806126f6da99aac4cc03be2479c62f00eecc 100644
--- a/include/core/Method.h
+++ b/include/core/Method.h
@@ -44,10 +44,12 @@ class Method
public:
const std::string m_Name; ///< Method name (as defined in XML)
const bool m_DebugMode = false; ///< true: on, throws exceptions and do
- /// additional checks, false: off, faster, but
+ /// additional checks, false: off, faster
/// unsafe
- int m_nThreads;
- std::string m_Type; ///< Method's engine type
+ std::string m_Type; ///< Method's engine type
+ unsigned int m_nThreads = 1;
+ adios::IOMode m_IOMode = adios::IOMode::INDEPENDENT;
+
std::map<std::string, std::string> m_Parameters; ///< method parameters
std::vector<std::map<std::string, std::string>>
m_TransportParameters; ///< each is a separate Transport containing
@@ -59,16 +61,16 @@ public:
* @param name is a label that can be used in the config file to set up the
* method at runtime
*/
- Method(std::string name, bool debugMode = false);
+ Method(const std::string name, const bool debugMode = false);
- ~Method() = default;
+ ~Method();
/** Check if the method was defined by the user in the config file.
* @return true if the method was user-defined, false otherwise when method
* is
* set with default parameters
*/
- bool isUserDefined();
+ bool IsUserDefined();
/**
* Define the engine type
@@ -88,9 +90,9 @@ public:
* Set this parameter like you set it for OpenMP, i.e. count one thread for
* the main process that calls
* ADIOS functions.
- * @param number of threads, minimum 1 is required
+ * @param nThreads, minimum 1 is required
*/
- void AllowThreads(const int nThreads);
+ void AllowThreads(const unsigned int nThreads);
/**
* Sets parameters for the method in "parameter=value" format
diff --git a/include/core/Profiler.h b/include/core/Profiler.h
deleted file mode 100644
index 7d804665bcc121ce355f200e4de0fc35460df5df..0000000000000000000000000000000000000000
--- a/include/core/Profiler.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Distributed under the OSI-approved Apache License, Version 2.0. See
- * accompanying file Copyright.txt for details.
- *
- * Profiler.h
- *
- * Created on: Mar 9, 2017
- * Author: wfg
- */
-
-#ifndef PROFILER_H_
-#define PROFILER_H_
-
-#include <chrono>
-
-#include "Support.h"
-
-namespace adios
-{
-
-class Timer
-{
-
-public:
- const std::string Process;
- unsigned long long int ProcessTime = 0;
-
- Timer(const std::string process, const Support::Resolutions resolution)
- : Process{process}, Resolution{resolution}
- {
- }
-
- void SetInitialTime()
- {
- InitialTime = std::chrono::high_resolution_clock::now();
- }
-
- void SetTime()
- {
- ElapsedTime = std::chrono::high_resolution_clock::now();
- ProcessTime += GetTime();
- }
-
- long long int GetTime()
- {
- if (Resolution == Support::Resolutions::mus)
- return std::chrono::duration_cast<std::chrono::microseconds>(
- ElapsedTime - InitialTime)
- .count();
-
- else if (Resolution == Support::Resolutions::ms)
- return std::chrono::duration_cast<std::chrono::milliseconds>(
- ElapsedTime - InitialTime)
- .count();
-
- else if (Resolution == Support::Resolutions::s)
- return std::chrono::duration_cast<std::chrono::seconds>(
- ElapsedTime - InitialTime)
- .count();
-
- else if (Resolution == Support::Resolutions::m)
- return std::chrono::duration_cast<std::chrono::minutes>(
- ElapsedTime - InitialTime)
- .count();
-
- else if (Resolution == Support::Resolutions::h)
- return std::chrono::duration_cast<std::chrono::hours>(ElapsedTime -
- InitialTime)
- .count();
-
- return -1; // failure
- }
-
- std::string GetUnits() const
- {
- std::string units;
- if (Resolution == Support::Resolutions::mus)
- units = "mus";
- else if (Resolution == Support::Resolutions::ms)
- units = "ms";
- else if (Resolution == Support::Resolutions::s)
- units = "s";
- else if (Resolution == Support::Resolutions::m)
- units = "m";
- else if (Resolution == Support::Resolutions::h)
- units = "h";
- return units;
- }
-
-private:
- const Support::Resolutions Resolution;
- std::chrono::time_point<std::chrono::high_resolution_clock> InitialTime;
- std::chrono::time_point<std::chrono::high_resolution_clock> ElapsedTime;
- bool InitialTimeSet = false;
-};
-
-/**
- * Utilities for profiling using the chrono header in C++11
- */
-struct Profiler
-{
- std::vector<Timer> m_Timers;
- std::vector<unsigned long long int> m_TotalBytes;
- bool m_IsActive = false;
-};
-
-} // end namespace
-
-#endif /* PROFILER_H_ */
diff --git a/include/core/Transport.h b/include/core/Transport.h
index 798a0db145aff5aecb9e05f0a4ab8c52149a5963..aa4c67b29ac4f4380d06e68e95ce9c96c7b86caf 100644
--- a/include/core/Transport.h
+++ b/include/core/Transport.h
@@ -16,9 +16,9 @@
#include <vector>
/// \endcond
-#include "ADIOS_MPI.h"
+#include "utilities/profiling/iochrono/IOChrono.h"
-#include "core/Profiler.h"
+#include "ADIOS_MPI.h"
namespace adios
{
@@ -34,10 +34,9 @@ public:
MPI_Comm m_MPIComm = MPI_COMM_SELF;
- int m_RankMPI = 0; ///< current MPI rank process
- int m_SizeMPI = 1; ///< current MPI processes size
- Profiler
- m_Profiler; ///< collects information about Open and bytes Transport
+ int m_RankMPI = 0; ///< current MPI rank process
+ int m_SizeMPI = 1; ///< current MPI processes size
+ profiling::IOChrono m_Profiler; ///< profiles Open, Write/Read, Close
/**
* Base constructor that all derived classes pass
@@ -45,7 +44,7 @@ public:
* @param mpiComm passed to m_MPIComm
* @param debugMode passed to m_DebugMode
*/
- Transport(std::string type, MPI_Comm mpiComm, bool debugMode);
+ Transport(const std::string type, MPI_Comm mpiComm, const bool debugMode);
virtual ~Transport() = default;
@@ -54,7 +53,8 @@ public:
* @param name name of stream or file
* @param accessMode r or read, w or write, a or append
*/
- virtual void Open(const std::string name, const std::string accessMode) = 0;
+ virtual void Open(const std::string &name,
+ const std::string accessMode) = 0;
/**
* Set buffer and size for a particular transport
@@ -77,12 +77,16 @@ public:
virtual void Close(); ///< closes current transport and flushes everything,
/// transport becomes unreachable
+ /**
+ * Inits the profiler
+ * @param accessMode
+ * @param resolution
+ */
virtual void InitProfiler(const std::string accessMode,
const Support::Resolutions resolution);
protected:
- const bool m_DebugMode =
- false; ///< if true: additional checks and exceptions
+ const bool m_DebugMode = false; ///< true: turn on exceptions
};
} // end namespace adios
diff --git a/include/core/Variable.h b/include/core/Variable.h
index cc932a484eebbe35c7c4e911b37587f548ecf120..ca91c790f73c96d9e8673b7aa17e57459da2bf29 100644
--- a/include/core/Variable.h
+++ b/include/core/Variable.h
@@ -26,7 +26,7 @@ namespace adios
struct TransformData
{
- Transform &Operation; ///< pointer to transform object
+ Transform &Operation; ///< from ADIOS.DefineTransform
std::map<std::string, std::string> Parameters; ///< transforms parameters
std::vector<std::size_t> Size; ///< vector that carries the sizes after a
/// transformation is applied
@@ -51,13 +51,13 @@ public:
/// Transforms[1]. Pointer used as
/// reference (no memory management).
- Variable<T>(const std::string name, const Dims dimensions,
- const Dims globalDimensions, const Dims globalOffsets,
+ Variable<T>(const std::string &name, const Dims localDimensions,
+ const Dims globalDimensions, const Dims offsets,
const bool debugMode)
- : VariableBase(name, GetType<T>(), sizeof(T), dimensions, globalDimensions,
- globalOffsets, debugMode)
+ : VariableBase(name, GetType<T>(), sizeof(T), localDimensions,
+ globalDimensions, offsets, debugMode)
{
- if (m_Dimensions == Dims{1})
+ if (m_LocalDimensions == Dims{1})
m_IsScalar = true;
}
diff --git a/include/core/VariableBase.h b/include/core/VariableBase.h
index 415458610149e9f115f3d003765996292945170e..49bb98a1e45e55f95664ec18d84326d220f6bf70 100644
--- a/include/core/VariableBase.h
+++ b/include/core/VariableBase.h
@@ -19,7 +19,7 @@
#include <vector>
/// \endcond
-#include "functions/adiosFunctions.h" //GetTotalSize, ConvertUint64VectorToSizetVector
+#include "functions/adiosFunctions.h" //GetTotalSize, DimsToCSV, ConvertUint64VectorToSizetVector
#include "functions/adiosTemplates.h" //GetType<T>
#include "selection/SelectionBoundingBox.h" //Selection
@@ -34,26 +34,38 @@ 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
+ /**
+ * Variable -> sizeof(T),
+ * VariableCompound -> from constructor sizeof(struct)
+ */
+ const std::size_t m_ElementSize;
+
+ Dims m_LocalDimensions; ///< dimensions per rank (MPI)
+ Dims m_GlobalDimensions; ///< total dimensions across MPI
+ Dims m_Offsets; ///< selections offset
+ Dims m_MemoryDimensions; ///< array of memory dimensions
+ Dims m_MemoryOffsets; ///< array of memory offsets
bool m_IsScalar = false;
const bool m_IsDimension = false;
+ const bool m_DebugMode = false;
- VariableBase(const std::string name, const std::string type,
- const std::size_t elementSize, const Dims dimensions,
- const Dims globalDimensions, const Dims globalOffsets,
+ VariableBase(const std::string &name, const std::string type,
+ const std::size_t elementSize, const Dims localDimensions,
+ const Dims globalDimensions, const Dims offsets,
const bool debugMode)
: m_Name{name}, m_Type{type}, m_ElementSize{elementSize},
- m_Dimensions{dimensions}, m_GlobalDimensions{globalDimensions},
- m_GlobalOffsets{globalOffsets}, m_DebugMode{debugMode}
+ m_LocalDimensions{localDimensions}, m_GlobalDimensions{globalDimensions},
+ m_Offsets{offsets}, m_DebugMode{debugMode}
{
}
virtual ~VariableBase() {}
- std::size_t DimensionsSize() const noexcept { return m_Dimensions.size(); }
+ std::size_t DimensionsSize() const noexcept
+ {
+ return m_LocalDimensions.size();
+ }
/**
* Returns the payload size in bytes
@@ -61,7 +73,7 @@ public:
*/
std::size_t PayLoadSize() const noexcept
{
- return GetTotalSize(m_Dimensions) * m_ElementSize;
+ return GetTotalSize(m_LocalDimensions) * m_ElementSize;
}
/**
@@ -70,7 +82,7 @@ public:
*/
std::size_t TotalSize() const noexcept
{
- return GetTotalSize(m_Dimensions);
+ return GetTotalSize(m_LocalDimensions);
}
/**
@@ -80,7 +92,6 @@ public:
*/
void SetSelection(const SelectionBoundingBox &sel)
{
-
if (m_GlobalDimensions.size() == 0)
{
throw std::invalid_argument("Variable.SetSelection() is an invalid "
@@ -93,8 +104,8 @@ public:
"dimension of the variable\n");
}
- ConvertUint64VectorToSizetVector(sel.m_Count, m_Dimensions);
- ConvertUint64VectorToSizetVector(sel.m_Start, m_GlobalOffsets);
+ ConvertUint64VectorToSizetVector(sel.m_Count, m_LocalDimensions);
+ ConvertUint64VectorToSizetVector(sel.m_Start, m_Offsets);
}
/**
@@ -121,38 +132,8 @@ public:
ConvertUint64VectorToSizetVector(sel.m_Count, m_MemoryDimensions);
ConvertUint64VectorToSizetVector(sel.m_Start, m_MemoryOffsets);
}
-
- // 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
- Dims m_MemoryDimensions; ///< array of memory dimensions
- Dims m_MemoryOffsets; ///< array of memory offsets
- const bool m_DebugMode = false;
-
- std::string GetDimensionAsString() { return dimsToString(m_Dimensions); }
- std::string GetGlobalDimensionAsString()
- {
- return dimsToString(m_GlobalDimensions);
- }
- std::string GetOffsetsAsString() { return dimsToString(m_GlobalOffsets); }
-
-private:
- std::string dimsToString(Dims dims)
- {
- std::ostringstream oss;
- if (!dims.empty())
- {
- // Convert all but the last element to avoid a trailing ","
- std::copy(dims.begin(), dims.end() - 1,
- std::ostream_iterator<std::size_t>(oss, ","));
- // Now add the last element with no delimiter
- oss << dims.back();
- }
- return oss.str();
- }
};
-}
+
+} // end namespace
#endif /* VARIABLEBASE_H_ */
diff --git a/include/engine/adios1/ADIOS1Reader.h b/include/engine/adios1/ADIOS1Reader.h
index 041887ba9150ea625da4dc92548188130e5067cb..53fb32bec3f8cf8c09ef7584c4f06213ed47bfba 100644
--- a/include/engine/adios1/ADIOS1Reader.h
+++ b/include/engine/adios1/ADIOS1Reader.h
@@ -46,48 +46,46 @@ public:
* @param debugMode
* @param hostLanguage
*/
- ADIOS1Reader(ADIOS &adios, const std::string name,
+ ADIOS1Reader(ADIOS &adios, const std::string &name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode = false,
- const unsigned int nthreads = 1);
+ const Method &method);
~ADIOS1Reader();
- Variable<void> *InquireVariable(const std::string name,
+ Variable<void> *InquireVariable(const std::string &name,
const bool readIn = true);
- Variable<char> *InquireVariableChar(const std::string name,
+ Variable<char> *InquireVariableChar(const std::string &name,
const bool readIn = true);
- Variable<unsigned char> *InquireVariableUChar(const std::string name,
+ Variable<unsigned char> *InquireVariableUChar(const std::string &name,
const bool readIn = true);
- Variable<short> *InquireVariableShort(const std::string name,
+ Variable<short> *InquireVariableShort(const std::string &name,
const bool readIn = true);
- Variable<unsigned short> *InquireVariableUShort(const std::string name,
+ Variable<unsigned short> *InquireVariableUShort(const std::string &name,
const bool readIn = true);
- Variable<int> *InquireVariableInt(const std::string name,
+ Variable<int> *InquireVariableInt(const std::string &name,
const bool readIn = true);
- Variable<unsigned int> *InquireVariableUInt(const std::string name,
+ Variable<unsigned int> *InquireVariableUInt(const std::string &name,
const bool readIn = true);
- Variable<long int> *InquireVariableLInt(const std::string name,
+ Variable<long int> *InquireVariableLInt(const std::string &name,
const bool readIn = true);
- Variable<unsigned long int> *InquireVariableULInt(const std::string name,
+ Variable<unsigned long int> *InquireVariableULInt(const std::string &name,
const bool readIn = true);
- Variable<long long int> *InquireVariableLLInt(const std::string name,
+ Variable<long long int> *InquireVariableLLInt(const std::string &name,
const bool readIn = true);
Variable<unsigned long long int> *
- InquireVariableULLInt(const std::string name, const bool readIn = true);
- Variable<float> *InquireVariableFloat(const std::string name,
+ InquireVariableULLInt(const std::string &name, const bool readIn = true);
+ Variable<float> *InquireVariableFloat(const std::string &name,
const bool readIn = true);
- Variable<double> *InquireVariableDouble(const std::string name,
+ Variable<double> *InquireVariableDouble(const std::string &name,
const bool readIn = true);
- Variable<long double> *InquireVariableLDouble(const std::string name,
+ Variable<long double> *InquireVariableLDouble(const std::string &name,
const bool readIn = true);
Variable<std::complex<float>> *
- InquireVariableCFloat(const std::string name, const bool readIn = true);
+ InquireVariableCFloat(const std::string &name, const bool readIn = true);
Variable<std::complex<double>> *
- InquireVariableCDouble(const std::string name, const bool readIn = true);
+ InquireVariableCDouble(const std::string &name, const bool readIn = true);
Variable<std::complex<long double>> *
- InquireVariableCLDouble(const std::string name, const bool readIn = true);
+ InquireVariableCLDouble(const std::string &name, const bool readIn = true);
/**
* Not implemented
@@ -95,7 +93,7 @@ public:
* @param readIn
* @return
*/
- VariableCompound *InquireVariableCompound(const std::string name,
+ VariableCompound *InquireVariableCompound(const std::string &name,
const bool readIn = true);
void Close(const int transportIndex = -1);
@@ -105,7 +103,7 @@ private:
/// transport method from settings
template <class T>
- Variable<T> *InquireVariableCommon(const std::string name,
+ Variable<T> *InquireVariableCommon(const std::string &name,
const bool readIn)
{
std::cout << "Hello ADIOS1Reader::InquireVariableCommon\n";
diff --git a/include/engine/adios1/ADIOS1Writer.h b/include/engine/adios1/ADIOS1Writer.h
index 0a3ebff9b83bbb99e53d9d49196834c5944ddb06..11a9eb313440eda2e2deba1c820d1f61989bc05a 100644
--- a/include/engine/adios1/ADIOS1Writer.h
+++ b/include/engine/adios1/ADIOS1Writer.h
@@ -38,11 +38,9 @@ public:
* @param method
* @param debugMode
*/
- ADIOS1Writer(ADIOS &adios, const std::string name,
+ ADIOS1Writer(ADIOS &adios, const std::string &name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode = false,
- const unsigned int nthreads = 1);
+ const Method &method);
~ADIOS1Writer();
@@ -70,29 +68,30 @@ public:
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);
- void Write(const std::string variableName, const short *values);
- void Write(const std::string variableName, const unsigned short *values);
- void Write(const std::string variableName, const int *values);
- void Write(const std::string variableName, const unsigned int *values);
- void Write(const std::string variableName, const long int *values);
- void Write(const std::string variableName, const unsigned long int *values);
- void Write(const std::string variableName, const long long int *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName, const char *values);
+ void Write(const std::string &variableName, const unsigned char *values);
+ void Write(const std::string &variableName, const short *values);
+ void Write(const std::string &variableName, const unsigned short *values);
+ void Write(const std::string &variableName, const int *values);
+ void Write(const std::string &variableName, const unsigned int *values);
+ void Write(const std::string &variableName, const long int *values);
+ void Write(const std::string &variableName,
+ const unsigned long int *values);
+ void Write(const std::string &variableName, const long long int *values);
+ void Write(const std::string &variableName,
const unsigned long long int *values);
- 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,
+ 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,
+ void Write(const std::string &variableName,
const std::complex<double> *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName,
const std::complex<long double> *values);
- void Write(const std::string variableName, const void *values);
+ void Write(const std::string &variableName, const void *values);
- void Advance();
+ void Advance(const float timeout_sec = 0.);
/**
* Closes a single transport or all transports
diff --git a/include/engine/bp/BPFileReader.h b/include/engine/bp/BPFileReader.h
index 74ef5e6a4e8ff91a78b2a08154a1b862eaf5045b..538be9fc3b446c5b09cd798a4c640c09d51813d2 100644
--- a/include/engine/bp/BPFileReader.h
+++ b/include/engine/bp/BPFileReader.h
@@ -15,7 +15,6 @@
#include "core/Engine.h"
-// supported capsules
#include "capsule/heap/STLVector.h"
namespace adios
@@ -36,47 +35,70 @@ public:
* @param debugMode
* @param hostLanguage
*/
- BPFileReader(ADIOS &adios, std::string name, std::string accessMode,
- MPI_Comm mpiComm, const Method &method, IOMode iomode,
- float timeout_sec, bool debugMode = false,
- unsigned int nthreads = 1);
+ BPFileReader(ADIOS &adios, const std::string &name,
+ const std::string accessMode, MPI_Comm mpiComm,
+ const Method &method);
virtual ~BPFileReader() = default;
- Variable<void> *InquireVariable(const std::string name,
+ Variable<void> *InquireVariable(const std::string &variableName,
const bool readIn = true);
- Variable<char> *InquireVariableChar(const std::string name,
+
+ Variable<char> *InquireVariableChar(const std::string &variableName,
const bool readIn = true);
- Variable<unsigned char> *InquireVariableUChar(const std::string name,
- const bool readIn = true);
- Variable<short> *InquireVariableShort(const std::string name,
+
+ Variable<unsigned char> *
+ InquireVariableUChar(const std::string &variableName,
+ const bool readIn = true);
+
+ Variable<short> *InquireVariableShort(const std::string &variableName,
const bool readIn = true);
- Variable<unsigned short> *InquireVariableUShort(const std::string name,
- const bool readIn = true);
- Variable<int> *InquireVariableInt(const std::string name,
+
+ Variable<unsigned short> *
+ InquireVariableUShort(const std::string &variableName,
+ const bool readIn = true);
+
+ Variable<int> *InquireVariableInt(const std::string &variableName,
const bool readIn = true);
- Variable<unsigned int> *InquireVariableUInt(const std::string name,
+
+ Variable<unsigned int> *InquireVariableUInt(const std::string &variableName,
const bool readIn = true);
- Variable<long int> *InquireVariableLInt(const std::string name,
+
+ Variable<long int> *InquireVariableLInt(const std::string &variableName,
const bool readIn = true);
- Variable<unsigned long int> *InquireVariableULInt(const std::string name,
- const bool readIn = true);
- Variable<long long int> *InquireVariableLLInt(const std::string name,
- const bool readIn = true);
+
+ Variable<unsigned long int> *
+ InquireVariableULInt(const std::string &variableName,
+ const bool readIn = true);
+
+ Variable<long long int> *
+ InquireVariableLLInt(const std::string &variableName,
+ const bool readIn = true);
+
Variable<unsigned long long int> *
- InquireVariableULLInt(const std::string name, const bool readIn = true);
- Variable<float> *InquireVariableFloat(const std::string name,
+ InquireVariableULLInt(const std::string &variableName,
+ const bool readIn = true);
+
+ Variable<float> *InquireVariableFloat(const std::string &variableName,
const bool readIn = true);
- Variable<double> *InquireVariableDouble(const std::string name,
+
+ Variable<double> *InquireVariableDouble(const std::string &variableName,
const bool readIn = true);
- Variable<long double> *InquireVariableLDouble(const std::string name,
- const bool readIn = true);
+ Variable<long double> *
+ InquireVariableLDouble(const std::string &variableName,
+ const bool readIn = true);
+
Variable<std::complex<float>> *
- InquireVariableCFloat(const std::string name, const bool readIn = true);
+ InquireVariableCFloat(const std::string &variableName,
+ const bool readIn = true);
+
Variable<std::complex<double>> *
- InquireVariableCDouble(const std::string name, const bool readIn = true);
+ InquireVariableCDouble(const std::string &variableName,
+ const bool readIn = true);
+
Variable<std::complex<long double>> *
- InquireVariableCLDouble(const std::string name, const bool readIn = true);
+ InquireVariableCLDouble(const std::string &variableName,
+ const bool readIn = true);
/**
* Not implemented
@@ -84,7 +106,7 @@ public:
* @param readIn
* @return
*/
- VariableCompound *InquireVariableCompound(const std::string name,
+ VariableCompound *InquireVariableCompound(const std::string &variableName,
const bool readIn = true);
void Close(const int transportIndex = -1);
@@ -98,7 +120,7 @@ private:
void Init(); ///< calls InitCapsules and InitTransports based on Method,
/// called from constructor
- void InitCapsules();
+
void InitTransports(); ///< from Transports
std::string
@@ -106,7 +128,7 @@ private:
const std::map<std::string, std::string> &mdtmParameters);
template <class T>
- Variable<T> *InquireVariableCommon(const std::string name,
+ Variable<T> *InquireVariableCommon(const std::string &name,
const bool readIn)
{
std::cout << "Hello BPReaderCommon\n";
diff --git a/include/engine/bp/BPFileWriter.h b/include/engine/bp/BPFileWriter.h
index 97db293c0defacf50cbced0b0ae84870c8e374c5..74ae04ce816096e62825bf047c5659bdd742fce6 100644
--- a/include/engine/bp/BPFileWriter.h
+++ b/include/engine/bp/BPFileWriter.h
@@ -11,12 +11,9 @@
#ifndef BPFILEWRITER_H_
#define BPFILEWRITER_H_
-#include "core/Engine.h"
-#include "format/BP1Aggregator.h"
-#include "format/BP1Writer.h"
-
-// supported capsules
#include "capsule/heap/STLVector.h"
+#include "core/Engine.h"
+#include "utilities/format/bp1/BP1.h"
namespace adios
{
@@ -34,12 +31,10 @@ public:
* @param method
* @param debugMode
*/
- BPFileWriter(ADIOS &adios, std::string name, const std::string &accessMode,
- MPI_Comm mpiComm, const Method &method,
- const IOMode iomode = IOMode::INDEPENDENT,
- const float timeout_sec = 0., const bool debugMode = false,
- const unsigned int nthreads = 1);
+ BPFileWriter(ADIOS &adios, const std::string &name,
+ const std::string accessMode, MPI_Comm mpiComm,
+ const Method &method);
~BPFileWriter();
void Write(Variable<char> &variable, const char *values);
@@ -66,27 +61,28 @@ public:
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);
- void Write(const std::string variableName, const short *values);
- void Write(const std::string variableName, const unsigned short *values);
- void Write(const std::string variableName, const int *values);
- void Write(const std::string variableName, const unsigned int *values);
- void Write(const std::string variableName, const long int *values);
- void Write(const std::string variableName, const unsigned long int *values);
- void Write(const std::string variableName, const long long int *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName, const char *values);
+ void Write(const std::string &variableName, const unsigned char *values);
+ void Write(const std::string &variableName, const short *values);
+ void Write(const std::string &variableName, const unsigned short *values);
+ void Write(const std::string &variableName, const int *values);
+ void Write(const std::string &variableName, const unsigned int *values);
+ void Write(const std::string &variableName, const long int *values);
+ void Write(const std::string &variableName,
+ const unsigned long int *values);
+ void Write(const std::string &variableName, const long long int *values);
+ void Write(const std::string &variableName,
const unsigned long long int *values);
- 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,
+ 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,
+ void Write(const std::string &variableName,
const std::complex<double> *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName,
const std::complex<long double> *values);
- void Write(const std::string variableName, const void *values);
+ void Write(const std::string &variableName, const void *values);
void Advance(float timeout_sec = 0.0);
@@ -120,8 +116,8 @@ private:
float m_GrowthFactor = 1.5; ///< capsule memory growth factor, new_memory =
/// m_GrowthFactor * current_memory
- bool m_TransportFlush =
- false; ///< true: transport flush happened, buffer must be reset
+ bool m_TransportFlush = false; ///< true: due to buffer overflow
+
bool m_CloseProcessGroup =
false; ///< set to true if advance is called, this
/// prevents flattening the data and metadata
@@ -143,8 +139,8 @@ private:
template <class T>
void WriteVariableCommon(Variable<T> &variable, const T *values)
{
- if (m_MetadataSet.Log.m_IsActive == true)
- m_MetadataSet.Log.m_Timers[0].SetInitialTime();
+ if (m_MetadataSet.Log.IsActive == true)
+ m_MetadataSet.Log.Timers[0].SetInitialTime();
// set variable
variable.m_AppValues = values;
@@ -181,8 +177,8 @@ private:
variable.m_AppValues =
nullptr; // setting pointer to null as not needed after write
- if (m_MetadataSet.Log.m_IsActive == true)
- m_MetadataSet.Log.m_Timers[0].SetTime();
+ if (m_MetadataSet.Log.IsActive == true)
+ m_MetadataSet.Log.Timers[0].SetTime();
}
};
diff --git a/include/engine/dataman/DataManReader.h b/include/engine/dataman/DataManReader.h
index 061d2713c2e70d828a563d96574d6ad91eb19b0d..6ed82a5982071e80bcb19e30426ac8f4acad0ba8 100644
--- a/include/engine/dataman/DataManReader.h
+++ b/include/engine/dataman/DataManReader.h
@@ -14,7 +14,7 @@
#include <iostream> //std::cout << Needs to go
#include "core/Engine.h"
-#include "format/BP1Writer.h"
+#include "utilities/format/bp1/BP1Writer.h"
// supported capsules
#include "capsule/heap/STLVector.h"
@@ -40,9 +40,7 @@ public:
*/
DataManReader(ADIOS &adios, const std::string name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode = false,
- const unsigned int nthreads = 1);
+ const Method &method);
~DataManReader();
@@ -117,7 +115,6 @@ private:
void Init(); ///< calls InitCapsules and InitTransports based on Method,
/// called from constructor
- void InitCapsules();
void InitTransports(); ///< from Transports
std::string
diff --git a/include/engine/dataman/DataManWriter.h b/include/engine/dataman/DataManWriter.h
index 3ca32bb3dad5f8e5b186d717c86a1609c16e0fa2..ec2392cf702cea65413f889fae38688e139888a2 100644
--- a/include/engine/dataman/DataManWriter.h
+++ b/include/engine/dataman/DataManWriter.h
@@ -15,7 +15,7 @@
#include <unistd.h> //sleep must be removed
#include "core/Engine.h"
-#include "format/BP1Writer.h"
+#include "utilities/format/bp1/BP1Writer.h"
// supported capsules
#include "capsule/heap/STLVector.h"
@@ -41,9 +41,7 @@ public:
*/
DataManWriter(ADIOS &adios, const std::string name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode = false,
- const unsigned int nthreads = 1);
+ const Method &method);
~DataManWriter();
@@ -74,25 +72,26 @@ public:
void Write(Variable<std::complex<long double>> &variable,
const std::complex<long double> *values);
- void Write(const std::string variableName, const char *values);
- void Write(const std::string variableName, const unsigned char *values);
- void Write(const std::string variableName, const short *values);
- void Write(const std::string variableName, const unsigned short *values);
- void Write(const std::string variableName, const int *values);
- void Write(const std::string variableName, const unsigned int *values);
- void Write(const std::string variableName, const long int *values);
- void Write(const std::string variableName, const unsigned long int *values);
- void Write(const std::string variableName, const long long int *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName, const char *values);
+ void Write(const std::string &variableName, const unsigned char *values);
+ void Write(const std::string &variableName, const short *values);
+ void Write(const std::string &variableName, const unsigned short *values);
+ void Write(const std::string &variableName, const int *values);
+ void Write(const std::string &variableName, const unsigned int *values);
+ void Write(const std::string &variableName, const long int *values);
+ void Write(const std::string &variableName,
+ const unsigned long int *values);
+ void Write(const std::string &variableName, const long long int *values);
+ void Write(const std::string &variableName,
const unsigned long long int *values);
- 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,
+ 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,
+ void Write(const std::string &variableName,
const std::complex<double> *values);
- void Write(const std::string variableName,
+ void Write(const std::string &variableName,
const std::complex<long double> *values);
void Close(const int transportIndex = -1);
@@ -114,7 +113,6 @@ private:
void Init(); ///< calls InitCapsules and InitTransports based on Method,
/// called from constructor
- void InitCapsules();
void InitTransports(); ///< from Transports
/**
diff --git a/include/functions/adiosFunctions.h b/include/functions/adiosFunctions.h
index 4f33c22675b8ee7072f0c4917785e6fc1bfb6311..418a075781663a6e0abcfd60094fb4f73bccf141 100644
--- a/include/functions/adiosFunctions.h
+++ b/include/functions/adiosFunctions.h
@@ -188,6 +188,13 @@ std::vector<int> CSVToVectorInt(const std::string csv);
*/
void ConvertUint64VectorToSizetVector(const std::vector<std::uint64_t> &in,
std::vector<std::size_t> &out);
+/**
+ * Converts a vector of dimensions to a CSV string
+ * @param dims vector of dimensions
+ * @return comma separate value (CSV)
+ */
+std::string DimsToCSV(const std::vector<std::size_t> &dims);
+
/**
* Common strategy to check for heap buffer allocation for data and metadata
* typically calculated in Write
diff --git a/include/transport/file/FStream.h b/include/transport/file/FStream.h
index 7a54d040b7fd46b61bcdb890ef281e0bb749e39d..79c6737c460b20cf4af7cdcc905bab7bbd865283 100644
--- a/include/transport/file/FStream.h
+++ b/include/transport/file/FStream.h
@@ -33,7 +33,7 @@ public:
virtual ~FStream() = default;
- void Open(const std::string name, const std::string accessMode);
+ void Open(const std::string &name, const std::string accessMode);
void SetBuffer(char *buffer, std::size_t size);
diff --git a/include/transport/file/FileDescriptor.h b/include/transport/file/FileDescriptor.h
index 63d7a672114aa11e0968ca8a4355ec838fd011d0..812bdcadb6e8591665c4c4f0505121db715e58db 100644
--- a/include/transport/file/FileDescriptor.h
+++ b/include/transport/file/FileDescriptor.h
@@ -29,7 +29,7 @@ public:
~FileDescriptor();
- void Open(const std::string name, const std::string accessMode);
+ void Open(const std::string &name, const std::string accessMode);
void Write(const char *buffer, std::size_t size);
diff --git a/include/transport/file/FilePointer.h b/include/transport/file/FilePointer.h
index c1de95056ff85e0886d7d7aa0ed7e9f1707e42d7..0967e400b4cfe31009c092446617acecc5acd9f6 100644
--- a/include/transport/file/FilePointer.h
+++ b/include/transport/file/FilePointer.h
@@ -34,7 +34,7 @@ public:
~FilePointer();
- void Open(const std::string name, const std::string accessMode);
+ void Open(const std::string &name, const std::string accessMode);
void SetBuffer(char *buffer, std::size_t size);
diff --git a/include/utilities/format/bp1/BP1.h b/include/utilities/format/bp1/BP1.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1b394088ed27a85e9d7a9cd2a448a9cbd986146
--- /dev/null
+++ b/include/utilities/format/bp1/BP1.h
@@ -0,0 +1,18 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * BP1.h
+ *
+ * Created on: Apr 4, 2017
+ * Author: wfg
+ */
+
+#ifndef BP1_H_
+#define BP1_H_
+
+#include "utilities/format/bp1/BP1Aggregator.h"
+#include "utilities/format/bp1/BP1Structs.h"
+#include "utilities/format/bp1/BP1Writer.h"
+
+#endif /* BP1_H_ */
diff --git a/include/format/BP1Aggregator.h b/include/utilities/format/bp1/BP1Aggregator.h
similarity index 92%
rename from include/format/BP1Aggregator.h
rename to include/utilities/format/bp1/BP1Aggregator.h
index 0522975a19d843c929deeffc3c0c9076ca23779b..8682ba62b84c625b94fe28e93776e513310985d0 100644
--- a/include/format/BP1Aggregator.h
+++ b/include/utilities/format/bp1/BP1Aggregator.h
@@ -11,6 +11,10 @@
#ifndef BP1AGGREGATOR_H_
#define BP1AGGREGATOR_H_
+/// \cond EXCLUDE_FROM_DOXYGEN
+#include <string>
+/// \endcond
+
#include "ADIOS_MPI.h"
namespace adios
@@ -39,8 +43,7 @@ public:
/**
* Function that aggregates and writes (from rank = 0) profiling.log in
- * python
- * dictionary format
+ * python dictionary format
* @param rankLog contain rank profiling info to be aggregated
*/
void WriteProfilingLog(const std::string fileName,
diff --git a/include/format/BP1.h b/include/utilities/format/bp1/BP1Base.h
similarity index 70%
rename from include/format/BP1.h
rename to include/utilities/format/bp1/BP1Base.h
index 96b7253aa207e1f1d286b85aa24268e30bc58a36..bb5173103545477c79111b1abc38436cdb21bf46 100644
--- a/include/format/BP1.h
+++ b/include/utilities/format/bp1/BP1Base.h
@@ -8,20 +8,18 @@
* Author: wfg
*/
-#ifndef BP1_H_
-#define BP1_H_
+#ifndef BP1BASE_H_
+#define BP1BASE_H_
/// \cond EXCLUDE_FROM_DOXYGEN
#include <cstdint> //std::uintX_t
#include <memory> //std::shared_ptr
#include <unordered_map>
#include <vector>
-//#include <queue> //std::priority_queue to be added later
/// \endcond
+//#include <queue> //std::priority_queue to be added later
#include "ADIOS_MPI.h"
-
-#include "core/Profiler.h"
#include "core/Transport.h"
namespace adios
@@ -29,67 +27,10 @@ namespace adios
namespace format
{
-/**
- * Used for Variables and Attributes, needed in a container for characteristic
- * sets merge independently for each Variable or Attribute
- */
-struct BP1Index
-{
- std::vector<char> Buffer; ///< metadata variable index, start with 100Kb
- std::uint64_t Count = 0; ///< number of characteristics sets (time and
- /// spatial aggregation)
- const std::uint32_t MemberID;
-
- BP1Index(const std::uint32_t memberID) : MemberID{memberID}
- {
- Buffer.reserve(500);
- }
-};
-
-/**
- * Single struct that tracks metadata indices in bp format
- */
-struct BP1MetadataSet
-{
- std::uint32_t
- TimeStep; ///< current time step, updated with advance step, if
- /// append it will be updated to last, starts with one
- /// in ADIOS1
-
- BP1Index PGIndex = BP1Index(0); ///< single buffer for PGIndex
-
- // no priority for now
- std::unordered_map<std::string, BP1Index> VarsIndices; ///< key: variable
- /// name, value: bp
- /// metadata variable
- /// index
- std::unordered_map<std::string, BP1Index> AttributesIndices; ///< key:
- /// attribute
- /// name, value:
- /// bp metadata
- /// attribute
- /// index
-
- const unsigned int MiniFooterSize = 28; ///< from bpls reader
-
- // PG (relative) positions in Data buffer to be updated
- std::uint64_t DataPGCount = 0;
- std::size_t DataPGLengthPosition = 0; ///< current PG initial ( relative )
- /// position, needs to be updated in
- /// every advance step or init
- std::uint32_t DataPGVarsCount = 0; ///< variables in current PG
- std::size_t DataPGVarsCountPosition =
- 0; ///< current PG variable count ( relative ) position, needs to be
- /// updated in every advance step or init
- bool DataPGIsOpen = false;
-
- Profiler Log; ///< object that takes buffering profiling info
-};
-
/**
* Base class for BP1Writer and BP1Reader format
*/
-class BP1
+class BP1Base
{
public:
@@ -109,7 +50,7 @@ public:
* @param transport file I/O transport
*/
void OpenRankFiles(const std::string name, const std::string accessMode,
- Transport &transport) const;
+ Transport &file) const;
protected:
/**
@@ -272,59 +213,63 @@ protected:
// Moving template BP1Writer::GetDataType template specializations outside of
// the class
template <>
-inline std::int8_t BP1::GetDataType<char>() const noexcept
+inline std::int8_t BP1Base::GetDataType<char>() const noexcept
{
return type_byte;
}
+
template <>
-inline std::int8_t BP1::GetDataType<short>() const noexcept
+inline std::int8_t BP1Base::GetDataType<short>() const noexcept
{
return type_short;
}
+
template <>
-inline std::int8_t BP1::GetDataType<int>() const noexcept
+inline std::int8_t BP1Base::GetDataType<int>() const noexcept
{
return type_integer;
}
template <>
-inline std::int8_t BP1::GetDataType<long int>() const noexcept
+inline std::int8_t BP1Base::GetDataType<long int>() const noexcept
{
return type_long;
}
template <>
-inline std::int8_t BP1::GetDataType<unsigned char>() const noexcept
+inline std::int8_t BP1Base::GetDataType<unsigned char>() const noexcept
{
return type_unsigned_byte;
}
template <>
-inline std::int8_t BP1::GetDataType<unsigned short>() const noexcept
+inline std::int8_t BP1Base::GetDataType<unsigned short>() const noexcept
{
return type_unsigned_short;
}
template <>
-inline std::int8_t BP1::GetDataType<unsigned int>() const noexcept
+inline std::int8_t BP1Base::GetDataType<unsigned int>() const noexcept
{
return type_unsigned_integer;
}
template <>
-inline std::int8_t BP1::GetDataType<unsigned long int>() const noexcept
+inline std::int8_t BP1Base::GetDataType<unsigned long int>() const noexcept
{
return type_unsigned_long;
}
template <>
-inline std::int8_t BP1::GetDataType<float>() const noexcept
+inline std::int8_t BP1Base::GetDataType<float>() const noexcept
{
return type_real;
}
+
template <>
-inline std::int8_t BP1::GetDataType<double>() const noexcept
+inline std::int8_t BP1Base::GetDataType<double>() const noexcept
{
return type_double;
}
+
template <>
-inline std::int8_t BP1::GetDataType<long double>() const noexcept
+inline std::int8_t BP1Base::GetDataType<long double>() const noexcept
{
return type_long_double;
}
@@ -332,4 +277,4 @@ inline std::int8_t BP1::GetDataType<long double>() const noexcept
} // end namespace format
} // end namespace adios
-#endif /* BP1_H_ */
+#endif /* BP1BASE_H_ */
diff --git a/include/utilities/format/bp1/BP1Structs.h b/include/utilities/format/bp1/BP1Structs.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0c50a0a6bdcfa44949c60388741105b5023ebeb
--- /dev/null
+++ b/include/utilities/format/bp1/BP1Structs.h
@@ -0,0 +1,87 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * BP1Structs.h
+ *
+ * Created on: Apr 3, 2017
+ * Author: wfg
+ */
+
+#ifndef BP1STRUCTS_H_
+#define BP1STRUCTS_H_
+
+/// \cond EXCLUDE_FROM_DOXYGEN
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+/// \endcond
+
+#include "utilities/profiling/iochrono/IOChrono.h"
+
+namespace adios
+{
+namespace format
+{
+
+/**
+ * Metadata index used for Variables and Attributes, needed in a container for
+ * characteristic
+ * sets merge independently for each Variable or Attribute
+ */
+struct BP1Index
+{
+ std::vector<char> Buffer; ///< metadata variable index, start with 100Kb
+ std::uint64_t Count =
+ 0; ///< number of characteristics sets (time and spatial aggregation)
+ const std::uint32_t MemberID;
+
+ BP1Index(const std::uint32_t memberID) : MemberID{memberID}
+ {
+ Buffer.reserve(500);
+ }
+};
+
+/**
+ * Single struct that tracks metadata indices in bp format
+ */
+struct BP1MetadataSet
+{
+ std::uint32_t
+ TimeStep; ///< current time step, updated with advance step, if
+ /// append it will be updated to last, starts with one in ADIOS1
+
+ BP1Index PGIndex = BP1Index(0); ///< single buffer for PGIndex
+
+ // no priority for now
+ /** @brief key: variable name, value: bp metadata variable index */
+ std::unordered_map<std::string, BP1Index> VarsIndices;
+
+ std::unordered_map<std::string, BP1Index>
+ AttributesIndices; ///< key: name, value: attribute bp index
+
+ const unsigned int MiniFooterSize = 28; ///< from bpls reader
+
+ // PG (relative) positions in Data buffer to be updated
+ std::uint64_t DataPGCount = 0;
+ std::size_t DataPGLengthPosition = 0; ///< current PG initial ( relative )
+ /// position, needs to be updated in
+ /// every advance step or init
+ std::uint32_t DataPGVarsCount = 0; ///< variables in current PG
+
+ /**
+ * current PG variable count ( relative ) position, needs to be
+ * updated in very Advance
+ */
+ std::size_t DataPGVarsCountPosition = 0;
+
+ bool DataPGIsOpen = false;
+
+ profiling::IOChrono Log; ///< object that takes buffering profiling info
+};
+
+} // end namespace format
+} // end namespace adios
+
+#endif /* BP1STRUCTS_H_ */
diff --git a/include/format/BP1Writer.h b/include/utilities/format/bp1/BP1Writer.h
similarity index 91%
rename from include/format/BP1Writer.h
rename to include/utilities/format/bp1/BP1Writer.h
index 765961978bcb4c5a15040981e342b87ac865e996..3dc4db2b15e6145ef811031a5e4bfbd088c1b1ec 100644
--- a/include/format/BP1Writer.h
+++ b/include/utilities/format/bp1/BP1Writer.h
@@ -15,12 +15,12 @@
#include <algorithm> //std::count, std::copy, std::for_each
#include <cmath> //std::ceil
#include <cstring> //std::memcpy
+
+#include "utilities/format/bp1/BP1Base.h"
+#include "utilities/format/bp1/BP1Structs.h"
/// \endcond
-#include "BP1.h"
#include "capsule/heap/STLVector.h"
-#include "core/Capsule.h"
-#include "core/Profiler.h"
#include "core/Variable.h"
#include "functions/adiosFunctions.h"
#include "functions/adiosTemplates.h"
@@ -30,16 +30,13 @@ namespace adios
namespace format
{
-class BP1Writer : public BP1
+class BP1Writer : public BP1Base
{
public:
- unsigned int m_Threads = 1; ///< number of threads for thread operations in
- /// large array (min,max)
- unsigned int m_Verbosity = 0; ///< statistics verbosity, can change if
- /// redefined in Engine method.
- float m_GrowthFactor = 1.5; ///< memory growth factor, can change if
- /// redefined in Engine method.
+ unsigned int m_Threads = 1; ///< thread operations in large array (min,max)
+ unsigned int m_Verbosity = 0; ///< statistics verbosity, only 0 is supported
+ float m_GrowthFactor = 1.5; ///< memory growth factor
const std::uint8_t m_Version = 3; ///< BP format version
/**
@@ -90,7 +87,7 @@ public:
// characteristics 3 and 4, check variable number of dimensions
const std::size_t dimensions =
- variable.DimensionsSize(); // number of commas in CSV + 1
+ variable.DimensionsSize(); // commas in CSV + 1
indexSize += 28 * dimensions; // 28 bytes per dimension
indexSize += 1; // id
@@ -124,10 +121,9 @@ public:
* @param metadataSet
*/
template <class T>
- inline void WriteVariableMetadata(const Variable<T> &variable,
- capsule::STLVector &heap,
- BP1MetadataSet &metadataSet) const
- noexcept
+ void WriteVariableMetadata(const Variable<T> &variable,
+ capsule::STLVector &heap,
+ BP1MetadataSet &metadataSet) const noexcept
{
Stats<T> stats = GetStats(variable);
WriteVariableMetadataCommon(variable, stats, heap, metadataSet);
@@ -237,7 +233,7 @@ private:
CopyToBuffer(buffer, &no);
// write variable dimensions
- const std::uint8_t dimensions = variable.m_Dimensions.size();
+ const std::uint8_t dimensions = variable.m_LocalDimensions.size();
CopyToBuffer(buffer, &dimensions); // count
std::uint16_t dimensionsLength =
27 *
@@ -245,9 +241,9 @@ private:
// y/n + global dimension, var y/n + global offset,
// changed for characteristic
CopyToBuffer(buffer, &dimensionsLength); // length
- WriteDimensionsRecord(buffer, variable.m_Dimensions,
- variable.m_GlobalDimensions,
- variable.m_GlobalOffsets, 18, true);
+ WriteDimensionsRecord(buffer, variable.m_LocalDimensions,
+ variable.m_GlobalDimensions, variable.m_Offsets,
+ 18, true);
// CHARACTERISTICS
WriteVariableCharacteristics(variable, stats, buffer, true);
@@ -306,8 +302,7 @@ private:
noexcept
{
const std::size_t characteristicsCountPosition =
- buffer.size(); // very important to track as writer is going
- // back to
+ buffer.size(); // very important to track as writer is going back to
// this position
buffer.insert(buffer.end(), 5,
0); // skip characteristics count(1) + length (4)
@@ -316,7 +311,7 @@ private:
// DIMENSIONS
std::uint8_t characteristicID = characteristic_dimensions;
CopyToBuffer(buffer, &characteristicID);
- const std::uint8_t dimensions = variable.m_Dimensions.size();
+ const std::uint8_t dimensions = variable.m_LocalDimensions.size();
if (addLength == true)
{
@@ -329,9 +324,9 @@ private:
CopyToBuffer(buffer, &dimensions); // count
const std::uint16_t dimensionsLength = 24 * dimensions;
CopyToBuffer(buffer, &dimensionsLength); // length
- WriteDimensionsRecord(buffer, variable.m_Dimensions,
- variable.m_GlobalDimensions,
- variable.m_GlobalOffsets, 16, addLength);
+ WriteDimensionsRecord(buffer, variable.m_LocalDimensions,
+ variable.m_GlobalDimensions, variable.m_Offsets,
+ 16, addLength);
++characteristicsCounter;
// VALUE for SCALAR or STAT min, max for ARRAY
@@ -356,8 +351,8 @@ private:
&characteristicsCounter); // count (1)
const std::uint32_t characteristicsLength =
buffer.size() - characteristicsCountPosition - 4 -
- 1; // remove its own length (4 bytes) + characteristic counter (
- // 1 byte
+ 1; // remove its own length (4 bytes) + characteristic counter ( 1
+ // byte
// )
CopyToBuffer(buffer, characteristicsCountPosition + 1,
&characteristicsLength); // length
@@ -381,7 +376,7 @@ private:
* @param position
* @param localDimensions
* @param globalDimensions
- * @param globalOffsets
+ * @param offsets
* @param addType true: for data buffers, false: for metadata buffer and
* data
* characteristic
@@ -389,7 +384,7 @@ private:
void WriteDimensionsRecord(std::vector<char> &buffer,
const std::vector<std::size_t> &localDimensions,
const std::vector<std::size_t> &globalDimensions,
- const std::vector<std::size_t> &globalOffsets,
+ const std::vector<std::size_t> &offsets,
const unsigned int skip,
const bool addType = false) const noexcept;
@@ -438,8 +433,7 @@ private:
// //here we can make decisions for threads
// based on valuesSize
GetMinMax(variable.m_AppValues, valuesSize, stats.Min,
- stats.Max,
- m_Threads); // here we can add cores from constructor
+ stats.Max, m_Threads);
else
GetMinMax(variable.m_AppValues, valuesSize, stats.Min,
stats.Max);
diff --git a/include/utilities/profiling/iochrono/IOChrono.h b/include/utilities/profiling/iochrono/IOChrono.h
new file mode 100644
index 0000000000000000000000000000000000000000..20796d332bffdc0873e9409aa5f439dce1db5c2b
--- /dev/null
+++ b/include/utilities/profiling/iochrono/IOChrono.h
@@ -0,0 +1,40 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * IOChrono.h
+ *
+ * Created on: Mar 9, 2017
+ * Author: wfg
+ */
+
+#ifndef IOCHRONO_H_
+#define IOCHRONO_H_
+
+/// \cond EXCLUDE_FROM_DOXYGEN
+#include <vector>
+/// \endcond
+
+#include "utilities/profiling/iochrono/Timer.h"
+
+namespace adios
+{
+namespace profiling
+{
+
+/**
+ * Struct used to track
+ */
+struct IOChrono
+{
+ std::vector<Timer>
+ Timers; ///< one timer for each process (open, write, buffering, etc.)
+ std::vector<unsigned long long int>
+ TotalBytes; ///< tracks bytes for buffering
+ bool IsActive = false; ///< flag to determine if profiling is used
+};
+
+} // end namespace
+} // end namespace
+
+#endif /* IOCHRONO_H_ */
diff --git a/include/utilities/profiling/iochrono/Timer.h b/include/utilities/profiling/iochrono/Timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bc7817a992ce86fb914abfac027d8870dc6e5e2
--- /dev/null
+++ b/include/utilities/profiling/iochrono/Timer.h
@@ -0,0 +1,62 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * Timer.h
+ *
+ * Created on: Apr 4, 2017
+ * Author: wfg
+ */
+
+#ifndef TIMER_H_
+#define TIMER_H_
+
+/// \cond EXCLUDE_FROM_DOXYGEN
+#include <chrono>
+#include <string>
+/// \endcond
+
+#include "core/Support.h"
+
+namespace adios
+{
+namespace profiling
+{
+
+class Timer
+{
+
+public:
+ const std::string m_Process;
+ unsigned long long int m_ProcessTime = 0;
+
+ /**
+ * Timer object constructor using std::chrono class
+ * @param process name of process to be measured
+ * @param resolution time resolution (mus, ms, s, etc.) from Resolutions in
+ * core/Support.h
+ * @param debugMode true: additional checks and exceptions, false: no checks
+ */
+ Timer(const std::string process, const Support::Resolutions resolution,
+ const bool debugMode = false);
+
+ ~Timer();
+
+ void SetInitialTime(); ///< set time to start counting for a process
+ void
+ SetTime(); ///< sets time to measure, it will add to overall process time
+ std::string GetUnits() const;
+
+private:
+ const Support::Resolutions m_Resolution;
+ const bool m_DebugMode = false;
+ std::chrono::time_point<std::chrono::high_resolution_clock> m_InitialTime;
+ std::chrono::time_point<std::chrono::high_resolution_clock> m_ElapsedTime;
+ bool m_InitialTimeSet = false;
+ long long int GetCurrentTime(); ///< called by SetTime
+};
+
+} // end namespace profiling
+} // end namespace adios
+
+#endif /* TIMER_H_ */
diff --git a/source/ADIOS.cpp b/source/ADIOS.cpp
index 2d44d18c976555039e0a5abc4082c5585f2c9e3f..729e6c8ee7b8732364d7a12561a83baeb98d719a 100644
--- a/source/ADIOS.cpp
+++ b/source/ADIOS.cpp
@@ -38,31 +38,31 @@
namespace adios
{
-ADIOS::ADIOS(const Verbose /*verbose*/, const bool debugMode)
+ADIOS::ADIOS(const Verbose verbose, const bool debugMode)
: m_DebugMode{debugMode}
{
InitMPI();
}
-ADIOS::ADIOS(std::string config, const Verbose /*verbose*/,
+ADIOS::ADIOS(const std::string config, const Verbose verbose,
const bool debugMode)
-: m_ConfigFile{std::move(config)}, m_DebugMode{debugMode}
+: m_ConfigFile(config), m_DebugMode(debugMode)
{
InitMPI();
// InitXML( m_ConfigFile, m_MPIComm, m_DebugMode, m_Transforms );
}
-ADIOS::ADIOS(std::string config, MPI_Comm mpiComm, const Verbose /*verbose*/,
- const bool debugMode)
-: m_MPIComm{mpiComm}, m_ConfigFile{std::move(config)}, m_DebugMode{debugMode}
+ADIOS::ADIOS(const std::string configFile, MPI_Comm mpiComm,
+ const Verbose verbose, const bool debugMode)
+: m_MPIComm(mpiComm), m_ConfigFile(configFile), m_DebugMode(debugMode)
{
InitMPI();
// InitXML( m_XMLConfigFile, m_MPIComm, m_DebugMode, m_HostLanguage,
// m_Transforms, m_Groups );
}
-ADIOS::ADIOS(MPI_Comm mpiComm, const Verbose /*verbose*/, const bool debugMode)
-: m_MPIComm{mpiComm}, m_DebugMode{debugMode}
+ADIOS::ADIOS(MPI_Comm mpiComm, const Verbose verbose, const bool debugMode)
+: m_MPIComm(mpiComm), m_DebugMode(debugMode)
{
InitMPI();
}
@@ -85,7 +85,7 @@ void ADIOS::InitMPI()
MPI_Comm_size(m_MPIComm, &m_SizeMPI);
}
-Method &ADIOS::DeclareMethod(const std::string &methodName)
+Method &ADIOS::DeclareMethod(const std::string methodName)
{
if (m_DebugMode == true)
{
@@ -101,10 +101,8 @@ Method &ADIOS::DeclareMethod(const std::string &methodName)
}
std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
- const std::string &accessMode,
- MPI_Comm mpiComm, const Method &method,
- const IOMode iomode,
- const float timeout_sec)
+ const std::string accessMode,
+ MPI_Comm mpiComm, const Method &method)
{
if (m_DebugMode == true)
{
@@ -134,14 +132,12 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
if (isDefaultWriter || type == "BPFileWriter" || type == "bpfilewriter")
{
return std::make_shared<BPFileWriter>(*this, name, accessMode, mpiComm,
- method, iomode, timeout_sec,
- m_DebugMode, method.m_nThreads);
+ method);
}
else if (isDefaultReader || type == "BPReader" || type == "bpreader")
{
return std::make_shared<BPFileReader>(*this, name, accessMode, mpiComm,
- method, iomode, timeout_sec,
- m_DebugMode, method.m_nThreads);
+ method);
}
else if (type == "SIRIUS" || type == "sirius" || type == "Sirius")
{
@@ -154,8 +150,7 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
{
#ifdef ADIOS_HAVE_DATAMAN
return std::make_shared<DataManWriter>(*this, name, accessMode, mpiComm,
- method, iomode, timeout_sec,
- m_DebugMode, method.m_nThreads);
+ method);
#else
throw std::invalid_argument(
"ERROR: this version didn't compile with "
@@ -166,8 +161,7 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
{
#ifdef ADIOS_HAVE_DATAMAN
return std::make_shared<DataManReader>(*this, name, accessMode, mpiComm,
- method, iomode, timeout_sec,
- m_DebugMode, method.m_nThreads);
+ method);
#else
throw std::invalid_argument(
"ERROR: this version didn't compile with "
@@ -178,8 +172,7 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
{
#ifdef ADIOS_HAVE_ADIOS1
return std::make_shared<ADIOS1Writer>(*this, name, accessMode, mpiComm,
- method, iomode, timeout_sec,
- m_DebugMode, method.m_nThreads);
+ method);
#else
throw std::invalid_argument(
"ERROR: this version didn't compile with ADIOS "
@@ -205,18 +198,17 @@ std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
return nullptr; // if debug mode is off
}
-std::shared_ptr<Engine> ADIOS::Open(const std::string &streamName,
- const std::string &accessMode,
- const Method &method, const IOMode iomode,
- const float timeout_sec)
+std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
+ const std::string accessMode,
+ const Method &method)
{
- return Open(streamName, accessMode, m_MPIComm, method, iomode, timeout_sec);
+ return Open(name, accessMode, m_MPIComm, method);
}
-std::shared_ptr<Engine>
-ADIOS::Open(const std::string &name, const std::string &accessMode,
- MPI_Comm mpiComm, const std::string &methodName,
- const IOMode iomode, const float timeout_sec)
+std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
+ const std::string accessMode,
+ MPI_Comm mpiComm,
+ const std::string methodName)
{
auto itMethod = m_Methods.find(methodName);
@@ -225,31 +217,28 @@ ADIOS::Open(const std::string &name, const std::string &accessMode,
CheckMethod(itMethod, methodName, " in call to Open\n");
}
- return Open(name, accessMode, mpiComm, itMethod->second, iomode,
- timeout_sec);
+ return Open(name, accessMode, mpiComm, itMethod->second);
}
std::shared_ptr<Engine> ADIOS::Open(const std::string &name,
- const std::string &accessMode,
- const std::string &methodName,
- const IOMode iomode,
- const float timeout_sec)
+ const std::string accessMode,
+ const std::string methodName)
{
- return Open(name, accessMode, m_MPIComm, methodName, iomode, timeout_sec);
+ return Open(name, accessMode, m_MPIComm, methodName);
}
-std::shared_ptr<Engine> ADIOS::OpenFileReader(const std::string &name,
- MPI_Comm /*mpiComm*/,
- const Method &method,
- const IOMode iomode)
+std::shared_ptr<Engine> ADIOS::OpenFileReader(const std::string &fileName,
+ MPI_Comm mpiComm,
+ const Method &method)
+
{
- return Open(name, "r", m_MPIComm, method, iomode);
+ return Open(fileName, "r", mpiComm, method);
}
std::shared_ptr<Engine> ADIOS::OpenFileReader(const std::string &name,
- MPI_Comm /*mpiComm*/,
- const std::string &methodName,
- const IOMode iomode)
+ MPI_Comm mpiComm,
+ const std::string methodName)
+
{
auto itMethod = m_Methods.find(methodName);
@@ -258,7 +247,7 @@ std::shared_ptr<Engine> ADIOS::OpenFileReader(const std::string &name,
CheckMethod(itMethod, methodName, " in call to Open\n");
}
- return Open(name, "r", m_MPIComm, itMethod->second, iomode);
+ return Open(name, "r", m_MPIComm, itMethod->second);
}
VariableCompound &ADIOS::GetVariableCompound(const std::string &name)
@@ -367,7 +356,7 @@ void ADIOS::CheckVariableInput(const std::string &name,
void ADIOS::CheckVariableName(
std::map<std::string, std::pair<std::string, unsigned int>>::const_iterator
itVariable,
- const std::string &name, const std::string &hint) const
+ const std::string &name, const std::string hint) const
{
if (m_DebugMode == true)
{
@@ -380,8 +369,8 @@ void ADIOS::CheckVariableName(
}
void ADIOS::CheckMethod(std::map<std::string, Method>::const_iterator itMethod,
- const std::string &methodName,
- const std::string &hint) const
+ const std::string methodName,
+ const std::string hint) const
{
if (itMethod == m_Methods.end())
{
diff --git a/source/ADIOS_inst.cpp b/source/ADIOS_inst.cpp
index c494bc3e286c886d983af23e1ea09bb90bff8721..81b91e56c6acdffc0e83fd0be83843310db6ef60 100644
--- a/source/ADIOS_inst.cpp
+++ b/source/ADIOS_inst.cpp
@@ -17,97 +17,99 @@ namespace adios
// -----------------------------------------------------------------------------
template <>
-std::map<unsigned int, Variable<char>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<char>> &ADIOS::GetVariableMap()
{
return m_Char;
}
template <>
-std::map<unsigned int, Variable<unsigned char>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<unsigned char>> &ADIOS::GetVariableMap()
{
return m_UChar;
}
template <>
-std::map<unsigned int, Variable<short>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<short>> &ADIOS::GetVariableMap()
{
return m_Short;
}
template <>
-std::map<unsigned int, Variable<unsigned short>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<unsigned short>> &ADIOS::GetVariableMap()
{
return m_UShort;
}
template <>
-std::map<unsigned int, Variable<int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<int>> &ADIOS::GetVariableMap()
{
return m_Int;
}
template <>
-std::map<unsigned int, Variable<unsigned int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<unsigned int>> &ADIOS::GetVariableMap()
{
return m_UInt;
}
template <>
-std::map<unsigned int, Variable<long int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<long int>> &ADIOS::GetVariableMap()
{
return m_LInt;
}
template <>
-std::map<unsigned int, Variable<unsigned long int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<unsigned long int>> &ADIOS::GetVariableMap()
{
return m_ULInt;
}
template <>
-std::map<unsigned int, Variable<long long int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<long long int>> &ADIOS::GetVariableMap()
{
return m_LLInt;
}
template <>
-std::map<unsigned int, Variable<unsigned long long int>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<unsigned long long int>> &
+ADIOS::GetVariableMap()
{
return m_ULLInt;
}
template <>
-std::map<unsigned int, Variable<float>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<float>> &ADIOS::GetVariableMap()
{
return m_Float;
}
template <>
-std::map<unsigned int, Variable<double>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<double>> &ADIOS::GetVariableMap()
{
return m_Double;
}
template <>
-std::map<unsigned int, Variable<long double>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<long double>> &ADIOS::GetVariableMap()
{
return m_LDouble;
}
template <>
-std::map<unsigned int, Variable<std::complex<float>>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<std::complex<float>>> &ADIOS::GetVariableMap()
{
return m_CFloat;
}
template <>
-std::map<unsigned int, Variable<std::complex<double>>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<std::complex<double>>> &ADIOS::GetVariableMap()
{
return m_CDouble;
}
template <>
-std::map<unsigned int, Variable<std::complex<long double>>> &ADIOS::GetVarMap()
+std::map<unsigned int, Variable<std::complex<long double>>> &
+ADIOS::GetVariableMap()
{
return m_CLDouble;
}
@@ -118,16 +120,17 @@ std::map<unsigned int, Variable<std::complex<long double>>> &ADIOS::GetVarMap()
template <typename T>
Variable<T> &
-ADIOS::DefineVariable(const std::string &name, const Dims dimensions,
- const Dims globalDimensions, const Dims globalOffsets)
-{
- auto &varMap = GetVarMap<T>();
- CheckVariableInput(name, dimensions);
- const unsigned int size = varMap.size();
- varMap.emplace(size, Variable<T>(name, dimensions, globalDimensions,
- globalOffsets, m_DebugMode));
+ADIOS::DefineVariable(const std::string &name, const Dims globalDimensions,
+ const Dims localDimensions, const Dims offsets)
+{
+ auto &variableMap = GetVariableMap<T>();
+ CheckVariableInput(name, globalDimensions);
+ const unsigned int size = variableMap.size();
+ variableMap.emplace(size,
+ Variable<T>(name, globalDimensions, localDimensions,
+ offsets, m_DebugMode));
m_Variables.emplace(name, std::make_pair(GetType<T>(), size));
- return varMap.at(size);
+ return variableMap.at(size);
}
#define define_template_instantiation(T) \
@@ -154,7 +157,7 @@ unsigned int ADIOS::GetVariableIndex(const std::string &name)
template <typename T>
Variable<T> &ADIOS::GetVariable(const std::string &name)
{
- return GetVarMap<T>().at(GetVariableIndex<T>(name));
+ return GetVariableMap<T>().at(GetVariableIndex<T>(name));
}
#define define_template_instatiation(T) \
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 766c5dec17a3689dfdac3c9d55faa5b4827b6064..2ccf94700c6304df4b8eacf788824956bdc5ac8d 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -26,15 +26,17 @@ foreach(adios2_target IN LISTS adios2_targets)
engine/bp/BPFileReader.cpp
engine/bp/BPFileWriter.cpp
- format/BP1.cpp
- format/BP1Aggregator.cpp
- format/BP1Writer.cpp
-
functions/adiosFunctions.cpp
transport/file/FStream.cpp
transport/file/FileDescriptor.cpp
transport/file/FilePointer.cpp
+
+ utilities/format/bp1/BP1Base.cpp
+ utilities/format/bp1/BP1Aggregator.cpp
+ utilities/format/bp1/BP1Writer.cpp
+
+ utilities/profiling/iochrono/Timer.cpp
)
target_include_directories(${adios2_target}
PUBLIC ${ADIOS_SOURCE_DIR}/include
diff --git a/source/core/Capsule.cpp b/source/core/Capsule.cpp
index 0b268a37065238800c19cdad2336774a2c553774..b30603ab42bc0137b0803d802a01e67b937eb7c0 100644
--- a/source/core/Capsule.cpp
+++ b/source/core/Capsule.cpp
@@ -15,8 +15,8 @@
namespace adios
{
-Capsule::Capsule(std::string type, std::string accessMode, int rankMPI,
- bool debugMode)
+Capsule::Capsule(const std::string type, const std::string accessMode,
+ int rankMPI, bool debugMode)
: m_Type{std::move(type)}, m_AccessMode{std::move(accessMode)},
m_RankMPI{rankMPI}, m_DebugMode{debugMode}
{
diff --git a/source/core/Engine.cpp b/source/core/Engine.cpp
index ad23b38f143866f8f97cc1710b22e21e3f4cb59d..101b5ef676e112a9594267e1f10e18297a4dbaff 100644
--- a/source/core/Engine.cpp
+++ b/source/core/Engine.cpp
@@ -17,13 +17,13 @@
namespace adios
{
-Engine::Engine(ADIOS &adios, std::string engineType, std::string name,
- std::string accessMode, MPI_Comm mpiComm, const Method &method,
- bool debugMode, unsigned int nthreads, std::string endMessage)
-: m_MPIComm(mpiComm), m_EngineType(std::move(engineType)),
- m_Name(std::move(name)), m_AccessMode(std::move(accessMode)),
- m_Method(method), m_ADIOS(adios), m_DebugMode(debugMode),
- m_nThreads(nthreads), m_EndMessage(std::move(endMessage))
+Engine::Engine(ADIOS &adios, const std::string engineType,
+ const std::string &name, const std::string accessMode,
+ MPI_Comm mpiComm, const Method &method,
+ const std::string endMessage)
+: m_MPIComm(mpiComm), m_EngineType(engineType), m_Name(name),
+ m_AccessMode(accessMode), m_Method(method), m_ADIOS(adios),
+ m_DebugMode(m_Method.m_DebugMode), m_EndMessage(endMessage)
{
if (m_DebugMode == true)
{
@@ -41,7 +41,7 @@ Engine::Engine(ADIOS &adios, std::string engineType, std::string name,
void Engine::SetCallBack(std::function<void(const void *, std::string,
std::string, std::string, Dims)>
- /*callback*/)
+ callback)
{
}
@@ -178,95 +178,101 @@ void Engine::AdvanceAsync(
void Engine::Close(const int /*transportIndex*/) {}
// READ
-Variable<void> *Engine::InquireVariable(const std::string /*name*/,
+Variable<void> *Engine::InquireVariable(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
-Variable<char> *Engine::InquireVariableChar(const std::string /*name*/,
+Variable<char> *Engine::InquireVariableChar(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<unsigned char> *
-Engine::InquireVariableUChar(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableUChar(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
-Variable<short> *Engine::InquireVariableShort(const std::string /*name*/,
+Variable<short> *Engine::InquireVariableShort(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<unsigned short> *
-Engine::InquireVariableUShort(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableUShort(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
-Variable<int> *Engine::InquireVariableInt(const std::string /*name*/,
+Variable<int> *Engine::InquireVariableInt(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
-Variable<unsigned int> *Engine::InquireVariableUInt(const std::string /*name*/,
- const bool /*readIn*/)
+Variable<unsigned int> *
+Engine::InquireVariableUInt(const std::string & /*name*/, const bool /*readIn*/)
{
return nullptr;
}
-Variable<long int> *Engine::InquireVariableLInt(const std::string /*name*/,
+Variable<long int> *Engine::InquireVariableLInt(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<unsigned long int> *
-Engine::InquireVariableULInt(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableULInt(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
Variable<long long int> *
-Engine::InquireVariableLLInt(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableLLInt(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
Variable<unsigned long long int> *
-Engine::InquireVariableULLInt(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableULLInt(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
-Variable<float> *Engine::InquireVariableFloat(const std::string /*name*/,
+Variable<float> *Engine::InquireVariableFloat(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
-Variable<double> *Engine::InquireVariableDouble(const std::string /*name*/,
+Variable<double> *Engine::InquireVariableDouble(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<long double> *
-Engine::InquireVariableLDouble(const std::string /*name*/,
+Engine::InquireVariableLDouble(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<std::complex<float>> *
-Engine::InquireVariableCFloat(const std::string /*name*/, const bool /*readIn*/)
+Engine::InquireVariableCFloat(const std::string & /*name*/,
+ const bool /*readIn*/)
{
return nullptr;
}
Variable<std::complex<double>> *
-Engine::InquireVariableCDouble(const std::string /*name*/,
+Engine::InquireVariableCDouble(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
Variable<std::complex<long double>> *
-Engine::InquireVariableCLDouble(const std::string /*name*/,
+Engine::InquireVariableCLDouble(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
}
-VariableCompound *Engine::InquireVariableCompound(const std::string /*name*/,
+VariableCompound *Engine::InquireVariableCompound(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
@@ -287,11 +293,11 @@ void Engine::InitParameters() {}
void Engine::InitTransports() {}
void Engine::CheckParameter(
- const std::map<std::string, std::string>::const_iterator itParam,
+ const std::map<std::string, std::string>::const_iterator itParameter,
const std::map<std::string, std::string> ¶meters,
const std::string parameterName, const std::string hint) const
{
- if (itParam == parameters.end())
+ if (itParameter == parameters.end())
{
{
throw std::invalid_argument("ERROR: parameter name " +
@@ -303,7 +309,9 @@ void Engine::CheckParameter(
bool Engine::TransportNamesUniqueness() const
{
auto lf_CheckTransportsType =
- [&](const std::set<std::string> &specificType) -> bool {
+ [&](const std::set<std::string> &specificType) -> bool
+
+ {
std::set<std::string> transportNames;
for (const auto ¶meters : m_Method.m_TransportParameters)
diff --git a/source/core/Method.cpp b/source/core/Method.cpp
index 02d1750344feb7fa6b2a5154394a7cb08cb396fd..720382cc26074a531918f3c6d21c210ad56dae1f 100644
--- a/source/core/Method.cpp
+++ b/source/core/Method.cpp
@@ -16,21 +16,21 @@
namespace adios
{
-Method::Method(std::string name, bool debugMode)
-: m_Name{std::move(name)}, m_DebugMode{debugMode}
+Method::Method(const std::string name, const bool debugMode)
+: m_Name{name}, m_DebugMode{debugMode}
{
- // m_Type can stay empty (forcing the choice of the default engine)
- m_nThreads = 1;
}
-bool Method::isUserDefined()
+Method::~Method() {}
+
+bool Method::IsUserDefined()
{
return false; // TODO(wfg): check if XML has the method defined
}
void Method::SetEngine(const std::string type) { m_Type = type; }
-void Method::AllowThreads(const int nThreads)
+void Method::AllowThreads(const unsigned int nThreads)
{
if (nThreads > 1)
{
diff --git a/source/core/Transport.cpp b/source/core/Transport.cpp
index a3a3e2505be5df43a9345377994ca2446bf175cc..1fde211ae4f9a8a6cca8768d07679afdc832081f 100644
--- a/source/core/Transport.cpp
+++ b/source/core/Transport.cpp
@@ -15,8 +15,9 @@
namespace adios
{
-Transport::Transport(std::string type, MPI_Comm mpiComm, bool debugMode)
-: m_Type{std::move(type)}, m_MPIComm{mpiComm}, m_DebugMode{debugMode}
+Transport::Transport(const std::string type, MPI_Comm mpiComm,
+ const bool debugMode)
+: m_Type(type), m_MPIComm(mpiComm), m_DebugMode(debugMode)
{
MPI_Comm_rank(m_MPIComm, &m_RankMPI);
MPI_Comm_size(m_MPIComm, &m_SizeMPI);
@@ -31,27 +32,21 @@ void Transport::Close() {}
void Transport::InitProfiler(const std::string accessMode,
const Support::Resolutions resolution)
{
- m_Profiler.m_Timers.emplace_back("open", Support::Resolutions::mus);
+ m_Profiler.Timers.emplace_back("open", Support::Resolutions::mus);
if (accessMode == "w" || accessMode == "write")
- {
- m_Profiler.m_Timers.emplace_back("write", resolution);
- }
+ m_Profiler.Timers.emplace_back("write", resolution);
else if (accessMode == "a" || accessMode == "append")
- {
- m_Profiler.m_Timers.emplace_back("append", resolution);
- }
+ m_Profiler.Timers.emplace_back("append", resolution);
else if (accessMode == "r" || accessMode == "read")
- {
- m_Profiler.m_Timers.emplace_back("read", resolution);
- }
+ m_Profiler.Timers.emplace_back("read", resolution);
- m_Profiler.m_Timers.emplace_back("close", Support::Resolutions::mus);
+ m_Profiler.Timers.emplace_back("close", Support::Resolutions::mus);
- m_Profiler.m_TotalBytes.push_back(0);
- m_Profiler.m_IsActive = true;
+ m_Profiler.TotalBytes.push_back(0);
+ m_Profiler.IsActive = true;
}
} // end namespace adios
diff --git a/source/engine/adios1/ADIOS1Reader.cpp b/source/engine/adios1/ADIOS1Reader.cpp
index 6f8fd564a959a147fe436a0f888651fe0ba8bac8..55a745a0e7370a437665321105cc3ecafd5e9f26 100644
--- a/source/engine/adios1/ADIOS1Reader.cpp
+++ b/source/engine/adios1/ADIOS1Reader.cpp
@@ -2,165 +2,229 @@
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*
- * ADIOS1Reader.cpp
+ * BPFileReader.cpp
*
* Created on: Feb 27, 2017
* Author: wfg
*/
-#include "engine/adios1/ADIOS1Reader.h"
-#include "ADIOS.h"
-
-extern int adios_verbose_level;
-extern int adios_errno;
+#include "core/Support.h"
+#include "engine/bp/BPFileReader.h"
+#include "functions/adiosFunctions.h" // CSVToVector
+#include "transport/file/FStream.h" // uses C++ fstream
+#include "transport/file/FileDescriptor.h" // uses POSIX
+#include "transport/file/FilePointer.h" // uses C FILE*
namespace adios
{
-ADIOS1Reader::ADIOS1Reader(ADIOS &adios, const std::string name,
+ADIOS1Reader::ADIOS1Reader(ADIOS &adios, const std::string &name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode,
- const unsigned int nthreads)
-: Engine(adios, "ADIOS1Reader", name, accessMode, mpiComm, method, debugMode,
- nthreads, " ADIOS1Reader constructor (or call to ADIOS Open).\n")
+ const Method &method)
+: Engine(adios, "BPFileReader", name, accessMode, mpiComm, method,
+ " BPFileReader constructor (or call to ADIOS Open).\n")
{
Init();
- adios_read_init_method(read_method, m_MPIComm, "");
}
-ADIOS1Reader::~ADIOS1Reader() { adios_read_finalize_method(read_method); }
+BPFileReader::~BPFileReader() {}
Variable<void> *
-ADIOS1Reader::InquireVariable(const std::string name,
+BPFileReader::InquireVariable(const std::string &variableName,
const bool readIn) // not yet implemented
{
return nullptr;
}
-Variable<char> *ADIOS1Reader::InquireVariableChar(const std::string name,
- const bool readIn)
+Variable<char> *
+BPFileReader::InquireVariableChar(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<char>(name, readIn);
+ return InquireVariableCommon<char>(variableName, readIn);
}
Variable<unsigned char> *
-ADIOS1Reader::InquireVariableUChar(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUChar(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<unsigned char>(name, readIn);
+ return InquireVariableCommon<unsigned char>(variableName, readIn);
}
-Variable<short> *ADIOS1Reader::InquireVariableShort(const std::string name,
- const bool readIn)
+Variable<short> *
+BPFileReader::InquireVariableShort(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<short>(name, readIn);
+ return InquireVariableCommon<short>(variableName, readIn);
}
Variable<unsigned short> *
-ADIOS1Reader::InquireVariableUShort(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUShort(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<unsigned short>(name, readIn);
+ return InquireVariableCommon<unsigned short>(variableName, readIn);
}
-Variable<int> *ADIOS1Reader::InquireVariableInt(const std::string name,
+Variable<int> *BPFileReader::InquireVariableInt(const std::string &variableName,
const bool readIn)
{
- return InquireVariableCommon<int>(name, readIn);
+ return InquireVariableCommon<int>(variableName, readIn);
}
Variable<unsigned int> *
-ADIOS1Reader::InquireVariableUInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUInt(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<unsigned int>(name, readIn);
+ return InquireVariableCommon<unsigned int>(variableName, readIn);
}
-Variable<long int> *ADIOS1Reader::InquireVariableLInt(const std::string name,
- const bool readIn)
+Variable<long int> *
+BPFileReader::InquireVariableLInt(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<long int>(name, readIn);
+ return InquireVariableCommon<long int>(variableName, readIn);
}
Variable<unsigned long int> *
-ADIOS1Reader::InquireVariableULInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableULInt(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<unsigned long int>(name, readIn);
+ return InquireVariableCommon<unsigned long int>(variableName, readIn);
}
Variable<long long int> *
-ADIOS1Reader::InquireVariableLLInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableLLInt(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<long long int>(name, readIn);
+ return InquireVariableCommon<long long int>(variableName, readIn);
}
Variable<unsigned long long int> *
-ADIOS1Reader::InquireVariableULLInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableULLInt(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<unsigned long long int>(name, readIn);
+ return InquireVariableCommon<unsigned long long int>(variableName, readIn);
}
-Variable<float> *ADIOS1Reader::InquireVariableFloat(const std::string name,
- const bool readIn)
+Variable<float> *
+BPFileReader::InquireVariableFloat(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<float>(name, readIn);
+ return InquireVariableCommon<float>(variableName, readIn);
}
-Variable<double> *ADIOS1Reader::InquireVariableDouble(const std::string name,
- const bool readIn)
+Variable<double> *
+BPFileReader::InquireVariableDouble(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<double>(name, readIn);
+ return InquireVariableCommon<double>(variableName, readIn);
}
Variable<long double> *
-ADIOS1Reader::InquireVariableLDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableLDouble(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<long double>(name, readIn);
+ return InquireVariableCommon<long double>(variableName, readIn);
}
Variable<std::complex<float>> *
-ADIOS1Reader::InquireVariableCFloat(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCFloat(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<std::complex<float>>(name, readIn);
+ return InquireVariableCommon<std::complex<float>>(variableName, readIn);
}
Variable<std::complex<double>> *
-ADIOS1Reader::InquireVariableCDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCDouble(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<std::complex<double>>(name, readIn);
+ return InquireVariableCommon<std::complex<double>>(variableName, readIn);
}
Variable<std::complex<long double>> *
-ADIOS1Reader::InquireVariableCLDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCLDouble(const std::string &variableName,
+ const bool readIn)
{
- return InquireVariableCommon<std::complex<long double>>(name, readIn);
+ return InquireVariableCommon<std::complex<long double>>(variableName,
+ readIn);
}
-VariableCompound *ADIOS1Reader::InquireVariableCompound(const std::string name,
- const bool readIn)
+VariableCompound *
+BPFileReader::InquireVariableCompound(const std::string &variableName,
+ const bool readIn)
{
return nullptr;
}
-void ADIOS1Reader::Close(const int transportIndex) {}
+void BPFileReader::Close(const int transportIndex) {}
// PRIVATE
-void ADIOS1Reader::Init()
+void BPFileReader::Init()
{
if (m_DebugMode == true)
{
if (m_AccessMode != "r" && m_AccessMode != "read")
throw std::invalid_argument(
- "ERROR: ADIOS1Reader doesn't support access mode " +
+ "ERROR: BPFileReader doesn't support access mode " +
m_AccessMode +
- ", in call to ADIOS Open or ADIOS1Reader constructor\n");
+ ", in call to ADIOS Open or BPFileReader constructor\n");
+ }
+
+ InitTransports();
+}
+
+void BPFileReader::InitTransports() // maybe move this?
+{
+ if (m_DebugMode == true)
+ {
+ if (TransportNamesUniqueness() == false)
+ {
+ throw std::invalid_argument(
+ "ERROR: two transports of the same kind (e.g file IO) "
+ "can't have the same name, modify with name= in Method "
+ "AddTransport\n");
+ }
}
for (const auto ¶meters : m_Method.m_TransportParameters)
{
auto itTransport = parameters.find("transport");
- if (itTransport->second == "file" || itTransport->second == "File" ||
- itTransport->second == "bp" || itTransport->second == "BP")
+ if (itTransport->second == "file" || itTransport->second == "File")
{
- read_method = ADIOS_READ_METHOD_BP;
+ auto itLibrary = parameters.find("library");
+ if (itLibrary == parameters.end() ||
+ itLibrary->second == "POSIX") // use default POSIX
+ {
+ auto file = std::make_shared<transport::FileDescriptor>(
+ m_MPIComm, m_DebugMode);
+ // m_BP1Reader.OpenRankFiles( m_Name, m_AccessMode, *file );
+ m_Transports.push_back(std::move(file));
+ }
+ else if (itLibrary->second == "FILE*" ||
+ itLibrary->second == "stdio.h")
+ {
+ auto file = std::make_shared<transport::FilePointer>(
+ m_MPIComm, m_DebugMode);
+ // m_BP1Reader.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_BP1Reader.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: file transport library " + itLibrary->second +
+ " not supported, in " + m_Name + m_EndMessage);
+ }
}
else
{
diff --git a/source/engine/adios1/ADIOS1Writer.cpp b/source/engine/adios1/ADIOS1Writer.cpp
index 81813dc63f759ec71aeebc70c13e1968f1b57aba..4a719f7659a8208d9dc362a6d8ae379e91274865 100644
--- a/source/engine/adios1/ADIOS1Writer.cpp
+++ b/source/engine/adios1/ADIOS1Writer.cpp
@@ -12,6 +12,7 @@
#include "engine/adios1/ADIOS1Writer.h"
#include "ADIOS.h"
+#include "functions/adiosFunctions.h"
extern int adios_verbose_level;
extern int adios_errno;
@@ -19,13 +20,11 @@ extern int adios_errno;
namespace adios
{
-ADIOS1Writer::ADIOS1Writer(ADIOS &adios, const std::string name,
+ADIOS1Writer::ADIOS1Writer(ADIOS &adios, const std::string &name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode,
- const unsigned int nthreads)
-: Engine(adios, "ADIOS1Writer", name, accessMode, mpiComm, method, debugMode,
- nthreads, " ADIOS1Writer constructor (or call to ADIOS Open).\n"),
+ const Method &method)
+: Engine(adios, "ADIOS1Writer", name, accessMode, mpiComm, method,
+ " ADIOS1Writer constructor (or call to ADIOS Open).\n"),
m_groupname{method.m_Name.c_str()}, m_filename{name.c_str()}, m_comm{mpiComm}
{
Init();
@@ -104,52 +103,52 @@ void ADIOS1Writer::WriteVariable(std::string name, bool isScalar,
void ADIOS1Writer::Write(Variable<char> &variable, const char *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_byte,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<unsigned char> &variable,
const unsigned char *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_unsigned_byte,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<short> &variable, const short *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_short,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<unsigned short> &variable,
const unsigned short *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_unsigned_short,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<int> &variable, const int *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_integer,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<unsigned int> &variable,
const unsigned int *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_unsigned_integer,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<long int> &variable, const long int *values)
@@ -161,9 +160,9 @@ void ADIOS1Writer::Write(Variable<long int> &variable, const long int *values)
type = adios_long;
}
WriteVariable(variable.m_Name, variable.m_IsScalar, type,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<unsigned long int> &variable,
@@ -176,43 +175,43 @@ void ADIOS1Writer::Write(Variable<unsigned long int> &variable,
type = adios_unsigned_long;
}
WriteVariable(variable.m_Name, variable.m_IsScalar, type,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<long long int> &variable,
const long long int *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_long,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<unsigned long long int> &variable,
const unsigned long long int *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_unsigned_long,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<float> &variable, const float *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_real,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<double> &variable, const double *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_double,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<long double> &variable,
@@ -222,27 +221,27 @@ void ADIOS1Writer::Write(Variable<long double> &variable,
* but
* long double is compiler dependent */
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_long_double,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<std::complex<float>> &variable,
const std::complex<float> *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_complex,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<std::complex<double>> &variable,
const std::complex<double> *values)
{
WriteVariable(variable.m_Name, variable.m_IsScalar, adios_double_complex,
- variable.GetDimensionAsString(),
- variable.GetGlobalDimensionAsString(),
- variable.GetOffsetsAsString(), values);
+ DimsToCSV(variable.m_LocalDimensions),
+ DimsToCSV(variable.m_GlobalDimensions),
+ DimsToCSV(variable.m_Offsets), values);
}
void ADIOS1Writer::Write(Variable<std::complex<long double>> &variable,
@@ -262,97 +261,98 @@ void ADIOS1Writer::Write(VariableCompound &variable, const void *values)
}
// String version
-void ADIOS1Writer::Write(const std::string variableName, const char *values)
+void ADIOS1Writer::Write(const std::string &variableName, const char *values)
{
Write(m_ADIOS.GetVariable<char>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const unsigned char *values)
{
Write(m_ADIOS.GetVariable<unsigned char>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName, const short *values)
+void ADIOS1Writer::Write(const std::string &variableName, const short *values)
{
Write(m_ADIOS.GetVariable<short>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const unsigned short *values)
{
Write(m_ADIOS.GetVariable<unsigned short>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName, const int *values)
+void ADIOS1Writer::Write(const std::string &variableName, const int *values)
{
Write(m_ADIOS.GetVariable<int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const unsigned int *values)
{
Write(m_ADIOS.GetVariable<unsigned int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName, const long int *values)
+void ADIOS1Writer::Write(const std::string &variableName,
+ const long int *values)
{
Write(m_ADIOS.GetVariable<long int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const unsigned long int *values)
{
Write(m_ADIOS.GetVariable<unsigned long int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const long long int *values)
{
Write(m_ADIOS.GetVariable<long long int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const unsigned long long int *values)
{
Write(m_ADIOS.GetVariable<unsigned long long int>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName, const float *values)
+void ADIOS1Writer::Write(const std::string &variableName, const float *values)
{
Write(m_ADIOS.GetVariable<float>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName, const double *values)
+void ADIOS1Writer::Write(const std::string &variableName, const double *values)
{
Write(m_ADIOS.GetVariable<double>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const long double *values)
{
Write(m_ADIOS.GetVariable<long double>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const std::complex<float> *values)
{
Write(m_ADIOS.GetVariable<std::complex<float>>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const std::complex<double> *values)
{
Write(m_ADIOS.GetVariable<std::complex<double>>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const std::complex<long double> *values)
{
Write(m_ADIOS.GetVariable<std::complex<long double>>(variableName), values);
}
-void ADIOS1Writer::Write(const std::string variableName,
+void ADIOS1Writer::Write(const std::string &variableName,
const void *values) // Compound type
{
throw std::invalid_argument("ERROR: Adios 1.x does not support compound "
@@ -360,7 +360,7 @@ void ADIOS1Writer::Write(const std::string variableName,
variableName + "\n");
}
-void ADIOS1Writer::Advance()
+void ADIOS1Writer::Advance(const float /*timeout_sec*/)
{
if (m_IsFileOpen)
{
diff --git a/source/engine/bp/BPFileReader.cpp b/source/engine/bp/BPFileReader.cpp
index b12b655e0f6327c094c9757f3cf255408db3ddfe..7d49cf6d135663533801943ea47c8d64d080eb6b 100644
--- a/source/engine/bp/BPFileReader.cpp
+++ b/source/engine/bp/BPFileReader.cpp
@@ -11,134 +11,130 @@
#include "engine/bp/BPFileReader.h"
#include "core/Support.h"
-#include "functions/adiosFunctions.h" //CSVToVector
+#include "functions/adiosFunctions.h" // CSVToVector
+#include "transport/file/FStream.h" // uses C++ fstream
#include "transport/file/FileDescriptor.h" // uses POSIX
#include "transport/file/FilePointer.h" // uses C FILE*
-// supported transports
-#include "transport/file/FStream.h" // uses C++ fstream
-
namespace adios
{
-BPFileReader::BPFileReader(ADIOS &adios, std::string name,
- std::string accessMode, MPI_Comm mpiComm,
- const Method &method, IOMode /*iomode*/,
- float /*timeout_sec*/, bool debugMode,
- unsigned int nthreads)
-: Engine(adios, "BPFileReader", std::move(name), std::move(accessMode), mpiComm,
- method, debugMode, nthreads,
+BPFileReader::BPFileReader(ADIOS &adios, const std::string &name,
+ const std::string accessMode, MPI_Comm mpiComm,
+ const Method &method)
+: Engine(adios, "BPFileReader", name, accessMode, mpiComm, method,
" BPFileReader constructor (or call to ADIOS Open).\n"),
m_Buffer(accessMode, m_RankMPI, m_DebugMode)
{
Init();
}
-Variable<void> *BPFileReader::InquireVariable(const std::string /*name*/,
+Variable<void> *BPFileReader::InquireVariable(const std::string & /*name*/,
const bool /*readIn*/)
{
// not yet implemented
return nullptr;
}
-Variable<char> *BPFileReader::InquireVariableChar(const std::string name,
+Variable<char> *BPFileReader::InquireVariableChar(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<char>(name, readIn);
}
Variable<unsigned char> *
-BPFileReader::InquireVariableUChar(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUChar(const std::string &name, const bool readIn)
{
return InquireVariableCommon<unsigned char>(name, readIn);
}
-Variable<short> *BPFileReader::InquireVariableShort(const std::string name,
+Variable<short> *BPFileReader::InquireVariableShort(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<short>(name, readIn);
}
Variable<unsigned short> *
-BPFileReader::InquireVariableUShort(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUShort(const std::string &name, const bool readIn)
{
return InquireVariableCommon<unsigned short>(name, readIn);
}
-Variable<int> *BPFileReader::InquireVariableInt(const std::string name,
+Variable<int> *BPFileReader::InquireVariableInt(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<int>(name, readIn);
}
Variable<unsigned int> *
-BPFileReader::InquireVariableUInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableUInt(const std::string &name, const bool readIn)
{
return InquireVariableCommon<unsigned int>(name, readIn);
}
-Variable<long int> *BPFileReader::InquireVariableLInt(const std::string name,
+Variable<long int> *BPFileReader::InquireVariableLInt(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<long int>(name, readIn);
}
Variable<unsigned long int> *
-BPFileReader::InquireVariableULInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableULInt(const std::string &name, const bool readIn)
{
return InquireVariableCommon<unsigned long int>(name, readIn);
}
Variable<long long int> *
-BPFileReader::InquireVariableLLInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableLLInt(const std::string &name, const bool readIn)
{
return InquireVariableCommon<long long int>(name, readIn);
}
Variable<unsigned long long int> *
-BPFileReader::InquireVariableULLInt(const std::string name, const bool readIn)
+BPFileReader::InquireVariableULLInt(const std::string &name, const bool readIn)
{
return InquireVariableCommon<unsigned long long int>(name, readIn);
}
-Variable<float> *BPFileReader::InquireVariableFloat(const std::string name,
+Variable<float> *BPFileReader::InquireVariableFloat(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<float>(name, readIn);
}
-Variable<double> *BPFileReader::InquireVariableDouble(const std::string name,
+Variable<double> *BPFileReader::InquireVariableDouble(const std::string &name,
const bool readIn)
{
return InquireVariableCommon<double>(name, readIn);
}
Variable<long double> *
-BPFileReader::InquireVariableLDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableLDouble(const std::string &name, const bool readIn)
{
return InquireVariableCommon<long double>(name, readIn);
}
Variable<std::complex<float>> *
-BPFileReader::InquireVariableCFloat(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCFloat(const std::string &name, const bool readIn)
{
return InquireVariableCommon<std::complex<float>>(name, readIn);
}
Variable<std::complex<double>> *
-BPFileReader::InquireVariableCDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCDouble(const std::string &name, const bool readIn)
{
return InquireVariableCommon<std::complex<double>>(name, readIn);
}
Variable<std::complex<long double>> *
-BPFileReader::InquireVariableCLDouble(const std::string name, const bool readIn)
+BPFileReader::InquireVariableCLDouble(const std::string &name,
+ const bool readIn)
{
return InquireVariableCommon<std::complex<long double>>(name, readIn);
}
VariableCompound *
-BPFileReader::InquireVariableCompound(const std::string /*name*/,
+BPFileReader::InquireVariableCompound(const std::string & /*name*/,
const bool /*readIn*/)
{
return nullptr;
@@ -160,15 +156,9 @@ void BPFileReader::Init()
}
}
- InitCapsules();
InitTransports();
}
-void BPFileReader::InitCapsules()
-{
- // here init memory capsules
-}
-
void BPFileReader::InitTransports() // maybe move this?
{
if (m_DebugMode == true)
diff --git a/source/engine/bp/BPFileWriter.cpp b/source/engine/bp/BPFileWriter.cpp
index 62f6c4d72c34678fcb987787d58b23b8568dadb9..027b60266660bad19356b7346a9ff3b45f22ca65 100644
--- a/source/engine/bp/BPFileWriter.cpp
+++ b/source/engine/bp/BPFileWriter.cpp
@@ -20,20 +20,16 @@
namespace adios
{
-BPFileWriter::BPFileWriter(ADIOS &adios, std::string name,
- const std::string &accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode /*iomode*/,
- const float /*timeout_sec*/, const bool debugMode,
- const unsigned int nthreads)
-: Engine(adios, "BPFileWriter", std::move(name), accessMode, mpiComm, method,
- debugMode, nthreads,
+BPFileWriter::BPFileWriter(ADIOS &adios, const std::string &name,
+ const std::string accessMode, MPI_Comm mpiComm,
+ const Method &method)
+: Engine(adios, "BPFileWriter", name, accessMode, mpiComm, method,
" BPFileWriter constructor (or call to ADIOS Open).\n"),
m_Buffer(accessMode, m_RankMPI, m_DebugMode),
- m_BP1Aggregator(m_MPIComm, debugMode),
+ m_BP1Aggregator(m_MPIComm, m_DebugMode),
m_MaxBufferSize(m_Buffer.m_Data.max_size())
{
- m_MetadataSet.TimeStep =
- 1; // starting at one to be compatible with ADIOS1.x
+ m_MetadataSet.TimeStep = 1; // to be compatible with ADIOS1.x
Init();
}
@@ -142,106 +138,107 @@ void BPFileWriter::Write(VariableCompound & /*variable*/,
}
// String version
-void BPFileWriter::Write(const std::string variableName, const char *values)
+void BPFileWriter::Write(const std::string &variableName, const char *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<char>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const unsigned char *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned char>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName, const short *values)
+void BPFileWriter::Write(const std::string &variableName, const short *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<short>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const unsigned short *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned short>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName, const int *values)
+void BPFileWriter::Write(const std::string &variableName, const int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<int>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const unsigned int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned int>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName, const long int *values)
+void BPFileWriter::Write(const std::string &variableName,
+ const long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long int>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const unsigned long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned long int>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const long long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long long int>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const unsigned long long int *values)
{
WriteVariableCommon(
m_ADIOS.GetVariable<unsigned long long int>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName, const float *values)
+void BPFileWriter::Write(const std::string &variableName, const float *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<float>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName, const double *values)
+void BPFileWriter::Write(const std::string &variableName, const double *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<double>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const long double *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long double>(variableName), values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const std::complex<float> *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<std::complex<float>>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const std::complex<double> *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<std::complex<double>>(variableName),
values);
}
-void BPFileWriter::Write(const std::string variableName,
+void BPFileWriter::Write(const std::string &variableName,
const std::complex<long double> *values)
{
WriteVariableCommon(
m_ADIOS.GetVariable<std::complex<long double>>(variableName), values);
}
-void BPFileWriter::Write(const std::string /*variableName*/,
+void BPFileWriter::Write(const std::string & /*variableName*/,
const void * /*values*/) // Compound type
{
}
@@ -270,7 +267,7 @@ void BPFileWriter::Close(const int transportIndex)
false); // false: not using aggregation for now
}
- if (m_MetadataSet.Log.m_IsActive == true)
+ if (m_MetadataSet.Log.IsActive == true)
{
bool allClose = true;
for (auto &transport : m_Transports)
@@ -353,33 +350,28 @@ void BPFileWriter::InitParameters()
auto itProfile = m_Method.m_Parameters.find("profile_units");
if (itProfile != m_Method.m_Parameters.end())
{
- auto &profiler = m_MetadataSet.Log;
+ auto &log = m_MetadataSet.Log;
if (itProfile->second == "mus" || itProfile->second == "microseconds")
{
- profiler.m_Timers.emplace_back("buffering",
- Support::Resolutions::mus);
+ log.Timers.emplace_back("buffering", Support::Resolutions::mus);
}
else if (itProfile->second == "ms" ||
itProfile->second == "milliseconds")
{
- profiler.m_Timers.emplace_back("buffering",
- Support::Resolutions::ms);
+ log.Timers.emplace_back("buffering", Support::Resolutions::ms);
}
else if (itProfile->second == "s" || itProfile->second == "seconds")
{
- profiler.m_Timers.emplace_back("buffering",
- Support::Resolutions::s);
+ log.Timers.emplace_back("buffering", Support::Resolutions::s);
}
else if (itProfile->second == "min" || itProfile->second == "minutes")
{
- profiler.m_Timers.emplace_back("buffering",
- Support::Resolutions::m);
+ log.Timers.emplace_back("buffering", Support::Resolutions::m);
}
else if (itProfile->second == "h" || itProfile->second == "hours")
{
- profiler.m_Timers.emplace_back("buffering",
- Support::Resolutions::h);
+ log.Timers.emplace_back("buffering", Support::Resolutions::h);
}
else
{
@@ -392,7 +384,7 @@ void BPFileWriter::InitParameters()
}
}
- profiler.m_IsActive = true;
+ log.IsActive = true;
}
}
@@ -527,9 +519,9 @@ void BPFileWriter::InitTransports()
void BPFileWriter::InitProcessGroup()
{
- if (m_MetadataSet.Log.m_IsActive == true)
+ if (m_MetadataSet.Log.IsActive == true)
{
- m_MetadataSet.Log.m_Timers[0].SetInitialTime();
+ m_MetadataSet.Log.Timers[0].SetInitialTime();
}
if (m_AccessMode == "a")
@@ -540,9 +532,9 @@ void BPFileWriter::InitProcessGroup()
WriteProcessGroupIndex();
- if (m_MetadataSet.Log.m_IsActive == true)
+ if (m_MetadataSet.Log.IsActive == true)
{
- m_MetadataSet.Log.m_Timers[0].SetTime();
+ m_MetadataSet.Log.Timers[0].SetTime();
}
}
diff --git a/source/engine/dataman/DataManReader.cpp b/source/engine/dataman/DataManReader.cpp
index 9de0149532e6302aa7ceb7133260d044f7804c8f..f90c446d885f3eb23a3e36f8c7d590c343c2b4ae 100644
--- a/source/engine/dataman/DataManReader.cpp
+++ b/source/engine/dataman/DataManReader.cpp
@@ -14,11 +14,11 @@
#include "functions/adiosFunctions.h" //CSVToVector
// supported transports
-#include "transport/file/FStream.h" // uses C++ fstream
-#include "transport/wan/MdtmMan.h" //uses Mdtm library
+#include "transport/file/FStream.h" // uses C++ fstream
+#include "transport/file/FileDescriptor.h" // uses POSIX
+#include "transport/file/FilePointer.h" // uses C FILE*
+#include "transport/wan/MdtmMan.h" //uses Mdtm library
-#include "../../../include/transport/file/FileDescriptor.h" // uses POSIX
-#include "../../../include/transport/file/FilePointer.h" // uses C FILE*
#include "DataMan.h" //here comes your DataMan header from external dataman library
namespace adios
@@ -26,12 +26,10 @@ namespace adios
DataManReader::DataManReader(ADIOS &adios, const std::string name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode,
- const unsigned int nthreads)
-: Engine(adios, "DataManReader", name, accessMode, mpiComm, method, debugMode,
- nthreads, " DataManReader constructor (or call to ADIOS Open).\n"),
- m_Buffer(accessMode, m_RankMPI, m_DebugMode)
+ const Method &method)
+: Engine(adios, "DataManReader", name, accessMode, mpiComm, method,
+ " DataManReader constructor (or call to ADIOS Open).\n")
+// m_Buffer(accessMode, m_RankMPI, m_DebugMode)
{
Init();
}
@@ -236,16 +234,10 @@ void DataManReader::Init()
}
else
{
- InitCapsules();
InitTransports();
}
}
-void DataManReader::InitCapsules()
-{
- // here init memory capsules
-}
-
void DataManReader::InitTransports() // maybe move this?
{
TransportNamesUniqueness();
diff --git a/source/engine/dataman/DataManWriter.cpp b/source/engine/dataman/DataManWriter.cpp
index 2aa7aaac8bd393d59c6ec923e990ccdc77bccb7c..de1cf8455a4cc0d60ecfb49e19d8a0c7193ce64b 100644
--- a/source/engine/dataman/DataManWriter.cpp
+++ b/source/engine/dataman/DataManWriter.cpp
@@ -24,11 +24,9 @@ namespace adios
DataManWriter::DataManWriter(ADIOS &adios, const std::string name,
const std::string accessMode, MPI_Comm mpiComm,
- const Method &method, const IOMode iomode,
- const float timeout_sec, const bool debugMode,
- const unsigned int nthreads)
-: Engine(adios, "DataManWriter", name, accessMode, mpiComm, method, debugMode,
- nthreads, " DataManWriter constructor (or call to ADIOS Open).\n"),
+ const Method &method)
+: Engine(adios, "DataManWriter", name, accessMode, mpiComm, method,
+ " DataManWriter constructor (or call to ADIOS Open).\n"),
m_Buffer(accessMode, m_RankMPI, m_DebugMode)
{
Init();
@@ -136,100 +134,100 @@ void DataManWriter::Write(Variable<std::complex<long double>> &variable,
}
// String version
-void DataManWriter::Write(const std::string variableName, const char *values)
+void DataManWriter::Write(const std::string &variableName, const char *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<char>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const unsigned char *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned char>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName, const short *values)
+void DataManWriter::Write(const std::string &variableName, const short *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<short>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const unsigned short *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned short>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName, const int *values)
+void DataManWriter::Write(const std::string &variableName, const int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<int>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const unsigned int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned int>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long int>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const unsigned long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<unsigned long int>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const long long int *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long long int>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const unsigned long long int *values)
{
WriteVariableCommon(
m_ADIOS.GetVariable<unsigned long long int>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName, const float *values)
+void DataManWriter::Write(const std::string &variableName, const float *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<float>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName, const double *values)
+void DataManWriter::Write(const std::string &variableName, const double *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<double>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const long double *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<long double>(variableName), values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const std::complex<float> *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<std::complex<float>>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const std::complex<double> *values)
{
WriteVariableCommon(m_ADIOS.GetVariable<std::complex<double>>(variableName),
values);
}
-void DataManWriter::Write(const std::string variableName,
+void DataManWriter::Write(const std::string &variableName,
const std::complex<long double> *values)
{
WriteVariableCommon(
@@ -329,16 +327,10 @@ void DataManWriter::Init()
}
else
{
- InitCapsules();
InitTransports();
}
}
-void DataManWriter::InitCapsules()
-{
- // here init memory capsules
-}
-
void DataManWriter::InitTransports() // maybe move this?
{
TransportNamesUniqueness();
diff --git a/source/functions/adiosFunctions.cpp b/source/functions/adiosFunctions.cpp
index 032d3aeb6238c0d8bfd0abe324971b465f49b8fe..47ab64cac7c6d82195b1449fc954900249052c31 100644
--- a/source/functions/adiosFunctions.cpp
+++ b/source/functions/adiosFunctions.cpp
@@ -633,6 +633,23 @@ std::vector<int> CSVToVectorInt(const std::string csv)
return numbers;
}
+std::string DimsToCSV(const std::vector<std::size_t> &dims)
+{
+ std::string dimsCSV;
+
+ for (const auto dim : dims)
+ {
+ dimsCSV += std::to_string(dim) + ",";
+ }
+
+ if (dimsCSV.empty() == false)
+ {
+ dimsCSV.pop_back();
+ }
+
+ return dimsCSV;
+}
+
void ConvertUint64VectorToSizetVector(const std::vector<std::uint64_t> &in,
std::vector<std::size_t> &out)
{
diff --git a/source/transport/file/FStream.cpp b/source/transport/file/FStream.cpp
index b516de8b067f6b6d373ba237965999e3c72b62d6..a813c67f27d8ed9ed30a706e3c7ca67285fa2e6a 100644
--- a/source/transport/file/FStream.cpp
+++ b/source/transport/file/FStream.cpp
@@ -20,12 +20,12 @@ namespace adios
namespace transport
{
-FStream::FStream(MPI_Comm mpiComm, bool debugMode)
+FStream::FStream(MPI_Comm mpiComm, const bool debugMode)
: Transport("fstream", mpiComm, debugMode)
{
}
-void FStream::Open(const std::string name, const std::string accessMode)
+void FStream::Open(const std::string &name, const std::string accessMode)
{
m_Name = name;
m_AccessMode = accessMode;
diff --git a/source/transport/file/FileDescriptor.cpp b/source/transport/file/FileDescriptor.cpp
index e1c3df9ab69d0ecd027a9ea3af072674e084e5ec..b71980c0f83403e3fa4e9ac65485e8262cd54ebd 100644
--- a/source/transport/file/FileDescriptor.cpp
+++ b/source/transport/file/FileDescriptor.cpp
@@ -9,11 +9,11 @@
*/
/// \cond EXCLUDE_FROM_DOXYGEN
-#include <fcntl.h> //open
-#include <ios> //std::ios_base::failure
+#include <fcntl.h> // open
+#include <ios> // std::ios_base::failure
#include <stddef.h> // write output
-#include <sys/stat.h> //open
-#include <sys/types.h> //open
+#include <sys/stat.h> // open
+#include <sys/types.h> // open
#include <unistd.h> // write, close
/// \endcond
@@ -37,52 +37,52 @@ FileDescriptor::~FileDescriptor()
}
}
-void FileDescriptor::Open(const std::string name, const std::string accessMode)
+void FileDescriptor::Open(const std::string &name, const std::string accessMode)
{
m_Name = name;
m_AccessMode = accessMode;
if (accessMode == "w" || accessMode == "write")
{
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetInitialTime();
+ m_Profiler.Timers[0].SetInitialTime();
}
m_FileDescriptor = open(m_Name.c_str(), O_WRONLY | O_CREAT, 0777);
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetTime();
+ m_Profiler.Timers[0].SetTime();
}
}
else if (accessMode == "a" || accessMode == "append")
{
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetInitialTime();
+ m_Profiler.Timers[0].SetInitialTime();
}
m_FileDescriptor = open(m_Name.c_str(),
O_WRONLY | O_APPEND); // we need to change this
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetTime();
+ m_Profiler.Timers[0].SetTime();
}
}
else if (accessMode == "r" || accessMode == "read")
{
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetInitialTime();
+ m_Profiler.Timers[0].SetInitialTime();
}
m_FileDescriptor = open(m_Name.c_str(), O_RDONLY);
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[0].SetTime();
+ m_Profiler.Timers[0].SetTime();
}
}
@@ -100,16 +100,16 @@ void FileDescriptor::Open(const std::string name, const std::string accessMode)
void FileDescriptor::Write(const char *buffer, std::size_t size)
{
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[1].SetInitialTime();
+ m_Profiler.Timers[1].SetInitialTime();
}
auto writtenSize = write(m_FileDescriptor, buffer, size);
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[1].SetTime();
+ m_Profiler.Timers[1].SetTime();
}
if (m_DebugMode == true)
@@ -132,16 +132,16 @@ void FileDescriptor::Write(const char *buffer, std::size_t size)
void FileDescriptor::Close()
{
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[2].SetInitialTime();
+ m_Profiler.Timers[2].SetInitialTime();
}
int status = close(m_FileDescriptor);
- if (m_Profiler.m_IsActive == true)
+ if (m_Profiler.IsActive == true)
{
- m_Profiler.m_Timers[2].SetTime();
+ m_Profiler.Timers[2].SetTime();
}
if (m_DebugMode == true)
diff --git a/source/transport/file/FilePointer.cpp b/source/transport/file/FilePointer.cpp
index 4cbe9a8918f4c8a2fcae03543460292e2a22648b..75effdf4311ac592d0453cfe347254a73de56aa3 100644
--- a/source/transport/file/FilePointer.cpp
+++ b/source/transport/file/FilePointer.cpp
@@ -32,7 +32,7 @@ FilePointer::~FilePointer()
}
}
-void FilePointer::Open(const std::string name, const std::string accessMode)
+void FilePointer::Open(const std::string &name, const std::string accessMode)
{
m_Name = name;
m_AccessMode = accessMode;
diff --git a/source/format/BP1Aggregator.cpp b/source/utilities/format/bp1/BP1Aggregator.cpp
similarity index 81%
rename from source/format/BP1Aggregator.cpp
rename to source/utilities/format/bp1/BP1Aggregator.cpp
index 7b095cb112fa0bb3c54c788e4b731db1f75ba2a7..b4468c03647989a1ce63c443b4493ede3771227a 100644
--- a/source/format/BP1Aggregator.cpp
+++ b/source/utilities/format/bp1/BP1Aggregator.cpp
@@ -9,13 +9,13 @@
*/
/// \cond EXCLUDE_FROM_DOXYGEN
+#include "utilities/format/bp1/BP1Aggregator.h"
+
#include <fstream>
#include <stdexcept>
#include <vector>
/// \endcond
-#include "format/BP1Aggregator.h"
-
namespace adios
{
namespace format
@@ -28,26 +28,23 @@ BP1Aggregator::BP1Aggregator(MPI_Comm mpiComm, const bool debugMode)
MPI_Comm_size(m_MPIComm, &m_SizeMPI);
}
-BP1Aggregator::~BP1Aggregator() = default;
+BP1Aggregator::~BP1Aggregator() {}
void BP1Aggregator::WriteProfilingLog(const std::string fileName,
const std::string &rankLog)
{
if (m_RankMPI == 0)
{
- unsigned int sizeMPI = static_cast<unsigned int>(m_SizeMPI);
- std::vector<std::vector<char>> rankLogs(
- sizeMPI - 1); // rankLogs from other processes
- std::vector<int> rankLogsSizes(sizeMPI - 1, -1); // init with -1
+ const unsigned int sizeMPI = static_cast<const unsigned int>(m_SizeMPI);
+ std::vector<std::vector<char>> rankLogs(sizeMPI - 1); // other ranks
+ std::vector<int> rankLogsSizes(sizeMPI - 1, -1); // init with -1
std::vector<MPI_Request> requests(sizeMPI);
std::vector<MPI_Status> statuses(sizeMPI);
// first receive sizes
for (unsigned int i = 1; i < sizeMPI; ++i)
- {
MPI_Irecv(&rankLogsSizes[i - 1], 1, MPI_INT, i, 0, m_MPIComm,
&requests[i]);
- }
for (unsigned int i = 1; i < sizeMPI; ++i)
{
@@ -55,27 +52,21 @@ void BP1Aggregator::WriteProfilingLog(const std::string fileName,
if (m_DebugMode == true)
{
if (rankLogsSizes[i - 1] == -1)
- {
throw std::runtime_error(
"ERROR: couldn't get size from rank " +
std::to_string(i) +
", in ADIOS aggregator for Profiling.log\n");
- }
}
rankLogs[i - 1].resize(rankLogsSizes[i - 1]); // allocate with zeros
}
// receive rankLog from other ranks
for (unsigned int i = 1; i < sizeMPI; ++i)
- {
MPI_Irecv(rankLogs[i - 1].data(), rankLogsSizes[i - 1], MPI_CHAR, i,
1, m_MPIComm, &requests[i]);
- }
for (unsigned int i = 1; i < sizeMPI; ++i)
- {
MPI_Wait(&requests[i], &statuses[i]);
- }
// write file
std::string logFile("log = { \n");
@@ -94,13 +85,13 @@ void BP1Aggregator::WriteProfilingLog(const std::string fileName,
}
else
{
- int rankLogSize = static_cast<int>(rankLog.size());
+ const int rankLogSize = static_cast<const int>(rankLog.size());
MPI_Request requestSize;
MPI_Isend(&rankLogSize, 1, MPI_INT, 0, 0, m_MPIComm, &requestSize);
MPI_Request requestRankLog;
- MPI_Isend(rankLog.data(), rankLogSize, MPI_CHAR, 0, 1, m_MPIComm,
- &requestRankLog);
+ MPI_Isend(const_cast<char *>(rankLog.c_str()), rankLogSize, MPI_CHAR, 0,
+ 1, m_MPIComm, &requestRankLog);
}
}
diff --git a/source/format/BP1.cpp b/source/utilities/format/bp1/BP1Base.cpp
similarity index 75%
rename from source/format/BP1.cpp
rename to source/utilities/format/bp1/BP1Base.cpp
index ef69751b1918312def11a2b3005594abf9afd829..9c44724575cc721eb8a6786fe359af3e9a5bb611 100644
--- a/source/format/BP1.cpp
+++ b/source/utilities/format/bp1/BP1Base.cpp
@@ -8,7 +8,7 @@
* Author: wfg
*/
-#include "format/BP1.h"
+#include "utilities/format/bp1/BP1Base.h"
#include "functions/adiosFunctions.h"
namespace adios
@@ -16,7 +16,7 @@ namespace adios
namespace format
{
-std::string BP1::GetDirectoryName(const std::string name) const noexcept
+std::string BP1Base::GetDirectoryName(const std::string name) const noexcept
{
std::string directory;
@@ -31,8 +31,9 @@ std::string BP1::GetDirectoryName(const std::string name) const noexcept
return directory;
}
-void BP1::OpenRankFiles(const std::string name, const std::string accessMode,
- Transport &file) const
+// this should go outside
+void BP1Base::OpenRankFiles(const std::string name,
+ const std::string accessMode, Transport &file) const
{
const std::string directory = GetDirectoryName(name);
CreateDirectory(
@@ -41,35 +42,25 @@ void BP1::OpenRankFiles(const std::string name, const std::string accessMode,
std::string fileName(directory + "/" + directory + "." +
std::to_string(file.m_RankMPI));
file.Open(fileName, accessMode); // opens a file transport under
- // name.bp.dir/name.bp.rank reserve that
- // location fro writing
+ // name.bp/name.bp.rank reserve that
+ // location for writing
}
-std::vector<std::uint8_t> BP1::GetMethodIDs(
+std::vector<std::uint8_t> BP1Base::GetMethodIDs(
const std::vector<std::shared_ptr<Transport>> &transports) const noexcept
{
auto lf_GetMethodID = [](const std::string method) -> std::uint8_t {
int id = METHOD_UNKNOWN;
if (method == "NULL")
- {
id = METHOD_NULL;
- }
else if (method == "POSIX")
- {
id = METHOD_POSIX;
- }
else if (method == "FStream")
- {
id = METHOD_FSTREAM;
- }
else if (method == "File")
- {
id = METHOD_FILE;
- }
else if (method == "MPI")
- {
id = METHOD_MPI;
- }
return id;
};
@@ -78,9 +69,7 @@ std::vector<std::uint8_t> BP1::GetMethodIDs(
methodIDs.reserve(transports.size());
for (const auto &transport : transports)
- {
methodIDs.push_back(lf_GetMethodID(transport->m_Type));
- }
return methodIDs;
}
diff --git a/source/format/BP1Writer.cpp b/source/utilities/format/bp1/BP1Writer.cpp
similarity index 89%
rename from source/format/BP1Writer.cpp
rename to source/utilities/format/bp1/BP1Writer.cpp
index 47b1ab716b5a0eeff07b5f6b22b8bbd5362e08af..30d393e9f088d9aa26f7ef2521af0abef12fc47e 100644
--- a/source/format/BP1Writer.cpp
+++ b/source/utilities/format/bp1/BP1Writer.cpp
@@ -9,13 +9,12 @@
*/
/// \cond EXCLUDE_FROM_DOXYGEN
+#include "utilities/format/bp1/BP1Writer.h"
+
#include <string>
#include <vector>
/// \endcond
-#include "core/Profiler.h"
-#include "format/BP1Writer.h"
-
namespace adios
{
namespace format
@@ -71,8 +70,8 @@ void BP1Writer::WriteProcessGroupIndex(
CopyToBuffer(dataBuffer, &metadataSet.TimeStep);
// offset to pg in data in metadata which is the current absolute position
- CopyToBuffer(metadataBuffer,
- reinterpret_cast<uint64_t *>(&heap.m_DataAbsolutePosition));
+ CopyToBuffer(metadataBuffer, reinterpret_cast<std::uint64_t *>(
+ &heap.m_DataAbsolutePosition));
// Back to writing metadata pg index length (length of group)
const std::uint16_t metadataPGIndexLength =
@@ -121,24 +120,18 @@ void BP1Writer::Close(BP1MetadataSet &metadataSet, capsule::STLVector &heap,
Transport &transport, bool &isFirstClose,
const bool doAggregation) const noexcept
{
- if (metadataSet.Log.m_IsActive == true)
- {
- metadataSet.Log.m_Timers[0].SetInitialTime();
- }
+ if (metadataSet.Log.IsActive == true)
+ metadataSet.Log.Timers[0].SetInitialTime();
if (isFirstClose == true)
{
if (metadataSet.DataPGIsOpen == true)
- {
FlattenData(metadataSet, heap);
- }
FlattenMetadata(metadataSet, heap);
- if (metadataSet.Log.m_IsActive == true)
- {
- metadataSet.Log.m_Timers[0].SetInitialTime();
- }
+ if (metadataSet.Log.IsActive == true)
+ metadataSet.Log.Timers[0].SetInitialTime();
if (doAggregation ==
true) // N-to-M where 1 <= M <= N-1, might need a new
@@ -165,29 +158,28 @@ std::string BP1Writer::GetRankProfilingLog(
const int rank, const BP1MetadataSet &metadataSet,
const std::vector<std::shared_ptr<Transport>> &transports) const noexcept
{
- auto lf_WriterTimer = [](std::string &rankLog, const Timer &timer) {
- rankLog += "'" + timer.Process + "_" + timer.GetUnits() + "': " +
- std::to_string(timer.ProcessTime) + ", ";
+ auto lf_WriterTimer = [](std::string &rankLog,
+ const profiling::Timer &timer) {
+ rankLog += "'" + timer.m_Process + "_" + timer.GetUnits() + "': " +
+ std::to_string(timer.m_ProcessTime) + ", ";
};
// prepare string dictionary per rank
std::string rankLog("'rank_" + std::to_string(rank) + "': { ");
auto &profiler = metadataSet.Log;
- rankLog += "'bytes': " + std::to_string(profiler.m_TotalBytes[0]) + ", ";
- lf_WriterTimer(rankLog, profiler.m_Timers[0]);
+ rankLog += "'bytes': " + std::to_string(profiler.TotalBytes[0]) + ", ";
+ lf_WriterTimer(rankLog, profiler.Timers[0]);
for (unsigned int t = 0; t < transports.size(); ++t)
{
- auto &timers = transports[t]->m_Profiler.m_Timers;
+ auto &timers = transports[t]->m_Profiler.Timers;
rankLog += "'transport_" + std::to_string(t) + "': { ";
rankLog += "'lib': " + transports[t]->m_Type + ", ";
for (unsigned int i = 0; i < 3; ++i)
- {
lf_WriterTimer(rankLog, timers[i]);
- }
rankLog += "}, ";
}
@@ -206,7 +198,8 @@ void BP1Writer::WriteDimensionsRecord(
auto lf_WriteFlaggedDim = [](std::vector<char> &buffer, const char no,
const std::size_t dimension) {
CopyToBuffer(buffer, &no);
- CopyToBuffer(buffer, reinterpret_cast<const uint64_t *>(&dimension));
+ CopyToBuffer(buffer,
+ reinterpret_cast<const std::uint64_t *>(&dimension));
};
// BODY Starts here
@@ -227,7 +220,7 @@ void BP1Writer::WriteDimensionsRecord(
{
for (const auto &localDimension : localDimensions)
{
- CopyToBuffer(buffer, reinterpret_cast<const uint64_t *>(
+ CopyToBuffer(buffer, reinterpret_cast<const std::uint64_t *>(
&localDimension));
buffer.insert(buffer.end(), skip, 0);
}
@@ -237,8 +230,7 @@ void BP1Writer::WriteDimensionsRecord(
{
if (addType == true)
{
- constexpr char no =
- 'n'; // dimension format unsigned int value for now
+ constexpr char no = 'n';
for (unsigned int d = 0; d < localDimensions.size(); ++d)
{
lf_WriteFlaggedDim(buffer, no, localDimensions[d]);
@@ -250,11 +242,11 @@ void BP1Writer::WriteDimensionsRecord(
{
for (unsigned int d = 0; d < localDimensions.size(); ++d)
{
- CopyToBuffer(buffer, reinterpret_cast<const uint64_t *>(
+ CopyToBuffer(buffer, reinterpret_cast<const std::uint64_t *>(
&localDimensions[d]));
- CopyToBuffer(buffer, reinterpret_cast<const uint64_t *>(
+ CopyToBuffer(buffer, reinterpret_cast<const std::uint64_t *>(
&globalDimensions[d]));
- CopyToBuffer(buffer, reinterpret_cast<const uint64_t *>(
+ CopyToBuffer(buffer, reinterpret_cast<const std::uint64_t *>(
&globalOffsets[d]));
}
}
@@ -319,6 +311,7 @@ void BP1Writer::FlattenMetadata(BP1MetadataSet &metadataSet,
auto lf_IndexCountLength =
[](std::unordered_map<std::string, BP1Index> &indices,
std::uint32_t &count, std::uint64_t &length) {
+
count = indices.size();
length = 0;
for (auto &indexPair : indices) // set each index length
@@ -402,10 +395,8 @@ void BP1Writer::FlattenMetadata(BP1MetadataSet &metadataSet,
heap.m_DataAbsolutePosition += footerSize;
- if (metadataSet.Log.m_IsActive == true)
- {
- metadataSet.Log.m_TotalBytes.push_back(heap.m_DataAbsolutePosition);
- }
+ if (metadataSet.Log.IsActive == true)
+ metadataSet.Log.TotalBytes.push_back(heap.m_DataAbsolutePosition);
}
} // end namespace format
diff --git a/source/utilities/profiling/iochrono/Timer.cpp b/source/utilities/profiling/iochrono/Timer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..797cb32b9b8840de2083bcc4f9800a18292881eb
--- /dev/null
+++ b/source/utilities/profiling/iochrono/Timer.cpp
@@ -0,0 +1,100 @@
+/*
+ * Distributed under the OSI-approved Apache License, Version 2.0. See
+ * accompanying file Copyright.txt for details.
+ *
+ * Timer.cpp
+ *
+ * Created on: Apr 4, 2017
+ * Author: wfg
+ */
+
+#include "utilities/profiling/iochrono/Timer.h"
+
+namespace adios
+{
+namespace profiling
+{
+
+Timer::Timer(const std::string process, const Support::Resolutions resolution,
+ const bool debug)
+: m_Process{process}, m_Resolution{resolution}, m_DebugMode{debug}
+{
+}
+
+Timer::~Timer() {}
+
+void Timer::SetInitialTime()
+{
+ m_InitialTime = std::chrono::high_resolution_clock::now();
+ m_InitialTimeSet = true;
+}
+
+void Timer::SetTime()
+{
+ m_ElapsedTime = std::chrono::high_resolution_clock::now();
+ m_ProcessTime += GetCurrentTime();
+}
+
+std::string Timer::GetUnits() const
+{
+ std::string units;
+ if (m_Resolution == Support::Resolutions::mus)
+ units = "mus";
+ else if (m_Resolution == Support::Resolutions::ms)
+ units = "ms";
+ else if (m_Resolution == Support::Resolutions::s)
+ units = "s";
+ else if (m_Resolution == Support::Resolutions::m)
+ units = "m";
+ else if (m_Resolution == Support::Resolutions::h)
+ units = "h";
+ return units;
+}
+
+// PRIVATE
+
+long long int Timer::GetCurrentTime()
+{
+ if (m_DebugMode == true)
+ {
+ if (m_InitialTimeSet == false)
+ throw std::invalid_argument("ERROR: SetInitialTime() in process " +
+ m_Process + " not called\n");
+ }
+
+ if (m_Resolution == Support::Resolutions::mus)
+ {
+ return std::chrono::duration_cast<std::chrono::microseconds>(
+ m_ElapsedTime - m_InitialTime)
+ .count();
+ }
+ else if (m_Resolution == Support::Resolutions::ms)
+ {
+ return std::chrono::duration_cast<std::chrono::milliseconds>(
+ m_ElapsedTime - m_InitialTime)
+ .count();
+ }
+ else if (m_Resolution == Support::Resolutions::s)
+ {
+ return std::chrono::duration_cast<std::chrono::seconds>(m_ElapsedTime -
+ m_InitialTime)
+ .count();
+ }
+ else if (m_Resolution == Support::Resolutions::m)
+ {
+ return std::chrono::duration_cast<std::chrono::minutes>(m_ElapsedTime -
+ m_InitialTime)
+ .count();
+ }
+ else if (m_Resolution == Support::Resolutions::h)
+ {
+ return std::chrono::duration_cast<std::chrono::hours>(m_ElapsedTime -
+ m_InitialTime)
+ .count();
+ }
+
+ return -1; // failure
+}
+
+} // end namespace
+} // end namespace