Add mutex in SZ operator

CMakeLists.txt

@@ -222,7 +222,7 @@ endif()
 
 
 set(ADIOS2_CONFIG_OPTS
-    BP5 DataMan DataSpaces HDF5 HDF5_VOL MHS SST CUDA Fortran MPI Python Blosc BZip2 LIBPRESSIO MGARD PNG SZ ZFP DAOS IME O_DIRECT SysVShMem ZeroMQ Profiling Endian_Reverse Sodium
+    BP5 DataMan DataSpaces HDF5 HDF5_VOL MHS SST CUDA Fortran MPI Python Blosc BZip2 LIBPRESSIO MGARD PNG SZ ZFP DAOS IME O_DIRECT Sodium SysVShMem ZeroMQ Profiling Endian_Reverse
 )
 
 GenerateADIOSHeaderConfig(${ADIOS2_CONFIG_OPTS})

bindings/CXX11/adios2/cxx11/Attribute.cpp

@@ -64,6 +64,14 @@ namespace adios2
     }                                                                          \
                                                                                \
     template <>                                                                \
+    bool Attribute<T>::IsValue() const                                         \
+    {                                                                          \
+        helper::CheckForNullptr(m_Attribute,                                   \
+                                "in call to Attribute<T>::IsValue()");         \
+        return m_Attribute->m_IsSingleValue;                                   \
+    }                                                                          \
+                                                                               \
+    template <>                                                                \
     std::string ToString(const Attribute<T> &attribute)                        \
     {                                                                          \
         return std::string("Attribute<") + attribute.Type() + ">(Name: \"" +   \

bindings/CXX11/adios2/cxx11/Attribute.h

@@ -67,6 +67,12 @@ class Attribute
      */
     std::vector<T> Data() const;
 
+    /**
+     * Distinguish single-value attributes from vector attributes
+     * @return true if single-value, false otherwise
+     */
+    bool IsValue() const;
+
 private:
     Attribute<T>(core::Attribute<IOType> *attribute);
     core::Attribute<IOType> *m_Attribute = nullptr;

source/adios2/CMakeLists.txt

@@ -168,9 +168,15 @@ if(ADIOS2_HAVE_MPI)
         core/IOMPI.cpp
         helper/adiosCommMPI.h helper/adiosCommMPI.cpp
         helper/adiosMpiHandshake.h helper/adiosMpiHandshake.cpp
-        engine/ssc/SscReader.cpp engine/ssc/SscReader.tcc
-        engine/ssc/SscWriter.cpp engine/ssc/SscWriter.tcc
         engine/ssc/SscHelper.cpp
+        engine/ssc/SscWriter.cpp
+        engine/ssc/SscWriterBase.cpp
+        engine/ssc/SscWriterGeneric.cpp
+        engine/ssc/SscWriterNaive.cpp
+        engine/ssc/SscReader.cpp
+        engine/ssc/SscReaderBase.cpp
+        engine/ssc/SscReaderGeneric.cpp
+        engine/ssc/SscReaderNaive.cpp
         )
     set_property(TARGET adios2_core_mpi PROPERTY EXPORT_NAME core_mpi)
     set_property(TARGET adios2_core_mpi PROPERTY OUTPUT_NAME adios2${ADIOS2_LIBRARY_SUFFIX}_core_mpi)

source/adios2/engine/ssc/SscHelper.cpp

@@ -9,11 +9,6 @@
  */
 
 #include "SscHelper.h"
-#include "adios2/common/ADIOSMacros.h"
-#include "adios2/helper/adiosFunctions.h"
-#include "adios2/helper/adiosType.h"
-#include <iostream>
-#include <numeric>
 
 namespace adios2
 {
@@ -248,55 +243,36 @@ void SerializeAttributes(IO &input, Buffer &output)
     }
 }
 
-void Deserialize(const Buffer &input, BlockVecVec &output, IO &io,
-                 const bool regVars, const bool regAttrs)
+void DeserializeAttribute(const Buffer &input, uint64_t &pos, IO &io,
+                          const bool regIO)
 {
-    for (auto &i : output)
-    {
-        i.clear();
-    }
+    const DataType type = static_cast<DataType>(input[pos]);
+    ++pos;
 
-    uint64_t pos = 2;
+    uint8_t nameSize = input[pos];
+    ++pos;
 
-    uint64_t blockSize = input.value<uint64_t>(pos);
+    std::vector<char> namev(nameSize);
+    std::memcpy(namev.data(), input.data(pos), nameSize);
+    std::string name = std::string(namev.begin(), namev.end());
+    pos += nameSize;
 
+    uint64_t size = input.value<uint64_t>(pos);
     pos += 8;
 
-    while (pos < blockSize)
+    if (regIO)
     {
-
-        uint8_t shapeId = input[pos];
-        ++pos;
-
-        if (shapeId == 66)
+        const auto &attributes = io.GetAttributes();
+        auto it = attributes.find(name);
+        if (it == attributes.end())
         {
-            const DataType type = static_cast<DataType>(input[pos]);
-            ++pos;
-
-            uint8_t nameSize = input[pos];
-            ++pos;
-
-            std::vector<char> namev(nameSize);
-            std::memcpy(namev.data(), input.data(pos), nameSize);
-            std::string name = std::string(namev.begin(), namev.end());
-            pos += nameSize;
-
-            uint64_t size = input.value<uint64_t>(pos);
-            pos += 8;
-
-            if (regAttrs)
+            int rank;
+            MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+            if (type == DataType::String)
             {
-                const auto &attributes = io.GetAttributes();
-                auto it = attributes.find(name);
-                if (it == attributes.end())
-                {
-                    int rank;
-                    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-                    if (type == DataType::String)
-                    {
-                        io.DefineAttribute<std::string>(
-                            name, std::string(input.data<char>(pos), size));
-                    }
+                io.DefineAttribute<std::string>(
+                    name, std::string(input.data<char>(pos), size));
+            }
 #define declare_type(T)                                                        \
     else if (type == helper::GetDataType<T>())                                 \
     {                                                                          \
@@ -309,75 +285,73 @@ void Deserialize(const Buffer &input, BlockVecVec &output, IO &io,
             io.DefineAttribute<T>(name, input.data<T>(pos), size / sizeof(T)); \
         }                                                                      \
     }
-                    ADIOS2_FOREACH_ATTRIBUTE_STDTYPE_1ARG(declare_type)
+            ADIOS2_FOREACH_ATTRIBUTE_STDTYPE_1ARG(declare_type)
 #undef declare_type
-                    else
-                    {
-                        helper::Throw<std::runtime_error>(
-                            "Engine", "SscHelper", "Deserialize",
-                            "unknown attribute data type");
-                    }
-                }
+            else
+            {
+                helper::Throw<std::runtime_error>(
+                    "Engine", "SscHelper", "Deserialize",
+                    "unknown attribute data type");
             }
-            pos += size;
         }
-        else
-        {
-            int rank = input.value<int>(pos);
-            pos += 4;
-            output[rank].emplace_back();
-            auto &b = output[rank].back();
-            b.shapeId = static_cast<ShapeID>(shapeId);
+    }
+    pos += size;
+}
 
-            uint8_t nameSize = input[pos];
-            ++pos;
+void DeserializeVariable(const Buffer &input, const ShapeID shapeId,
+                         uint64_t &pos, BlockInfo &b, IO &io, const bool regIO)
+{
+    b.shapeId = static_cast<ShapeID>(shapeId);
 
-            std::vector<char> name(nameSize);
-            std::memcpy(name.data(), input.data(pos), nameSize);
-            b.name = std::string(name.begin(), name.end());
-            pos += nameSize;
+    uint8_t nameSize = input[pos];
+    ++pos;
 
-            b.type = static_cast<DataType>(input[pos]);
-            ++pos;
+    std::vector<char> name(nameSize);
+    std::memcpy(name.data(), input.data(pos), nameSize);
+    b.name = std::string(name.begin(), name.end());
+    pos += nameSize;
 
-            uint8_t shapeSize = input[pos];
-            ++pos;
-            b.shape.resize(shapeSize);
-            b.start.resize(shapeSize);
-            b.count.resize(shapeSize);
+    b.type = static_cast<DataType>(input[pos]);
+    ++pos;
 
-            std::memcpy(b.shape.data(), input.data(pos), 8 * shapeSize);
-            pos += 8 * shapeSize;
+    uint8_t shapeSize = input[pos];
+    ++pos;
+    b.shape.resize(shapeSize);
+    b.start.resize(shapeSize);
+    b.count.resize(shapeSize);
 
-            std::memcpy(b.start.data(), input.data(pos), 8 * shapeSize);
-            pos += 8 * shapeSize;
+    std::memcpy(b.shape.data(), input.data(pos), 8 * shapeSize);
+    pos += 8 * shapeSize;
 
-            std::memcpy(b.count.data(), input.data(pos), 8 * shapeSize);
-            pos += 8 * shapeSize;
+    std::memcpy(b.start.data(), input.data(pos), 8 * shapeSize);
+    pos += 8 * shapeSize;
 
-            b.bufferStart = input.value<uint64_t>(pos);
-            pos += 8;
+    std::memcpy(b.count.data(), input.data(pos), 8 * shapeSize);
+    pos += 8 * shapeSize;
 
-            b.bufferCount = input.value<uint64_t>(pos);
-            pos += 8;
+    b.bufferStart = input.value<uint64_t>(pos);
+    pos += 8;
 
-            uint8_t valueSize = input[pos];
-            pos++;
-            b.value.resize(valueSize);
-            if (valueSize > 0)
-            {
-                std::memcpy(b.value.data(), input.data() + pos, valueSize);
-                pos += valueSize;
-            }
+    b.bufferCount = input.value<uint64_t>(pos);
+    pos += 8;
 
-            if (regVars)
-            {
-                if (b.type == DataType::None)
-                {
-                    helper::Throw<std::runtime_error>(
-                        "Engine", "SscHelper", "Deserialize",
-                        "unknown variable data type");
-                }
+    uint8_t valueSize = input[pos];
+    pos++;
+    b.value.resize(valueSize);
+    if (valueSize > 0)
+    {
+        std::memcpy(b.value.data(), input.data() + pos, valueSize);
+        pos += valueSize;
+    }
+
+    if (regIO)
+    {
+        if (b.type == DataType::None)
+        {
+            helper::Throw<std::runtime_error>("Engine", "SscHelper",
+                                              "Deserialize",
+                                              "unknown variable data type");
+        }
 #define declare_type(T)                                                        \
     else if (b.type == helper::GetDataType<T>())                               \
     {                                                                          \
@@ -409,15 +383,50 @@ void Deserialize(const Buffer &input, BlockVecVec &output, IO &io,
             }                                                                  \
         }                                                                      \
     }
-                ADIOS2_FOREACH_STDTYPE_1ARG(declare_type)
+        ADIOS2_FOREACH_STDTYPE_1ARG(declare_type)
 #undef declare_type
-                else
-                {
-                    helper::Throw<std::runtime_error>(
-                        "Engine", "SscHelper", "Deserialize",
-                        "unknown variable data type");
-                }
-            }
+        else
+        {
+            helper::Throw<std::runtime_error>("Engine", "SscHelper",
+                                              "Deserialize",
+                                              "unknown variable data type");
+        }
+    }
+}
+
+void Deserialize(const Buffer &input, BlockVecVec &output, IO &io,
+                 const bool regVars, const bool regAttrs)
+{
+    for (auto &i : output)
+    {
+        i.clear();
+    }
+
+    uint64_t pos = 2;
+
+    uint64_t blockSize = input.value<uint64_t>(pos);
+
+    pos += 8;
+
+    while (pos < blockSize)
+    {
+
+        uint8_t shapeId = input[pos];
+        ++pos;
+
+        if (shapeId == 66)
+        {
+            DeserializeAttribute(input, pos, io, regAttrs);
+        }
+        else
+        {
+            int rank = input.value<int>(pos);
+            pos += 4;
+            output[rank].emplace_back();
+            auto &b = output[rank].back();
+
+            DeserializeVariable(input, static_cast<ShapeID>(shapeId), pos, b,
+                                io, regVars);
         }
     }
 }

source/adios2/engine/ssc/SscHelper.h

@@ -11,12 +11,8 @@
 #ifndef ADIOS2_ENGINE_SSCHELPER_H_
 #define ADIOS2_ENGINE_SSCHELPER_H_
 
-#include "adios2/common/ADIOSTypes.h"
 #include "adios2/core/IO.h"
-#include "adios2/helper/adiosLog.h"
 #include <mpi.h>
-#include <unordered_map>
-#include <vector>
 
 namespace adios2
 {
@@ -152,6 +148,10 @@ RankPosMap CalculateOverlap(BlockVecVec &globalPattern,
 
 void SerializeVariables(const BlockVec &input, Buffer &output, const int rank);
 void SerializeAttributes(IO &input, Buffer &output);
+void DeserializeVariable(const Buffer &input, const ShapeID shapeId,
+                         uint64_t &pos, BlockInfo &b, IO &io, const bool regIO);
+void DeserializeAttribute(const Buffer &input, uint64_t &pos, IO &io,
+                          const bool regIO);
 void Deserialize(const Buffer &input, BlockVecVec &output, IO &io,
                  const bool regVars, const bool regAttrs);
 void AggregateMetadata(const Buffer &localBuffer, Buffer &globalBuffer,