Getting more metadata info

examples/hello/bpReader/helloBPReader.cpp

@@ -41,13 +41,18 @@ int main(int argc, char *argv[])
 
         /** Engine derived class, spawned to start IO operations */
         adios2::Engine &bpReader = bpIO.Open("myVector.bp", adios2::Mode::Read);
-        const std::map<std::string, std::string> variables =
+        const std::map<std::string, adios2::Params> variables =
             bpIO.GetAvailableVariables();
 
-        for (const auto variablePair : variables)
+        for (const auto &variablePair : variables)
         {
-            std::cout << "Name: " << variablePair.first
-                      << "  type: " << variablePair.second << "\n";
+            std::cout << "Name: " << variablePair.first;
+
+            for (const auto &parameter : variablePair.second)
+            {
+                std::cout << "\t" << parameter.first << ": " << parameter.second
+                          << "\n";
+            }
         }
 
         /** Write variable for buffering */
@@ -60,7 +65,7 @@ int main(int argc, char *argv[])
             bpReader.GetSync<float>(*bpFloats, myFloats.data());
         }
 
-        if (bpFloats != nullptr) // means not found
+        if (bpInts != nullptr) // means not found
         {
             bpReader.GetSync<int>(*bpInts, myInts.data());
         }

source/adios2/ADIOSTypes.h

@@ -262,7 +262,11 @@ struct FixedWidthInt<8, false>
 
 // Some core type information that may be useful at compile time
 template <typename T, typename Enable = void>
-struct TypeInfo;
+struct TypeInfo
+{
+    using IOType = T;
+    using ValueType = T;
+};
 
 template <typename T>
 struct TypeInfo<T, typename std::enable_if<std::is_integral<T>::value>::type>

source/adios2/core/Engine.tcc

@@ -77,6 +77,14 @@ ADIOS2_FOREACH_LAUNCH_MODE(declare_launch_mode)
     {                                                                          \
         if (m_DebugMode)                                                       \
         {                                                                      \
+            if (&variable == nullptr)                                          \
+            {                                                                  \
+                throw std::invalid_argument("ERROR: variable reference is "    \
+                                            "undefined, try using "            \
+                                            "IO::InquireVariable(name) "       \
+                                            "function first, in call to Get" + \
+                                            std::string(#L) + "\n");           \
+            }                                                                  \
             variable.CheckDimensions("Get" + std::string(#L));                 \
                                                                                \
             if (data == nullptr)                                               \

source/adios2/core/IO.cpp

@@ -11,6 +11,8 @@
 #include "IO.h"
 #include "IO.tcc"
 
+#include <sstream>
+
 #include "adios2/ADIOSMPI.h"
 #include "adios2/engine/bp/BPFileReader.h"
 #include "adios2/engine/bp/BPFileWriter.h"
@@ -145,14 +147,38 @@ bool IO::RemoveVariable(const std::string &name) noexcept
     return isRemoved;
 }
 
-std::map<std::string, std::string> IO::GetAvailableVariables() const noexcept
+std::map<std::string, Params> IO::GetAvailableVariables() noexcept
 {
-    std::map<std::string, std::string> variables;
+    std::map<std::string, Params> variablesInfo;
     for (const auto &variablePair : m_Variables)
     {
-        variables[variablePair.first] = variablePair.second.first;
+        const std::string name(variablePair.first);
+        const std::string type(variablePair.second.first);
+        variablesInfo[name]["Type"] = type;
+
+        if (type == "compound")
+        {
+        }
+#define declare_template_instantiation(T)                                      \
+    else if (type == GetType<T>())                                             \
+    {                                                                          \
+        Variable<T> &variable = *InquireVariable<T>(name);                     \
+        std::ostringstream minSS;                                              \
+        minSS << variable.m_Min;                                               \
+        variablesInfo[name]["Min"] = minSS.str();                              \
+        std::ostringstream maxSS;                                              \
+        maxSS << variable.m_Max;                                               \
+        variablesInfo[name]["Max"] = maxSS.str();                              \
+        variablesInfo[name]["StepsStart"] =                                    \
+            std::to_string(variable.m_AvailableStepsStart);                    \
+        variablesInfo[name]["StepsCount"] =                                    \
+            std::to_string(variable.m_AvailableStepsCount);                    \
+    }
+        ADIOS2_FOREACH_TYPE_1ARG(declare_template_instantiation)
+#undef declare_template_instantiation
     }
-    return variables;
+    // TODO: add dimensions
+    return variablesInfo;
 }
 
 std::string IO::InquireVariableType(const std::string &name) const noexcept

source/adios2/core/IO.h

@@ -181,7 +181,7 @@ public:
      * Map with variables info: key: name, value: type
      * @return populate map with current variables
      */
-    std::map<std::string, std::string> GetAvailableVariables() const noexcept;
+    std::map<std::string, Params> GetAvailableVariables() noexcept;
 
     /**
      * Gets an existing variable of primitive type by name

source/adios2/core/Variable.h

@@ -18,6 +18,7 @@
 #include <vector>
 /// \endcond
 
+#include "adios2/ADIOSTypes.h"
 #include "adios2/core/VariableBase.h"
 
 namespace adios2
@@ -31,15 +32,10 @@ class Variable : public VariableBase
 {
 
 public:
-    /**
-     * Unique constructor
-     * @param name
-     * @param shape
-     * @param start
-     * @param count
-     * @param constantShape
-     * @param debugMode
-     */
+    typename TypeInfo<T>::ValueType m_Min;
+    typename TypeInfo<T>::ValueType m_Max;
+    typename TypeInfo<T>::ValueType m_Value;
+
     Variable<T>(const std::string &name, const Dims &shape, const Dims &start,
                 const Dims &count, const bool constantShape, T *data,
                 const bool debugMode);

source/adios2/toolkit/format/bp3/BP3Base.h

@@ -326,15 +326,17 @@ protected:
         uint64_t PayloadOffset;
         T Min;
         T Max;
+        T Value;
         uint32_t Step;
         uint32_t FileIndex;
         uint32_t MemberID;
+        bool IsValue = false;
     };
 
     template <class T>
     struct Characteristics
     {
-        Stats<T> Statistics;
+        Stats<typename TypeInfo<T>::ValueType> Statistics;
         Dims Shape;
         Dims Start;
         Dims Count;

source/adios2/toolkit/format/bp3/BP3Base.tcc

@@ -187,19 +187,23 @@ BP3Base::ReadElementIndexCharacteristics(const std::vector<char> &buffer,
 
         case (characteristic_value):
         { // TODO make sure it's string or string array
-            characteristics.Statistics.Min = ReadValue<T>(buffer, position);
+            characteristics.Statistics.Value =
+                ReadValue<typename TypeInfo<T>::ValueType>(buffer, position);
+            characteristics.Statistics.IsValue = true;
             break;
         }
 
         case (characteristic_min):
         {
-            characteristics.Statistics.Min = ReadValue<T>(buffer, position);
+            characteristics.Statistics.Min =
+                ReadValue<typename TypeInfo<T>::ValueType>(buffer, position);
             break;
         }
 
         case (characteristic_max):
         {
-            characteristics.Statistics.Max = ReadValue<T>(buffer, position);
+            characteristics.Statistics.Max =
+                ReadValue<typename TypeInfo<T>::ValueType>(buffer, position);
             break;
         }
 

source/adios2/toolkit/format/bp3/BP3Deserializer.tcc

@@ -55,12 +55,22 @@ void BP3Deserializer::DefineVariableInIO(const ElementIndexHeader &header,
     }
 
     Variable<T> *variable = nullptr;
+    if (characteristics.Statistics.IsValue)
+    {
+        std::lock_guard<std::mutex> lock(m_Mutex);
+        variable = &io.DefineVariable<T>(variableName);
+        variable->m_Min = characteristics.Statistics.Value;
+        variable->m_Max = characteristics.Statistics.Value;
+    }
+    else
     {
-        // std::mutex portion
         std::lock_guard<std::mutex> lock(m_Mutex);
         variable =
             &io.DefineVariable<T>(variableName, characteristics.Shape,
                                   characteristics.Start, characteristics.Count);
+
+        variable->m_Min = characteristics.Statistics.Min;
+        variable->m_Max = characteristics.Statistics.Max;
     }
 
     // going back to get variable index position
@@ -83,8 +93,9 @@ void BP3Deserializer::DefineVariableInIO(const ElementIndexHeader &header,
         const size_t subsetPosition = position;
 
         // read until step is found
-        const Characteristics<T> subsetCharacteristics =
-            ReadElementIndexCharacteristics<T>(buffer, position, true);
+        const Characteristics<typename TypeInfo<T>::ValueType>
+            subsetCharacteristics = ReadElementIndexCharacteristics<
+                typename TypeInfo<T>::ValueType>(buffer, position, false);
 
         if (subsetCharacteristics.Statistics.Step > currentStep)
         {
@@ -94,6 +105,16 @@ void BP3Deserializer::DefineVariableInIO(const ElementIndexHeader &header,
             subsetPositions.clear();
         }
 
+        if (subsetCharacteristics.Statistics.Min < variable->m_Min)
+        {
+            variable->m_Min = subsetCharacteristics.Statistics.Min;
+        }
+
+        if (subsetCharacteristics.Statistics.Max > variable->m_Max)
+        {
+            variable->m_Max = subsetCharacteristics.Statistics.Max;
+        }
+
         subsetPositions.push_back(subsetPosition);
         position = subsetPosition + subsetCharacteristics.EntryLength + 5;
 

source/utils/bpls2/BPLS2.cpp

@@ -208,39 +208,53 @@ void BPLS2::ProcessTransport() const
             endianness = "Big Endian";
         }
         std::cout << "  endianness: " << endianness << "\n";
-        std::cout << "  statistics: Min / Max / Avg / Std_dev\n" << std::endl;
+        std::cout << "  statistics: Min / Max\n";
+        std::cout << "\n";
     };
 
     auto lf_PrintVariables =
-        [&](const std::map<std::string, std::string> &variablesMap) {
+        [&](const std::map<std::string, Params> &variablesMap)
 
-            // get maximum sizes
-            size_t maxTypeSize = 0;
-            size_t maxNameSize = 0;
-            for (const auto &variablePair : variablesMap)
+    {
+        // get maximum sizes
+        size_t maxTypeSize = 0;
+        size_t maxNameSize = 0;
+        for (const auto &variablePair : variablesMap)
+        {
+            const size_t nameSize = variablePair.first.size();
+            if (nameSize > maxNameSize)
+            {
+                maxNameSize = nameSize;
+            }
+
+            const Params &parameters = variablePair.second;
+            const size_t typeSize = parameters.at("Type").size();
+            if (typeSize > maxTypeSize)
             {
-                const size_t nameSize = variablePair.first.size();
-                if (nameSize > maxNameSize)
-                {
-                    maxNameSize = nameSize;
-                }
-
-                const size_t typeSize = variablePair.second.size();
-                if (typeSize > maxTypeSize)
-                {
-                    maxTypeSize = typeSize;
-                }
+                maxTypeSize = typeSize;
             }
+        }
 
-            for (const auto &variablePair : variablesMap)
+        for (const auto &variablePair : variablesMap)
+        {
+            const std::string name(variablePair.first);
+            const Params &parameters = variablePair.second;
+            const std::string type(parameters.at("Type"));
+
+            std::cout << "  ";
+            std::cout << std::left << std::setw(maxTypeSize) << type << "  ";
+            std::cout << std::left << std::setw(maxNameSize) << name << "  ";
+
+            // print min max
+            if (m_Parameters.count("long") == 1)
             {
-                std::cout << "  ";
-                std::cout << std::left << std::setw(maxTypeSize)
-                          << variablePair.second << "  ";
-                std::cout << std::left << std::setw(maxNameSize)
-                          << variablePair.first << std::endl;
+                std::cout << parameters.at("Min") << " / "
+                          << parameters.at("Max");
             }
-        };
+            std::cout << "\n";
+        }
+        std::cout << std::endl;
+    };
 
     ADIOS adios(true);
     IO &io = adios.DeclareIO("bpls2");