Avoid flushing for scalar components

Author: franzpoeschel

CMakeLists.txt

@@ -469,6 +469,7 @@ set(CORE_SOURCE
         src/benchmark/mpi/OneDimensionalBlockSlicer.cpp
         src/helper/list_series.cpp)
 set(IO_SOURCE
+        src/IO/AbstractIOHandlerImpl.cpp
         src/IO/AbstractIOHandlerHelper.cpp
         src/IO/DummyIOHandler.cpp
         src/IO/IOTask.cpp

docs/source/dev/design.rst

@@ -23,7 +23,7 @@ Therefore, enabling users to handle hierarchical, self-describing file formats w
 
 .. literalinclude:: IOTask.hpp
    :language: cpp
-   :lines: 44-60
+   :lines: 44-62
 
 Every task is designed to be a fully self-contained description of one such atomic operation. By describing a required minimal step of work (without any side-effect), these operations are the foundation of the unified handling mechanism across suitable file formats.
 The actual low-level exchange of data is implemented in ``IOHandlers``, one per file format (possibly two if handlingi MPI-parallel work is possible and requires different behaviour).

include/openPMD/IO/AbstractIOHandlerImpl.hpp

@@ -190,6 +190,12 @@ class AbstractIOHandlerImpl
                         deref_dynamic_cast<Parameter<O::AVAILABLE_CHUNKS> >(
                             i.parameter.get()));
                     break;
+                case O::KEEP_SYNCHRONOUS:
+                    keepSynchronous(
+                        i.writable,
+                        deref_dynamic_cast<Parameter<O::KEEP_SYNCHRONOUS> >(
+                            i.parameter.get()));
+                    break;
                 }
             }
             catch (...)
@@ -523,6 +529,9 @@ class AbstractIOHandlerImpl
     virtual void
     listAttributes(Writable *, Parameter<Operation::LIST_ATTS> &) = 0;
 
+    void
+    keepSynchronous(Writable *, Parameter<Operation::KEEP_SYNCHRONOUS> param);
+
     AbstractIOHandler *m_handler;
 }; // AbstractIOHandlerImpl
 } // namespace openPMD

include/openPMD/IO/IOTask.hpp

@@ -44,18 +44,20 @@ Writable *getWritable(Attributable *);
 /** Type of IO operation between logical and persistent data.
  */
 OPENPMDAPI_EXPORT_ENUM_CLASS(Operation){
-    CREATE_FILE,     OPEN_FILE,      CLOSE_FILE,    DELETE_FILE,
+    CREATE_FILE,      OPEN_FILE,      CLOSE_FILE,    DELETE_FILE,
 
-    CREATE_PATH,     CLOSE_PATH,     OPEN_PATH,     DELETE_PATH,
+    CREATE_PATH,      CLOSE_PATH,     OPEN_PATH,     DELETE_PATH,
     LIST_PATHS,
 
-    CREATE_DATASET,  EXTEND_DATASET, OPEN_DATASET,  DELETE_DATASET,
-    WRITE_DATASET,   READ_DATASET,   LIST_DATASETS, GET_BUFFER_VIEW,
+    CREATE_DATASET,   EXTEND_DATASET, OPEN_DATASET,  DELETE_DATASET,
+    WRITE_DATASET,    READ_DATASET,   LIST_DATASETS, GET_BUFFER_VIEW,
 
-    DELETE_ATT,      WRITE_ATT,      READ_ATT,      LIST_ATTS,
+    DELETE_ATT,       WRITE_ATT,      READ_ATT,      LIST_ATTS,
 
     ADVANCE,
-    AVAILABLE_CHUNKS //!< Query chunks that can be loaded in a dataset
+    AVAILABLE_CHUNKS, //!< Query chunks that can be loaded in a dataset
+    KEEP_SYNCHRONOUS //!< Keep two items in the object model synchronous with
+                     //!< each other
 }; // note: if you change the enum members here, please update
    // docs/source/dev/design.rst
 
@@ -257,8 +259,8 @@ struct OPENPMDAPI_EXPORT Parameter<Operation::LIST_PATHS>
             new Parameter<Operation::LIST_PATHS>(*this));
     }
 
-    std::shared_ptr<std::vector<std::string> > paths =
-        std::make_shared<std::vector<std::string> >();
+    std::shared_ptr<std::vector<std::string>> paths =
+        std::make_shared<std::vector<std::string>>();
 };
 
 template <>
@@ -434,8 +436,8 @@ struct OPENPMDAPI_EXPORT Parameter<Operation::LIST_DATASETS>
             new Parameter<Operation::LIST_DATASETS>(*this));
     }
 
-    std::shared_ptr<std::vector<std::string> > datasets =
-        std::make_shared<std::vector<std::string> >();
+    std::shared_ptr<std::vector<std::string>> datasets =
+        std::make_shared<std::vector<std::string>>();
 };
 
 template <>
@@ -569,8 +571,8 @@ struct OPENPMDAPI_EXPORT Parameter<Operation::LIST_ATTS>
             new Parameter<Operation::LIST_ATTS>(*this));
     }
 
-    std::shared_ptr<std::vector<std::string> > attributes =
-        std::make_shared<std::vector<std::string> >();
+    std::shared_ptr<std::vector<std::string>> attributes =
+        std::make_shared<std::vector<std::string>>();
 };
 
 template <>
@@ -619,6 +621,23 @@ struct OPENPMDAPI_EXPORT Parameter<Operation::AVAILABLE_CHUNKS>
     std::shared_ptr<ChunkTable> chunks = std::make_shared<ChunkTable>();
 };
 
+template <>
+struct OPENPMDAPI_EXPORT Parameter<Operation::KEEP_SYNCHRONOUS>
+    : public AbstractParameter
+{
+    Parameter() = default;
+    Parameter(Parameter const &p)
+        : AbstractParameter(), otherWritable(p.otherWritable)
+    {}
+
+    std::unique_ptr<AbstractParameter> clone() const override
+    {
+        return std::make_unique<Parameter<Operation::KEEP_SYNCHRONOUS>>(*this);
+    }
+
+    Writable *otherWritable;
+};
+
 /** @brief Self-contained description of a single IO operation.
  *
  * Contained are

include/openPMD/backend/Writable.hpp

@@ -75,6 +75,7 @@ class Writable final
     friend class ParticleSpecies;
     friend class Series;
     friend class Record;
+    friend class AbstractIOHandlerImpl;
     template <typename>
     friend class CommonADIOS1IOHandlerImpl;
     friend class ADIOS1IOHandlerImpl;

src/IO/ADIOS/ADIOS1IOHandler.cpp

@@ -134,6 +134,12 @@ std::future<void> ADIOS1IOHandlerImpl::flush()
                     deref_dynamic_cast<Parameter<O::OPEN_FILE> >(
                         i.parameter.get()));
                 break;
+            case O::KEEP_SYNCHRONOUS:
+                keepSynchronous(
+                    i.writable,
+                    deref_dynamic_cast<Parameter<O::KEEP_SYNCHRONOUS> >(
+                        i.parameter.get()));
+                break;
             default:
                 VERIFY(
                     false,
@@ -345,6 +351,7 @@ void ADIOS1IOHandler::enqueue(IOTask const &i)
     case Operation::CREATE_DATASET:
     case Operation::OPEN_FILE:
     case Operation::WRITE_ATT:
+    case Operation::KEEP_SYNCHRONOUS:
         m_setup.push(i);
         return;
     default:

src/IO/ADIOS/ParallelADIOS1IOHandler.cpp

@@ -156,6 +156,12 @@ std::future<void> ParallelADIOS1IOHandlerImpl::flush()
                     deref_dynamic_cast<Parameter<O::OPEN_FILE> >(
                         i.parameter.get()));
                 break;
+            case O::KEEP_SYNCHRONOUS:
+                keepSynchronous(
+                    i.writable,
+                    deref_dynamic_cast<Parameter<O::KEEP_SYNCHRONOUS> >(
+                        i.parameter.get()));
+                break;
             default:
                 VERIFY(
                     false,
@@ -364,6 +370,7 @@ void ParallelADIOS1IOHandler::enqueue(IOTask const &i)
     case Operation::CREATE_DATASET:
     case Operation::OPEN_FILE:
     case Operation::WRITE_ATT:
+    case Operation::KEEP_SYNCHRONOUS:
         m_setup.push(i);
         return;
     default:

src/IO/AbstractIOHandlerImpl.cpp

@@ -0,0 +1,33 @@
+/* Copyright 2022 Franz Poeschel
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "openPMD/IO/AbstractIOHandlerImpl.hpp"
+#include "openPMD/backend/Writable.hpp"
+
+namespace openPMD
+{
+void AbstractIOHandlerImpl::keepSynchronous(
+    Writable *writable, Parameter<Operation::KEEP_SYNCHRONOUS> param)
+{
+    writable->abstractFilePosition = param.otherWritable->abstractFilePosition;
+    writable->written = true;
+}
+} // namespace openPMD

src/Mesh.cpp

@@ -230,10 +230,9 @@ void Mesh::flush_impl(
                 MeshRecordComponent &mrc = at(RecordComponent::SCALAR);
                 mrc.parent() = parent();
                 mrc.flush(name, flushParams);
-                IOHandler()->flush(flushParams);
-                writable().abstractFilePosition =
-                    mrc.writable().abstractFilePosition;
-                written() = true;
+                Parameter<Operation::KEEP_SYNCHRONOUS> pSynchronize;
+                pSynchronize.otherWritable = &mrc.writable();
+                IOHandler()->enqueue(IOTask(this, pSynchronize));
             }
             else
             {

src/Record.cpp

@@ -60,10 +60,9 @@ void Record::flush_impl(
                 RecordComponent &rc = at(RecordComponent::SCALAR);
                 rc.parent() = parent();
                 rc.flush(name, flushParams);
-                IOHandler()->flush(flushParams);
-                writable().abstractFilePosition =
-                    rc.writable().abstractFilePosition;
-                written() = true;
+                Parameter<Operation::KEEP_SYNCHRONOUS> pSynchronize;
+                pSynchronize.otherWritable = &rc.writable();
+                IOHandler()->enqueue(IOTask(this, pSynchronize));
             }
             else
             {