wip: try splitting m_work in two

Author: franzpoeschel

include/openPMD/IO/AbstractIOHandler.hpp

@@ -59,6 +59,11 @@ enum class FlushLevel
      * This mode defines a flush point (see docs/source/usage/workflow.rst.rst).
      */
     UserFlush,
+    /**
+     * Flush triggered by storeChunk in immediate flush mode.
+     * Must not perform storeChunk operations of the Span API.
+     */
+    ImmediateFlush,
     /**
      * Default mode, used when flushes are triggered internally, e.g. during
      * parsing to read attributes. Does not trigger a flush point.
@@ -81,6 +86,66 @@ enum class FlushLevel
     CreateOrOpenFiles
 };
 
+namespace flush_level
+{
+    inline constexpr auto global_flushpoint(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            return true;
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto write_datasets(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+            return true;
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto write_attributes(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+            return true;
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto flush_hierarchy(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+            return true;
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+} // namespace flush_level
+
 enum class OpenpmdStandard
 {
     v_1_0_0,

include/openPMD/RecordComponent.tpp

@@ -155,8 +155,14 @@ inline DynamicMemoryView<T> RecordComponent::storeChunkSpanCreateBuffer_impl(
         getBufferView.out->ptr = static_cast<void *>(data.get());
         if (size > 0)
         {
-            storeChunk(std::move(data), std::move(o), std::move(e));
+            internal::LoadStoreConfigWithBuffer ls_cfg{
+                std::move(o), std::move(e), std::nullopt};
+            storeChunk_impl(
+                auxiliary::WriteBuffer(std::move(data)),
+                getBufferView.dtype,
+                std::move(ls_cfg));
         }
+        // storeChunk(std::move(data), std::move(o), std::move(e));
     }
     setDirtyRecursive(true);
     return DynamicMemoryView<T>{std::move(getBufferView), size, *this};

src/IO/ADIOS/ADIOS2File.cpp

@@ -1080,25 +1080,16 @@ void ADIOS2File::flush_impl(
         drainedUniquePtrPuts.swap(m_uniquePtrPuts);
     }
 
-    if (readOnly(m_mode))
+    if (readOnly(m_mode) || flush_level::write_datasets(level))
     {
-        level = FlushLevel::UserFlush;
-    }
-
-    switch (level)
-    {
-    case FlushLevel::UserFlush:
         performPutGets(*this, eng);
         m_updateSpans.clear();
         m_buffer.clear();
         m_alreadyEnqueued.clear();
         drainedUniquePtrPuts.clear();
-
-        break;
-
-    case FlushLevel::InternalFlush:
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
+    }
+    else
+    {
         /*
          * Tasks have been given to ADIOS2, but we don't flush them
          * yet. So, move everything to m_alreadyEnqueued to avoid
@@ -1115,7 +1106,6 @@ void ADIOS2File::flush_impl(
                 "wrong time.");
         }
         m_buffer.clear();
-        break;
     }
 }
 

src/Iteration.cpp

@@ -320,15 +320,9 @@ void Iteration::flushFileBased(
         s.openIteration(i, *this);
     }
 
-    switch (flushParams.flushLevel)
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -343,15 +337,9 @@ void Iteration::flushGroupBased(
         IOHandler()->enqueue(IOTask(this, pCreate));
     }
 
-    switch (flushParams.flushLevel)
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -366,17 +354,13 @@ void Iteration::flushVariableBased(
         IOHandler()->enqueue(IOTask(this, pOpen));
     }
 
-    switch (flushParams.flushLevel)
+    if (!flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        flush(flushParams);
-        break;
     }
 
+    flush(flushParams);
+
     if (!written())
     {
         /* create iteration path */

src/backend/Attributable.cpp

@@ -312,15 +312,9 @@ Attributable::seriesFlush_impl<false>(internal::FlushParams const &flushParams);
 
 void Attributable::flushAttributes(internal::FlushParams const &flushParams)
 {
-    switch (flushParams.flushLevel)
+    if (!flush_level::write_attributes(flushParams.flushLevel))
     {
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        // pass
-        break;
     }
     if (dirty())
     {