Performance optimizations for interacting with many meshes / species types (#1741)

* Emplace scalar tuple only when needed

* Flush only dirty meshes/species

TODO: Maybe do this in more places, and also when reading

* Improved specification of standards

* Don't forward empty Span operations to backend

* Verify that Iterations are not reparsed

* Check for dirtyRecursive more fine-grained

* Update include/openPMD/backend/BaseRecord.hpp

Author: franzpoeschel

include/openPMD/RecordComponent.tpp

@@ -114,6 +114,15 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
         dCreate.name = rc.m_name;
         IOHandler()->enqueue(IOTask(this, dCreate));
     }
+
+    if (size == 0)
+    {
+        // Don't forward this operation to the backend as it might create ugly
+        // zero-blocks in ADIOS2
+        setDirtyRecursive(true);
+        return DynamicMemoryView<T>();
+    }
+
     Parameter<Operation::GET_BUFFER_VIEW> getBufferView;
     getBufferView.offset = o;
     getBufferView.extent = e;

include/openPMD/Span.hpp

@@ -113,7 +113,10 @@ class DynamicMemoryView
     }
 
 public:
-    explicit DynamicMemoryView() = default;
+    explicit DynamicMemoryView()
+    {
+        m_param.out->backendManagedBuffer = false;
+    }
 
     /**
      * @brief Acquire the underlying buffer at its current position in memory.

src/Iteration.cpp

@@ -362,9 +362,14 @@ void Iteration::flush(internal::FlushParams const &flushParams)
                 s.setMeshesPath("meshes/");
                 s.flushMeshesPath();
             }
-            meshes.flush(s.meshesPath(), flushParams);
-            for (auto &m : meshes)
-                m.second.flush(m.first, flushParams);
+            if (meshes.dirtyRecursive())
+            {
+                meshes.flush(s.meshesPath(), flushParams);
+                for (auto &m : meshes)
+                {
+                    m.second.flush(m.first, flushParams);
+                }
+            }
         }
         else
         {
@@ -378,9 +383,14 @@ void Iteration::flush(internal::FlushParams const &flushParams)
                 s.setParticlesPath("particles/");
                 s.flushParticlesPath();
             }
-            particles.flush(s.particlesPath(), flushParams);
-            for (auto &species : particles)
-                species.second.flush(species.first, flushParams);
+            if (particles.dirtyRecursive())
+            {
+                particles.flush(s.particlesPath(), flushParams);
+                for (auto &species : particles)
+                {
+                    species.second.flush(species.first, flushParams);
+                }
+            }
         }
         else
         {
@@ -470,6 +480,11 @@ void Iteration::readGorVBased(
 
 void Iteration::read_impl(std::string const &groupPath)
 {
+    if (!get().m_deferredParseAccess.has_value())
+    {
+        throw error::Internal(
+            "Attempted reparsing an Iteration that is already parsed.");
+    }
     Parameter<Operation::OPEN_PATH> pOpen;
     pOpen.path = groupPath;
     IOHandler()->enqueue(IOTask(this, pOpen));

src/Mesh.cpp

@@ -366,6 +366,10 @@ template Mesh &Mesh::setTimeOffset(float);
 void Mesh::flush_impl(
     std::string const &name, internal::FlushParams const &flushParams)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
         auto &m = get();

src/ParticleSpecies.cpp

@@ -155,6 +155,10 @@ namespace
 void ParticleSpecies::flush(
     std::string const &path, internal::FlushParams const &flushParams)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
         for (auto &record : *this)
@@ -168,12 +172,15 @@ void ParticleSpecies::flush(
     }
     else
     {
-        auto it = find("position");
-        if (it != end())
-            it->second.setUnitDimension({{UnitDimension::L, 1}});
-        it = find("positionOffset");
-        if (it != end())
-            it->second.setUnitDimension({{UnitDimension::L, 1}});
+        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
+        {
+            auto it = find("position");
+            if (it != end())
+                it->second.setUnitDimension({{UnitDimension::L, 1}});
+            it = find("positionOffset");
+            if (it != end())
+                it->second.setUnitDimension({{UnitDimension::L, 1}});
+        }
 
         Container<Record>::flush(path, flushParams);
 

src/Record.cpp

@@ -45,13 +45,17 @@ Record &Record::setUnitDimension(unit_representations::AsMap const &udim)
 }
 Record &Record::setUnitDimension(unit_representations::AsArray const &udim)
 {
-    return setUnitDimension(
-        unit_representations::asMap(udim, /* skip_zeros = */ false));
+    setAttribute("unitDimension", udim);
+    return *this;
 }
 
 void Record::flush_impl(
     std::string const &name, internal::FlushParams const &flushParams)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
         if (scalar())

src/RecordComponent.cpp

@@ -255,6 +255,10 @@ bool RecordComponent::empty() const
 void RecordComponent::flush(
     std::string const &name, internal::FlushParams const &flushParams)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     auto &rc = get();
     if (flushParams.flushLevel == FlushLevel::SkeletonOnly)
     {

src/backend/BaseRecord.cpp

@@ -819,6 +819,11 @@ template <typename T_elem>
 inline void BaseRecord<T_elem>::flush(
     std::string const &name, internal::FlushParams const &flushParams)
 {
+    if (!this->dirtyRecursive())
+    {
+        return;
+    }
+
     if (!this->written() && this->empty() && !this->datasetDefined())
         throw std::runtime_error(
             "A Record can not be written without any contained "

src/backend/MeshRecordComponent.cpp

@@ -72,6 +72,10 @@ void MeshRecordComponent::read()
 void MeshRecordComponent::flush(
     std::string const &name, internal::FlushParams const &params)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     if (access::write(IOHandler()->m_frontendAccess) &&
         !containsAttribute("position"))
     {

src/backend/PatchRecord.cpp

@@ -41,6 +41,10 @@ PatchRecord::setUnitDimension(std::map<UnitDimension, double> const &udim)
 void PatchRecord::flush_impl(
     std::string const &path, internal::FlushParams const &flushParams)
 {
+    if (!dirtyRecursive())
+    {
+        return;
+    }
     if (!this->datasetDefined())
     {
         if (IOHandler()->m_frontendAccess != Access::READ_ONLY)