Test memory selection

Author: franzpoeschel

include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp

@@ -24,6 +24,7 @@
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2FilePosition.hpp"
+#include "openPMD/IO/ADIOS/macros.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/AbstractIOHandlerImpl.hpp"
 #include "openPMD/IO/AbstractIOHandlerImplCommon.hpp"
@@ -481,6 +482,7 @@ class ADIOS2IOHandlerImpl
         var.SetSelection(
             {adios2::Dims(offset.begin(), offset.end()),
              adios2::Dims(extent.begin(), extent.end())});
+
         if (memorySelection.has_value())
         {
             var.SetMemorySelection(
@@ -490,14 +492,38 @@ class ADIOS2IOHandlerImpl
                  adios2::Dims(
                      memorySelection->extent.begin(),
                      memorySelection->extent.end())});
+            if constexpr (!CanTheMemorySelectionBeReset)
+            {
+                if (!printedWarningsAlready.memorySelection)
+                {
+                    std::cerr
+                        << "[Warning] Using a version of ADIOS2 that cannot "
+                           "reset memory selections on a variable, once "
+                           "specified. When using memory selections, then "
+                           "please specify it explicitly on all storeChunk() "
+                           "calls. Further info: "
+                           "https://github.com/ornladios/ADIOS2/pull/4169."
+                        << std::endl;
+                    printedWarningsAlready.memorySelection = true;
+                }
+            }
         }
+        else
+        {
+            if constexpr (CanTheMemorySelectionBeReset)
+            {
+                var.SetMemorySelection();
+            }
+        }
+
         return var;
     }
 
     struct
     {
         bool noGroupBased = false;
         bool blosc2bp5 = false;
+        bool memorySelection = false;
     } printedWarningsAlready;
 }; // ADIOS2IOHandlerImpl
 

include/openPMD/IO/ADIOS/macros.hpp

@@ -26,6 +26,26 @@
 #define openPMD_HAVE_ADIOS2_BP5 0
 #endif
 
+namespace detail
+{
+template <typename Variable, typename SFINAE = void>
+struct CanTheMemorySelectionBeReset
+{
+    static constexpr bool value = false;
+};
+
+template <typename Variable>
+struct CanTheMemorySelectionBeReset<
+    Variable,
+    decltype(std::declval<Variable>().SetMemorySelection())>
+{
+    static constexpr bool value = true;
+};
+} // namespace detail
+
+constexpr bool CanTheMemorySelectionBeReset =
+    detail::CanTheMemorySelectionBeReset<adios2::Variable<int>>::value;
+
 #else
 
 #define openPMD_HAS_ADIOS_2_8 0

include/openPMD/LoadStoreChunk.hpp

@@ -120,7 +120,7 @@ class ConfigureStoreChunkFromBuffer
     auto storeChunkConfig() const -> internal::StoreChunkConfigFromBuffer;
 
 public:
-    auto memorySelection(MemorySelection) & -> ConfigureStoreChunkFromBuffer &;
+    auto memorySelection(MemorySelection) -> ConfigureStoreChunkFromBuffer &;
 
     auto as_parent() && -> parent_t &&;
     auto as_parent() & -> parent_t &;

src/LoadStoreChunk.cpp

@@ -13,6 +13,7 @@
 #include "openPMD/DatatypeMacros.hpp"
 
 #include <memory>
+#include <optional>
 #include <stdexcept>
 
 namespace openPMD
@@ -151,6 +152,14 @@ auto ConfigureStoreChunkFromBuffer<Ptr_Type>::storeChunkConfig() const
         this->getOffset(), this->getExtent(), m_mem_select};
 }
 
+template <typename Ptr_Type>
+auto ConfigureStoreChunkFromBuffer<Ptr_Type>::memorySelection(
+    MemorySelection sel) -> ConfigureStoreChunkFromBuffer &
+{
+    this->m_mem_select = std::make_optional<MemorySelection>(std::move(sel));
+    return *this;
+}
+
 template <typename Ptr_Type>
 auto ConfigureStoreChunkFromBuffer<Ptr_Type>::enqueue() -> void
 {

test/ParallelIOTest.cpp

@@ -421,13 +421,42 @@ void available_chunks_test(std::string const &file_ending)
 }
 )END";
 
-    std::vector<int> data{2, 4, 6, 8};
+    std::vector<int> xdata{2, 4, 6, 8};
+    std::vector<int> ydata{0, 0, 0, 0, 0, //
+                           0, 1, 2, 3, 0, //
+                           0, 4, 5, 6, 0, //
+                           0, 7, 8, 9, 0, //
+                           0, 0, 0, 0, 0};
+    std::vector<int> ydata_firstandlastrow{-1, -1, -1};
     {
         Series write(name, Access::CREATE, MPI_COMM_WORLD, parameters.str());
         Iteration it0 = write.iterations[0];
         auto E_x = it0.meshes["E"]["x"];
         E_x.resetDataset({Datatype::INT, {mpi_size, 4}});
-        E_x.storeChunk(data, {mpi_rank, 0}, {1, 4});
+        E_x.storeChunk(xdata, {mpi_rank, 0}, {1, 4});
+        auto E_y = it0.meshes["E"]["y"];
+        E_y.resetDataset({Datatype::INT, {5, 3ul * mpi_size}});
+        E_y.prepareStoreChunk()
+            .fromContiguousContainer(ydata_firstandlastrow)
+            .offset({0, 3ul * mpi_rank})
+            .extent({1, 3})
+            .enqueue();
+        E_y.prepareStoreChunk()
+            .offset({1, 3ul * mpi_rank})
+            .extent({3, 3})
+            .fromContiguousContainer(ydata)
+            .memorySelection({{1, 1}, {5, 5}})
+            .enqueue();
+        // if condition checks if this PR is available in ADIOS2:
+        // https://github.com/ornladios/ADIOS2/pull/4169
+        if constexpr (CanTheMemorySelectionBeReset)
+        {
+            E_y.prepareStoreChunk()
+                .fromContiguousContainer(ydata_firstandlastrow)
+                .offset({4, 3ul * mpi_rank})
+                .extent({1, 3})
+                .enqueue();
+        }
         it0.close();
     }
 
@@ -459,6 +488,36 @@ void available_chunks_test(std::string const &file_ending)
         {
             REQUIRE(ranks[i] == i);
         }
+
+        auto E_y = it0.meshes["E"]["y"];
+        auto width = E_y.getExtent()[1];
+        auto first_row = E_y.loadChunk<int>({0, 0}, {1, width});
+        auto middle_rows = E_y.loadChunk<int>({1, 0}, {3, width});
+        auto last_row = E_y.loadChunk<int>({4, 0}, {1, width});
+        read.flush();
+
+        for (auto row : [&]() -> std::vector<std::shared_ptr<int> *> {
+                 if constexpr (CanTheMemorySelectionBeReset)
+                 {
+                     return {&first_row, &last_row};
+                 }
+                 else
+                 {
+                     return {&first_row};
+                 }
+             }())
+        {
+            for (size_t i = 0; i < width; ++i)
+            {
+                REQUIRE(row->get()[i] == -1);
+            }
+        }
+        for (size_t i = 0; i < width * 3; ++i)
+        {
+            size_t row = i / width;
+            int required_value = row * 3 + (i % 3) + 1;
+            REQUIRE(middle_rows.get()[i] == required_value);
+        }
     }
 }