Added more Read functions

source/adios2/core/VariableBase.cpp

@@ -187,6 +187,15 @@ void VariableBase::CheckDimensions(const std::string hint) const
     // TODO need to think more exceptions here
 }
 
+Box<Dims> VariableBase::CurrentBoxSelection() const noexcept
+{
+    Dims end;
+    std::transform(m_Start.begin(), m_Start.end(), m_Count.begin(),
+                   std::back_inserter(end), std::plus<size_t>());
+
+    return Box<Dims>{m_Start, end};
+}
+
 // PRIVATE
 void VariableBase::InitShapeType()
 {

source/adios2/core/VariableBase.h

@@ -145,6 +145,12 @@ public:
      * @param hint extra debugging info for the exception */
     void CheckDimensions(const std::string hint) const;
 
+    /**
+     * Gets the current (start, start+count = end) box
+     * @return box with current selection start and end points
+     */
+    Box<Dims> CurrentBoxSelection() const noexcept;
+
 protected:
     const bool m_DebugMode = false;
 

source/adios2/engine/bp/BPFileWriter.tcc

@@ -55,7 +55,7 @@ void BPFileWriter::PutSyncCommon(Variable<T> &variable, const T *values)
     m_BP3Serializer.PutVariableMetadata(variable);
     m_BP3Serializer.PutVariablePayload(variable);
 
-    // variable.SetData(nullptr); // not needed after PutSync
+    // variable.SetData(nullptr); // not needed after PutSync?
 }
 
 template <class T>

source/adios2/helper/adiosMath.cpp

@@ -129,8 +129,22 @@ size_t LinearIndex(const Box<Dims> &localBox, const Dims &point,
         return linearIndex;
     };
 
-    //  TODO auto lf_ColumnOne = [](const Dims &count,
-    //                           const Dims &normalizedPoint) -> size_t {};
+    auto lf_ColumnOne = [](const Dims &count,
+                           const Dims &normalizedPoint) -> size_t {
+
+        const size_t countSize = count.size();
+        size_t linearIndex = 0;
+        size_t product = std::accumulate(count.begin(), count.end() - 1, 1,
+                                         std::multiplies<size_t>());
+
+        for (size_t p = 1; p < countSize; ++p)
+        {
+            linearIndex += (normalizedPoint[countSize - p] - 1) * product;
+            product /= count[countSize - p];
+        }
+        linearIndex += (normalizedPoint[0] - 1); // fastest
+        return linearIndex;
+    };
 
     const Dims &start = localBox.first;
     const Dims &count = localBox.second;
@@ -151,16 +165,11 @@ size_t LinearIndex(const Box<Dims> &localBox, const Dims &point,
     {
         linearIndex = lf_RowZero(count, normalizedPoint);
     }
-    else if (isRowMajor && !isZeroIndex)
-    {
-    }
     else if (!isRowMajor && !isZeroIndex)
     {
-        // TODO: Fortran Column-Major and 1-index
-    }
-    else // column-major and Zero index // who uses this?
-    {
+        linearIndex = lf_ColumnOne(count, normalizedPoint);
     }
+
     return linearIndex;
 }
 

source/adios2/helper/adiosMath.h

@@ -108,8 +108,16 @@ size_t NextExponentialSize(const size_t requiredSize, const size_t currentSize,
 Box<Dims> IntersectionBox(const Box<Dims> &box1,
                           const Box<Dims> &box2) noexcept;
 
+/**
+ * Get a linear index for a point inside a localBox
+ * @param localBox start and count
+ * @param point inside box
+ * @param isRowMajor
+ * @param isZeroIndex
+ * @return linear index for contiguous memory
+ */
 size_t LinearIndex(const Box<Dims> &localBox, const Dims &point,
-                   const bool isRowMajor = true, const bool isZeroIndex = true);
+                   const bool isRowMajor, const bool isZeroIndex);
 
 } // end namespace adios2
 

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

@@ -36,6 +36,30 @@ void BP3Deserializer::ParseMetadata(IO &io)
     // ParseAttributesIndex(io);
 }
 
+void BP3Deserializer::ClipContiguousMemory(
+    const std::string &variableName, IO &io,
+    const std::vector<char> &contiguousMemory, const Box<Dims> &intersectionBox)
+{
+    // get variable pointer and set data in it with local dimensions
+    const std::string type(io.InquireVariableType(variableName));
+
+    if (type == "compound")
+    {
+    }
+#define declare_type(T)                                                        \
+    else if (type == GetType<T>())                                             \
+    {                                                                          \
+        Variable<T> *variable = io.InquireVariable<T>(variableName);           \
+        if (variable != nullptr)                                               \
+        {                                                                      \
+            ClipContiguousMemoryCommon(*variable, contiguousMemory,            \
+                                       intersectionBox);                       \
+        }                                                                      \
+    }
+    ADIOS2_FOREACH_TYPE_1ARG(declare_type)
+#undef declare_type
+}
+
 // PRIVATE
 void BP3Deserializer::ParseMinifooter()
 {

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

@@ -54,10 +54,9 @@ public:
     std::map<std::string, SubFileInfoMap>
     PerformGetsVariablesSubFileInfo(IO &io);
 
-    template <class T>
-    void ClipContiguousMemory(const std::vector<char> &contiguousMemory,
-                              const Box<Dims> &intersectionBox,
-                              Variable<T> &variable);
+    void ClipContiguousMemory(const std::string &variableName, IO &io,
+                              const std::vector<char> &contiguousMemory,
+                              const Box<Dims> &intersectionBox);
 
 private:
     std::map<std::string, SubFileInfoMap> m_DeferredVariables;
@@ -84,6 +83,17 @@ private:
 
     template <class T>
     SubFileInfoMap GetSubFileInfo(const Variable<T> &variable) const;
+
+    template <class T>
+    void ClipContiguousMemoryCommon(Variable<T> &variable,
+                                    const std::vector<char> &contiguousMemory,
+                                    const Box<Dims> &intersectionBox);
+
+    template <class T>
+    void
+    ClipContiguousMemoryCommonRowZero(Variable<T> &variable,
+                                      const std::vector<char> &contiguousMemory,
+                                      const Box<Dims> &intersectionBox);
 };
 
 #define declare_template_instantiation(T)                                      \

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

@@ -148,14 +148,16 @@ BP3Deserializer::GetSubFileInfo(const Variable<T> &variable) const
                 continue;
             }
             // if they intersect get info Seeks (first: start, second: end)
-            // TODO: get row-major, zero-index for each language
+            // TODO: map to sizeof(T)?
             info.Seeks.first =
                 LinearIndex(blockDimensions, info.IntersectionBox.first,
-                            m_IsRowMajor, m_IsZeroIndex);
+                            m_IsRowMajor, m_IsZeroIndex) *
+                sizeof(T);
 
             info.Seeks.second =
                 LinearIndex(blockDimensions, info.IntersectionBox.second,
-                            m_IsRowMajor, m_IsZeroIndex);
+                            m_IsRowMajor, m_IsZeroIndex) *
+                sizeof(T);
 
             const size_t fileIndex = static_cast<const size_t>(
                 blockCharacteristics.Statistics.FileIndex);
@@ -167,6 +169,90 @@ BP3Deserializer::GetSubFileInfo(const Variable<T> &variable) const
     return infoMap;
 }
 
+template <class T>
+void BP3Deserializer::ClipContiguousMemoryCommon(
+    Variable<T> &variable, const std::vector<char> &contiguousMemory,
+    const Box<Dims> &intersectionBox)
+{
+    const Dims &start = intersectionBox.first;
+    if (start.size() == 1) // 1D copy memory
+    {
+        // normalize intersection start with variable.m_Start
+        const size_t normalizedStart =
+            (start[0] - variable.m_Start[0]) * sizeof(T);
+        char *rawVariableData = reinterpret_cast<char *>(variable.GetData());
+
+        std::copy(contiguousMemory.begin(), contiguousMemory.end(),
+                  &rawVariableData[normalizedStart]);
+
+        return;
+    }
+
+    if (m_IsRowMajor && m_IsZeroIndex)
+    {
+        ClipContiguousMemoryCommonRowZero(variable, contiguousMemory,
+                                          intersectionBox);
+    }
+}
+
+template <class T>
+void BP3Deserializer::ClipContiguousMemoryCommonRowZero(
+    Variable<T> &variable, const std::vector<char> &contiguousMemory,
+    const Box<Dims> &intersectionBox)
+{
+    const Dims &start = intersectionBox.first;
+    const Dims &end = intersectionBox.second;
+    const size_t dimensions = start.size();
+    const size_t stride = end[dimensions - 1] - start[dimensions - 1];
+
+    Dims currentPoint(start); // current point for memory copy
+
+    const Box<Dims> variableSelection = variable.CurrentBoxSelection();
+
+    bool run = true;
+
+    while (run)
+    {
+        // here copy current linear memory between currentPoint and end
+        const size_t contiguousStart =
+            LinearIndex(intersectionBox, currentPoint, true, true);
+
+        const size_t variableStart =
+            LinearIndex(variableSelection, currentPoint, true, true);
+
+        char *rawVariableData = reinterpret_cast<char *>(variable.GetData());
+
+        std::copy(&contiguousMemory[contiguousStart],
+                  &contiguousMemory[contiguousStart + stride],
+                  &rawVariableData[variableStart]);
+
+        // here update each index recursively, always starting from the 2nd
+        // fastest changing index, since fastest changing index is the
+        // continuous part in the previous std::copy
+        size_t p = dimensions - 2;
+        while (true)
+        {
+            ++currentPoint[p];
+
+            if (currentPoint[p] == end[p])
+            {
+                if (p == 0)
+                {
+                    run = false; // we are done
+                }
+                else
+                {
+                    --p;
+                }
+            }
+            else
+            {
+                break; // break inner p loop
+            }
+        } // dimension index update
+    }     // run
+}
+
 } // end namespace format
 } // end namespace adios2