Works

Author: franzpoeschel

include/openPMD/IO/AbstractIOHandlerImplCommon.hpp

@@ -103,6 +103,8 @@ class AbstractIOHandlerImplCommon : public AbstractIOHandlerImpl
     FilePositionType *
     setAndGetFilePosition(Writable *writable, std::string extend);
 
+    void propagateFilestateToRoot(Writable *writable);
+
     /*
      * The "virtual" methods here must be implemented by the child class,
      * but the references are resolved at compile time, hence not really
@@ -138,8 +140,9 @@ AbstractIOHandlerImplCommon<IOHandler_t, FilePositionType>::makeFile(
     Writable *writable, std::string file, bool consider_open_files)
 {
     auto make_new = [&]() {
-        new (&writable->fileState)
-            internal::SharedFileState(std::in_place, file);
+        using SharedFileState = internal::SharedFileState;
+        writable->fileState.~SharedFileState();
+        new (&writable->fileState) SharedFileState(std::in_place, file);
         m_files[std::move(file)].derive_from(writable->fileState);
     };
     if (consider_open_files)
@@ -311,4 +314,16 @@ auto AbstractIOHandlerImplCommon<IOHandlerImpl_t, FilePositionType>::
     writable->abstractFilePosition = std::move(new_pos);
     return dynamic_cast<FilePositionType *>(res);
 }
+
+template <typename IOHandlerImpl_t, typename FilePositionType>
+void AbstractIOHandlerImplCommon<IOHandlerImpl_t, FilePositionType>::
+    propagateFilestateToRoot(Writable *const writable)
+{
+    auto ancestor = writable;
+    while (ancestor->parent)
+    {
+        ancestor = ancestor->parent;
+        ancestor->fileState.derive_from(writable->fileState);
+    }
+}
 } // namespace openPMD

include/openPMD/IO/IOTask.hpp

@@ -166,6 +166,7 @@ struct OPENPMDAPI_EXPORT
             new Parameter<Operation::CREATE_FILE>(std::move(*this)));
     }
 
+    Writable *storageLocation = nullptr;
     std::string name = "";
 };
 
@@ -225,6 +226,7 @@ struct OPENPMDAPI_EXPORT
         NoReopen
     };
 
+    Writable *storageLocation = nullptr;
     std::string name = "";
     Reopen reopen = Reopen::NoReopen;
     using ParsePreference = internal::ParsePreference;

include/openPMD/Series.hpp

@@ -907,7 +907,7 @@ OPENPMD_private
      */
     void readFileBased(
         std::optional<IterationIndex_t> read_only_this_single_iteration);
-    void readOneIterationFileBased(std::string const &filePath);
+    void readOneIterationFileBased(std::string const &filePath, Iteration &it);
     /**
      * Note on re-parsing of a Series:
      * If init == false, the parsing process will seek for new

src/IO/ADIOS/ADIOS2IOHandler.cpp

@@ -680,8 +680,11 @@ void ADIOS2IOHandlerImpl::createFile(
     {
         std::string name = parameters.name + fileSuffix();
 
+        auto storageLocation =
+            parameters.storageLocation ? parameters.storageLocation : writable;
         auto &file =
-            makeFile(writable, name, /* consider_open_files = */ false);
+            makeFile(storageLocation, name, /* consider_open_files = */ false);
+        propagateFilestateToRoot(storageLocation);
         auto &file_state = **file;
         if (m_handler->m_backendAccess != Access::CREATE &&
             m_handler->m_backendAccess != Access::APPEND &&
@@ -1015,9 +1018,11 @@ void ADIOS2IOHandlerImpl::openFile(
 
     std::string name = parameters.name + fileSuffix();
 
-    auto &file = makeFile(writable, name, /* consider_open_files = */ true);
-
-    associateWithFile(writable, file);
+    auto storageLocation =
+        parameters.storageLocation ? parameters.storageLocation : writable;
+    auto &file =
+        makeFile(storageLocation, name, /* consider_open_files = */ true);
+    propagateFilestateToRoot(storageLocation);
 
     writable->written = true;
     writable->abstractFilePosition = std::make_shared<ADIOS2FilePosition>();

src/IO/AbstractIOHandlerImpl.cpp

@@ -107,7 +107,19 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     "->",
                     i.writable,
                     "] CREATE_FILE: ",
-                    parameter.name);
+                    parameter.name,
+                    [ptr = parameter.storageLocation]() {
+                        if (ptr)
+                        {
+                            std::stringstream s;
+                            s << " into " << ptr;
+                            return s.str();
+                        }
+                        else
+                        {
+                            return std::string();
+                        }
+                    });
                 createFile(i.writable, parameter);
                 break;
             }
@@ -175,7 +187,19 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     "->",
                     i.writable,
                     "] OPEN_FILE: ",
-                    parameter.name);
+                    parameter.name,
+                    [ptr = parameter.storageLocation]() {
+                        if (ptr)
+                        {
+                            std::stringstream s;
+                            s << " into " << ptr;
+                            return s.str();
+                        }
+                        else
+                        {
+                            return std::string();
+                        }
+                    });
                 openFile(i.writable, parameter);
                 break;
             }

src/IO/JSON/JSONIOHandlerImpl.cpp

@@ -516,8 +516,11 @@ void JSONIOHandlerImpl::createFile(
     {
         std::string name = parameters.name + m_originalExtension;
 
+        auto storageLocation =
+            parameters.storageLocation ? parameters.storageLocation : writable;
         auto &file =
-            makeFile(writable, name, /* consider_open_files = */ false);
+            makeFile(storageLocation, name, /* consider_open_files = */ false);
+        propagateFilestateToRoot(storageLocation);
         auto &file_state = **file;
         auto file_exists = auxiliary::file_exists(fullPath(file_state));
 
@@ -1012,7 +1015,11 @@ void JSONIOHandlerImpl::openFile(
 
     std::string name = parameter.name + m_originalExtension;
 
-    auto &file = makeFile(writable, name, /* consider_open_files = */ true);
+    auto storageLocation =
+        parameter.storageLocation ? parameter.storageLocation : writable;
+    auto &file =
+        makeFile(storageLocation, name, /* consider_open_files = */ true);
+    propagateFilestateToRoot(storageLocation);
 
     associateWithFile(writable, file);
 

src/Iteration.cpp

@@ -229,6 +229,7 @@ void Iteration::flushFileBased(
         /* create file */
         Parameter<Operation::CREATE_FILE> fCreate;
         fCreate.name = filename;
+        fCreate.storageLocation = &this->writable();
         IOHandler()->enqueue(IOTask(&s.writable(), fCreate));
 
         /*
@@ -428,7 +429,7 @@ void Iteration::readFileBased(
     }
     auto series = retrieveSeries();
 
-    series.readOneIterationFileBased(filePath);
+    series.readOneIterationFileBased(filePath, *this);
 
     auto &series_data = series.get();
     if (series_data.m_iterationFilenames.find(idx) ==

src/Series.cpp

@@ -1553,7 +1553,6 @@ void Series::readFileBased(
     std::optional<IterationIndex_t> read_only_this_single_iteration)
 {
     auto &series = get();
-    Parameter<Operation::OPEN_FILE> fOpen;
     Parameter<Operation::READ_ATT> aRead;
 
     // Tell the backend that we are parsing file-based iteration encoding.
@@ -1766,7 +1765,8 @@ void Series::readFileBased(
             "Please specify '%0<N>T' or open as read-only.");
 }
 
-void Series::readOneIterationFileBased(std::string const &filePath)
+void Series::readOneIterationFileBased(
+    std::string const &filePath, Iteration &it)
 {
     auto &series = get();
 
@@ -1780,6 +1780,7 @@ void Series::readOneIterationFileBased(std::string const &filePath)
     Parameter<Operation::READ_ATT> aRead;
 
     fOpen.name = filePath;
+    fOpen.storageLocation = &it.writable();
     IOHandler()->enqueue(IOTask(this, fOpen));
     IOHandler()->flush(internal::defaultFlushParams);
     series.iterations.parent() = getWritable(this);
@@ -2867,6 +2868,7 @@ void Series::openIteration(IterationIndex_t index, Iteration &iteration)
         {
             fOpen.reopen = R::WasFoundOnDisk;
         }
+        fOpen.storageLocation = &iteration.writable();
         IOHandler()->enqueue(IOTask(this, fOpen));
 
         /* open base path */